递归函数编程困境

recursion functional programming dilemma

本文关键字:困境 函数编程 递归      更新时间:2023-09-26

下面是我的JavaScript代码。下面的循环答案是正确的答案。

我的递归版本是不正确的,它是如此不合逻辑,以至于当索引为3,数组长度为3时,计算机仍然输入if语句。。。为什么?如果3不小于3,则计算机不应输入If语句。帮我修正递归答案。循环正确且良好,应保持原样。

var data = [
   { 
      name: "Jamestown",
     population: 2047,
     temperatures: [-34, 67, 101, 87]
   },
 {
   name: "Awesome Town",
   population: 3568,
   temperatures: [-3, 4, 9, 12]
 },
{
  name: "Funky Town",
  population: 1000000,
  temperatures: [75, 75, 75, 75, 75]
}
];

递归答案

function john( arr, i, j, total, coord)
{
   var total = total || 0;
   var coord = coord || [];
  if(i < arr.length)
  {
   if(j < arr[i].temperatures.length)
   {
     total = arr[i].temperatures[j] + total;
     john(arr, i, j + 1, total, coord)
   }
     ave = total / arr[i].temperatures.length;
     total = 0;
     coord.push([ave, arr[i].population])
     john(arr, i + 1, 0, total, coord)
    }
    return coord;
  }
console.log("recursion answer(it is wrong) is")
console.log( john(data, 0, 0, 0))

环路应答

var coords = [],
   totalTemperature = 0,
   averageTemperature = 0;
for (var i=0; i < data.length; i++) {
  totalTemperature = 0;
 for (var j=0; j < data[i].temperatures.length; j++) {
   totalTemperature += data[i].temperatures[j];
 }
  averageTemperature = totalTemperature / data[i].temperatures.length;
  coords.push([averageTemperature, data[i].population]);
}
console.log("correct answer is this loop answer ...")
console.log(coords)

不能用对同一函数的两个递归调用来替换嵌套循环。

当您用i, j + 1调用函数时,它不仅会为j调用以下值,还会为i调用以下值。当您用i + 1, j调用它时,它不仅会为i调用以下值,还会为j调用以下值。

而不是像这样接到一连串的电话:

0,0
  0,1
    0,2
      0,3
  1,0
    1,1
      1,2
        1,3
    2,0
      2,1
        2,2
          2,3
            2,4

你会得到这样的东西:

0,0
  0,1
    0,2
      0,3
        0,4
          1,0
            1,1
              1,2
                1,3
                  2,0
                    2,1
                      2,2
                        2,3
                          2,4
                2,0
                  2,1
                    2,2
                      2,3
                        2,4
              2,0
                2,1
                  2,2
                    2,3
                      2,4
            2,0
              2,1
                2,2
                  2,3
                    2,4
        1,0
          1,1
            1,2
              1,3
                2,0
                  2,1
                    2,2
                      2,3
                        2,4
              2,0
                2,1
                  2,2
                    2,3
                      2,4
            2,0
              2,1
                2,2
                  2,3
                    2,4
          2,0
            2,1
              2,2
                2,3
                  2,4
      1,0
        1,1
          1,2
            1,3
              2,0
                2,1
                  2,2
                    2,3
                      2,4
            2,0
              2,1
                2,2
                  2,3
                    2,4
          2,0
            2,1
              2,2
                2,3
                  2,4
        2,0
          2,1
            2,2
              2,3
                2,4
    1,0
      1,1
        1,2
          1,3
            2,0
              2,1
                2,2
                  2,3
                    2,4
          2,0
            2,1
              2,2
                2,3
                  2,4
        2,0
          2,1
            2,2
              2,3
                2,4
      2,0
        2,1
          2,2
            2,3
              2,4
  1,0
    1,1
      1,2
        1,3
          2,0
            2,1
              2,2
                2,3
                  2,4
        2,0
          2,1
            2,2
              2,3
                2,4
      2,0
        2,1
          2,2
            2,3
              2,4
    2,0
      2,1
        2,2
          2,3
            2,4

此外,它不会在每个j值范围的末尾推送一个结果,而是为每个调用推送一次结果。

///递归答案

function john( arr, i, j, total, coord)
{
   var total = total || 0;
   var coord = coord || [];
  if(i < arr.length)
  {
   if(j < arr[i].temperatures.length)
   {
     total = arr[i].temperatures[j] + total;
     john(arr, i, j + 1, total, coord)
   }
     ave = total / arr[i].temperatures.length;
     total = 0;
     coord.push([ave, arr[i].population])
     return john(arr, i + 1, 0, total, coord)
    }
    return return coord;
  }

///递归答案

function john( arr, i, j, total, coord)
{
   var total = total || 0;
   var coord = coord || [];
  if(i < arr.length)
  {
   if(j < arr[i].temperatures.length)
   {
     total = arr[i].temperatures[j] + total;
     john(arr, i, j + 1, total, coord)
   }
     ave = total / arr[i].temperatures.length;
     total = 0;
     coord.push([ave, arr[i].population])
     // it need return john(arr, i + 1, 0, total, coord)
     // cannot be john(arr, i+1, 0, total, coord)
     return john(arr, i + 1, 0, total, coord)
    }
    return coord;
  }