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

344.反转字符串

题目链接 lc.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. 设定头尾两个指针，然后交换他们的值（字符）后，向中间移动
2. 判断条件为 left < right ，当取到等号的时候，他们交换也不影响最后的结果，（但是取消等号在leetcode指向时间更短）

class Solution {
public:
    void reverseString(vector<char>& s) {
        int i = 0;
        int j = s.size() - 1;

        while (i < j) {
            char temp;
            temp = s[i];
            s[i] = s[j];
            s[j] = temp;
            i++;
            j--;
        }
    }
};

总结： 主要要知道什么时候用库函数，什么时候不用！

1. 如果题目关键的部分直接用库函数就可以解决，建议不要使用库函数。
2. 如果库函数仅仅是 解题过程中的一小部分，并且你已经很清楚这个库函数的内部实现原理的话，可以考虑使用库函数。

541. 反转字符串II

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

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

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

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

思路：

1. 在反转字符串的基础上加上了步长的反转，我们可以根据题意移动2k步，然后对前k步进行反转
2. for循环里i移动变成i += 2k 这样能直接移动2k步。
3. 字符少于 k 个，将剩余字符全部反转，那么可以留作判断最后的情况。

class Solution {
public:
    string reverseStr(string s, int k) {
        // 1.每间隔 2k 然后对前 K个进行反转
        // 我们平常习惯 i++，那么这里我们可以直接用 i += 2k，每次增加2k
        for (int i = 0; i < s.size(); i += (2*k)) {
            if (i + k <= s.size()) {   // 当我 每次取k个的时候，主要小于等于字符串长度。就进行反转。
                reverse(s.begin() + i, s.begin() + i + k);
                continue;
            }
            // 不足长度k了，进行最后一段的翻转
            reverse(s.begin() + i, s.end());  
        }
        return s;
    }
};

总结：

1. 移动的时候要知道移动步长2k，方便进行统计
2. 字符串里面有很多的库函数，需要知道并且会使用。

剑指Offer 05.替换空格

题目链接 剑指Offer 05.替换空格

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

示例 1：

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

思路：

1. 首先遍历字符串，统计空格出现的次数count
2. 对原字符串进行扩容，扩容大小为原字符串长度 + 2*count
3. 设置两个指针，指向原有字符串末尾和扩容后的末尾，当遇到空格后，对其进行替换，同时移动指针。

class Solution {
public:
    string replaceSpace(string s) {
        int OldLen = s.size();
        int count = 0; // 统计空格个数
        for (int i = 0; i < OldLen; i++) {
            if (s[i] == ' ') {
                count++;
            }
        }
        //扩大s的长度，因为原来的空格只有一个空间，而%20占三个，但是空格占了一个，所以扩大两倍count
        s.resize(OldLen + 2*count);
        int newLen = s.size();
        //从右往左遍历方便实现O(n)的时间复杂度
        //双指针，一个指向老的s， 一个指向新的s
        for (int i = newLen-1, j = OldLen - 1; j < i; i--, j--) {
            //遍历s[j] 来判断，此时的s[i]指向的新空间，后面都是空的
            if (s[j] != ' ') {
                s[i] = s[j];   
            }
            else {
                s[i] = '0';
                s[i-1] = '2';
                s[i-2] = '%';
                i -= 2;  //注意移动位置
            }
        }
        return s;
    }
};

总结：

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

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

这么做有两个好处：

1. 不用申请新数组。
2. 从后向前填充元素，避免了从前先后填充元素要来的 每次添加元素都要将添加元素之后的所有元素向后移动。

想把这道题做到极致，就是要有这样的思维。

151.翻转字符串里的单词

给你一个字符串 s ，请你反转字符串中 单词 的顺序。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

思路：

1. 首先删除多余的空格，因为我们不需要头尾和中间多出来的空格
2. 将整个字符串翻转，这样能够保证每个单词已经被翻转过来了
3. 最后对每个单词进行翻转，我们用空格和末尾做判断，当满足其中一个的时候，就翻转单词字符，
   总体实现就是如上，但是实际操作中有很多不好想的地方。

首先是移除空格：

 void removeBlank(string &s) {
      int slow = 0;
      for(int fast = 0; fast < s.size(); fast++) {
          if (s[fast] !=' ') {
          //这句话不写在while下面，需要先判断是不是头再去交换，否则会导致交换完后换，多一个空格出错。这句话的目的主要是在每个词后面先加上空格再进行判断
              if (slow != 0) s[slow++] = ' ';
              // 移动指针的时候，保证不超出长度
              while (fast < s.size() && s[fast] != ' ') {
                  s[slow++] = s[fast++];
              }
          }
      }
      //最后重构s
      s.resize(slow);
   }

对比移除数组中的元素，需要再多一些判断。
主要就是要想到怎么在每个词后添加空格这一步和移动指针放在循环里面，这是第一次写的时候不容易想到的。

class Solution {
public:
    void removeBlank(string &s) {
        int slow = 0;
        for(int fast = 0; fast < s.size(); fast++) {
            if (s[fast] !=' ') {
                if (slow != 0) s[slow++] = ' ';
                while (fast < s.size() && s[fast] != ' ') {
                    s[slow++] = s[fast++];
                }
            }
        }
        s.resize(slow);
    }

    void reverse(string &s, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            swap(s[i], s[j]);
        }
    }

    string reverseWords(string s) {
        removeBlank(s);
        reverse(s, 0, s.size() - 1);
        int start = 0;
        for (int i = 0; i <= s.size(); ++i) {
            if (s[i] == ' ' || i == s.size()) {
                reverse(s, start, i - 1);
                start = i + 1;
            }
        }
        return s;
    }
};

总结：本题要考虑的点比较多，算是字符串里面比较难的题目，需要后续多看这道题。

1. 在移除空格的时候多想想双指针法，这样才能习惯这类题目
2. 翻转整句再翻转单词，这一点也不容易想到，只有多记住这种解法，才能习惯。

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

题目链接 剑指Offer58-II.左旋转字符串

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

思路：

1. 通过上一题，我们知道通过翻转局部和整体，能够实现翻转

通过这三步，能实现字符串的左旋。

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

**总结：**要完成这一道题，主要是要先把上一道题目给完成，才能清楚这一道题目为什么可以这样做