算法通关村 | 字符串反转问题

反转字符串

LeetCode344. 题目要求：编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

示例1：
输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]

示例2：
输入：s = ["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

这是最基本的反转题，也是最简单的问题，使用双指针方法最直接。具体做法是:
对于长度为 N 的待被反转的字符数组，我们可以观察反转前后下标的变化，假设反转前字符数组为 s[0] s[1] s[2] … s[N - 1]，那么反转后字符数组为 s[N - 1] s[N - 2] … s[0]。比较反转前后下标变化很容易得出 s[i] 的字符与 s[N - 1 - i] 的字符发生了交换的规律，因此我们可以得出如下双指针的解法：

• 将 left 指向字符数组首元素，right 指向字符数组尾元素。
• 当 left < right：
  • 交换 s[left] 和 s[right]；
  • left 指针右移一位，即 left = left + 1；
  • right 指针左移一位，即 right = right - 1。
• 当 left >= right，反转结束，返回字符数组即可。

public void reverseString(char[] s) {
    if (s == null || s.length() == 0) {
        return s;
    }
    int n = s.length;
    for (int left = 0, right = n - 1; left < right; ++left, --right) {
        char tmp = s[left];
        s[left] = s[right];
        s[right] = tmp;
    }
}

仅仅反转字母

LeetCode.917 这个题有点难度，我们来看一下：
给定一个字符串 S，返回 “反转后的” 字符串，其中不是字母的字符都保留在原地，而所有字母的位置发生反转。

示例1：
输入："ab-cd"
输出："dc-ba"

示例2：
输入："a-bC-dEf-ghIj"
输出："j-Ih-gfE-dCba"

示例3：
输入："Test1ng-Leet=code-Q!"
输出："Qedo1ct-eeLg=ntse-T!"

这里第一眼感觉不是特别复杂，同样从两头向中间即可，但问题是"-"不是均匀的有些划分的段长，有的短，这就增加了处理的难度。

方法1：使用栈

将 s 中的所有字母单独存入栈中，所以出栈等价于对字母反序操作。（或者，可以用数组存储字母并反序数组。）
然后，遍历 s 的所有字符，如果是字母我们就选择栈顶元素输出。

class Solution {
    public String reverseOnlyLetters(String S) {

        Stack<Character> letters = new Stack();
        for (char c: S.toCharArray())
            if (Character.isLetter(c))
                letters.push(c);

        StringBuilder ans = new StringBuilder();
        for (char c: S.toCharArray()) {
            if (Character.isLetter(c))
                ans.append(letters.pop());
            else
                ans.append(c); //当前位置是 "-"
        }

        return ans.toString();
    }
}

方法2：使用双转指针
一个接一个输出 s 的所有字符。当遇到一个字母时，我们希望找到逆序遍历字符串的下一个字母。
所以我们这么做：维护一个指针 j 从后往前遍历字符串，当需要字母时就使用它。

class Solution {
    public String reverseOnlyLetters(String S) {
        if (S == null || S.length() == 0) {
            return S;
        }
        StringBuilder ans = new StringBuilder();
        int j = S.length() - 1;
        for (int i = 0; i < S.length(); ++i) {
            if (Character.isLetter(S.charAt(i))) {
                while (!Character.isLetter(S.charAt(j)))
                    j--;
                ans.append(S.charAt(j--));
            } else {
                ans.append(S.charAt(i));
            }
        }

        return ans.toString();
    }
}

判定是否互为字符重排

这是一道典型的看似吓人 ，其实很简单的问题。
LeetCode242 给定两个字符串 s1 和 s2，请编写一个程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。

示例1：
输入: s1 = "abcadfhg", s2 = "bcafdagh"
输出: true 

示例2：
输入: s1 = "abc", s2 = "bad"
输出: false

这个题第一眼看，感觉是个排列组合的题目，然后如果使用排列的算法来处理， 难度会非常大，而且效果还不一定好。用简单的方式就能解决。
第一种方法：将两个字符串全部从小到大或者从大到小排列，然后再逐个位置比较，这时候不管两个原始字符串是什么，都可以判断出来。 代码也不复杂：

public boolean checkPermutation(String s1, String s2) {
    // 将字符串转换成字符数组
    char[] s1Chars = s1.toCharArray();
    char[] s2Chars = s2.toCharArray();
    // 对字符数组进行排序
    Arrays.sort(s1Chars);
    Arrays.sort(s2Chars);
    // 再将字符数组转换成字符串，比较是否相等
    return new String(s1Chars).equals(new String(s2Chars));
}

注意这里我们使用了不同语言的排序函数，你是否记得我们在数组一章提到过这个方法必须牢记。
第二种方法：使用Hash，注意这里我们不能简单的存是否已经存在，因为字符可能在某个串里重复存在例如"abac"。我们可以记录出现的次数，如果一个字符串经过重新排列后，能够变成另外一个字符串，那么它们的每个不同字符的出现次数是相同的。如果出现次数不同，那么表示两个字符串不能够经过重新排列得到。
这个代码逻辑不复杂，但是写起来稍微长一点：

public boolean checkPermutation(String s1, String s2) {
    if (s1.length() != s2.length()) {
        return false;
    }
    char[] s1Chars = s1.toCharArray();
    Map<Character, Integer> s1Map = getMap(s1);
    Map<Character, Integer> s2Map = getMap(s2);
    for (char s1Char : s1Chars) {
        if (!s2Map.containsKey(s1Char) || s2Map.get(s1Char) != s1Map.get(s1Char)) {
            return false;
        }
    }
    return true;
}

// 统计指定字符串str中各字符的出现次数，并以Map的形式返回
private Map<Character, Integer> getMap(String str) {
    Map<Character, Integer> map = new HashMap<>();
    char[] chars = str.toCharArray();
    for (char aChar : chars) {
        map.put(aChar, map.getOrDefault(aChar, 0) + 1);
    }
    return map;
}

leecode上面的题解

class Solution {
    public boolean isAnagram(String s, String t) {
        if(s.length() != t.length())
            return false;
        int[] alpha = new int[26];
        for(int i = 0; i< s.length(); i++) {
            alpha[s.charAt(i) - 'a'] ++;
            alpha[t.charAt(i) - 'a'] --;
        }
        for(int i=0;i<26;i++)
            if(alpha[i] != 0)
                return false;
        return true;
    }
}

剪枝后

public boolean isAnagram(String s, String t) {
    if(s.length() != t.length()) return false;
    int[] arr = new int[26];
    for(char c : s.toCharArray()) 
        ++arr[c - 'a'];
    for(char c : t.toCharArray()){
        --arr[c - 'a'];
        if(arr[c - 'a'] < 0) return false;
    }
    return true;
}