字符串——面试考察高频算法题

转换成小写字母

字符串转化为整数

反转相关的问题

反转字符串

k个一组反转

仅仅反转字母

反转字符串里的单词

验证回文串

判断是否互为字符重排

最长公共前缀

字符串压缩问题

转换成小写字母

给你一个字符串 s ，将该字符串中的大写字母转换成相同的小写字母，返回新的字符串。

每个字母都是有确定的 ASCII的，因此我们可以根据码表操作字符串即可。

常见ASCII范围是：

a-z：97-122
A-Z：65-90
0-9：48-57

public static String toLowerCase(String s) {
    int n = s.length();
    char[] chars = s.toCharArray();
    for (int i = 0; i < n; ++i) {
        if (chars[i] >= 65 && chars[i] <= 90) {
            chars[i] += 32;
        }
    }
    String str = new String(chars);
    return str;
}

字符串转化为整数

请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数

函数 myAtoi(string s) 的算法如下：

空格：读入字符串并丢弃无用的前导空格（" "）

符号：检查下一个字符（假设还未到字符末尾）为 '-' 还是 '+'。如果两者都不存在，则假定结果为正。

转换：通过跳过前置零来读取该整数，直到遇到非数字字符或到达字符串的结尾。如果没有读取数字，则结果为0。

舍入：如果整数数超过 32 位有符号整数范围 [−2(31), 2(31 )− 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −2(31) 的整数应该被舍入为 −2(31) ，大于 2(31 )− 1 的整数应该被舍入为 2(31 )− 1 。

返回整数作为最终结果。

public static int myAtoi(String str) {
    int len = str.length();
    char[] charArray = str.toCharArray();
    // 1、去除前导空格
    int index = 0;
    while (index < len && charArray[index] == ' ') {
        index++;
    }
    
    // 2、如果已经遍历完成（针对极端用例 "      "）
    if (index == len) {
        return 0;
    }
    
    // 3、如果出现符号字符，仅第 1 个有效，并记录正负
    int sign = 1;
    char firstChar = charArray[index];
    if (firstChar == '+') {
        index++;
    } else if (firstChar == '-') {
        index++;
        sign = -1;
    }
    
    // 4、将后续出现的数字字符进行转换
    // 不能使用 long 类型，这是题目说的
    int res = 0;
    while (index < len) {
        char currChar = charArray[index];
        // 4.1 先判断不合法的情况
        if (currChar > '9' || currChar < '0') {
            break;
        }
    
        // 这是解决溢出问题的经典处理方式。
        if (res > Integer.MAX_VALUE / 10 || (res == Integer.MAX_VALUE / 10 && (currChar - '0') > Integer.MAX_VALUE % 10)) {
            return Integer.MAX_VALUE;
        }
        if (res < Integer.MIN_VALUE / 10 || (res == Integer.MIN_VALUE / 10 && (currChar - '0') > -(Integer.MIN_VALUE % 10))) {
            return Integer.MIN_VALUE;
        }
    
        // 合法的情况下，才考虑转换，每一步都把符号位乘进去
        // 想想这里为什么要带着sign乘
        res = res * 10 + sign * (currChar - '0');
        index++;
    }
    return res;
}

反转相关的问题

反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

一看就是双指针问题！太经典了！

public void reverseString(char[] s) {
       if (s == null || s.length() == 0) {
            return ;
        }
        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;
        }
    }

k个一组反转

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。

如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

反转每个下标从 2k的倍数开始的，长度为 k的子串。若该子串长度不足 k，则反转整个子串。

public String reverseStr(String s, int k) {
       if (s == null || s.length() == 0) {
            return s;
        }
        int n = s.length();
        char[] arr = s.toCharArray();
        for (int i = 0; i < n; i += 2 * k) {
            reverse(arr, i, Math.min(i + k, n) - 1);
        }
        return new String(arr);
    }

    public void reverse(char[] arr, int left, int right) {
        while (left < right) {
            char temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }

仅仅反转字母

给定一个字符串 S，返回 “反转后的” 字符串，其中不是字母的字符都保留在原地，而所有字母的位置发生反转。

示例1：

输入："ab-cd"

输出："dc-ba"

示例2：

输入："a-bC-dEf-ghIj"

输出："j-Ih-gfE-dCba"

示例3：

输入："Test1ng-Leet=code-Q!"

输出："Qedo1ct-eeLg=ntse-T!"

栈：将 s 中的所有字母单独存入栈中，所以出栈等价于对字母反序操作。（或者可以用数组存储字母并反序数组）然后，遍历 s 的所有字符，如果是字母我们就选择栈顶元素输出。
双指针：一个接一个输出 s 的所有字符。当遇到一个字母时，我们希望找到逆序遍历字符串的下一个字母。所以我们这么做：维护一个指针 j 从后往前遍历字符串，当需要字母时就使用它。

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();
    }
}

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();
    }
}

反转字符串里的单词

给你一个字符串 s ，逐个反转字符串中的所有单词。

单词是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的单词 分隔开。

请你返回一个反转 s 中单词顺序并用单个空格相连的字符串。

说明：

输入字符串 s 可以在前面、后面或者单词间包含多余的空格。
反转后单词间应当仅用一个空格分隔。
反转后的字符串中不应包含额外的空格。

示例1：

输入：s = "the sky is blue"

输出："blue is sky the"

示例2：

输入：s = "hello world"

输出："world hello"

解释：输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

public String reverseWords(String s) {
        if (s == null || s.length() == 0) {
            return s;
        }
        // 除去开头和末尾的空白字符，记住这个操作
        s = s.trim();
        // 正则匹配连续的空白字符作为分隔符分割
        List<String> wordList = Arrays.asList(s.split("\\s+"));
        Collections.reverse(wordList);
        return String.join(" ", wordList);
    }

class Solution {
    public String reverseWords(String s) {
        StringBuilder sb = trimSpaces(s);

        // 翻转字符串
        reverse(sb, 0, sb.length() - 1);

        // 翻转每个单词
        reverseEachWord(sb);

        return sb.toString();
    }

    public StringBuilder trimSpaces(String s) {
        int left = 0, right = s.length() - 1;
        // 去掉字符串开头的空白字符
        while (left <= right && s.charAt(left) == ' ') {
            ++left;
        }

        // 去掉字符串末尾的空白字符
        while (left <= right && s.charAt(right) == ' ') {
            --right;
        }

        // 将字符串间多余的空白字符去除
        StringBuilder sb = new StringBuilder();
        while (left <= right) {
            char c = s.charAt(left);

            if (c != ' ') {
                sb.append(c);
            } else if (sb.charAt(sb.length() - 1) != ' ') {
                sb.append(c);
            }

            ++left;
        }
        return sb;
    }

    public void reverse(StringBuilder sb, int left, int right) {
        while (left < right) {
            char tmp = sb.charAt(left);
            sb.setCharAt(left++, sb.charAt(right));
            sb.setCharAt(right--, tmp);
        }
    }

    public void reverseEachWord(StringBuilder sb) {
        int n = sb.length();
        int start = 0, end = 0;

        while (start < n) {
            // 循环至单词的末尾
            while (end < n && sb.charAt(end) != ' ') {
                ++end;
            }
            // 翻转单词
            reverse(sb, start, end - 1);
            // 更新start，去找下一个单词
            start = end + 1;
            ++end;
        }
    }
}

验证回文串

给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。

在第一次遍历时，我们使用哈希映射统计出字符串中每个字符出现的次数。在第二次遍历时，我们只要遍历到了一个只出现一次的字符，那么就返回它的索引，否则在遍历结束后返回 -1。

public int firstUniqChar(String s) {
       if (s == null || s.length() == 0) {
           return 0;
       }
       Map<Character, Integer> frequency = new HashMap<Character, Integer>();
       for (int i = 0; i < s.length(); ++i) {
           char ch = s.charAt(i);
           frequency.put(ch, frequency.getOrDefault(ch, 0) + 1);
       }
       for (int i = 0; i < s.length(); ++i) {
           if (frequency.get(s.charAt(i)) == 1) {
               return i;
           }
       }
       return -1;
   }

判断是否互为字符重排

给定两个字符串 s1 和 s2，请编写一个程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。

将两个字符串全部从小到大或者从大到小排列，然后再逐个位置比较
我们可以记录出现的次数，如果一个字符串经过重新排列后，能够变成另外一个字符串，那么它们的每个不同字符的出现次数是相同的。如果出现次数不同，那么表示两个字符串不能够经过重新排列得到。

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));
    }

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) || (int)s2Map.get(s1Char) != (int)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;
    }

最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 ""。

示例1：

输入：strs = ["flower","flow","flight"]

输出："fl"

示例2：

输入：strs = ["dog","racecar","car"]

输出：""

解释：输入不存在公共前缀。

竖着比较，每前进一个位置就比较各个串，看是不是都是相等的，只要在某一轮遇到一个不相等的，那么就结束。
横着比较，借鉴归并的思想，先两两一组找fix，然后将找到的fix再两两归并。依次遍历字符串数组中的每个字符串，对于每个遍历到的字符串，更新最长公共前缀（其实就是看是否要缩短，一定不会变长），当遍历完所有的字符串以后，即可得到字符串数组中的最长公共前缀。如果在尚未遍历完所有的字符串时，最长公共前缀已经是空串，则最长公共前缀一定是空串，因此不需要继续遍历剩下的字符串，直接返回空串即可。

public String longestCommonPrefix(String[] strs) {
        if (strs == null || strs.length == 0) {
            return "";
        }
        int length = strs[0].length();
        int count = strs.length;
        for (int i = 0; i < length; i++) {
            char c = strs[0].charAt(i);
            for (int j = 1; j < count; j++) {
                if (i == strs[j].length() || strs[j].charAt(i) != c) {
                    return strs[0].substring(0, i);
                }
            }
        }
        return strs[0];

public String longestCommonPrefix(String[] strs) {
    if (strs == null || strs.length == 0) {
        return "";
    }
    String prefix = strs[0];
    int count = strs.length;
    for (int i = 1; i < count; i++) {
        prefix = longestCommonPrefix(prefix, strs[i]);
        if (prefix.length() == 0) {
            break;
        }
    }
    return prefix;
}

public String longestCommonPrefix(String str1, String str2) {
    int length = Math.min(str1.length(), str2.length());
    int index = 0;
    while (index < length && str1.charAt(index) == str2.charAt(index)) {
        index++;
    }
    return str1.substring(0, index);
}

字符串压缩问题

给你一个字符数组 chars ，请使用下述算法压缩：

从一个空字符串 s 开始。对于 chars 中的每组连续重复字符：

如果这一组长度为 1 ，则将字符追加到 s 中。
否则，需要向 s 追加字符，后跟这一组的长度。压缩后得到的字符串 s 不应该直接返回，需要转储到字符数组 chars 中。需要注意的是，如果组长度为 10 或 10 以上，则在 chars 数组中会被拆分为多个字符。

请在修改完输入数组后，返回该数组的新长度。你必须设计并实现一个只使用常量额外空间的算法来解决此问题。

示例1：
输入：chars = ["a","a","b","b","c","c","c"]
输出：返回 6 ，输入数组的前 6 个字符应该是：["a","2","b","2","c","3"]
解释：
"aa" 被 "a2" 替代。"bb" 被 "b2" 替代。"ccc" 被 "c3" 替代。

示例2：
输入：chars = ["a"]
输出：返回 1 ，输入数组的前 1 个字符应该是：["a"]
解释：
没有任何字符串被替代。

示例3：
输入：chars = ["a","b","b","b","b","b","b","b","b","b","b","b","b"]
输出：返回 4 ，输入数组的前 4 个字符应该是：["a","b","1","2"]。
解释：
由于字符 "a" 不重复，所以不会被压缩。"bbbbbbbbbbbb" 被 “b12” 替代。
注意每个数字在数组中都有它自己的位置。

可以使用两个指针分别标志我们在字符串中读和写的位置，还要一个指针left用来标记重复字段的开始位置。read指针不断向前读取，每次当读指针 read 移动到某一段连续相同子串的最右侧，我们就在写指针 write 处依次写入该子串对应的字符和子串长度即可。当读指针read 位于字符串的末尾，或读指针read 指向的字符不同于下一个字符时，我们就认为读指针read 位于某一段连续相同子串的最右侧。该子串对应的字符即为读指针 read 指向的字符串。我们使用变量 left 记录该子串的最左侧的位置，这样子串长度即为 read−left+1。这里还有一个问题，就是长度可能超过10，因此还要实现将数字转化为字符串写入到原字符串的功能。这里我们采用短除法将子串长度倒序写入原字符串中，然后再将其反转即可。

public int compress(char[] chars) {
        int n = chars.length;
        int write = 0, left = 0;
        for (int read = 0; read < n; read++) {
            if (read == n - 1 || chars[read] != chars[read + 1]) {
                chars[write++] = chars[read];
                int num = read - left + 1;
                if (num > 1) {
                    int anchor = write;
                    while (num > 0) {
                        chars[write++] = (char) (num % 10 + '0');
                        num /= 10;
                    }
                    reverse(chars, anchor, write - 1);
                }
                left = read + 1;
            }
        }
        return write;
    }

    public void reverse(char[] chars, int left, int right) {
        while (left < right) {
            char temp = chars[left];
            chars[left] = chars[right];
            chars[right] = temp;
            left++;
            right--;
        }
    }
}