Java 递归调用的返回值是多少

我有以下代码，我正在努力理解和跟踪

我不明白的部分是结尾的*a。什么时候叫乘法？power1a的返回值是多少，n-1

是n-1*a吗

如果用a=2和n=3调用power1，将发生以下情况：

结果=功率12，2*2； power12，2=power12，1*2； power12，1=power12，0*2； power12，0=1

在上面的示例中，*a总共发生三次。每当power1a，n返回一个值时，就会调用它。第一个返回值的power1a，n将是power12，0这是因为n=0是您的基本情况。然后power12，1将返回2。然后power12将返回4。然后您对power12，3的初始调用将返回8。

返回power1a，n-1的值 我们可以看到power1被定义为公共静态double power1double a，int n这意味着

结果=功率1A，n-1*a

类型为：

double=double*double

当乘法被调用时 我们从n和a开始函数。在这个实现中，a将是恒定的。它直接给出了下一个递归调用

然而，n是不同的

我们称之为power1a，n。它首先检查n==0；事实并非如此。 所以我们转到if的另一部分。计算结果的时间

要知道结果的值是多少，我们需要power1a，n-1。我们继续。n-1可以是0，也可以不是

如果是0，我们返回1，现在我们知道power1a，n-1=1。现在我们可以把它乘以a

如果它不是0，那么我们需要一个新的结果，因为我们在一个完全独立的power1方法调用中。我们现在需要电源1A，n-2。我们再次检查0。如果n-2==0，则返回1以让调用方计算powera，n-1。如果不去另一个电话，现在与n-3。。。等

在调用乘法的时间方面。

---

它首先调用所有n个递归调用，然后再进行n次乘法。

首先调用幂a，n-1，直到n==0，这是基本情况

然后返回1并乘以a的值。

---

然后a返回到上一个调用，在那里它被乘以a。该过程重复N次，因此得到^N。我建议您通读这段代码的一个示例，给它一些初始值，并使用钢笔和纸跟踪代码。

您可以修改代码以打印递归跟踪。这可以帮助你了解发生了什么

 public static double power1(double a, int n) {
        double result;
        if(n == 0) {
            return 1;
        }
        else {
            result = power1(a, n - 1) * a;

            return result;
        }
    }

输出

---

如您所见，内部返回的值将成为外部返回语句的结果。

尝试将其写在纸上。返回值将取决于传递给该方法的参数。如果你像@LoganKulinski所说的那样写出它，你会发现它是递归调用的double*double a，这意味着你会得到一个double back，这正是power1方法定义的。至于何时被调用：程序将首先检查n==0，显然不是。然后计算结果。对于结果，它需要：1 power1 en 2 a。计算功率1的时间。启动电源1A，n-1。重新启动，检查是否为0。在某一点上，你的n-k将为零。当k=n时。所以它返回一个1。然后它跳回到你的n-k为1的时候。它现在被称为powera，n-k=>1*a；它返回a。然后回到它知道powera，n-k+1的时候。它有一个a。一个来自递归，一个来自实际参数。等等，在它完成计算powera所需的所有步骤之前，n-1*a您可能想说n-k==0。if检查n值是否为0，递归深度为variable.Rafael。在发布答案之前，请尝试验证答案。你是为整个社区写的。这个社区的全部目的是在其他代码中发现错误。

 public static double power1(double a, int n) {
        double result;
        if(n == 0) {
            return 1;
        }
        else {
            result = power1(a, n - 1) * a;

            return result;
        }
    }

/**
 * Print string form of `o`, but indented with n spaces
 */
private static void printIndented(int n, Object o) {
    while (n-->0) System.out.print("  ");
    System.out.println(o);
}

/* 
 * Added a third param `d` to keep track of the depth of the recursion
 */
public static double power1(double a, int n, int d) {
    // Entering a "possible" recursive call
    printIndented(d, "call power1, a=" + a + ", n=" + n + ", d=" + d);

    double result;
    if(n == 0) {
        // Returning from the base case, this should have the largest depth.
        printIndented(d, "return 1.0");

        return 1;
    }
    else {
        result = power1(a, n - 1, d + 1);

        // Return from intermediate recursive calls, we print
        // the value of power1(a, n-1) as well.
        printIndented(d, "return " + result + " * " + a);
        return result * a;
    }
}

public static void main(String [] args) {
    System.out.println(power1(1.4, 3, 0));
}

call power1, a=1.4, n=3, d=0
  call power1, a=1.4, n=2, d=1
    call power1, a=1.4, n=1, d=2
      call power1, a=1.4, n=0, d=3
      return 1.0
    return 1.0 * 1.4
  return 1.4 * 1.4
return 1.9599999999999997 * 1.4
2.7439999999999993