代码随想录算法训练营D8

D8: 好想出去玩，好想去找npy

字符串：注意字符串终结符’\0’

344. Reverse String
既然问的事reverse肯定不能用库函数了，自己写吧，代码如下：

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

swap函数的简单原理如下

namespace std{  
    template<typename T>  
    void swap(T&a, T& b){  
        T temp(a);  
        a=b;  
        b=temp;  
    }  
} 

另一种通过位运算，避免使用任何额外的存储空间实现交换

s[i] ^= s[j];
s[j] ^= s[i];
s[i] ^= s[j];

541. Reverse String II
这个题巧妙就巧妙在循环变量的操作，每次递增$2k$个长度，代码如下：

class Solution {
public:
    string reverseStr(string s, int k) {
        for (int i = 0; i < s.size(); i += (2 * k)) {
            // 1. 每隔 2k 个字符的前 k 个字符进行反转
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= s.size()) {
                reverse(s.begin() + i, s.begin() + i + k );
            } else {
                // 3. 剩余字符少于 k 个，则将剩余字符全部反转。
                reverse(s.begin() + i, s.end());
            }
        }
        return s;
    }
};

54. 替换数字
将string中所有数字替换为number，一开始想着直接用库函数…如下：

int main(){
    string s;
    cin >> s;
    for(int i=0;i<s.size();i++){
        if(isdigit(s[i])){
            s[i]='n';
            s.insert(i+1, "umber");
        }
    }
    cout << s;
    return 0;
}

看了Carl的指导，使用双指针法，左指针指向旧字符串长度的尾部，右指针指向新字符串长度的尾部。讲解如下

代码如下：

int main(){
    string s;
    cin >> s;
    
    int sOldsize=s.size();
    int numberCount=0;
    for(char c:s){
        if(c<='9' && c>='0') numberCount++;
    }
    
    s.resize(s.size() + numberCount * 5);
    int sNewsize=s.size();
    
    for(int i=sOldsize,j=sNewsize;i<j;i--,j--){
        if(s[i] > '9' || s[i] < '0'){
            s[j]=s[i];
        }else{
            s[j]='r';
            s[j-1]='e';
            s[j-2]='b';
            s[j-3]='m';
            s[j-4]='u';
            s[j-5]='n';
            j -= 5; // 注意右指针要-5
        }
    }

    cout << s << endl;
    return 0;
}

151. Reverse Words in a String
想到了暴力解法，时间复杂度$O(n)$，空间复杂度$O(n)$，代码如下：

class Solution {
public:
    string reverseWords(string s) {
        if (s.size() <= 0)
            return s;
        int start = s.size() - 1;
        int end = start;
        string r;

        while (start >= 0) {
            if (s[start] == ' ') {
                r.push_back(' ');
                while (start >= 0 && s[start] == ' ')
                    start--;
            } else {
                string tmp;
                end = start;
                while (end >= 0 && s[end] != ' ') {
                    tmp.push_back(s[end]);
                    end--;
                }
                reverse(tmp.begin(), tmp.end());
                r.append(tmp);
                start = end;
            }
        }

        if (r[0] == ' ') {
            r.erase(r.begin());
        }

        if (r[r.size() - 1] == ' ') {
            r.erase(r.end() - 1);
        }
        return r;
    }
};

那么如何不适用额外的空间呢？可以有以下思路

• 移除多余空格
• 将整个字符串反转
• 将每个单词反转

举个例子，源字符串为："the sky is blue "

• 移除多余空格 : “the sky is blue”
• 字符串反转：“eulb si yks eht”
• 单词反转：“blue is sky the”
  代码如下：

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

55. 右旋字符串
第一次了解到右旋是有库函数的，如下：

#include <iostream>
#include <algorithm> // 包含 std::rotate
#include <string>

void rotateString(std::string &s, int k) {
    int n = s.length();
    // 确保k是有效的
    k = k % n;
    // 使用std::rotate进行旋转
    std::rotate(s.begin(), s.end() - k, s.end());
}

int main() {
    std::string s = "HelloWorld";
    int k = 3;
    rotateString(s, k);
    std::cout << "Rotated string: " << s << std::endl;
    return 0;
}

rotateString函数接受一个字符串s和一个整数k作为参数，然后将s中的所有字符向后移动k位。std::rotate的第一个参数是旋转开始的位置（这里从字符串的开始开始），第二个参数是新的“第一个”元素应该在哪里（这里是end() - k，表示向后移动k位后的开始位置），最后一个参数是旋转的结束位置（这里是字符串的末尾）。
不使用库函数的话，可以有如下思路：

• 反转整个字符串
• 反转前k个字符
• 反转后size-k个字符

所以有如下代码：

#include <vector>
#include <algorithm>
#include <random>
#include <iostream>

using namespace std;

int main(){
   string s;
   int k;
   cin >> k;
   cin >> s;
   
   for(int i=0;i<s.size()/2;i++){
       swap(s[i],s[s.size()-i-1]);
   }
   for(int i=0;i<k/2;i++){
       swap(s[i],s[k-i-1]);
   }
   for(int i=0;i<(s.size()-k)/2;i++){
       swap(s[i+k],s[s.size()-i-1]);
   }
   cout << s<< endl;
   
   return 0;
}

总结：今天是字符串的基础操作，包括使用双指针法来替换字符串内容。