Question

尝试递归地交换数组中的对，设法迭代地获取它。我如何递归地实现交换部分？我想我的大部分都是正确的！如果有奇数，则最后一个保持不变。如果可能的话，我不想拥有帮助交换功能。

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));
    // }

Answer 1

如果可能的话，我不想拥有帮助交换功能。

而且你不需要它 - 只需返回第二个和第一个元素就可以了：

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

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

与任何其他递归算法一样：

做一些小工作。在这种情况下 - 它将返回一个包含2个第一个交换元素的数组。
用其余的

JSFiddle：http://jsfiddle.net/am8rz1jx/

Answer 2

本着@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) ];
  };

}

然后

permuter = permute_chunks(5, arr => arr.sort());

将对五个元素的每个元素进行排序。

以递归方式交换数组中的对

2 个答案: