“return 1”以某种方式给了我一个递归方法的解决方案答案

【问题标题】："return 1" somehow gives me a solution in a Recursive Method“return 1”以某种方式给了我一个递归方法的解决方案
【发布时间】：2012-11-08 02:35:53
【问题描述】：

 {
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？

【问题讨论】：

此处解释：pastebin.com/raw.php?i=dHTnSPuY（也在我的回答中）
函数有时返回 1，有时返回另一个表达式。实际上，它只返回 1 一次；每隔一次它返回另一个表达式。

标签： java methods recursion

【解决方案1】：

Recursion：

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

【讨论】：

【解决方案2】：

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（我的评论以@符号开头）

【讨论】：

【解决方案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)->32.

【讨论】：

当然，你已经说明了发生了什么......但就目前而言，这个答案很丑陋而且不是特别有用。

【解决方案4】：

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

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

【讨论】：

【解决方案5】：

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

【讨论】：

【解决方案6】：

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

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

if (exp == 0)
    return 1;

当 exp 为 0 时，它停止。没有它，就会产生stackoverflow！

【讨论】：

【解决方案7】：

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

对于基础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 以获得新结果。一般来说，我们可以使用以下两条规则生成整个序列：

b^0 = 1 为所有 b

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）。

最后，几点说明。

在else 子句中，简单地显示减法而不是使用预增量会更清楚。也就是说，考虑使用：
```
return baseNum * power(baseNum, exp - 1); /* exp - 1 instead of --exp */
```
如果传递给你的函数的exp是否定的，它可能会在递归调用自身太多次并耗尽内存后崩溃。

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

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;
}

【讨论】：