Question

我想了解以下问题：

public class Main {
    public static int fact(int n){
        if (n == 0){
            return 1;
        }else{
            return n * fact(n - 1);
        }
    }
    public static void main(String[] args){
      System.out.print(fact(5));
    }
}

当编译器通过并且return n * fact(n - 1);确实它实际上乘以n或者它只在它达到基本情况后才这样做，然后将存储在堆栈中的所有值相乘？

注意我仍然是这种递归编码方式的新手。

Answer 1

查看乘法执行顺序的好方法，将n * fact(...)替换为mult(n, fact(...))，其中mult是您编写的方法，需要两个数字并返回其产品。然后，您可以在mult中添加一些输出打印，并查看调用的顺序。

public class FactorialExample {
    // The new mult method.
    private static int mult( final int x, final int y ) {
        System.out.println( "Multiplying "+x+" and "+y+"." );
        return x * y;
    }

    public static int fact(int n){
        if (n == 0){
            return 1;
        }else{
            return mult(n, fact(n - 1)); // using the new mult method
        }
    }

    public static void main(String[] args){
      System.out.print(fact(5));
    }
}

这会产生以下输出：

Multiplying 1 and 1.
Multiplying 2 and 1.
Multiplying 3 and 2.
Multiplying 4 and 6.
Multiplying 5 and 24.
120

回想一下，左加数是与n对应的加数，并且第一次对fact的调用具有最大值。因此，递归调用fact(4)必须先完成（生成24），然后将5与24相乘。

Answer 2

（注意：编译器不是评估fact的程序;程序本身就是这样做。）

当程序遇到声明时

n * fact(n - 1)

它将通过调用fact(n - 1)并将fact作为参数传递来单独计算n - 1。一旦该函数完成运行并返回，它将具有一个值，然后它可以乘以n。这样的净效果是，直到达到基本情况的点之后才执行乘法，此时存储在堆栈上的n的值将全部相乘。您可以通过在行

处设置断点来查看此信息

return n * fact(n - 1);

并观察程序展开递归以计算整体值。

希望这有帮助！

Answer 3

1. java tries to output unknown value, so java execute fact with N = 5
  2. tries to multiple 5 by value, which is unknown, it executes fact with N=5-1
    3. tries to multiple 4 by value ..... N=3
      4. tries to multiple 3 by value ..... N=2
        5. tries to multiple 2 by value ..... N=1
          6. tries to multiple 1 by value ..... N=0
            7. returns 1 and go back to 6th item
          8. 1*1 = 1 and go back to 5th item
        9. 2*1 = 2 and go back to 4th item
      10. 3*2 = 6 and go back to 3rd item
    11. 4*6 = 24 and go back to 2nd item
  12. 5*24 = 120 and return to 1st item
13. display 120

Answer 4

一旦n被评估，它将与fact(n - 1)和fact(n - 1)相乘（直到你遇到基本情况为止。

递归fact()调用被链接在一起，直到最后一个调用返回。

Answer 5

这是简单的递归。在任何递归的情况下，它首先向下钻取到基本情况（使用堆栈），然后进行乘法（在堆栈展开过程中）

那么，在你的例子即事实（5）

的情况下会发生什么

fact(5) --> 5 * fact(4) // Here another recursive call is made to calculate fact(4)
fact(4) --> 4 * fact(3)//Here another recursive call is made to calculate fact(3)
.
.
.
fact(1) --> 1 * fact(0)// fact(0) is 1 as per your code

从此时起，堆栈展开，每个fact(n)现在由其简化版本表示。到底 fact(5) --> 5 * fact(4)转换为fact(5) --> 5 * 4 * 3 *2 *1

在这个递归因子函数中何时进行乘法运算？

5 个答案: