打卡第八天|力扣344.反转字符串、541. 反转字符串II、剑指Offer 05.替换空格 、 151.翻转字符串里的单词 、 剑指Offer58-II.左旋转字符串 。

344.反转字符串

题目链接如下：344. 反转字符串

翻转字符串，题目说要用使用 O(1) 的额外空间解决这一问题，问题不大，我们还是使用两个指针依次交换，当然交换也可以直接用swap函数

class Solution {
public:
    void reverseString(vector<char>& s) {
     int n=s.size();
//字符串从0开始计数，所以是n-1
     int l=0,r=n-1;
     while(l<r){
//c是临时变量
         char c=s[l];
         s[l]=s[r];
         s[r]=c;
         ++l;
         --r;
     }
    }
};

当然，你也可以直接用c++自带的库函数 reverse

class Solution {
public:
    void reverseString(vector<char>& s) {
      reverse(s.begin(),s.end());
    }
};

541. 反转字符串II

题目链接如下：541. 反转字符串 II

这道题相当于是上一题的进阶版了，其实仔细想想我们能少去很多条件判断，我们在中学想必都学过周期函数，要对一个周期函数研究，当然在单个周期里面对函数研究，这题由题意可得，每一个有规律的周期是2K，所以如果我们循环是以2K为周期，那显然就很简单了；

class Solution {
public:
    string reverseStr(string s, int k) {
        //2k为一个周期遍历
      for(int i = 0; i < s.size(); i += 2*k){
//如果没超出范围
          if(i + k <= s.size()){
              reverse(i + s.begin(), s.begin()+i+k);
//超出范围，那肯定剩下的不足k个了
          }else{
              reverse(i + s.begin(),s.end());
          }
      }
      return s;
    }
};

剑指Offer 05.替换空格

这道题也是很经典的一道题目了

首先最直接的方法，用库函数搞定

class Solution {
public:
    string replaceSpace(string str) {
       for (int i = 0; i < str.size(); i ++)
        {
            if (str[i] == ' ')
            {
                str.erase(str.begin() + i);
                str.insert(i, "%20");    
            }
        }
        return str;
    }
};

当然，我们也可以用双指针搞定

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;
    }
};

151.翻转字符串里的单词

题目链接如下：151. 反转字符串中的单词

一种解题思路是，我们先对整个字符串翻转，然后再对里面的每个单词翻转，这样就得到正确的单词顺序，最后再想办法处理空格问题

当然思路很简单，其实最难的是对空格的处理

为了训练的效果，我们要求空间是0(1)的，这意味不能开一个新字符串

所以我们还是用双指针吧

class Solution {
public:
    void reverse(string& s, int start, int end){ //翻转，区间写法：左闭又闭 []
        for (int i = start, j = end; i < j; i++, j--) {
            swap(s[i], s[j]);
        }
    }

    void removeExtraSpaces(string& s) {//去除所有空格并在相邻单词之间添加空格, 快慢指针。
        int slow = 0;   
        for (int fast = 0; fast < s.size(); fast++) { //
            if (s[fast] != ' ') { //遇到非空格就处理，即删除所有空格。
                if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
                while (fast < s.size() && s[fast] != ' ') { //补上该单词，遇到空格说明单词结束。
                    s[slow++] = s[fast++];
                }
            }
        }
        s.resize(slow); //slow的大小即为去除多余空格后的大小。
    }

    string reverseWords(string s) {
        removeExtraSpaces(s); //去除多余空格，保证单词之间之只有一个空格，且字符串首尾没空格。
        reverse(s, 0, s.size() - 1);
        int start = 0; //removeExtraSpaces后保证第一个单词的开始下标一定是0。
        for (int i = 0; i <= s.size(); ++i) {
            if (i == s.size() || s[i] == ' ') { //到达空格或者串尾，说明一个单词结束。进行翻转。
                reverse(s, start, i - 1); //翻转，注意是左闭右闭 []的翻转。
                start = i + 1; //更新下一个单词的开始下标start
            }
        }
        return s;
    }
};

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

题目链接：剑指 Offer 58 - II. 左旋转字符串

这道题好像没有空间要求也，那我直接开一个新字符串那就是简简单单

class Solution {
public:
    string reverseLeftWords(string s, int k) {
      int n = s.size();
      string ret =s;
      for(int i=0;i<n;i++){
          ret[i]=s[(i+k)%n];//防止数组越界
      }
      return ret;
    }
};

和上一题差不多，整体翻转加局部翻转可以玩出很多花样，而且这题还没有空格问题

这题思路就是

1. 反转区间为前n的子串

2. 反转区间为n到末尾的子串

3. 反转整个字符串

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;
    }
};