0 
 {
System.out.println (base + " to the " + i + " power =  " + 
                          power(base, i));   
}

    public static double power(double baseNum, int exp) 
    {
        if (exp == 0)
            return 1;
        else
            return baseNum * power(baseNum, --exp); 
    }

快速提问，上面称为“power”的方法在返回“1”时以某种方式返回答案的答案。因此，如果我传递参数来计算 2 ^ 5，RETURN 1 会以某种方式变成 32.0。这里到底发生了什么？“1”如何变成32.0？

4

7 回答 7

3

递归：

power(2, 5)
= 2 * power(2, 4)
== 2 * 2 * power(2, 3)
=== 2 * 2 * 2 * power(2, 2)
==== 2 * 2 * 2 * 2 * power(2, 1)
===== 2 * 2 * 2 * 2 * 2 * power(2, 0)
====== 2 * 2 * 2 * 2 * 2 * 1 (exp == 0)
===== 2 * 2 * 2 * 2 * 2
==== 2 * 2 * 2 * 4
=== 2 * 2 * 8
== 2 * 16
= 32
于 2012-11-08T02:44:03.280 回答
1 
else
    return baseNum * power(baseNum, --exp);

那个代码就在那里。当其中一个power函数返回 1 时，它实际上是由 this 调用的。所以它会是这样的：

return baseNum * power(baseNum, --exp);

和power返回的 1，所以：

return baseNum * 1;

在这种情况下，baseNum 将为 32.0。

递归。

更好的解释：http ://pastebin.com/raw.php?i=dHTnSPuY （我的评论以@符号开头）

于 2012-11-08T02:41:30.900 回答
1

幂(2, 5)->2*幂(2,4)->2*2*幂(2,3)->2*2*2*幂(2,2)->2*2*2* 2*power(2,1)->2*2*2*2*2*power(2,0)->32。

于 2012-11-08T02:43:12.863 回答
1

这是，如果你会原谅双关语，递归的力量。它是这样工作的：

power(2, 5) = 2 * power(2, 4)
            = 2 * 2 * power(2, 3)
            . . .
            = 2 * 2 * 2 * 2 * 2 * power(2, 0)
            = 2 * 2 * 2 * 2 * 2 * 1
            = 32
于 2012-11-08T02:45:08.400 回答
1

既然你已经有了答案。请参阅此以了解有关递归的更多信息位置 01:47

于 2012-11-08T02:49:58.777 回答
0

在递归中，有一件重要的事情要记住，那就是基本情况。每个递归都需要在某个时间点停止。它不可能永远持续下去。

因此，在幂函数中，这是基本情况。

if (exp == 0)
    return 1;

当 exp 为 0 时，它停止。没有它，它将给出stackoverflow！

于 2012-11-08T02:54:43.827 回答
0

考虑如何指定函数的输出power(base, exp)。

对于 base b，我们指定以下内容：

power(b, 0) = b^0 = 1
power(b, 1) = b^1 = b
power(b, 2) = b^2 = b * b
power(b, 3) = b^3 = b * b * b
...
power(b, n) = b^n = b * b * ... * b  (n times)

请注意，每次我们将指数增加一时，我们将结果乘以b得到新结果。一般来说，我们可以使用以下两条规则生成整个序列：

  1. b^0 = 1对全部b
  2. b^n = b^(n-1) * b对于所有正整数n

这两个规则直接转换为您提供的函数定义。

public static double power(double baseNum, int exp) 
{
    if (exp == 0)  /* when the exponent is zero, the result is always 1. */
        return 1;
    else           /* otherwise, the power is equal to b^(n-1) * b. */
        return baseNum * power(baseNum, --exp); 
}

当您从正整数指数开始时，我们使用规则 2 根据较小的指数计算结果，直到我们到达指数零 - 当我们知道结果应该始终为 1 时（使用规则 1）。

最后，几点说明。

  1. 在该else子句中，简单地显示减法而不是使用前置增量会更清楚。也就是说，考虑使用：

    return baseNum * power(baseNum, exp - 1); /* exp - 1 instead of --exp */

  2. 如果exp传递给你的函数是负数，它可能会在递归调用自身太多次并耗尽内存后崩溃。

  3. 如果您希望该函数考虑负索引，您仍然可以使用递归调用，除了反转我们的递归规则以使指数向零移动：

    public static double power(double base, int exp)
{
    if (exp == 0)
        return 1;
    else if (exp < 0)
        return power(base, exp + 1) / base;
    else
        return power(base, exp - 1) * base;
}
于 2012-11-08T03:15:15.570 回答