代码随想录(day08)-LeetCode：344、541、剑指Offer05、151、剑指Offer58-II

1. 【344】反转字符串

【力扣题目链接】：344

【题目描述】：

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 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"]

【提示】：

• 1 <= s.length <= 10^5
• s[i] 都是 ASCII 码表中的可打印字符

---

讨论：若在现场面试中，什么时候使用库函数，什么时候不要用库函数呢？

• **若题目关键的部分直接用库函数就可以解决，建议不要使用库函数。**毕竟面试官一定不是考察你对库函数的熟悉程度， 如果使用python和java 的同学更需要注意这一点，因为python、java提供的库函数十分丰富。
• 若库函数仅仅是解题过程中的一小部分，并且你已经很清楚这个库函数的内部实现原理的话，可以考虑使用库函数。

双指针法

在反转链表中，使用了双指针的方法。而在反转字符串依然是使用双指针的方法，只不过对于字符串的反转，其实要比链表简单一些。

因为字符串也是一种数组，所以元素在内存中是连续分布，这就决定了反转链表和反转字符串方式上还是有所差异的。

对于字符串，我们定义两个指针（也可以说是索引下标），一个从字符串前面，一个从字符串后面，两个指针同时向中间移动，并交换元素。

【代码实现】：

class Solution {
    public void reverseString(char[] s) {
        int left = 0; 
        int right = s.length - 1;
        while (left < right) {
            // 前后元素交换
            char temp = s[left];
            s[left] = s[right];
            s[right] = temp;

            //指针移动
            left++;
            right--;
        }

    }
}

---

2. 【541】反转字符串II

【力扣题目链接】：541

【题目描述】：

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

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

【示例1】：

输入：s = "abcdefg", k = 2
输出："bacdfeg"

【示例2】：

输入：s = "abcd", k = 2
输出："bacd"

【提示】：

• 1 <= s.length <= 10^4
• s 仅由小写英文组成
• 1 <= k <= 10^4

---

【解题思路】：

常规的处理逻辑，每隔2k个字符的前k的字符，写了一堆逻辑代码或者再搞一个计数器，来统计2k，再统计前k个字符。

其实在遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动2 * k就可以了，然后判断是否需要有反转的区间。因为要找的也就是每2 * k 区间的起点，这样写，程序会高效很多。

【代码实现】：

class Solution {
    public String reverseStr(String s, int k) {
        // 将s转为char型数组
        char[] ch = s.toCharArray();
        // 1.每2k个字符间的前k个字符进行反转
        // i指向数组中每个2k的下标
        for (int i = 0; i < ch.length; i += 2 * k) { 
            // 2.剩余字符小于2k但大于或或等于k个，则反转前k个字符
            if (i + k <= ch.length){
                reverse(ch, i , i + k - 1);
                continue;
            }

            // i + k > ch.lenght; 
            // 3.剩余字符小于k个，则将剩余字符全部反转
            reverse(ch, i, ch.length - 1);
        }
        return new String(ch);

    }

    // 自定义reverse函数，反转数组中第i下标开始，第j下标结束的字符
    public void reverse(char[] ch, int i, int j) {
        // i, j表示的是字符数组的下标
        for (; i < j; i++, j--) { //注意终止条件为：i < j
            char temp = ch[i];
            ch[i] = ch[j];
            ch[j] = temp;
        }
    }
}

---

3. 【剑指Offer：05】替换空格

【力扣题目链接】：剑指Offer 05

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

【示例1】：

输入：s = "We are happy."
输出："We%20are%20happy."

【限制】：0 <= s 的长度 <= 10000

---

双指针算法

【解题思路】：

若想把该题做到极致，就不要只用额外的辅助空间了！

首先扩充数组大小到每个空格被替换为"%20"之后的大小。然后从后向前替换空格，也就是双指针法。right指向新长度的末尾，left指向旧长度的末尾 。

思考：为什么要从后向前替换空格，而非从前向后？

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

• 不用申请新数组。
• 从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

【代码实现】：

class Solution {
    public String replaceSpace(String s) {
        int sOldLen = s.length(); // 原字符串长度
        // 统计原字符串中空格的个数并扩容
        // 1个空格替换为20%后，容量增加了2
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == ' ') {
                str.append("  ");
            }
        }
        // 扩容后的新字符串
        s += str.toString();
        int sNewLen = s.length();
        char[] ch = s.toCharArray();
        // 从后向前将空格替换为20%
        // 注意判断条件为:left < right
        for (int left = sOldLen - 1, right = sNewLen - 1; left < right; left--, right--) {
            if (ch[left] != ' ') { //为空格的情况
                ch[right] = ch[left];
            } else { // 不为空格的情况
                ch[right] = '0';
                ch[right - 1] = '2';
                ch[right - 2] = '%';
                right -= 2; //一定要注意right的移动大小
            }
        }
        return new String(ch);

    }
}

---

4. 【151】翻转字符串里的单词

【力扣题目链接】：151

【题目描述】：

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

【提示】：

• 1 <= s.length <= 10^4
• s 包含英文大小写字母、数字和空格 ' '
• s 中 至少存在一个 单词

---

补充：为了达到更好的性能，假设要求解题算法的空间复杂度为：O(1)，即不使用辅助空间。同时，不使用split等库函数，在原字符串上实现相关的操作。

【解题思路】：

• 移除多余空格

• 将整个字符串反转

• 将每个单词反转

【示例】：原字符串为：“the sky is blue”

1.移除多余空格 : "the sky is blue"
2.字符串反转："eulb si yks eht"
3.单词反转："blue is sky the"

【代码实现】：

class Solution {
    public String reverseWords(String s) {
        // 双指针算法实现，时间复杂度为O(n)

        char[] chars = s.toCharArray();
        // 1.去除首位及空间多余的空格
        chars = removeExtraSpace(chars); //chars指向去了多余空格后的数组
        // 2.整个字符串反转
        reverse(chars, 0, chars.length -1);
        // 3.单词反转
        reverseWords(chars);
        return new String(chars);
    }

    // 1.【去除多余空格的函数】
    // 整个过程可画图理解，如原字符串为："  HI  Bob  "
    public char[] removeExtraSpace(char[] chars) {
        int slow = 0; //慢指针
        // fast快指针用于遍历数组元素
        for (int fast = 0; fast < chars.length; fast++) {
            if (chars[fast] != ' ') {
                if (slow != 0) { //首字符前不用加空格
                    chars[slow] = ' ';
                    slow++;
                }
                while (fast < chars.length && chars[fast] != ' '){
                    chars[slow] = chars[fast];
                    slow++;
                    fast++;
                }
            }     
        }
        char[] newChars = new char[slow];
        System.arraycopy(chars, 0, newChars, 0, slow);
        return newChars;   
    }

    // 2.【字符串反转函数】
    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--;
        }
    }

    // 3.【单词反转函数】
    public void reverseWords(char[] chars) {
        int start = 0;
        //"="是为了让end永远指向单词末尾后一个位置
        for (int end = 0; end <= chars.length; end++) { 
            if (end == chars.length || chars[end] == ' ') { //先判断前个条件
                reverse(chars, start, end - 1);
                start = end + 1;
            }
        }
    }
}

---

5. 【剑指Offer 58-II】：左旋转字符串

【力扣题目链接】：剑指Offer 58-II （左旋转字符串）

【题目描述】：

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。

比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

【示例1】：

输入: s = "abcdefg", k = 2
输出: "cdefgab"

【示例2】：

输入: s = "lrloseumgh", k = 6
输出: "umghlrlose"

【提示】：1 <= k < s.length <= 10000

---

注意：为了让本题更有意义，提升一下本题难度：不能申请额外空间，只能在本串上操作。

【解题思路】：这题可以通过 局部反转+整体反转 达到左旋转的目的。

1. 反转区间为前n的子串
2. 反转区间为n到末尾的子串
3. 反转整个字符串

上述三步骤就可以达到左旋n的目的，而不用定义新的字符串，完全在本串上操作。

【代码实现】：

class Solution {
    public String reverseLeftWords(String s, int n) {
        //用原始数组反转，空间复杂度为O(1)
        char[] chars = s.toCharArray();
        //1.反转前n个字符
        reverse(chars, 0, n -1);
        //2。反转n到末尾间的字符
        reverse(chars, n, chars.length - 1);
        //3.反转整个字符串
        reverse(chars, 0, chars.length - 1);
        
        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--;
        }
    }
}

---

6. 总结

万丈高楼平地起，加油！day day up！

---