回文算法的时空复杂度

Question

What is the time and space complexity of the following code for finding a palindrome in Java:

    public static boolean isPalindrome(String str) {
        return str.equals(new StringBuilder(str).reverse().toString());
    }

I know reverse() is O(n). toString() is also O(n). equals is also O(n). Does this mean that this code is O(n)?

As for space complexity, a StringBuilder needs to be created. I'm not sure what happens to it after it gets converted into a string. Does Java allocate space for the StringBuilder that was converted into a string, then forget about the StringBuilder (allowing it to be picked up by the garbage collector)?

Thanks!

---------- EDIT -------------

I want to know more about what is created on the stack after isPalindrome is called. How efficient is it space-wise compared to, say,

Thanks. I still don't really understand how efficient space-wise this code is though? What exactly will be created on the stack, And how efficient is it (in terms of space) compared to, say,

public boolean palindrome2(String str) {    
        int n = str.length();
        for( int i = 0; i < n/2; i++ )
            if (str.charAt(i) != str.charAt(n-i-1)) return false;
        return true;    
}

Answer 1

Assuming all these operations are really O(n), I'd say you are right: O(n) + O(n) + O(n) = 3 * O(n) (or O(3n), if you will), which then falls to O(n) category.

What comes to the StringBuilder - you create an anonymous instance and after the method isPalindrome ends, there are no references to the object as its scope is local only for this method. So yes, it will eventually be processed by garbage collector. Most likely not immediately, but I think that is none of your concern anyway.

Answer 2

public static boolean isPalindrome(String argument){    
    //remove special character    
    String done = argument.trim().replaceAll("[^a-zA-Z]+", " ");   
    //remove white spaces   
    String result = done.replaceAll("\\s", "");   
    //assign result string to argument   
    argument = result;   
    //convert string to a char then into a List of Charaters
    ArrayList<Character> characterList = (ArrayList<Character>) result.chars().mapToObj(c -> (char)c).collect(Collectors.toList());     
    //Using Collections reverse character List   
    Collections.reverse(characterList);
    //convert reversed List int a String    
    String reversedStr  = characterList.stream().map(String::valueOf).collect(Collectors.joining());   
    //Compare argument with reversedStr then return true or false   
    if(argument.equalsIgnoreCase(reversedStr))   
        return true;       

 public static boolean isPalindrome(String argument){
        //remove special character
        String done = argument.trim().replaceAll("[^a-zA-Z]+", " ");
        //remove white spaces
        String result = done.replaceAll("\\s", "");
        //assign result string to argument
        argument = result;
        //convert string to a char then into a List of Charaters
        ArrayList<Character> characterList = (ArrayList<Character>) result.chars().mapToObj(c -> (char)c).collect(Collectors.toList());
        //Using Collections reverse character List
        Collections.reverse(characterList);
        //convert reversed List int a String 
        String reversedStr  = characterList.stream().map(String::valueOf).collect(Collectors.joining());
        //Compare argument with reversedStr then return true or false
        if(argument.equalsIgnoreCase(reversedStr))
            return true;
        
        return false;
    }
    return false;   
}