代码随想录算法训练营day08| LeetCode 344 反转字符串 、LeetCode 541 反转字符串 II、剑指 Offer 05 替换空格、LeetCode 151 反转字符串中的单词

LeetCode 344 反转字符串

题目链接：https://leetcode.cn/problems/reverse-string/
视频讲解：https://www.bilibili.com/video/BV1fV4y17748/

题目描述： 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 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) {
        for(int i = 0, j = s.length - 1; i < s.length / 2; i++,j--){
            char temp = s[i];
            s[i] = s[j];
            s[j] = temp;
        }
    }
}

LeetCode 541 反转字符串 II

题目链接：https://leetcode.cn/problems/reverse-string-ii/
视频讲解：https://www.bilibili.com/video/BV1dT411j7NN/

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

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

示例2：输入：s = “abcd”, k = 2
输出：“bacd”

思路：题目的意思其实概括为 每隔2k个反转前k个，尾数不够k个时候全部反转，主要是确定反转的区间，然后就是常规的反转字符串。

class Solution {
    public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        for(int i = 0; i < ch.length; i += 2 * k){
            int start = i;
            // 判断尾数够不够k个来取决end指针的位置
            int end = Math.min(ch.length - 1, start + k -1);
            while(start < end){//反转
                char temp = ch[start];
                ch[start] = ch[end];
                ch[end] = temp;
                start++;
                end--;
            }
        }
        return new String(ch);
    }
}

剑指 Offer 05 替换空格

题目链接：https://leetcode.cn/problems/ti-huan-kong-ge-lcof/

题目描述：请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例1：输入：s = “We are happy.”
输出：“We%20are%20happy.”

解法1：双指针法

思路：如果想把这道题目做到极致，就不要只用额外的辅助空间了！首先扩充数组到每个空格替换成"%20"之后的大小。然后从后向前替换空格，也就是双指针法，过程如下：i指向新长度的末尾，j指向旧长度的末尾。

为什么要从后向前填充，从前向后填充不行么？
从前向后填充就是O(n^2)的算法了，因为每次添加元素都要将添加元素之后的所有元素向后移动。

其实很多数组填充类的问题，都可以先预先给数组扩容带填充后的大小，然后在从后向前进行操作。

这么做有两个好处：

• 不用申请新数组。
• 从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。
  （来自Carl哥的代码随想录）

class Solution {
    public String replaceSpace(String s) {
        if(s == null || s.length() == 0){
            return s;
        }
        //扩充空间，空格数量2倍
        StringBuilder str = new StringBuilder();
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) == ' '){
                str.append("  ");
            }
        }
        if(str.length() == 0){//若是没有空格直接返回
            return s;
        }
        //有空格情况 定义两个指针
        int left = s.length() - 1;//左指针：指向原始字符串最后一个位置
        s += str.toString();
        int right = s.length() - 1;//右指针：指向扩展字符串的最后一个位置
        char[] chars = s.toCharArray();
        while(left >= 0){
            if(chars[left] == ' '){
                chars[right--] = '0';
                chars[right--] = '2';
                chars[right] = '%';
            }else{
                chars[right] = chars[left];
            }
            left--;
            right--;
        }
        return new String(chars);
    }
}

解法2

思路：使用一个新的对象，复制 str，复制的过程对其判断，是空格则替换，否则直接复制，类似于数组复制。

class Solution {
    public String replaceSpace(String s) {
        if(s == null){
            return null;
        }
        StringBuilder sb = new StringBuilder();
        //使用 sb 逐个复制 s ，碰到空格则替换，否则直接复制
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) == ' '){
                sb.append("%20");
            }else{
                sb.append(s.charAt(i));
            }
        }
        return sb.toString();
    }
}

LeetCode 151 反转字符串中的单词

题目链接：https://leetcode.cn/problems/reverse-words-in-a-string/
视频讲解：https://www.bilibili.com/video/BV1uT41177fX/

题目描述：给你一个字符串 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”
解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。

思路：我们将整个字符串都反转过来，那么单词的顺序指定是倒序了，只不过单词本身也倒序了，那么再把单词反转一下，单词不就正过来了。
所以解题思路如下：

• 移除多余空格
• 将整个字符串反转
• 将每个单词反转

举个例子，源字符串为："the sky is blue "

• 移除多余空格 : “the sky is blue”
• 字符串反转：“eulb si yks eht”
• 单词反转：“blue is sky the”

这样我们就完成了翻转字符串里的单词。

解法1：

class Solution {
    public String reverseWords(String s) {
        // 1.去除首尾以及中间多余空格
        StringBuilder sb = removeSpace(s);
         // 2.反转整个字符串
         reverseString(sb, 0, sb.length() - 1);
          // 3.反转各个单词
          reverseEachWord(sb);
          return sb.toString();
    }
    private StringBuilder removeSpace(String s){
        int start = 0;
        int end = s.length() - 1;
        while(s.charAt(start) == ' ')start++;
        while(s.charAt(end) == ' ')end--;
        StringBuilder sb = new StringBuilder();
        while(start <= end){
            char c = s.charAt(start);
            if(c != ' ' || sb.charAt(sb.length() - 1) != ' '){
                sb.append(c);
            }
            start++;
        }
        return sb;
    }
    //反转字符串指定区间[start, end]的字符
    public void reverseString(StringBuilder sb, int start, int end){
        while(start < end){
            char temp = sb.charAt(start);
            sb.setCharAt(start, sb.charAt(end));
            sb.setCharAt(end, temp);
            start++;
            end--;
        }   
    }
    private void reverseEachWord(StringBuilder sb){
        int start = 0; 
        int end = 1;
        int n = sb.length();
        while(start < n){
            while(end < n && sb.charAt(end) != ' '){
                end++;
            }
            reverseString(sb, start, end - 1);
            start = end + 1;
            end = start + 1;
        }
    }
}

解法2：双反转+移位

class Solution {
    public String reverseWords(String s) {
        //步骤1：字符串整体反转（此时其中的单词也都反转了）
        char[] initialArr = s.toCharArray();
        reverse(initialArr, 0, s.length() - 1);
        int k = 0;
        for(int i = 0; i < initialArr.length; i++){
            if(initialArr[i] == ' '){
                continue;
            }
            int tempCur = i;
            while(i < initialArr.length && initialArr[i] != ' '){
                i++;
            }
            for(int j = tempCur; j < i; j++){
                if(j == tempCur){//步骤二：二次反转
                    reverse(initialArr, tempCur, i - 1);
                }
                //步骤三：移动操作
                initialArr[k++] = initialArr[j];
                if(j == i - 1){
                    if(k < initialArr.length){
                        initialArr[k++] = ' ';
                    }
                }
            }
        }
        if(k == 0){
            return "";
        }else{
            return new String(initialArr, 0, (k == initialArr.length) && initialArr[k - 1] != ' ' ? k : k - 1);
        }
    }
    public void reverse(char[] chars, int begin, int end){
        for(int i = begin, j = end; i < j; i++, j--){
            char temp = chars[begin];
            chars[begin] = chars[end];
            chars[end] = temp;
            begin++;
            end--;
        }
    }
}

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

题目链接：https://leetcode.cn/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/

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

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

示例2：输入: s = “lrloseumgh”, k = 6
输出: “umghlrlose”

思路：这题可以通过局部反转+整体反转 达到左旋转的目的。
具体步骤为：

• 反转区间为前n的子串
• 反转区间为n到末尾的子串
• 反转整个字符串
  

class Solution {
    public String reverseLeftWords(String s, int n) {
        char[] chars = s.toCharArray();
        reverse(chars, 0, chars.length - 1);//整个字符串反转
        reverse(chars, 0, chars.length - 1 - n);//反转前面的
        reverse(chars, chars.length - n, chars.length - 1);//反转后面 n 个
        return new String(chars);
    }
    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--;
        }
    }
}

总结：今天的题量有点多，第四题还是有点懵，还是没理解到位，需要复盘。