0

代码：

public static void main(String[] args) {
    System.out.println(test(13549));
}    

public static int test(int a){
    if(a<10)
        return a;
    int b = (a%10);
    int c = test(a/10);
    int d = Math.max(b,c);
    return d;
}

我了解该方法的作用（在使用调试器之后）并且我了解该方法会调用自身直到它小于 10 并且它运行并检查更大的 b 或 c。现在我不明白的是，为什么当有 return 语句return d;时它返回int c = test(a/10)而不是int test(int a){.

4

5 回答 5

3

该return语句返回对的调用的输出test。因此，在行上return d;它只是返回行中的test(a/10)值c = test(a/10)。

于 2013-03-18T21:39:56.827 回答
1

这是递归的一个基本思想——当你在自身内部调用方法时，它不仅仅是跳回到方法的开头。

视觉上：

1
|
|  2
|__|
|  |  3
|  |__|
   |  |  x
   |  |__|
      |  .
      |  .

其中每条垂直线是函数的运行，而水平线是递归调用。

每次调用后，它都会返回到它被调用的方法的实例中的位置 有效，这意味着在第三次递归中，您在堆栈中（在内存中）有 3 个版本的函数，而不是简单地返回到当前函数的顶部 3 次。

于 2013-03-18T21:47:25.083 回答
0

每次调用递归函数时，它都会从函数的顶部开始。由于您在递归函数调用之后定义了 d，因此您将永远不会到达 d。您将继续递归调用您的函数，直到您能够返回 a。

于 2013-03-18T21:49:37.330 回答
0

当您调用test(13549)时，会发生以下情况：

test(13549){
   false
   b=9
   c= test(1354){
       false
       b=4
       c=test(135){
           false
           b=5
           c=test(13){
               false
               b=3
               c=test(1){
                  true
                  return 1
                }
                d=Max(3,1)
                return 3
              }
               d=Max(3,3)
               return 3
             }
             d=Max(5,3)
             return 5
           }
          d=Max(4,5)
          return 5
        }
    d=Max(9,5)
    return 9
  }

抱歉，如果我可能以任何方式计算错误.. 但是您可以看到，直到所有递归调用都完成并且第一个 c 具有实际值，才到达第一个 return 语句。

于 2013-03-18T22:02:25.367 回答
0

在跟踪您的代码时，假设您有一个堆栈（函数执行）。每当您发现该函数正在调用自身时，就在堆栈顶部放置一个新函数执行，并在函数返回时取出堆栈元素。

你会发现这个函数会一直调用它自己，直到它达到“基本情况”——当 a<10 时。

将代码放在 return 语句下面不会有任何好处（在某些语言中它甚至不会编译），一旦函数返回，任何代码都不会被执行

于 2013-03-18T21:44:22.877 回答