What is the most efficient algorithm for reversing a String in Java?

Question

I am wondering which way to reverse a string in Java that is most efficient. Should I use some sort of xor method? The easy way would be to put all the chars in a stack and put them back into a string again but I doubt that's a very efficient way to do it. And please do not tell me to use some built in function in Java. I am interested in learning how to do it not to use an efficient function but not knowing why it's efficient or how it's built up.

Answer 1

You said you don't want to do it the easy way, but for those Googling you should use StringBuilder.reverse:

String reversed = new StringBuilder(s).reverse().toString();

If you need to implement it yourself, then iterate over the characters in reverse order and append them to a StringBuilder. You have to be careful if there are (or can be) surrogate pairs, as these should not be reversed. The method shown above does this for you automatically, which is why you should use it if possible.

Answer 2

The following does not deal with UTF-16 surrogate pairs.

public static String reverse(String orig)
{
    char[] s = orig.toCharArray();
    int n = s.length;
    int halfLength = n / 2;
    for (int i=0; i<halfLength; i++)
    {
        char temp = s[i];
        s[i] = s[n-1-i];
        s[n-1-i] = temp;
    }
    return new String(s);
}

Answer 3

You say you want to know the most efficient way and you don't want to know some standard built-in way of doing this. Then I say to you: RTSL (read the source, luke):

This is the sourced code for AbstractStringBuilder#reverse which gets called by StringBuilder#reverse. I bet it does some stuff that you would not have considered for a robust reverse operation.

Answer 4

The fastest way would be to use the reverse() method on the StringBuilder or StringBuffer classes :)

If you want to implement it yourself, you can get the character array, allocate a second character array and move the chars, in pseudo code this would be like:

String reverse(String str) {
    char[] c = str.getCharArray
    char[] r = new char[c.length];
    int    end = c.length - 1

    for (int n = 0; n <= end; n++) {
        r[n] = c[end - n];
    }

    return new String(r);
}

You could also run half the array length and swap the chars, the checks involved slow things down probably.

Answer 5

If you do not want to use any built in function, you need to go back with the string to its component parts: an array of chars.

Now the question becomes what is the most efficient way to reverse an array? The answer to this question in practice also depends upon memory usage (for very large strings), but in theory efficiency in these cases is measured in array accesses.

The easiest way is to create a new array and fill it with the values you encounter while reverse iterating over the original array, and returning the new array. (Although with a temporary variable you could also do this without an additional array, as in Simon Nickersons answer).

In this way you access each element exactly once for an array with n elements. Thus giving an efficiency of O(n).

Answer 6

I'm not really sure by what you mean when you say you need an efficient algorithm.

The ways of reversing a string that I can think of are (they are all already mentioned in other answers):

1. Use a stack (your idea).

2. Create a new reversed String by adding characters one by one in reverse order from the original String to a blank String/StringBuilder/char[].

3. Exchange all characters in the first half of the String with its corresponding position in the last half (i.e. the ith character gets swapped with the (length-i-1)th character).

The thing is that all of them have the same runtime complexity: O(N). Thus it cannot really be argued that any one is any significantly better than the others for very large values of N (i.e. very large strings).

The third method does have one thing going for it, the other two require O(N) extra space (for the stack or the new String), while it can perform swaps in place. But Strings are immutable in Java so you need to perform swaps on a newly created StringBuilder/char[] anyway and thus end up needing O(N) extra space.

Answer 7

public class ReverseInPlace {

static char[] str=null;

public static void main(String s[]) {
  if(s.length==0)
    System.exit(-1);

   str=s[0].toCharArray();

   int begin=0;
   int end=str.length-1;

   System.out.print("Original string=");
   for(int i=0; i<str.length; i++){
     System.out.print(str[i]);
   }

   while(begin<end){
      str[begin]= (char) (str[begin]^str[end]);
      str[end]= (char)   (str[begin]^str[end]);
      str[begin]= (char) (str[end]^str[begin]);

      begin++;
      end--;       
   }

   System.out.print("\n" + "Reversed string=");
   for(int i=0; i<str.length; i++){
     System.out.print(str[i]);
   }

}

}