Javascript 递归地反转数组中的元素

我想用javascript编写一个递归函数，它返回一个元素颠倒的数组。此代码生成以下错误：

未定义不是一个函数

---

lastOfIndex不是函数，您可能想使用lastIndexOf。这里有一个类似的方法：

function reverseArray (toBeReversed){
  var reversed = [];

  function reverser (toBeReversed){
    if (toBeReversed.length !== 0){
      reversed.push( toBeReversed.pop() );
      reverser( toBeReversed );
    }
  }

  reverser(toBeReversed);
  return reversed;
}

---

lastOfIndex不是函数，您可能想使用lastIndexOf。这里有一个类似的方法：

function reverseArray (toBeReversed){
  var reversed = [];

  function reverser (toBeReversed){
    if (toBeReversed.length !== 0){
      reversed.push( toBeReversed.pop() );
      reverser( toBeReversed );
    }
  }

  reverser(toBeReversed);
  return reversed;
}

试一试

功能反转箭头（toBeReversed）{
返回（功能反转器（r，t）{
r、 推（t.拼接（-1,1）[0]）；
返回！！t.length？反向器（r，t）：r
}（[]，与之相反）；
};
var rev=document.getElementsByTagName（“pre”）[0]；
document.getElementsByTagName（“按钮”）[0]
.addEventListener（“单击”，函数（e）{
rev.innerText=“[”+reversearlay（JSON.parse（rev.innerText））+“]”
})

[1,2,3,4,5,6,7]单击
尝试


功能反转箭头（toBeReversed）{
返回（功能反转器（r，t）{
r、 推（t.拼接（-1,1）[0]）；
返回！！t.length？反向器（r，t）：r
}（[]，与之相反）；
};
var rev=document.getElementsByTagName（“pre”）[0]；
document.getElementsByTagName（“按钮”）[0]
.addEventListener（“单击”，函数（e）{
rev.innerText=“[”+reversearlay（JSON.parse（rev.innerText））+“]”
})
[1,2,3,4,5,6,7]单击
这是我的方法：

var letters = ["a", "b", "c", "d", "e", "f", "g", "h"];
var reversed = reverse(letters);

输出：

function reverse(a) {
    if (!a.length) return a;
     return reverse(a.slice(1)).concat(a[0]);
}

我会这样做：

var letters = ["a", "b", "c", "d", "e", "f", "g", "h"];
var reversed = reverse(letters);

输出：

function reverse(a) {
    if (!a.length) return a;
     return reverse(a.slice(1)).concat(a[0]);
}

一个经典的递归实现是

function head(a)    { return a[0];         }
function tail(a)    { return a.slice(1);   }
function push(a, v) { a.push(v); return a; }
function empty(a)   { return !a.length;    }

function reverse(a) { 
    if (empty(a)) return a;
    return push(reverse(tail(a)), head(a)); 
}

您不需要任何循环、累积值的数组、函数中的函数或任何其他机制

如果您喜欢编写小的一行程序来提高代码的可读性，那么

function unshift(a, v) { a.unshift(v); return a; }

function reverse(a) { return _reverse(a, []); }

function _reverse(a, result) {
    if (empty(a)) return result;
    return _reverse(tail(a), unshift(result, head(a)));
}

这个小程序的特点是它可以被“读”成英语，我认为更多的程序应该具备这一点。在这种情况下，它是

数组的反面为（1）空（如果为空）；（2） 否则，将头部添加到尾部反向的末端的结果

不幸的是，即使在提供优化的尾部递归的JS实现中（恰好在此时），它也不会应用于这种情况，因为JS必须保持堆栈，以便每次调用
reverse
的结果时调用
concat
。我们可以写一些可优化的东西吗？是，通过携带另一个值，即到目前为止反转数组的结果：

function reverse(a) { 
    return function _reverse(a, result {
        if (empty(a)) return result;
        return _reverse(tail(a), unshift(result, head(a)));
    }(a, []);
}

或者如果你愿意的话

const recursiveRev = arr => arr.length === 0 || arr.length === 1 ? arr : arr.slice(arr.length-1).concat(recursiveRev(arr.slice(-arr.length, -1)));

这并不是很干净，但给了我们这样一个好处：仍然能够递归地思考，而不需要与递归相关的正常堆栈开销。
一个经典的递归实现是

function head(a)    { return a[0];         }
function tail(a)    { return a.slice(1);   }
function push(a, v) { a.push(v); return a; }
function empty(a)   { return !a.length;    }

function reverse(a) { 
    if (empty(a)) return a;
    return push(reverse(tail(a)), head(a)); 
}

   function reverseArr(arr, i, j){
      if(i < j){
        var temp1 = arr[i];
        arr[i] = arr[j];
        arr[j] = temp1;
        i++;
        j--;
        return reverseArr(arr,i,j);
      } else if(i === j ){
        return arr;
      }
    }
    var originalArr = [1,5,7,3,2,9,11];
    result = reverseArr(originalArr, 0, originalArr.length-1);
    console.log(result);

您不需要任何循环、累积值的数组、函数中的函数或任何其他机制

如果您喜欢编写小的一行程序来提高代码的可读性，那么

function unshift(a, v) { a.unshift(v); return a; }

function reverse(a) { return _reverse(a, []); }

function _reverse(a, result) {
    if (empty(a)) return result;
    return _reverse(tail(a), unshift(result, head(a)));
}

这个小程序的特点是它可以被“读”成英语，我认为更多的程序应该具备这一点。在这种情况下，它是

数组的反面为（1）空（如果为空）；（2） 否则，将头部添加到尾部反向的末端的结果

不幸的是，即使在提供优化的尾部递归的JS实现中（恰好在此时），它也不会应用于这种情况，因为JS必须保持堆栈，以便每次调用
reverse
的结果时调用
concat
。我们可以写一些可优化的东西吗？是，通过携带另一个值，即到目前为止反转数组的结果：

function reverse(a) { 
    return function _reverse(a, result {
        if (empty(a)) return result;
        return _reverse(tail(a), unshift(result, head(a)));
    }(a, []);
}

或者如果你愿意的话

const recursiveRev = arr => arr.length === 0 || arr.length === 1 ? arr : arr.slice(arr.length-1).concat(recursiveRev(arr.slice(-arr.length, -1)));

这并不是很干净，但给了我们这样的好处，即仍然能够递归地思考，而不需要与递归相关的正常堆栈开销。
下面是我的解决方案，它处理原始数组

   function reverseArr(arr, i, j){
      if(i < j){
        var temp1 = arr[i];
        arr[i] = arr[j];
        arr[j] = temp1;
        i++;
        j--;
        return reverseArr(arr,i,j);
      } else if(i === j ){
        return arr;
      }
    }
    var originalArr = [1,5,7,3,2,9,11];
    result = reverseArr(originalArr, 0, originalArr.length-1);
    console.log(result);

let arr = ["1","2","3"]; //declaration of array

function reverseArr(param){
  let i=param.length; //set counter i to the array length
  
  if(i==0){ //when to exit recursion
    return;
  }
  
  console.log(param[i-1]) //what to do until you exit,[i-1] because arrays are 0-based
  param.pop(param[i-1]) //pop already printed element from array
  
  reverseArr(param) //pass the new array and invoke function again
}

reverseArr(arr)

功能反转器（arr，i，j）{
if（i

链接到fiddle:
这是我的解决方案，它处理原始数组

let arr = ["1","2","3"]; //declaration of array

function reverseArr(param){
  let i=param.length; //set counter i to the array length
  
  if(i==0){ //when to exit recursion
    return;
  }
  
  console.log(param[i-1]) //what to do until you exit,[i-1] because arrays are 0-based
  param.pop(param[i-1]) //pop already printed element from array
  
  reverseArr(param) //pass the new array and invoke function again
}

reverseArr(arr)

功能反转器（arr，i，j）{
if（i

链接到fiddle:
我使用递归得出了这个答案


功能反转（arr）{
返回（arr.length>1）？[arr.pop（）].concat（反向（arr））：arr.pop（）；
}
常量数据集=[0,1,2,3,4]；
console.log（反向（数据集））我通过使用递归得出了这个答案


功能反转（arr）{
返回（arr.length>1）？[arr.pop（）].concat（反向（arr））：arr.pop（）；
}
常量数据集=[0,1,2,3,4]；
console.log（反向（数据集））以下是我的反向函数解决方案：


很深
不改变输入数组


函数反转器=（数组）=>{
常量反转=[]；
for（设i=array.length-1；i>=0；i--）{
if（Array.isArray（Array[i]））{
反向推送（反向器（数组[i]））
}否则{
反向推送（数组[i]）
}
}
反向返回；
}
常数arr1=[1,2,3,4,5,6,7,8,9]
常数arr2=[[1,2,3]，[4,5,6]，[7,8,9]]
常数arr3=[[1,2]，[3]，[[4,5]，[6]，[[7,8]，[9]]
控制台日志（反向器（arr1））
控制台日志（反向器（arr2））
console.log（reverser（arr3））
以下是我的反向函数解决方案：


很深
不改变输入数组


函数反转器=（数组）=>{
常量反转=[]；
for（设i=array.length-1；i>=0；i--）