leetcode344. 反转字符串、541. 反转字符串 II、54. 替换数字、151. 反转字符串中的单词

344. 反转字符串

基础
学习库函数 reverse 的内部实现

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

时间复杂度O(n) ，空间复杂度O(1)

541. 反转字符串 II

看懂题意之后还是很好实现的
注意这里的reverse函数跟上题函数的区别

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]);
        }
    }
    string reverseStr(string s, int k) {
        for(int i = 0; i < s.size(); i += (2 * k)){
            if(i + k <= s.size()){
                reverse(s, i, i + k - 1);
            } else {
                reverse(s, i, s.size() - 1);
            }
        }
        return s;
    }
};

时间复杂度O(n) ，空间复杂度O(1)

54. 替换数字

先扩容，计算出替换后的字符串长度
再填充，用旧指针从原字符串最右边开始，用新指针从扩充后新长度右边开始。旧指针指向字母，新指针就复制；旧指针指向数字，新指针就填充n u m b e r

#include<iostream>
using namespace std;
int main(){
    string s;
    while(cin >> s){
        int sOldIndex = s.size() - 1;
        int count = 0; //统计数字的个数
        for(int i = 0; i < s.size(); i++){
            if(s[i] >= '0' && s[i] <=  '9') {
                count++;
            }
        }
        //扩充字符串s的大小，即每个数字都替换成“number”之后的大小
        s.resize(s.size() + count * 5);
        int sNewIndex = s.size() - 1;
        while(sOldIndex >= 0){
            if(s[sOldIndex] >= '0' && s[sOldIndex] <= '9'){
                s[sNewIndex--] = 'r';
                s[sNewIndex--] = 'e';
                s[sNewIndex--] = 'b';
                s[sNewIndex--] = 'm';
                s[sNewIndex--] = 'u';
                s[sNewIndex--] = 'n';
            } else {
                s[sNewIndex--] = s[sOldIndex];
            }
            sOldIndex--;
        }
        cout << s << endl;
    }
}

151. 反转字符串中的单词

解题思路如下：

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

class Solution {
public:
    void removeExtraSpaces(string& s){
        for(int i = s.size() - 1; i > 0; i-- ){ 
            if(i > 0 && s[i] == s[i - 1] && s[i] == ' '){
                s.erase(s.begin() + i);
            }
        }
        while(s.size() > 0 && s[s.size() - 1] == ' '){
            s.erase(s.begin() + s.size() - 1);
        }
        while(s.size() > 0 && s[0] == ' '){
            s.erase(s.begin());
        }
    }
    
    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) {
        removeExtraSpaces(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;
    }
};

时间复杂度为O(n^2)，因为earse函数的时间复杂度为O(n)

reverseExtraSpaces移除空格函数，使用双指针函数更简洁些：

void removeExtraSpaces(string& s){
        int slow = 0, fast = 0;
        for(fast; 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); //slow的大小即为去除多余空格后的大小
    }

时间复杂度: O(n)
空间复杂度: O(1)

55. 右旋字符串

乍一看可能想不出来，但是解决方法其实很简单，通过整体倒叙，把两段子串顺序颠倒，两个段子串里的的字符再分别倒叙一把，负负得正，这样就不影响子串里面字符的顺序了

#include<iostream>
#include<algorithm>
using namespace std;

int main(){
    int k;
    string s;
    cin >> k;
    cin >> s;
    int len = s.size();
    
    reverse(s.begin(), s.end());
    reverse(s.begin(), s.begin() + k);
    reverse(s.begin() + k, s.end());
    
    cout << s << endl;
}