Java递归简单字符串

Question

The below code works just fine, it reverses a string.But, I do not understand how it works. I think it should return an empty string since each time we are calling reversedString(sub); it takes out the character at index 0, so we should end up with an empty string at the end.

import components.simplewriter.SimpleWriter;
import components.simplewriter.SimpleWriter1L;


public final class HelloWorld {




    private static String reversedString(String s) {
        if (s.length() == 0) {
            return s;
        } else {
            String sub = s.substring(1);
            String revSub = reversedString(sub);
            String result = revSub + s.charAt(0);
            return result;
        }
    }


    public static void main(String[] args) {
        SimpleWriter out = new SimpleWriter1L();
        out.println(reversedString("Banana"));

        out.close();
    }

}

Answer 1

I've heard you like visualizations:

reversedString("Banana");
\----------------------/
          |
    /---------------------------\
    reversedString("anana") + "B";
    \---------------------/
              |        
        /--------------------------\
        reversedString("nana") + "a" + "B";
        \--------------------/
                  |
            /-------------------------\
            reversedString("ana") + "n" + "a" + "B";
            \-------------------/
                      |
                /------------------------\
                reversedString("na") + "a" + "n" + "a" + "B";
                \------------------/
                          |
                    /-----------------------\
                    reversedString("a") + "n" + "a" + "n" + "a" + "B";
                    \-----------------/
                              |
                        /----------------------\
                        reversedString("") + "a" + "n" + "a" + "n" + "a" + "B";
                        \----------------/
                                  |
                                 /-\
                                  "" 

Answer 2

Sometimes, it helps to just print the values rather than return them.

reverse("Reversed");

    
public static void reverse(String s) {
    if (s.length() > 1) {
        reverse(s.substring(1));
        // returns will emerge from this location
        // just like any other return. After the
        // point at which the method was called. 
    }
    System.out.print(s.charAt(0));
}

prints

desreveR

If you move the print statement to the first position in the method, it will print in normal order.

The thing to remember is that for each call of the method, the previous value is stored on the call stack. So when it eventually returns, each modification of the string is returned in the opposite order. So here is what happens if you change the method to the following:

public static void reverse(String s) {
    System.out.println("Entered method via call : s = " + s);
    if (s.length() > 1) {
        reverse(s.substring(1));
        // returns will emerge from this location
        // just like any other return. After the
        // point at which the method was called. 
    }
    // first time this point is reached
    // s only contains one character.
    System.out.println("Returning : s = " + s);
}

Prints

Entered method via call : s = Reversed
Entered method via call : s = eversed
Entered method via call : s = versed
Entered method via call : s = ersed
Entered method via call : s = rsed
Entered method via call : s = sed
Entered method via call : s = ed
Entered method via call : s = d
Returning : s = d
Returning : s = ed
Returning : s = sed
Returning : s = rsed
Returning : s = ersed
Returning : s = versed
Returning : s = eversed
Returning : s = Reversed