Question

我在尝试为递归反转数组的函数编写函数时遇到问题，但只有一个参数。

function ReverseArray(arr) {

  var i = 0;
  var j = arr.length - 1;

  if (i < j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
    return ReverseArray(arr);
  }

  return arr;
}

我意识到这不起作用，因为当函数调用自身时，变量将被重新初始化。

我只是在寻找一些想法，因为我被卡住了。

Answer 1

首先，对于可能想要将数组转换为真正的问题而非家庭作业的其他人，请使用Array.reverse，不要浪费时间尝试自己实现它。

如果你绝对必须，那么这里的技巧就是在你使用{{3}展开时递归和重建最终数组时传递一个较小的数组（使用slice减去第一个和最后一个元素） }。例如：

function ReverseArray(arr) {
  if (arr.length < 2) {
    return arr;
  } else {
    var first = arr[0];
    var last = arr[arr.length - 1];
    return [last].concat(ReverseArray(arr.slice(1, length - 1))).concat([first]);
  }

}

alert(ReverseArray([1,2,3,4,5]));

Answer 2

为什么要编写自己的反向方法？为什么不在数组上使用反向方法？

function ReverseArray(arr) {
    arr = arr.reverse();
}

<强>更新

上面的方法显然没有多大意义，因为你只需要在任何你想要的地方调用反向方法。

Answer 3

我认为以下解决方案是最简单的递归实现：

＆＃13;

var a = [1,2,3,4,5];
alert(ReverseArray(a));

function ReverseArray(arr) {
    if(arr.length < 2) {
        return arr;
    } else {
        return [arr.pop()].concat(ReverseArray(arr));
    }
}

＆＃13;

Answer 4

我正在使用shift，pop，unshift和push来避免制作数组的部分副本。可能比在每次递归调用时使用切片复制部分数组要快一点，但不要指望它优于非递归解决方案或内置反向方法：

function recReverse(list){
  if(list.length>=2){
    var lo=list.shift();
    var hi=list.pop();
    list=recReverse(list);
    list.unshift(hi);
    list.push(lo);
  }
  return list;
}

和fiddle

Answer 5

假设你有一个数组[1 2 3 4 5]

只需将最后一个号码存储在某处，然后再次将1-4输入该功能（结果为5-1234）

当fed in数组中只有一个数字时，将该数字作为单个数组成员返回。

返回数组时，将返回的数组附加到临时数字中，然后添加到新数组中。

这应该是4-123，然后是3-12，然后是2-1，这将全部反馈，导致5-4-3-2-1

简明版：

var input_array = [1,2,3,4,5]

function rev(input) {
  if (input.length == 1) { return input; }
  if (input.length == 0) { return []; }
  return [input[input.length-1]].concat(rev(input.splice(0, input.length-1)));
}

rev(input_array);

展开版本：

var input_array = [1,2,3,4,5]

function rev(input) {
  if (input.length == 1) { return input; }
  if (input.length == 0) { return []; }
  var last = [input[input.length-1]];
  var newarr = rev(input.splice(0, input.length-1));
  var answer = last.concat(newarr);
  return answer;
}

rev(input_array);

Answer 6

你需要做的就是这个

function reverse(x, i, j) {
    if (i < j) {//Swap
        var tmp = x[i];
        x[i] = x[j];
        x[j] = tmp;
        reverse(x, ++i, --j);//Recursive
    }
}

function reverseIt(x) {
    console.log(x);
    reverse(x, 0, x.length - 1);
    console.log(x);
}


var q = [1, 2, 3, 4, 5, 6, 7, 8, 9];
reverseIt(q);

Answer 7

function reverseArray(origArray)
{
    if (origArray.length > 1) {
        var element = origArray[0];
        var newArray = reverseArray(origArray.slice(1));
        newArray[newArray.length] = element;
        return newArray;
    } else {
        return origArray;
    } 
}

Answer 8

var result = [];
function reverseArray(arr) {
  result.push(arr.pop());
  j= arr.length;
  if (j>0) {
   reverseArray(arr);   
  }   
}  
reverseArray([1,4,3,5]);
console.log(result);

具有一个参数的反向数组函数。（JavaScript的）

8 个答案:

具有一个参数的反向数组函数。 （JavaScript的）

8 个答案:

具有一个参数的反向数组函数。（JavaScript的）