Question

我试图理解递归，并发现以下内容是对freecodecamp递归练习进行因子分解的答案。是正确的，但我不知道它是如何运行的。

-如果'return 1'退出函数，那么输出不应该为1吗？
-所需的模式（如果是10x9x8x7等）。但是，如果每次调用它自己都不遵循10x9、9x8、8x7等模式？

很抱歉，如果这不是一个合适的问题，请首次使用。

function factorialize(num) {
  if (num === 0) { return 1; }
  return num * factorialize(num-1);
}

factorialize(5);
>120

Answer 1

由于累加了递归函数的各个结果，因此可以通过以下方式想象这一过程：

致电factorialize（5）;
第一个递归步骤返回-> 5 * factorialize（4）

当前值：5 *因式分解（4）
第二个递归步骤返回-> 4 * factorialize（3）

当前值：5 * 4 *因式分解（3）
第三次递归步骤返回-> 3 * factorialize（2）

当前值：5 * 4 * 3 *因式分解（2）
第四递归步骤返回-> 2 * factorialize（1）

当前值：5 * 4 * 3 * 2 * factorialize（1）
第六个递归步骤返回-> 1 * factorialize（0）

当前值：5 * 4 * 3 * 2 * 1 *析因（0）
第7个（最后一个）递归步骤返回-> 1

当前值：5 * 4 * 3 * 2 * 1 * 1

结果为120。

function factorialize(num) {
  if (num === 0) { return 1; }      // 7th step
  return num * factorialize(num-1); // 1st to 6th step
}

Answer 2

迭代编写函数可能有助于澄清问题；循环中的每一步等效于一个递归调用。

function factorialize(num) {
  let factorial = 1; // base case, equivalent to fact(0)

  for (let i = 1; i <= num; i++) { // multiply for each number from 1 to n
    factorial *= i;
  }

  return factorial;
}

console.log(factorialize(5));

递归函数以相同的方式工作。 fact(n)是原始调用，但是要计算fact(n)，它必须首先计算n - 1的阶乘。如果没有fact(n - 1)，就无法计算fact(n - 2)。每个函数都被推入调用堆栈，等待其上方的函数解析。最终将调用fact(0)，根据recursive definition of factorial，我们知道它是1。 fact(0)被称为基本情况，并且不会进行任何递归调用。如果没有基本情况，n会越来越小，直到堆栈空间不足，导致程序崩溃。

有了基本案例的信息，fact(1)现在可以计算1 * 1并将结果1传递到其调用函数fact(2)。 fact(2)计算2 * 1并将结果传递到fact(3)，后者计算3 * 2并将结果传递给fact(4)，后者计算4 * 6并传递结果返回到fact(5)，后者将计算5 * 24并返回120的最终结果。

如果仍然没有意义，请扔console.log()来查看沿途的每个步骤：

function factorialize(num) {
  if (num === 0) { // base case 
    console.log("fact(0) returning 1");
    return 1; 
  }

  // recursive case
  const result = num * factorialize(num - 1);
  console.log("fact(" + num + ") returning " + result);
  return result;
}

console.log(factorialize(5));

使用递归分解一个数字

2 个答案: