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

Question

Code:

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;
}

I understand what the method does (after using the debugger) and I understand that the method calls itself till it is less than 10 and it runs and checks what's bigger, b or c. Now what I don't understand is that why when there is the return statement return d; it returns to int c = test(a/10) and not to the start of the method of int test(int a){ .

Answer 1

The return statement returns the output of the call to test . So on the line return d; it's just returning the value of test(a/10) in the line c = test(a/10) .

Answer 2

This is a basic idea of recursion - when you call the method within itself, it isn't just jumping back to the start of the method.

visually:

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

Where each vertical line the running of the function, and the horizontal lines are recursive calls.

After each call, it returns back to the place in the instance of the method it was called in Effectively, that means that in the 3rd recursion, you have 3 versions of the function on the stack (in memory), rather than simply going back to the top of the current function 3 times.

Answer 3

When tracing your code, imagine you have a stack (of function execution). Whenever you find the function is calling itself, put a new function execution on top of the stack, and when the function returns take out the stack element.

You'll find that the function will keep calling itself until it reach the 'base case' -- when a<10.

Putting a code below a return statement won't do any good (in some language it won't even compile), none of the code will get executed once the function returns

Answer 4

Each time you call your recursive function, it starts from the top of the function. Since you have d defined after your recursive function call you will never get to d. You will continue to recursively call your function until you are able to return a.

Answer 5

When you call test(13549) this is what happens:

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
  }

Sorry if I may have miscalculated in any way.. but there you can see, that the first return statement is not reached until all recursive calls are finished and the very first c hast an actual value.