【剑指Offer】字符串

---

励志：

Why waste precious time dreaming when waking life is so much better.
人生之美醒时现，何必耽梦负韶华。

1.反转字符串

Leetcode344.

Write a function that reverses a string. The input string is given as an array of characters s.

题目大意：

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

示例 1：

输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]

示例 2：

输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

图解：

AC代码：

class Solution {
    public void reverseString(char[] s) {
        int len = s.length;
        for(int i = 0; i < len/2; i++){
            char temp = s[i];
            s[i] = s[len - 1 - i];
            s[len - 1 - i] = temp;
        }
    }
}

时间复杂度：O（N）遍历数组长度
空间复杂度：O（1）

// 更好的体现双指针模板
class Solution {
    public void reverseString(char[] s) {
        int len = s.length; 
        int left = 0;
        int right = len - 1;
        while(left < right){
            char temp = s[left];
            s[left] = s[right];
            s[right] = temp;
            left++;
            right--;
        }
    }
}

2. 整数反转

Leetcode7.

Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-231, 231 - 1], then return 0.

题目大意：

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

示例 1：

输入：x = 123
输出：321

示例 2：

输入：x = -123
输出：-321

示例 3：

输入：x = 120
输出：21

示例 4：

输入：x = 0
输出：0

提示：

-231 <= x <= 231 - 1

思路：判断整数是否溢出+整数反转
图解：

对于int整数型：取值范围应为

判定条件，我们可以简化为：

Ps：Integer.MIN_VALUE、Integer.MAX_VALUE

---

AC代码：
法一：

class Solution {
    public int reverse(int x) {
        int res = 0;
        while(x!=0){
            // 整数溢出
            if(res < Integer.MIN_VALUE/10 || res > Integer.MAX_VALUE/10){
                return 0;
            }
            int rem = x % 10;
            res = res*10 + rem ;
            x /= 10;
        }
        return res;
    }
}

法二：

class Solution {
    public int reverse(int x) {
        int res = 0;
        while(x!=0){
       		 int rem = x % 10;
       		 int newRes = res*10 + rem ;
            // 整数溢出
            if(newRes/10 != res){
                return 0;
            }
            res = newRes;       
            x /= 10;
        }
        return res;
    }
}

3.字符串中的第一个唯一字符

Leetcode387.

Given a string s, find the first non-repeating character in it and return its index. If it does not exist, return -1.

题目大意：

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

示例：

s = "leetcode"
返回 0

s = "loveleetcode"
返回 2

两次遍历：

思路：统计次数+寻找一次
AC代码：

class Solution {
    public int firstUniqChar(String s) {
        // 将字符串转化成字符数组
        char[] ss = s.toCharArray();
        int len = ss.length;
        // 统计字符出现的次数
        int[] count = new int[26];
        for(int i = 0; i < len; i++){
            count[ss[i] - 'a'] ++;
        }
        // 查找出现过一次的字符
        for(int i = 0; i < len; i++){
            if(count[ss[i] - 'a'] == 1) {
                return i;
            }
        }
        return -1;
    }
}

使用Java的API

思路：
charAt(i) 函数 是获取字符串中第i位置的字符.
图解：

AC代码：

class Solution {
    public int firstUniqChar(String s) {
        int len = s.length();
        for(int i = 0; i < len; i++){
            if(s.indexOf(s.charAt(i)) == s.lastIndexOf(s.charAt(i))){
                return i;
            }
        }
        return -1;
    }
}

4.有效的字母异位词

Leetcode242.

Given two strings s and t, return true if t is an anagram of s, and false otherwise.

题目大意：

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

---

若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

---

思路：字符串→字符数组→排序→比对
AC代码：

class Solution {
    public boolean isAnagram(String s, String t) {
        if(s.length() != t.length()){
            return false;
        }
        char[] s1 = s.toCharArray();
        char[] s2 = t.toCharArray();
        Arrays.sort(s1);
        Arrays.sort(s2);
        return Arrays.equals(s1,s2);
    }
}

5.验证回文串

Leetcode125.

Given a string s, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.

题目大意：

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

示例 1:

输入: "A man, a plan, a canal: Panama"
输出: true
解释："amanaplanacanalpanama" 是回文串

示例 2:

输入: "race a car"
输出: false
解释："raceacar" 不是回文串

提示：

1 <= s.length <= 2 * 105
字符串 s 由 ASCII 字符组成

双指针

思路：
双指针+跳过非数字字母+字母统一小写
AC代码：

class Solution {
    public boolean isPalindrome(String s) {
        if(s == null){
            return true;
        }
        s = s.toLowerCase(); // 全部转化成小写
        int len = s.length();
        int left = 0;
        int right = len - 1;
        while(left < right){
        	// 跳过非数字字母
            while(left < right && !Character.isLetterOrDigit(s.charAt(left))){
                left++;
            }
            while(left < right && !Character.isLetterOrDigit(s.charAt(right))){
                right--;
            }
            if(s.charAt(left) != s.charAt(right)){
            return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

正则匹配

class Solution {
    public boolean isPalindrome(String s) {
        s = s.replaceAll("[^a-zA-Z0-9]","").toLowerCase();
        String s1 = new StringBuffer(s).reverse().toString();
        return s.equals(s1);
    }
}

6. 字符串转换整数 (atoi)

Leetcode8.

Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer (similar to C/C++'s atoi function).

题目大意：

实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。
函数 myAtoi(string s) 的算法如下：

• 读入字符串并丢弃无用的前导空格
• 检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
• 读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
• 将前面步骤读入的这些数字转换为整数（即，“123” -> 123， “0032” -> 32）。如果没有读入数字，则整数为 0。必要时更改符号（从步骤 2 开始）。
• 如果整数数超过 32 位有符号整数范围 [−2^31, 2^31 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于−2^31 的整数应该被固定为 −2^31 ，大于 2^31 − 1 的整数应该被固定为 2^31 − 1 。
• 返回整数作为最终结果。

注意：

本题中的空白字符只包括空格字符 ' ' 。
除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。

AC代码：
法一：

 public int myAtoi(String str) {
        str = str.trim();//去掉前后的空格
		int len = str.length(); 	
        if (len == 0){
			return 0;
		}
        int index = 0;
        int res = 0;
        int sign = 1;//符号，1是正数，-1是负数，默认为正数
        //判断符号
        if (str.charAt(index) == '-' || str.charAt(index) == '+')	
            sign = str.charAt(index) == '+' ? 1 : -1;
         index++;
        for (; index < len; ++index) {
            int digit = str.charAt(index) - '0';
            if (digit < 0 || digit > 9)
                break;
            //越界处理
            if (res > Integer.MAX_VALUE / 10 || (res == Integer.MAX_VALUE / 10 && digit > Integer.MAX_VALUE % 10))
             return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
           
           res = res * 10 + digit;
        }
        return sign * res;
    }

法二：

class Solution {
    public int myAtoi(String s) {
        s = s.trim(); // 去除首尾空格
        int len = s.length();
        if(len == 0){
            return 0;
        }
        int index = 0;
        int sign = 1; // 默认正数
        int res = 0;
        // 判断符号，没有符号默认正数
        if(s.charAt(index) == '-' || s.charAt(index) == '+'){
            sign = s.charAt(index) == '+' ? 1 : -1;
            index++;
        }
        // 判断数字  
        for(; index < len; index++){
            int digit = s.charAt(index) - '0';
            // 判断当前是否为数字
            if( digit< 0 || digit > 9){
                break;
            }
            int newRes = res * 10 + digit;
            // 越界处理,数字在0-9之间所以，可以/10忽略
            if(newRes/10 != res){
                return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
            }else{
                res = newRes;
            }
        }
        return sign * res;
    }
}

7. 实现 strStr()

Leetcode28.

Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

题目大意：

给两个字符串 haystack 和 needle ，在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。

使用Java的API

AC代码：

class Solution {
    public int strStr(String haystack, String needle) {
        return haystack.indexOf(needle);
    }
}

双指针

思路：双指针 +一一比对
AC代码：

class Solution {
    public int strStr(String haystack, String needle) {
        int len1 = haystack.length();
        int len2 = needle.length();
        if(len2 == 0){
            return 0;
        }
        int p = 0; // haystack
        int q = 0; // needle
        while(p < len1 && q < len2){
            if(haystack.charAt(p) == needle.charAt(q)){
                p++;
                q++;
            }else{ // 若不匹配,指针回退,p:原位的下一位,q:0位
                p = p - q + 1; // p = (p - q) + 1
                q = 0;  // q = q - q
            }
            // 全部匹配
            if(q == len2){
                return p - q;
            }
        }
        return -1;
    }
}

KMP算法

图解：



补充，next数组储存的是前缀==后缀，缀的长度

AC代码：

class Solution {
    public int strStr(String haystack, String needle) {
        int len1 = haystack.length();
        int len2 = needle.length();
        if(len2 == 0){
            return 0;
        }
        // 放个哨兵
        haystack = " " + haystack;
        needle = " " + needle;
        char[] s1 = haystack.toCharArray();
        char[] s2 = needle.toCharArray();
        // 构造next[]
        int[] next = new int[len2 + 1];
        // 从第二个开始，第一个默认为0
        for(int i = 2, j = 0; i <= len2; i++){
            // 不匹配
            while(s2[i] != s2[j + 1] && j > 0){
                j = next[j];
            }
            // 匹配成功
            if(s2[i] == s2[j + 1]){
                j++; 
            }
            next[i] = j;
        }

        // 两字符串匹配
        for(int i = 1, j = 0; i <= len1; i++){
            // 不匹配
            while(s1[i] != s2[j + 1] && j > 0){
                j = next[j];
            }
            // 匹配成功
            if(s1[i] == s2[j + 1]){
                j++;
            }
            if(j == len2){
                return i - j;
            }
        }
        return -1;
    }
}

8. 外观数列

Leetcode38.

The count-and-say sequence is a sequence of digit strings defined by the recursive formula

题目大意：

给定一个正整数 n ，输出外观数列的第 n 项。

「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。

1.     1
2.     11
3.     21
4.     1211
5.     111221
第一项是数字 1 
描述前一项，这个数是 1 即 “ 一 个 1 ”，记作 "11"
描述前一项，这个数是 11 即 “ 二 个 1 ” ，记作 "21"
描述前一项，这个数是 21 即 “ 一 个 2 + 一 个 1 ” ，记作 "1211"
描述前一项，这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ，记作 "111221"

要 描述 一个数字字符串，首先要将字符串分割为 最小 数量的组，每个组都由连续的最多 相同字符 组成。然后对于每个组，先描述字符的数量，然后描述字符，形成一个描述组。要将描述转换为数字字符串，先将每组中的字符数量用数字替换，再将所有描述组连接起来。

例如，数字字符串 “3322251” 的描述如下图：

示例 1：

输入：n = 1
输出："1"
解释：这是一个基本样例。

示例 2：

输入：n = 4
输出："1211"
解释：
countAndSay(1) = "1"
countAndSay(2) = 读 "1" = 一 个 1 = "11"
countAndSay(3) = 读 "11" = 二 个 1 = "21"
countAndSay(4) = 读 "21" = 一 个 2 + 一 个 1 = "12" + "11" = "1211"

提示：

1 <= n <= 30
思路：递归 (每次的结果都与上一次的结果有关)
AC代码：

class Solution {
    public String countAndSay(int n) {
        // 递归出口
        if(n==1){
            return "1";
        }
        // 上一次的结果
        String s1 = countAndSay(n - 1);
        // 结果
        StringBuilder res = new StringBuilder();
        // 从第一个开始比对
        char local = s1.charAt(0);
        int count = 1;
        for (int i = 1; i < s1.length(); i++) {
            // 同一个数字出现的次数 count
            if(s1.charAt(i) == local){
                count++;
            }else {
                // 不符合
                res.append(count);
                res.append(local);
                count = 1;
                local = s1.charAt(i);
            }
        }
        // 追加剩下的最后一次
        res.append(count);
        res.append(local);
        return res.toString();
    }
}

9. 最长公共前缀

Leetcode14.

Write a function to find the longest common prefix string amongst an array of strings.

题目大意：

编写一个函数来查找字符串数组中的最长公共前缀。

示例 1：

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

示例 2：

输入：strs = ["dog","racecar","car"]
输出：""
解释：输入不存在公共前缀。

提示：

0 <= strs.length <= 200
0 <= strs[i].length <= 200
strs[i] 仅由小写英文字母组成

AC代码：

class Solution {
    public String longestCommonPrefix(String[] strs) {
        int len = strs.length;
        if (strs == null || len == 0)
           return "";
        // 假设第一个为公共前缀
        String str = strs[0];
        for(int i = 1; i < len; i ++){
            // 逐一比对取共同
            while(strs[i].indexOf(str) != 0){
                str = str.substring(0, str.length() - 1);
            }
        }
        return str;
    }
}

总结