【C++代码】反转字符串，反转字符串II，替换空格，翻转字符串里的单词--代码随想录

题目：反转字符串

• 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

题解

• 对于长度为 N 的待被反转的字符数组，我们可以观察反转前后下标的变化，假设反转前字符数组为 s[0] s[1] s[2] … s[N - 1]，那么反转后字符数组为 s[N - 1] s[N - 2] … s[0]。比较反转前后下标变化很容易得出 s[i] 的字符与 s[N - 1 - i] 的字符发生了交换的规律，因此我们可以得出如下双指针的解法：

  • 将 left 指向字符数组首元素，right 指向字符数组尾元素。

  • 当 left < right：

    • 交换 s[left] 和 s[right]；
    • left 指针右移一位，即 left = left + 1；
    • right 指针左移一位，即 right = right - 1

  • 当 left >= right，反转结束，返回字符数组即可。

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

• 时间复杂度：O(N)，其中 N 为字符数组的长度。一共执行了 N/2 次的交换。空间复杂度：O(1)。只使用了常数空间来存放若干变量。

• 对于这道题目直接用C++里的一个库函数 reverse，调一下直接完事了， 相信每一门编程语言都有这样的库函数。

• swap可以有两种实现。一种就是常见的交换数值,一种就是通过位运算：

  • int tmp = s[i];
    s[i] = s[j];
    s[j] = tmp;
    //位运算
    s[i] ^= s[j];
    s[j] ^= s[i];
    s[i] ^= s[j];
    

题目：反转字符串 II

• 给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。如果剩余字符少于 k 个，则将剩余字符全部反转。如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

题解

• 我们直接按题意进行模拟：反转每个下标从 2k 的倍数开始的，长度为 k 的子串。若该子串长度不足 k，则反转整个子串。

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

• 时间复杂度：O(n)，其中 n 是字符串 s 的长度。空间复杂度：O(1) 或 O(n)，取决于使用的语言中字符串类型的性质。如果字符串是可修改的，那么我们可以直接在原字符串上修改，空间复杂度为 O(1)，否则需要使用 O(n) 的空间将字符串临时转换为可以修改的数据结构（例如数组），空间复杂度为 O(n)。

题目：替换空格

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

题解

• 如果想把这道题目做到极致，就不要只用额外的辅助空间了！首先扩充数组到每个空格替换成"%20"之后的大小。然后从后向前替换空格，也就是双指针法，过程如下：i指向新长度的末尾，j指向旧长度的末尾。

• 在 C++ 语言中， string 被设计成「可变」的类型，因此可以在不新建字符串的情况下实现原地修改。由于需要将空格替换为 “%20” ，字符串的总字符数增加，因此需要扩展原字符串 s 的长度，计算公式为：新字符串长度 = 原字符串长度 + 2 * 空格个数。

  • 初始化：空格数量 count ，字符串 s 的长度 len ；

  • 统计空格数量：遍历 s ，遇空格则 count++ ；

  • 修改 s 长度：添加完 “%20” 后的字符串长度应为 len + 2 * count ；

  • 倒序遍历修改：i 指向原字符串尾部元素， j 指向新字符串尾部元素；当 i = j 时跳出（代表左方已没有空格，无需继续遍历）；

    • 当 s[i] 不为空格时：执行 s[j] = s[i] ；

    • 当 s[i] 为空格时：将字符串闭区间 [j-2, j] 的元素修改为 “%20” ；由于修改了 3 个元素，因此需要 j -= 2 ；

  • 返回值：已修改的字符串 s ；

• class Solution {
  public:
      string replaceSpace(string s) {
          int count_space = 0;
          int len_s=s.size();
          for(int i=0;i<s.size();i++){
              if(s[i]==' ')count_space++;
          }
          s.resize(len_s+2*count_space);
          for(int i=len_s-1,j=s.size()-1;i<j;i--,j--){
              if(s[i]==' '){
                  s[j]='0';
                  s[j-1]='2';
                  s[j-2]='%';
                  j-=2;
              }else{
                  s[j]=s[i];
              }
          }
          return s;
      }
  };
  

• 时间复杂度 O(N)： 遍历统计、遍历修改皆使用 O(N) 时间。空间复杂度 O(1)： 由于是原地扩展 s 长度，因此使用 O(1) 额外空间。

题目：反转字符串中的单词

• 给你一个字符串 s ，请你反转字符串中 单词 的顺序。单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

• 输入: "  hello world!  " ；输出: “world! hello” ；

  • 解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

题解

• 我们也可以不使用语言中的 API，而是自己编写对应的函数。在不同语言中，这些函数实现是不一样的，主要的差别是有些语言的字符串不可变（如 Java 和 Python)，有些语言的字符串可变（如 C++)。

• 想一下，我们将整个字符串都反转过来，那么单词的顺序指定是倒序了，只不过单词本身也倒序了，那么再把单词反转一下，单词不就正过来了。所以解题思路如下：

  • 移除多余空格：逻辑很简单，从前向后遍历，遇到空格了就erase。如果不仔细琢磨一下erase的时间复杂度，还以为以上的代码是O(n)的时间复杂度呢。想一下真正的时间复杂度是多少，一个erase本来就是O(n)的操作。erase操作上面还套了一个for循环，那么代码移除冗余空格的代码时间复杂度为$O(n^2)$。那么使用双指针法来去移除空格，最后resize（重新设置）一下字符串的大小，就可以做到O(n)的时间复杂度。

  • 将整个字符串反转

  • 将每个单词反转

• // class Solution {
  // public:
  //     void reverseStr(string& s,int start,int end){
  //         for(int i=start,j=end;i
  //             swap(s[i],s[j]);
  //         }
  //     }
  //     void removeSomeSpace(string& s){
  //         int slow=0;
  //         for(int i=0;i
  //             if(s[i]==' '){
  //                 if(slow!=0)//手动控制空格，给单词之间添加空格。
  //                 //slow != 0说明不是第一个单词，需要在单词前添加空格。
  //                     s[slow++]=' ';
  //                 while(i
  //                     s[slow++]=s[i++];
  //                 }
  //             }
  //         }
  //         s.resize(slow);
  //     }
  //     string reverseWords(string s) {
  //         removeSomeSpace(s);
  //         reverseStr(s,0,s.size()-1);
  //         int start=0;
  //         for(int i=0;i<=s.size();i++){
  //             if(i==s.size()||s[i]==' '){
  //                 reverseStr(s,start,i-1);
  //                 start=i+1;
  //             }
  //         }
  //         return s;
  //     }
  // };
  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;   //整体思想参考https://programmercarl.com/0027.移除元素.html
          for (int i = 0; i < s.size(); ++i) { //
              if (s[i] != ' ') { //遇到非空格就处理，即删除所有空格。
                  if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
                  while (i < s.size() && s[i] != ' ') { //补上该单词，遇到空格说明单词结束。
                      s[slow++] = s[i++];
                  }
              }
          }
          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;
      }
  };