试图找出递归基础答案

【问题标题】：Trying to figure out recursive basics试图找出递归基础
【发布时间】：2015-02-09 22:42:10
【问题描述】：

如果有人能向我解释我编写的这段代码与我认为它会产生的代码有什么不同，我会非常高兴。我编写代码试图证明int n 将是n = 4，所以在我的脑海和纸面上，我认为我的逐步结果如下：

4 * 4 + (3) = 19
3 * 3 + (2) = 11
2 * 2 + (1) = 5
1 * 1 + (0) = 1

返回 0

谁能告诉我为什么不是这样？并引导我完成递归步骤？

public static void main(String[] args) {

         Scanner kbd = new Scanner(System.in);

         int n;
         System.out.println("Enter a number: ");
         n = kbd.nextInt();

        System.out.println("recursive value "+intValue(n));
   }
   public static int intValue(int n)
   {
         int total;
         int x;
        if(n == 0)
           return 0;
        else 
          total = n * n + intValue(n-1);
          System.out.println("Recursive total: "+total);
          return total;
  }

【问题讨论】：

您可以使用调试器自行完成。
您的 IDE 应该有一个“调试”模式，这将允许您逐行单步执行您的代码。
确保通过单击要停止的行来添加断点。
它说的是调试开始
1*1+0 = 1 顺便说一句

标签： java if-statement recursion methods

【解决方案1】：

以下是递归步骤，从n 开始是4：

intValue(4)
  n is not 0.  total is 4 * 4 + intValue(3)
  intValue(3)
    n is not 0.  total is 3 * 3 + intValue(2)
    intValue(2)
      n is not 0.  total is 2 * 2 + intValue(1)
      intValue(1)
        n is not 0.  total is 1 * 1 + intValue(0)
        intValue(0)
          n is 0, intValue(0) returns 0.
        1 * 1 + 0 = 1.
        Print Recursive value: 1, intValue(1) returns 1.
      2 * 2 + 1 = 5.
      Print Recursive value: 5, intValue(2) returns 5.
    3 * 3 + 5 = 14.
    Print Recursive value: 14, intValue(3) returns 14.
  4 * 4 + 14 = 30.
  Print Recursive value: 30, intValue(4) returns 30.

回到main，初始调用返回30，并打印recursive value 30。

递归调用不返回要添加的n - 1 本身；它返回以n - 1为参数再次调用intValue的结果。

【讨论】：

【解决方案2】：

所以你的递归方程是

total = n * n + intValue(n-1);

当你用 4 运行它时，它是

4 * 4 + intValue(3)

在这种情况下 intValue(3) 是

3 * 3 + intValue(2)

在这种情况下 intValue(2) 是

2 * 2 + intValue(1)

在这种情况下 intValue(1) 是

1 * 1 + intValue(0)

在这种情况下 intValue(0) 是

在这种情况下，intValue(1)是

1 * 1 + intValue(0) = 1*1 + 0 = 1;

在这种情况下，intValue(2)是

2 * 2 + intValue(1) = 2 * 2 + 1 = 5

在这种情况下 intValue(3) 是

3 * 3 + intValue(2) = 3 * 3 + 5 = 14

在这种情况下 intValue(4) 是

4 * 4 + intValue(3) = 4 * 4 + 14 = 30

【讨论】：

为什么一旦它一直下降到 0 就不会返回 0？为什么它会备份？
@JeffGreenwood：假设您有 5 个函数 intValueA、intValueB、intValueC 等，每个函数都调用下一个函数，而不是它自己。这能回答你的问题吗？
因为intValue(2)的结果是5，而intValue(3)的结果取决于intValue(2)，例如5。我试图编辑我的帖子以使其更清晰。
是的，只是仍然习惯于递归它有点时髦
把递归想象成一个堆栈......每次你进行递归调用时，都会将一个新项目推入堆栈。当达到基本情况时，每个项目都会从堆栈中弹出，这会在每个后续项目被弹出时创建一个返回值。这就是你问的“回去”。一旦堆栈为空，您的函数就完成了。

【解决方案3】：

关于递归的事情是它不断调用自己，直到它到达点 n == 0 返回。你试图在纸上解决它的方式是颠倒的。

在 n == 0 之前它不会计算您的等式，并且所有递归调用基本上都在等待结果。所以它是这样计算出来的，（括号中的每个操作都在等待递归调用的结果）：

总计 = 4 * 4 + (3*3 + (2 * 2 + (1 * 1 + 0)))

评估 5.（栈顶），n = 0，返回0
4. n = 1, 1 * 1 + 0, 返回 1
3. n = 2, 2 * 2 + 1, 返回 5
2. n = 3, 3 * 3 + 5, 返回 14
1. n = 4, 4 * 4 + 14, 返回 30

【讨论】：