Reverse String | LeetCode OJ

1 最简单的实现方法，将字符串依次倒序复制到到另一字符串。但是该方法是Time Limit Exceeded的。时间复杂度为O(N);

---

2 另一方法，从字符串两端开始，依次交换。时间复杂度降为O(N/2);该方法Accepted。

public class Solution {
    public String reverseString(String s) {
        String re = "";
        char[] x = s.toCharArray();
        int left = 0, right = s.length()-1;
        while(left<right){
            char t = x[left];
            x[left++] = x[right];
            x[right--] = t;   
        }
        return String.valueOf(x);
    }
}

---

3 利用java reverse()方法，一行代码就可以解决。

public class Solution {
    public String reverseString(String s) {
        return new StringBuffer(s).reverse().toString();
    }
}

---

查看reverse()方法的源码。

    /**
     * Causes this character sequence to be replaced by the reverse of
     * the sequence. If there are any surrogate pairs included in the
     * sequence, these are treated as single characters for the
     * reverse operation. Thus, the order of the high-low surrogates
     * is never reversed.
     *
     * Let <i>n</i> be the character length of this character sequence
     * (not the length in {@code char} values) just prior to
     * execution of the {@code reverse} method. Then the
     * character at index <i>k</i> in the new character sequence is
     * equal to the character at index <i>n-k-1</i> in the old
     * character sequence.
     *
     * <p>Note that the reverse operation may result in producing
     * surrogate pairs that were unpaired low-surrogates and
     * high-surrogates before the operation. For example, reversing
     * "\u005CuDC00\u005CuD800" produces "\u005CuD800\u005CuDC00" which is
     * a valid surrogate pair.
     *
     * @return  a reference to this object.
     */
    public AbstractStringBuilder reverse() {
        boolean hasSurrogates = false;
        int n = count - 1;
        for (int j = (n-1) >> 1; j >= 0; j--) {
            int k = n - j;
            char cj = value[j];
            char ck = value[k];
            value[j] = ck;
            value[k] = cj;
            if (Character.isSurrogate(cj) ||
                Character.isSurrogate(ck)) {
                hasSurrogates = true;
            }
        }
        if (hasSurrogates) {
            reverseAllValidSurrogatePairs();
        }
        return this;
    }

    /** Outlined helper method for reverse() */
    private void reverseAllValidSurrogatePairs() {
        for (int i = 0; i < count - 1; i++) {
            char c2 = value[i];
            if (Character.isLowSurrogate(c2)) {
                char c1 = value[i + 1];
                if (Character.isHighSurrogate(c1)) {
                    value[i++] = c1;
                    value[i] = c2;
                }
            }
        }
    }

这里涉及到surrogate pair的概念。
参考百度百科的解释

Surrogate Pair是UTF-16中用于扩展字符而使用的编码方式，是一种采用四个字节(两个UTF-16编码)来表示一个字符。

结合上面代码块的注释部分，char在java中是16位的，刚好是一个UTF-16编码。而字符串中可能含有Surrogate Pair,但他们是一个单一完整的字符，只不过是用两个char来表示而已，因此在反转字符串的过程中Surrogate Pairs 是不应该被反转的。
可见，第二种方法是不够严谨的。但是Accpted了。