JAVA递归程序逻辑

运行上面的代码，我得到24？ 我不太明白怎么做

我的疑问是： 1.当m=1，n=4时，我们调用prod，直到m和n等于1。 那么输出应该是n，否则不应该执行块

---

有人请帮我理解逻辑。

只需用数字来完成这个过程，你需要把它写下来，以便准确地看到行为（将来，我建议在你的代码中添加大量打印，以检查变量以及它们如何随每次传递而变化）

因此，您的程序打印24

有时，理解一个程序的最好方法是机械地逐行地完成这些步骤，在你的头脑中（或在纸上）执行它们以跟踪事情。

要理解任何具有函数的程序，你假设被调用的函数都能正确地完成它们的工作，并检查调用函数是否以正确的顺序使用正确的参数调用它们，并正确组合结果

对于递归函数，您需要检查每个递归调用是否更接近没有递归的情况

这里没有人告诉我们结果应该是什么。每当

m==n

时，递归就结束，递归调用是使用

n=n-1

，因此只有当

m=m

时，这才有效。知道这就是正在发生的事情，很容易检查我们（到目前为止）的直觉是否正确

prod(1,4)
m=1,n=4
m != n so, recurse = prod(1, 3)

prod(1, 3)
m=1,n=3
m != n so, recurse = prod(1, 2)

prod(1, 2)
m=1,n=2
m != n so, recurse = prod(1, 1)

prod(1, 1)
m=1,n=1
m == n so,
return 1

returns to prod(1, 2)
recurse = 1
result = 2 * 1
return 2

returns to prod(1, 3)
recurse = 2
result = 3 * 2
return 6

returns to prod(1, 4)
recurse = 6
result = 4 * 6
return 24

可以用m==1转换为：

prod(1, 4);

public static int prod(int m, int n) {
    if (m == n) {
        return n;
    } else {
        int recurse = prod(m, n-1);
        int result = n * recurse;
        return result;
    }
}

其中包含一个转换（头递归）：

这是阶乘函数

prod(1, 4);

public static int prod(int m, int n) {
    if (m == n) {
        return n;
    } else {
        int recurse = prod(m, n-1);
        int result = n * recurse;
        return result;
    }
}

prodA(4);
public static int prodA(int n) {
    if (1 == n) {
        return n;
    } else {
        int recurse = prodA(n-1);
        int result = n * recurse;
        return result;
    }
}

public static int prodA(int n) {
    int result = 1;
    while (n > 1) { // Actually n != 1
        result *= n;
        --n;
    }
    return result;
}