Javascript 递归地交换数组中的对

尝试以递归方式交换数组中的对，并设法以迭代方式获得它。 如何递归地实现交换部分？我想我大部分都是对的！如果有奇数，则最后一个保持不变。如果可能的话，我不想使用助手交换函数

pairSwap = function(arr) {
      var newArray = []
      for (var i = 0; i < arr.length; i += 2) {
        var current = arr[i];
        var next = arr[i + 1]
        if (next !== undefined) {
          newArray.push(next)
        }
        if (current !== undefined) {
          newArray.push(current)
        };
      };
      return newArray;
    }

    console.log(pairSwap([1, 2, 3, 4, 5]))
    pairSwapRecursive = function(arr) {

      if (arr.length < 2) {
        return arr;
      } else {
        //swap the first and second:
        return (swap ? ) + pairSwapRecursive(arr.slice(2))

      }


    }

    console.log(pairSwapRecursive([1, 2, 3, 4, 5])) //should return [2, 1, 4, 3, 5]

//something similar in Java:

    // public String swapPairs(String s) {
    //      if (s.length() < 2)
    //           return s;
    //      else
    //           return swap(s.charAt(0), s.charAt(1)) + swapPairs(s.substring(2));
    // }

pairSwap=函数（arr）{
var newArray=[]
对于（变量i=0；i

如果可能的话，我不想使用助手交换函数

pairSwap = function(arr) {
      var newArray = []
      for (var i = 0; i < arr.length; i += 2) {
        var current = arr[i];
        var next = arr[i + 1]
        if (next !== undefined) {
          newArray.push(next)
        }
        if (current !== undefined) {
          newArray.push(current)
        };
      };
      return newArray;
    }

    console.log(pairSwap([1, 2, 3, 4, 5]))
    pairSwapRecursive = function(arr) {

      if (arr.length < 2) {
        return arr;
      } else {
        //swap the first and second:
        return (swap ? ) + pairSwapRecursive(arr.slice(2))

      }


    }

    console.log(pairSwapRecursive([1, 2, 3, 4, 5])) //should return [2, 1, 4, 3, 5]

//something similar in Java:

    // public String swapPairs(String s) {
    //      if (s.length() < 2)
    //           return s;
    //      else
    //           return swap(s.charAt(0), s.charAt(1)) + swapPairs(s.substring(2));
    // }

您不需要它-只需返回第二个和第一个元素，您就完成了：

var pairSwapRecursive = function(arr) {
    if (arr.length < 2) {
        return arr;
    }

    return [arr[1], arr[0]].concat(pairSwapRecursive(arr.slice(2)));
};

var pairswapercursive=函数（arr）{
如果（arr.length<2）{
返回arr；
}
返回[arr[1]，arr[0]].concat（pairswapercursive（arr.slice（2））；
};

因此，与任何其他递归算法一样，它：

做一些小的工作。在本例中-返回一个交换了前两个元素的数组

与其余部分一起调用自身

---

jsiddle:

本着@zerkms解决方案的精神，这里有一个版本可以反转任何长度的块：

function reverse_chunks(n) {

  return function _reverse_chunks(arr) {
    if (!arr.length) return arr;
    return arr.slice(0, n).reverse().concat(_reverse_chunks(arr.slice(n)));
  };

}

reverser = reverse_chunks(2);
reverser([1, 2, 3, 4])

如果您想让它更具语义和可读性，并转到ES6：

function reverse_chunks(n) {

  return function _reverse_chunks(arr) {
    var [head, tail] = [arr.slice(0, n), arr.slice(n)];
    if (!arr.length) return [];
    return [ ...head.reverse(), ..._reverse_chunks(tail) ];
  };

}

如果您愿意，还可以使用函数将其参数化，以排列每个块的元素：

function permute_chunks(n = 2, permute = arr => arr.reverse()) {

  return function _permute_chunks(arr) {
    var [head, tail] = [arr.slice(0, n), arr.slice(n)];
    if (!arr.length) return [];
    return [ ...permute(head), ..._permute_chunks(tail) ];
  };

}

然后

---

将每个区块分成五个元素。

不需要帮助函数的原因是什么？@torazaburo pure recursion:）这是一个学习练习。