需要帮助理解 Eloquent Javascript 中的递归函数示例

Question

function power(base, exponent) {
  if (exponent == 0)
  return 1;
else
  return base * power(base, exponent - 1);
}

我想我理解了递归的基本原理，它只是意味着你在函数本身内调用函数。这可以用来执行各种循环，但我无法弄清楚上面的代码实际上是如何决定循环以计算出一个数字的指数值。我使用函数 power(2,5) 作为参数，并且函数知道答案是 32，但是怎么做呢？函数是否循环本身每次从指数中减去 1，然后乘以 base * base 直到指数达到零？如果是这样，那么在函数中调用 power 函数是如何准确地完成这一点的呢？一旦指数达到零，函数不会只返回 1 而不是正确答案吗？

Answer 1

我认为每个递归步骤（调用自身的函数）都会产生更短更容易的问题。

最简单的问题是power(base, 0)，它满足exponent == 0并返回1（任何底数的0次方都是1）。

然后，请注意，无论指数有多大，它都会将exponent 减一，保证它最终会达到指数为零的“最简单”的问题。它不能是负数，否则永远达不到这个“基本情况”。

因此，2^5 或幂 (2, 5) 变为 2 * 2^4。并且 2^4 = 2 * 2^3。通过继续这个展开，我们得到 2 * 2 * 2 * 2 * 2 * 1，它等于 32。1 代表exponent == 0 为真的情况。

计算必须跟踪它累积了多少次乘法，一旦达到exponent == 0 的基本情况，将所有数字相乘。它无法提前确定power(base, exponent-1) 会返回什么。

Answer 2

遵循调用模式..假设我们执行 power(2,2).. 你得到这个：

power(2,2) -> (exponent != 0) 2 * power(2, 1)

2 * power(2, 1) -> (exponent != 0) 2 * power(2, 0)

2 * 2 * 幂(2,0) -> (指数 == 0) 1

2 * 2 * 1 = 4

它的工作方式基本上是你的调用堆栈，只要你不断调用子方法，你的父级就不会返回。所以它会一直嵌套自己，直到遇到具体的 # ——在本例中为 1，然后它返回堆栈实际上执行 *。

Answer 3

这显示了可以帮助您遵循逻辑的中间结果：
每个级别都有自己的底数、指数、答案值。

function power(base, exponent) {
  var answer; // local
  level = level + 1;
  console.log("Entering: power(" + base + ", " + exponent + 
      ") (level " + level + ")");
  if (exponent == 0) { // don't recurse any more
    answer = 1; }
  else {               // recurse to get answer
    answer = base * power(base, exponent - 1); }
  // now return answer
  console.log("Leaving: power("+ base + ", " + exponent + 
      ") (level " + level + ") ans=" + answer);
  level = level - 1
  return answer;
  }
var level = 0; // global
console.log("Final answer: " + power(2, 5)); 

Answer 4

解释上述递归的最好方法是看控制台返回什么

 function power(base, exponent) {
     // termination/base case
     if (exponent == 0)
        return 1;
     // recursive case
     else
        console.log(base + ':' + exponent)
        return base * power(base, exponent - 1);

     //  2 * (2, 4) = 4
     //  4 * (2, 3) = 8
     //  8 * (2, 2) = 16
     //  16 *(2, 1) = 32
     //  16 *(2, 0) = 1 recursive stops and returns 1
     //  function calls the last return  = 32

  } 

  var result = power(2,10)
  console.log(result)

我希望这能让您更直观地了解这种递归是如何工作的

Answer 5

当我第一次看到它时，这也让我很困惑，在主演它 10 分钟后，它突然出现在我的脑海中......没什么神奇的......

function power(base, exponent) {
  if (exponent == 0)
  return 1;
else
  return base * power(base, exponent - 1);
}

console.log(power(2, 5));

这就是它的运行方式：

return base * power(base, exponent - 1)

看着上面的线本身，我也迷路了。没有对给定参数 2 和 5 执行任何操作（+、-、*、/、%），但不知何故，console.log 最终只知道生成正确的数字。

因为它不返回数值，所以它只是返回base * power(base, exponent -1)本身，当程序到达power(base, exponent -1) strong>，它会在 return 发生之前执行它，直到 exponent == 0 变为 true。

第一个： 返回基数 * 幂（基数，5 - 1）；

第二： 返回基数 * 基数 * 幂（基数，4 - 1）；

第三： 返回基数 * 基数 * 基数 * 幂（基数，3 - 1）；

第四： 返回基数 * 基数 * 基数 * 基数 * 幂（基数，2 - 1）；

第五： 返回基数 * 基数 * 基数 * 基数 * 基数 * 幂（基数，1 - 1）；

第六： 返回基数 * 基数 * 基数 * 基数 * 基数 * 1;

因为 if (exponent == 0) 返回 1

所以： 2*2*2*2*2*1 = 32