我如何在一个递归javascript函数中把数组推到数组中，这样当它完成时我就可以使用它了？

Question

我想这是第一个问题。如果需要更多信息，请告诉我，以便你们帮助我。

所以我试着用javascript实现一个使用递归函数的算法。

该函数是从JavaScript中实现置换堆算法复制的，如下所示：

let swap = function(array, index1, index2) {
    let temp = array[index1]
    array[index1] = array[index2]
    array[index2] = temp
    return array
}

let permutationHeap = (array, result, n) => {
    n = n || array.length // set n default to array.length
    if (n === 1) {
        result(array)
    } else {
        for (let i = 1; i <= n; i++) {
            permutationHeap(array, result, n - 1)
            if (n % 2) {
                swap(array, 0, n - 1) // when length is odd so n % 2 is 1,  select the first number, then the second number, then the third number. . . to be swapped with the last number
            } else {
                swap(array, i - 1, n - 1) // when length is even so n % 2 is 0,  always select the first number with the last number
            }
        }
    }
}


let output = function(input) {
    console.log(output)
}

permutationHeap([1,2,3,4,5], output)

输出函数（回调？）中的console.log给了我正确的输出。如果我将console.log移动到置换堆函数中的if语句下方，我也会得到正确的输出（console.log（数组），在这种情况下）。

我想做的是将每个输出存储为一个数组，在一个数组中，我以后可以使用它。我猜我正在努力学习Javascript 101。处理异步思维。但我一辈子都搞不懂如何得到数组！

< li >如果我在permutationHeap-函数和。push(array)它只存储[1，2，3，4，5]。如果我在输出函数中做同样的事情，结果是一样的。 < li >我还尝试将一个空数组传递给permutationHeap-函数，并以这种方式进行推送。仍然没有运气。

有人愿意为一个可能超级无聊的问题发光吗？：）非常感谢！

Answer 1

我想我已经通过使用生成器和yield成功修复了你的代码。虽然我不能确切地解释它...

js prettyprint-override">var swap = function(array, index1, index2) {
    let temp = array[index1]
    array[index1] = array[index2]
    array[index2] = temp
    return array
}

var permutationHeap = function*(array, result, n) {
    n = n || array.length // set n default to array.length
    if (n === 1) {
        yield (array.slice(0))
    } else {
        for (let i = 1; i <= n; i++) {
            yield* permutationHeap(array, result, n - 1)
            if (n % 2) {
                swap(array, 0, n - 1) // when length is odd so n % 2 is 1,  select the first number, then the second number, then the third number. . . to be swapped with the last number
            } else {
                swap(array, i - 1, n - 1) // when length is even so n % 2 is 0,  always select the first number with the last number
            }
        }
    }
}

var x = permutationHeap([1,2,3,4,5])
var results = Array.from(x);
console.log(results);

Answer 2

实际上，我在之前的答案中打破了算法，因为通过重复数组不断迭代，我打破了算法中依赖数组随时间变化的部分。

我已经做出了一个答案，它使用您最初更有效地使用的代码：

var swap = function(array, index1, index2) {
  var temp = array[index1];
  array[index1] = array[index2];
  array[index2] = temp;
  return array;
};

var permutationHeap = function(array, result, n) {
  n = n || array.length; // set n default to array.length
  if (n === 1) {
    result(array);
  } else {
    for (var i = 1; i <= n; i++) {
      permutationHeap(array, result, n - 1);
      if (n % 2) {
        swap(array, 0, n - 1); // when length is odd so n % 2 is 1,  select the first number, then the second number, then the third number. . . to be swapped with the last number
      } else {
        swap(array, i - 1, n - 1); // when length is even so n % 2 is 0,  always select the first number with the last number
      }
    }
  }
};

function getPermutations(array) {
  var results = [];
  var output = function(res) {
    results.push(res.slice(0));
  }

  permutationHeap(array, output);

  return results;
}

var permutations = getPermutations([1,2,3]);
console.log(permutations);