在方法本身调用后有return语句的情况下，以Java递归

Question

码：

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){的方法的开始。

Answer 1

return语句返回对test的调用的输出 。 这样就return d; 它只是返回的值test(a/10)在线路c = test(a/10)

Answer 2

这是递归的基本思想-当您在内部调用方法时，它不只是跳回到方法的开始。

视觉：

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

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

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

Answer 3

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

您会发现该函数将继续调用自身，直到达到“基本情况”为止-当a <10时。

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

Answer 4

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

Answer 5

当您调用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语句。