代码随想录算法训练营第八天 | 344. 反转字符串、541. 反转字符串II、剑指Offer 05. 替换空格、151. 翻转字符串里的单词、剑指Offer58-II. 左旋转字符串

344. 反转字符串

题目链接：LeetCode344. 反转字符串

文章讲解：代码随想录—344. 反转字符串

思路：

题很简单，只是虽然能用反转库函数直接解决，但没有任何意义，因为要求在空间复杂度O(1)解决问题，所以首先想到双指针算法

class Solution {
public:
    void reverseString(vector<char>& s) {
        for (int i = 0, j = s.size() - 1; i < j; i ++, j --) {
            swap(s[i], s[j]);
        }
    }
};

时间复杂度：O(n)

空间复杂度：O(1)

541. 反转字符串II

题目链接：LeetCode541. 反转字符串II

文章讲解：代码随想录—541. 反转字符串II

 思路：

我的想法是每 k 位循环一次，但显然处理反转和不反转区域是很麻烦的。因此想要每 2k 次进行一次循环，只要检查前 k 位是否满足反转条件即可。

因为本题重点不是库函数，因此可以使用 reverse 进行翻转，也可以自己实现一个 reverse 函数。

class Solution {
public:
    string reverseStr(string s, int k) {
        for (int i = 0; i < s.size(); i += 2 * k) {
            if (i + k <= s.size()) reverse(s.begin() + i, s.begin() + i + k);
            else reverse(s.begin() + i, s.end());
        }
        return s;
    }
};

时间复杂度：O(n)

空间复杂度：O(1)

剑指Offer 05. 替换空格

文章讲解：代码随想录—剑指Offer 05. 替换空格

思路：

刚做这个题的第一想法肯定是双指针从前往后遍历，但显然这不是最优解，本题的解决重点在于要从后向前遍历。

从后向前遍历的好处在于不需要重新简历数组 (会增加空间复杂度)、不会像从前向后遍历一样要把数组每一位都往后移 (增加时间复杂度)

class Solution {
public:
    string replaceSpace(string s) {
        int count = 0; // 统计空格的个数
        int sOldSize = s.size();
        for (int i = 0; i < s.size(); i++) {
            if (s[i] == ' ') {
                count++;
            }
        }
        // 扩充字符串s的大小，也就是每个空格替换成"%20"之后的大小
        s.resize(s.size() + count * 2);
        int sNewSize = s.size();
        // 从后先前将空格替换为"%20"
        for (int i = sNewSize - 1, j = sOldSize - 1; j < i; i--, j--) {
            if (s[j] != ' ') {
                s[i] = s[j];
            } else {
                s[i] = '0';
                s[i - 1] = '2';
                s[i - 2] = '%';
                i -= 2;
            }
        }
        return s;
    }
};

时间复杂度：O(n)

空间复杂度：O(1)

151. 翻转字符串里的单词

题目链接：LeetCode151. 翻转字符串里的单词

文章讲解：代码随想录—151. 翻转字符串里的单词

思路：

想翻转句子中的单词顺序，可以先反转句子中的所有字符，再翻转每个单词的字符。因为题中存在多余空格的情况，因此需要把首位多余空格删掉，再删除句中的多余空格。

因此本题需要完成三件事：1. 删除多余空格 2. 翻转整个句子 3. 翻转单词

删除函数可以使用erase，但需要知道erase函数本身时间复杂度是O(n)，因此在循环中使用会让本题时间复杂度上升为O(n^2)，因此还是考虑双指针算法。

class Solution {
public:
    void reverse(string& s, int begin, int end) {
        for (int left = begin, right = end; left < right; left ++, right --) {
            swap(s[left], s[right]);
        }
        return;
    }

    string reverseWords(string s) {
        int slow = 0;
        for (int i = 0; i < s.size(); i ++) {
            if (s[i] != ' ') {
                if (slow != 0) s[slow ++] = ' ';
                while (s[i] != ' ' && i < s.size()) s[slow ++] = s[i ++];
            }
        }
        s.resize(slow);

        reverse(s, 0, s.size() - 1);

        for (int left = 0, right = 0; right <= s.size(); right ++) {
            if (s[right] == ' ' || right == s.size()) {
                reverse(s, left, right - 1);
                left = right + 1;
            }
        }
        return s;
    }
};

时间复杂度：O(n)

空间复杂度：O(1)

剑指Offer58-II. 左旋转字符串

文章讲解：代码随想录—剑指Offer58-II. 左旋转字符串

思路：

和上一题思路完全一样，比上一题简单，只需要简单的局部反转+全局反转即可。

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        reverse(s.begin(), s.begin() + n);
        reverse(s.begin() + n, s.end());
        reverse(s.begin(), s.end());
        return s;
    }
};

时间复杂度：O(n)

空间复杂度：O(1)

总结：

本期题目中主要难点就在于151题，需要有局部翻转+全局反转的思路。此外解决删除多余空格的问题也需要多加考虑，如何用简单的代码实现繁琐的操作，需要多做几次加深记忆。