Question

我无法理解递归。如何使用递归逻辑转换循环？这就是我所拥有的。我已经遵循递归基础来避免无限次调用，但这使得它不会调用递归操作。

    function getArrayOf5(array,n) {
     var result = [];

     for(i = 0; i < array.length; i+= 5){
     var arr = array.slice(i,n)
     result.push(arr)
     n+=5;
  }
   return result;
}

 function recArrayOf5(array,i,n) {

  var result = [];

  //base case
  if(i > array.length) {return;}

  //action case
  result.push(array.slice(i,n));

  //recursive case
  recArrayOf5(array,i+5,n+5);

 return result;
}

这里是JSBin链接 https://jsbin.com/giqateketi/edit?js,console

Answer 1

尝试以下方法：

function recArrayOf5(array, n, result){
    if(array.length <= n){
        result.push(array.slice(0, n));
        return(result); //base case
    }
    result.push(array.slice(0, n));
    return recArrayOf5(array.slice(5), n, result); //recursive call
}
function getArrayOf5(array,n) {
     var result = [];

     for(i = 0; i < array.length; i+= 5){
     var arr = array.slice(i,n)
     result.push(arr)
     n+=5;
  }
   return result;
}
f = [8, 4, 5, 67, 1, 5, 2, 7, 9, 4, 4, 3, 7, 8, 32, 5, 3, 2]
console.log(JSON.stringify(getArrayOf5(f, 3)));
console.log(JSON.stringify(recArrayOf5(f, 3, [])));

Answer 2

function getArrayOf5(array, n, i) {
    var result = [];
    if (i >= array.length) 
        return result;
    result.push(array.slice(i, n));
    return result.concat(getArrayOf5(array, i+5, n+5);
} //Javascript

function getArrayOf5($array, $n, $i) {
    $result = [];
    if ($i >= count($array)) {
        return $result;
    }           
    array_push($result, array_slice($array, $i, $n));

    return array_merge($result, getArrayOf52($array, $i+5, $n+5));
} //original answer in PHP

你的代码正在做的是它以递归方式调用函数，但从不对函数的返回值做任何事情。

要在第一个和第二个函数之间使用相同的输出，您需要实际执行一些递归调用函数的结果。

我已经编辑了包含Javascript代码的响应，但我仍然会将PHP留在那里。

Answer 3

试试这样。我正在使用递归的最后一个参数作为累加器，并将结果收集到该累加器。

function getArrayOf5(array,n) {
  var result = [];

  for(i = 0; i < array.length; i+= 5){
     var arr = array.slice(i,n)
     result.push(arr)
     n+=5;
  }
   return result;
}

function recArrayOf5(array, i, n, result) {
  
  var result = result || [];

  //base case
  if(i >= array.length) {return result;}

  //action case
  result.push(array.slice(i,n));

  //recursive case
  return recArrayOf5(array,i+5,n+5, result);
}

var array = [1,2,3,4,5,6,7,8,9,10]

console.log(JSON.stringify(getArrayOf5(array,5)))
console.log(JSON.stringify(recArrayOf5(array,0,5,[]))) //at first accumulator/result is empty

====

我认为更好地解决你的递归问题会看起来像这样

var arr = [1,2,3,4,5,6,7,8,9,10]

function getArrayOfN(array, n, res){
  var res = res || [];
	
  if(array.length === 0) return res;
  
  return getArrayOfN(array.slice(n), n, res.concat([array.slice(0,n)]));
}

console.log(JSON.stringify(getArrayOfN(arr, 5)));

在每次递归调用中，我将第一个N元素的slice添加到第三个参数中的结果（累加器）：

res.concat([array.slice(0,n)])，

其余的主数组作为第一个参数：array.slice(n)，

和N一样：

getArrayOfN(array.slice(n), n, res.concat([array.slice(0,n)]));

Answer 4

你的问题是

//action case
result.push(array.slice(i,n));

//recursive case
recArrayOf5(array,i+5,n+5);

在第一次调用中，将slice []保存到结果中，调用递归调用，对结果不执行任何操作，并返回在递归之前所执行的切片。在进行递归调用时，您希望返回调用的结果，或者让函数改变传递的值之一，以便每个调用的工作从调用传递到调用。

请注意，在其他答案中，您可以使您的基本案例调用您的递归调用，重要的是它确实终止，并且每个调用都试图完成一部分工作。

Answer 5

我认为你不应该改变功能签名（参数列表）。请注意，如果您希望轻松调试并使代码更易于理解，则使用一致的命名和缩进非常重要。

＆＃13;

function groupByN(arr, n) {
    var result = [];

    for (i = 0; i < arr.length; i+=n) {
        result.push(arr.slice(i, i+n));
    }

    return result;
}

function groupByNRec(arr, n) {
    if ( arr.length < n ) {
        if ( arr.length > 0 )  // feel free to remove these two lines  
            return [arr];      // if you don't want the remaining items
        return;
    }

    var item = arr.slice(0, n);
    var remaining = groupByNRec(arr.slice(n), n);

    return remaining ? [item].concat(remaining) : [item];
} 
    
var arr = [1,2,3,4,5,6,7,8,9,10];

console.log(JSON.stringify(groupByN(arr, 3)));
console.log(JSON.stringify(groupByNRec(arr, 3)));

＆＃13;

return remaining ? [item].concat(remaining) : [item];：此行使用三元运算符（condition ? true : false）并测试remaining是否未定义。你也可以写：

if ( remaining )
    return [item].concat(remaining);
return [item];

使用recusrion逻辑转换循环

5 个答案: