Question

即使这是一个非常简单的例子，我也无法理解这种递归。当它进入power(base, exponent - 1);应该做什么？当权力一直被调用直到exponent等于0时，事物如何成倍增加？

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

Answer 1

这类似于Math.pow();它将base参数提升为exponent。

例如，2 ^ 4为16，因此power(2, 4)将返回16。 if()语句检查指数（幂）是否为零，如果是，则返回1 - 任何提升到0的数字等于1。

最后一行

return base * power(base, exponent - 1);

是一个递归函数，从power()中调用exponent，但power()中的值多次指定。

我会尝试从下往上解释递归，或者我们会说“从中间”;它可能更容易理解。

2最常调用1和1作为参数，并返回power()。然后在2的第二次调用中使用此返回值，因此这次传递的参数为2和4，后者输出power()，依此类推，直到最常见的2来电通过4和16，会回复{{1}}。

Answer 2

让我们从头开始。

假设您致电power(base, 0)。由于exponent为0，因此函数返回1.

现在，假设您致电power(base, 1)。由于此次exponent不为0，因此该函数会调用power(base, exponent - 1) 并将其乘以 base。（这是关键所在......它从递归调用中获取结果，并添加自己的扭曲。）由于exponent - 1 = 0，而power(base, 0)为1，因此结果有效{{1} }。阅读：base * 1。

现在开始base。最终成为power(base, 2)。 base * power(base, 1)是power(base, 1)。最终结果：base * power(base, 0)。阅读：base * (base * 1)平方。

等等。

如果不明显，顺便说一下，这个函数只适用于非负整数指数。如果base为负数，或者甚至是最小或多于整数的最小位，则该函数将“永久”运行。（实际上，一旦递归吞噬了所有堆栈，你很可能会导致堆栈溢出。）

您可以使用某些代码（例如

）修复负功率的功能

exponent

对于非整数......除了抛出异常之外，没有其他方法可以解决这个问题。将数字提升为非整数幂是有道理的，因此您不希望仅截断指数或以其他方式假装他们没有尝试这样做 - 您最终会返回错误的答案。

Answer 3

假设初始通话为power(10, 3) ...

  v-----first power() call returns base * (result of next power() call)
        v-----second power() call returns base * (result of next power() call)
              v-----third power() call returns base * (result of last power() call)
                   v------result of last power() call returns 1
(10 * (10 * (10 * (1))))
                   ^-----return 1
              ^-----return base * 1 (10)
        ^-----return base * 10 (100)
  ^-----return base * 100 (1000)

或向左走，向右走。从power() ...

开始，每一行都是对power(10, 3)的后续调用

return base * power(base, 2);  // return base * 100 (1000)
return base * power(base, 1);  // return base * 10   (100)
return base * power(base, 0);  // return base * 1     (10)
return 1;                      // return 1             (1)

Answer 4

使用2 ^ 3示例：

power(2, 3);

调用：

function power(2, 3) {
    if (3 === 0) {
        return 1;
    } else {
        return 2 * power(2, 2); //called
    }
}

导致：

function power(2, 2) {
    if (2 === 0) {
        return 1;
    } else {
        return 2 * power(2, 1); //called
    }
}

导致：

function power(2, 1) {
    if (1 === 0) {
        return 1;
    } else {
        return 2 * power(2, 0); //called
    }
}

导致：

function power(2, 0) {
    if (1 === 0) {
        return 1; //returned
    } else {
        return 2 * power(2, -1);
    }
}

导致：

function power(2, 1) {
    if (1 === 0) {
        return 1;
    } else {
        return 2 * 1; //returned
    }
}

导致：

function power(2, 2) {
    if (2 === 0) {
        return 1;
    } else {
        return 2 * 2; //returned
    }
}

导致：

function power(2, 3) {
    if (3 === 0) {
        return 1;
    } else {
        return 2 * 4; //returned
    }
}

最终返回8，即2 ^ 3.

Answer 5

base = 10 power = 3

10 *功率（10,2）

10 * 10 *功率（10,1）

10 * 10 * 10

对于正整数可能没问题......

Answer 6

让我们尝试用一些数学来解释这个。

f(x,y) = x^y                     # (1) function definition
       = x * x * x * ... * x     # (2) multiply x with itself y times
       = x * (x * x * ... * x)   # (3) rewrite using parentheses for clarity
       = x * (x^(y-1))           # (4) replace the second part by (1) notation
       = x * f(x, y-1)           # (5) replace again by using f(x,y) notation according to (1)

f(x,0) = 1                       # base case: x^0 = 1

在此之后，您可以看到f(x,y) = x * f(x, y-1)。

您还可以看到

if (exponent === 0) {
    return 1;
}

来自，即基本情况，即0次方的某些东西总是等于1：f(x,0) = 1。

这就是这种递归的推导方式。

有人可以解释这个递归的JS代码来计算指数吗？

6 个答案: