代码随想绿算法训练营第八天|344. 反转字符串，541. 反转字符串 II,剑指 Offer 05. 替换空格,151. 反转字符串中的单词,剑指 Offer 58 - II. 左旋转字符串

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 <= 105
• s[i] 都是 ASCII 码表中的可打印字符

时间复杂度O（n），空间复杂度O（1）；这道题这要是来说明什么时间可以使用函数接口，什么时候不要使用；

一本题为例，它本身是让我们练习字符串反转，如果我们直接调用reverse（），那么这道题则索然无味，但swap（）交换就可以直接使用，因为我们的中的不是练习这道题

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

541. 反转字符串 II

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

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

示例 1：

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

示例 2：

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

提示：

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

上一道题思想的进阶版，拿来练习使用，不过多讨论

class Solution {
public:
    string reverseStr(string s, int k) {
        for(int i=0;i<s.size();i+=2*k){
            if(k>s.size()-i){
                for(int j=i,q=s.size()-1;j<(s.size()+i)/2;j++,q--){
                    swap(s[q],s[j]);
                }
                return s;
        }else{
            for(int j=i,q=i+k-1;j<i+k/2;j++,q--){
                    swap(s[q],s[j]);
                }
        }
        }
        return s;
    }
};

剑指 Offer 05. 替换空格

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

示例 1：

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

限制：

0 <= s 的长度 <= 10000

今天全是对string的处理问题，这道题则是有加了双指针；

最近使用过的双指针的题目有

• 27.移除元素
• 15.三数之和
• 18.四数之和
• 206.翻转链表
• 142.环形链表II
• 344.反转字符串​​​​​

之前的blog都可以找到；

注：主要收获resize（）接口的使用；

class Solution {
public:
    string replaceSpace(string s) {
        int count=0;
        for(int i=0;i<s.size();i++){
            if(s[i]==' '){
                count++;
            }
        }
        int m=s.size()-1;
        s.resize(s.size()+count*2);
        for(int i=s.size()-1;i>=0&&m>=0;i--,m--){
            if(s[m]!=' '){
                s[i]=s[m];
            }else{
                s[i--]='0';
                s[i--]='2';
                s[i]='%';
            } 
        }
        return s;
    }
};

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 <= 104
• s 包含英文大小写字母、数字和空格 ' '
• s 中 至少存在一个 单词

进阶：如果字符串在你使用的编程语言中是一种可变数据类型，请尝试使用 O(1) 额外空间复杂度的 原地 解法。

对于这道题其实已经做过很多遍了，但是以前做法跟随想录上说的一样，很大程度上没有起到锻炼的作用，这次就把这道题完全解答一遍

1.首先我想的的是先把每一个单词先颠倒，然后在把整个字符串颠倒就把整个问题解决了

2.单词颠倒

• 先处理空格问题，可以使用erase但那种时间复杂度为O(n)，这里我们使用快慢指针，先把开头空格去掉，在考虑中间空格，多余的覆盖
• 然后考虑到我们颠倒单词的思路为了避免讨论，我们在字符串后面加一个‘ ’；
• 将单词 颠倒我觉得应该不必多说啦，实在不会就看看代码吧；

3.把整个字符串颠倒

class Solution {
public:
    string reverseWords(string s) {
        int slow=0,fast=0;
        while(s.size()>0&&fast<s.size()&&s[fast]==' ')fast++;//去除字符串开头的空格
        for(;fast<s.size();fast++){
            if(fast-1>=0&&s[fast]==' '&&s[fast]==s[fast-1])continue;
            else s[slow++]=s[fast];
        }
        s.resize(slow);
        if(s[s.size()-1]!=' ')s+=' ';
        int i=0;
        while(i<s.size()){
            int j=i;
            while(s[j]!=' '&&j<s.size())j++;
            int t=j;
            for(int m=i,q=j-1;m<(i+j)/2;m++,q--)
            swap(s[m],s[q]);
            i=t+1;
        }
        if(s[s.size()-1]==' ')s.erase(s.end()-1);
        for(int m=0,q=s.size()-1;m<s.size()/2;m++,q--)
        swap(s[m],s[q]);
        return s;
    }
};

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

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

示例 1：

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

示例 2：

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

限制：

• 1 <= k < s.length <= 10000

使用了翻转子串的方法，想起来挺自然的，但浪费了空间；

另一种解法先翻转前n个，再翻转后面的，最后全部一起在翻转一次，就得到了想要的

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        string s1="0";
        s1.resize(n);
        for(int i=0;i<s.size();i++){
            if(i<n)s1[i]=s[i];
            else s[i-n]=s[i];
        }
        int m=0;
        for(int i=s.size()-n;i<s.size();i++)s[i]=s1[m++];
        return s;
    }
};