递归函数输出不清楚

Question

 public void numbers(int n)
 {
     if(n>0)
     {
         System.out.print(n);
         numbers(n-2);
         System.out.print(n);
     }
 }

I have the above code snippet. When i call numbers(5) It gives me an output : 531135

I understood till 531. But after this how can the second print statement be even reached when n<0?? And why is it 135 like this?

I really don't have any clue regarding this and please help me with a detailed explanation and dry run.

If I am asking something silly please forgive me.

Thank you

Answer 1

I'm gonna try to trace what the program is doing:

numbers(5)
  5>0
    print(5)
    numbers(3)
      3>0
        print(3)
        numbers(1)
          1>0
            print(1)
            numbers(-1)
              -1>0
            print(1)
        print(3)
    print(5)

As you can see, the second print -statement of each function call does not depend on any if (the if of the recursive call doesn't matter to the calling method). Therefore every number is ALWAYS printed twice (or never).

I hope this is somewhat clear to understand.

Answer 2

You can use a debugger to walk through the program. Below I modified your program and added a few println() showing the various states of the program. I also added r to show the recursion level and __ to help indenting the output. See if this now help you understand better.

public class NumberRecursion {

    public static void main(String[] args) {
        numbers(5);

    }

    private static int r = 0;           // recursion level
    private static String __ = "";      // indent prefix
    public static void numbers(int n)
     {
        r++;                            // recursion level
        __ += "    ";                   // indent by another four spaces 

        System.out.println(__+ "[" + r + "] numbers(" + n + ") entered");
         if(n>0)                    // L3
         {
             System.out.println(__+ "["  + r + "] L3 tested true (and n=" + n + ")");
             System.out.println(n); // P1
             System.out.println(__+ "["  + r + "] about to invoke numbers(" + (n-2) + ")");
             numbers(n-2);          // N
             System.out.println(__+ "["  + r + "] numbers(" + (n-2) + ") just finished");
             System.out.println(n); // P2
         } else {
            System.out.println(__+ "[" + r + "] L3 tested false (and n=" + n + ")");
         }
        System.out.println(__+ "["  + r + "] numbers(" + n + ") about to return");
        __ = __.substring(0, __.length()-4);
                                        // indent now has four less spaces
        r--;                            // recursion level
     }


}

The output of this program would be this. In this output, the number in square brackets (eg [1] ) is the level of recursion.

    [1] numbers(5) entered
    [1] L3 tested true (and n=5)
5
    [1] about to invoke numbers(3)
        [2] numbers(3) entered
        [2] L3 tested true (and n=3)
3
        [2] about to invoke numbers(1)
            [3] numbers(1) entered
            [3] L3 tested true (and n=1)
1
            [3] about to invoke numbers(-1)
                [4] numbers(-1) entered
                [4] L3 tested false (and n=-1)
                [4] numbers(-1) about to return
            [3] numbers(-1) just finished
1
            [3] numbers(1) about to return
        [2] numbers(1) just finished
3
        [2] numbers(3) about to return
    [1] numbers(3) just finished
5
    [1] numbers(5) about to return