查找此递归函数的时间复杂度

Question

This algorithm is a bit nonsense because I reduced it to the basic scheme.

Basically, it takes a string as input, scan this string and create a new string that does not contain the first letter of the old string. Is that a O(n^2)? If you can justify the answer. Thank you.

recursiveProc(String myString){
    if(myString.length() >= 1){
        char firstLetter = myString.charAt(0);
        String newString = "";

        for(int i = 0; i < myString.length(); i++){
            if(myString.charAt(i) != firstLetter){
                newString = newString + myString.charAt(i);
            }
        }
        recursiveProc(newString);
    }}

Answer 1

It's actually worse than O(N^2) . Looks like O(N^3) .

Each recursive call will reduce the input String by at least one character, so there would be at most N recursive calls (in the worst case there would be exactly N recursive calls, each reducing the input String by exactly one character).

However, your loop takes O(N^2) , since it has O(N) iterations, and each iteration creates a new String whose length is not a constant.

Suppose you have the String "0123456789"

The first recursive call will remove the '0' character by creating the following String s:

"1"
"12"
"123"
"1234"
"12345"
"123456"
"1234567"
"12345678"
"123456789"

This would take O(N^2) time. And that's just the first recursive call.

You could improve it by using a StringBuilder instead of String concatenation to create the new String .

    StringBuilder sb = new StringBuilder(myString.length()-1);
    for(int i = 0; i < myString.length(); i++){
        if(myString.charAt(i) != firstLetter){
            sb.append(myString.charAt(i));
        }
    }
    recursiveProc(sb.toString());

In that case the loop would take O(N) (since each iteration of the loop does constant work) and the entire recursion would take O(N^2) .