Question

我正在尝试使用递归编写N个嵌套循环，但实现它需要花费太长时间。我还没有解决如何比较包含循环索引的数组的所有级别。我的目标是使索引数组遍历所有组合。

例如，如果N为3，则迭代的嵌套循环将如下所示：

var i = 10;
while (i--) {
    var j = 10;
    while (j--) {
        var k = 10;
        while (k--) {
            if (i === 0 && j === 0 && k === 0) { return 0; }
        }
    }
}

，i，j，k之间的组合从[9, 9, 9]转到[0, 0, 0]。

我的尝试是这样的：

function nloops(n) {
    loop(n, [], 0);
}

function loop(n, array, index) {
    if(array.length != n) {
        array[index] = 10 - 1;
        loop(n, array, index + 1);
    } else {
        if ((n - index + 1) < 0) {

        } else {
            if (array[n - index + 1] > 0) { 
                array[n - index + 1]--; loop(n, array, index + 1);
            }
        }
    }
}

nloops(3);

我预期的行为是从[9, 9, 9]走到[0, 0, 0]的数组。

Answer 1

要正确使用递归，您需要从思考“如何”实现结果转向思考结果的“结果”。例如，什么是大小n的组合？如果n为零，则结果为空集，否则，它是源集的所有组合以及大小为n - 1的所有组合。

function combinations(elements, size) {
    var result = [];

    if (size === 0) {

        result.push([]);

    } else {

        combinations(elements, size - 1).forEach(function (previousComb) {
            elements.forEach(function (element) {
                result.push([element].concat(previousComb));
            });
        });
    }

    return result;
}

var combs = combinations(['a', 'b', 'c', 'd'], 3);
document.write("<pre>" + JSON.stringify(combs,0,3));

Answer 2

你总是可以作弊：使用整数并拆分并在每次迭代时将其推入数组。比担心需要更新的数组索引要容易得多。另外：奖励迭代功能。

function pad(str) {
  if (str.length === 3) return str;
  return pad(0 + str);
}

function iter(n, init) {
  if (Array.isArray(n)) n = n.join('');
  var arr = pad(n.toString()).split('').map(Number);
  init.push(arr);
  return n === 0 ? init : iter(--n, init);
}

var out = iter([9, 9, 9], []);

DEMO

JavaScript - 如何使用递归创建变量嵌套循环？

2 个答案: