Leetcode 刷题笔记(七) —— 字符串篇之经典题目

系列文章目录

一、 数组类型解题方法一：二分法
二、数组类型解题方法二：双指针法
三、数组类型解题方法三：滑动窗口
四、数组类型解题方法四：模拟
五、链表篇之链表的基础操作和经典题目
六、哈希表篇之经典题目
七、字符串篇之经典题目
八、字符串篇之 KMP
九、解题方法：双指针
十、栈与队列篇之经典题目
十 一、栈与队列篇之 top-K 问题
更新中 … …

---

刷题路线来自 ：代码随想录

题录

344. 反转字符串

Leetcode 链接
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 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”]
题解：
左右交换

class Solution {
    public void reverseString(char[] s) {
        int left = 0;
        int right = s.length - 1;
        while (left < right) {
        // 交换左右指针位置字符
            char ch = s[left];
            s[left] = s[right];
            s[right] = ch;
            // 左右指针向中间移动
            left++;
            right--;
        }
    }
}

541. 反转字符串 II

Leetcode 链接
给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。如果剩余字符少于 k 个，则将剩余字符全部反转。如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

示例 1：
输入：s = “abcdefg”, k = 2
输出：“bacdfeg”

示例 2：
输入：s = “abcd”, k = 2
输出：“bacd”
题解：
在上题的基础上，找到需要反转的开始和末尾位置

class Solution {
    public String reverseStr(String s, int k) {
        int len = s.length();
        char[] arr = s.toCharArray();
        // i 始终指向反转的起始位置，所以i每次需要加 2k, i += 2 * k
        for (int i = 0; i < len; i += 2 * k) {
        	// 需要反转的末尾位置为 i + k - 1；
            if ((i + k - 1) < len) {
            	// 末尾指针没越界
                reverse(arr, i, i + k - 1); 
            } else {
            	// 末尾指针越界，也就是剩余字符少于 k 个，反转剩下的字符      
                reverse(arr, i, len - 1);
            }
        }
        return String.valueOf(arr);
        //return new String(arr);
    }
	// 反转
    public void reverse(char[] arr, int l, int r) {
        while (l < r) {
            char ch = arr[l];
            arr[l] = arr[r];
            arr[r] = ch;
            l++;
            r--;
        }
    }
}

剑指 Offer 05. 替换空格

Leetcode 链接
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：
输入：s = “We are happy.”
输出：“We%20are%20happy.”
题解：
方式一：从头遍历拼接新的字符串

    public String replaceSpace(String s) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == ' ') {
                sb.append("%20");
            } else {
                sb.append(s.charAt(i));
            }
        }
        return String.valueOf(sb);
    }

方式二：双指针法，先根据空格个数扩容数组，再从后向前填充

class Solution {
    public String replaceSpace(String s) {
        int len = s.length();
        // 统计空格个数计算返回数组长度
        int count = 0;
        for (int i = 0; i < len; i++) {
            if (s.charAt(i) == ' ') count++;
        }
        // 扩容后的新数组
        char[] res = new char[len + count * 2];
		// j 始终指向新数组要填充位置，i 始终指向原数组拷贝位置
        int j = res.length - 1;
        for (int i = len - 1; i >= 0; i--) {
            char ch = s.charAt(i);
            if (ch != ' ') {
            	// 不是空格直接拷贝
                res[j--] = ch;
            } else {
            	/// 空格时填充 20%
                res[j--] = '0';
                res[j--] = '2';
                res[j--] = '%';
            }
        }
        return String.valueOf(res);
    }
}

151. 翻转字符串里的单词

Leetcode 链接
给你一个字符串 s ，逐个翻转字符串中的所有 单词 。单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。请你返回一个翻转 s 中单词顺序并用单个空格相连的字符串。

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

示例 1：
输入：s = “the sky is blue”
输出：“blue is sky the”

示例 2：
输入：s = " hello world "
输出：“world hello”
解释：输入字符串可以在前面或者后面包含多余的空格，但是翻转后的字符不能包括。

示例 3：
输入：s = “a good example”
输出：“example good a”
解释：如果两个单词间有多余的空格，将翻转后单词间的空格减少到只含一个。

示例 4：
输入：s = " Bob Loves Alice "
输出：“Alice Loves Bob”

示例 5：
输入：s = “Alice does not even like bob”
输出：“bob like even not does Alice”
题解：
方式一：根据空格分割字符串得到一个保存单词的数组，再从后向前拼接

    public String reverseWords(String s) {
    	// 1.去头尾空格
        s = s.trim();
        // 2.根据空格分割
        String[] arr = s.split(" ");
        // 3.拼接新的字符串
        StringBuilder sb = new StringBuilder();
        // 从后向前拼接
        for (int i = arr.length - 1; i > 0; i--) {
        	// 如果有连续空格 经空格分割后出现 “” 需要跳过
            if (arr[i] != "") {
            	// 拼接单词和新空格
                sb.append(arr[i]).append(' ');
            }
        }
        // 最后一个单词不需要拼接空格，单独进行拼接
        sb.append(arr[0]);
        return String.valueOf(sb);
    }

不用库函数版本：

class Solution {
    public String reverseWords(String s) {
        // 1.移除前后空格 s.trim();
        String str = removeSpace(s);
        // 2.根据空格分割  String[] arr = s.split(" ");
        List<String> list = splitBySpace(str);
        // 3.拼接新的字符串
        StringBuilder sb = new StringBuilder();
        for (int i = list.size() - 1; i > 0; i--) {
            if (list.get(i) != "") {
            	// 如果有连续空格 splitBySpace() 中前后指针指向同一个空格，substring(left, right)出现空串,这也是为什么使用split()出现 ”“ 的原因
                sb.append(list.get(i)).append(' ');
            }
        }
        sb.append(list.get(0));
        return String.valueOf(sb);
    }
    
    // 根据空格分割
    public List<String> splitBySpace(String s) {
    	// 因为数组创建时确定大小且不可改变，这里改为使用顺序表接受分割后的字符串
        List<String> list = new ArrayList<>();
        int left = 0;
        int right = left + 1;
        // 右指针找向后走
        for ( ; right < s.length(); right++) {
        	// 直到右指针遇到空格，添加子串
            if (s.charAt(right) == ' ') {
                list.add(s.substring(left, right));
                // 更新左指针位置，左指针指向下次子串的开头位置
                left = right + 1;
            }
        }
        // 最后右指针越界结束循环，还未添加最后一个子串，这里手动添加一下
        list.add(s.substring(left, right));
        return list;
    }

	// 去前后空格
    public String removeSpace(String s) {
        int left = 0;
        int right = s.length() - 1;
        while (s.charAt(left) == ' ') left++;
        while (s.charAt(right) == ' ') right--;
        // 返回子串
        return s.substring(left, right + 1);
    }
}

双反转法：
举个例子：源字符串为："the sky is blue "
移除多余空格 : “the sky is blue”
字符串反转：“eulb si yks eht”
单词反转：“blue is sky the”

    public String reverseWords(String s) {
        // 1.去除首尾和中间多余空格，上方法只是去前后空格
        StringBuilder sb = removeSpace(s);
        // 2.反转整个字符串
        reverseString(sb, 0, sb.length() - 1);
        // 3.反转各个单词
        reverseEachWord(sb);
        return String.valueOf(sb);
    }
	// 反转每个单词
    private void reverseEachWord(StringBuilder sb) {
        int l = 0;
        int r = l + 1;
        // n 为最大下标
        int n = sb.length() - 1;
        while (l <= n) {
        	// r 指向单词末尾
            while (r <= n && sb.charAt(r) != ' ') {
                r++;
            }
            //反转单词
            reverseString(sb, l, r - 1);
            // l指向单词开头，r从 l+1 开始找下一个结尾位置
            l = r + 1;
            r = l + 1;
        }
    }
	// 反转字符串
    private void reverseString(StringBuilder sb, int start, int end) {
        while(start < end) {
            char ch = sb.charAt(start);
            sb.setCharAt(start, sb.charAt(end));
            sb.setCharAt(end, ch);
            start++;
            end--;
        }
    }
	// 移除两头和中间空格
    private StringBuilder removeSpace(String s) {
        int l = 0;
        int r = s.length() - 1;
        // 1.去两头空格
        while (s.charAt(l) == ' ') l++;
        while (s.charAt(r) == ' ') r--;
        StringBuilder sb = new StringBuilder();
        // 2.去中间空格，使用 l遍历
        while (l <= r) {
        	// 如果 l 位置不为空格(拼接字母)，或者前一个位置不为空格(最多拼接一个空格，达到去中间多余空格的目的)进行拼接
            if (s.charAt(l) != ' ' || s.charAt(l - 1) != ' ') {
                sb.append(s.charAt(l));
            }
            l++;
        }
        return sb;
    }

剑指 Offer 58 - II. 左旋转字符串

Leetcode 链接
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

示例 1：
输入: s = “abcdefg”, k = 2
输出: “cdefgab”

示例 2：
输入: s = “lrloseumgh”, k = 6
输出: “umghlrlose”
题解：
方法一： 直接使用 substring 将字符串分开然后 append 拼接

class Solution {
    public String reverseLeftWords(String s, int n) {
        StringBuilder sb = new StringBuilder();
        // substring(l,r) 子串区间为[l,r)
        sb.append(s.substring(n, s.length())).append(s.substring(0, n));
        return String.valueOf(sb);
    }
}

方法二： 双反转
举个栗子： abcdefg 2 --> cdefgab
先分开反转：ab cdefg --> ba gfedc
再整体反转：ba gfedc --> edrfg ab

class Solution {
    public String reverseLeftWords(String s, int n) {
        StringBuilder sb = new StringBuilder(s);
        //sb.append(s.substring(n, s.length())).append(s.substring(0, n));
        // 1.分开反转
        reverseString(sb, 0, n - 1);
        reverseString(sb, n, s.length() - 1);
        // 2.整体反转
        sb.reverse();
        return String.valueOf(sb);
    }
	
	// 反转方法
    public void reverseString(StringBuilder sb, int l, int r) {
        while (l < r) {
            char ch = sb.charAt(l);
            sb.setCharAt(l, sb.charAt(r));
            sb.setCharAt(r, ch);
            l++;
            r--;
        }
    }
}

总结

1. 熟练使用库函数，但不要太依赖。
   substring() 子串区间为左闭右开，s小写。
   StringBuilder 中有 setCharAt 方法可以修改指定位置的值
   indexOf() 可以查找子串返回子串第一个字符下标
2. 反转系列，先整体反转再局部反转，实现了反转字符串里的单词，先局部反转再整体反转达到了左旋的效果。
3. 双指针，这里是先给数组扩容带填充后的大小，然后在从后向前进行操作用到双指针，很多数组填充类的问题都会用到，后边细讲