字符串复习

344:反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

示例 1：

输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]

注意不能使用额外空间，这里就使用左右双指针来进行翻转

class Solution {
public:
    void reverseString(vector<char>& s) {
        int l = 0, r = s.size() - 1;
        while(l < r){
            char tmp;
            tmp = s[l];
            s[l] = s[r];
            s[r] = tmp;
            l++;
            r--;
        }
    }
};

541:反转字符串II

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

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

示例 1：

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

根据题目意思走，步长设置为2k，左右指针的设定上右指针需要判断右边的剩余元素是否小于k，只要不小于就正常进行替换，如果小于k，将右指针设置为右边界并进行替换。

class Solution {
public:
    string reverseStr(string s, int k) {
        int n = s.size();
        for(int i = 0; i < s.size(); i += 2 * k){
            int l = i, r = min(l + k - 1, n - 1);
            while(l < r){
                char tmp = s[l];
                s[l] = s[r];
                s[r] = tmp;
                l++;
                r--;
            }
        }
        return s;
    }
};

 54:替换数字

给定一个字符串 s，它包含小写字母和数字字符，请编写一个函数，将字符串中的字母字符保持不变，而将每个数字字符替换为number。 例如，对于输入字符串 "a1b2c3"，函数应该将其转换为 "anumberbnumbercnumber"。

输入描述

输入一个字符串 s,s 仅包含小写字母和数字字符。

输出描述

打印一个新的字符串，其中每个数字字符都被替换为了number

输入示例

a1b2c3

输出示例

anumberbnumbercnumber

 先进行一遍遍历确定数字个数，然后新建一个合适大小的数组，这里注意开空间的时候为数字个数n*6-n = 5 * n,然后使用前后两个指针一个指向新数组的末尾，一个指向原数组的末尾，左指针检测到数字就从右指针开始填充number，不然就将当前元素赋值给当前右指针位置然后一起前移。

#include<bits/stdc++.h>
using namespace std;

int main(){
    string s;
    cin >> s;
    int n = s.size();
    int count = 0;
    for(int i = 0; i < n; i++){
        if(s[i] >= '0' && s[i] <= '9'){
            count++;
        }
    }
    
    
    vector<char> new_nums(n + count * 5);
    for(int i = 0; i < n; i++){
        new_nums[i] = s[i];
    }
    
    int l = n - 1, r = new_nums.size() - 1;
    while(l >= 0){
        if(new_nums[l] >= '0' && new_nums[l] <= '9'){
            new_nums[r--] = 'r';
            new_nums[r--] = 'e';
            new_nums[r--] = 'b';
            new_nums[r--] = 'm';
            new_nums[r--] = 'u';
            new_nums[r--] = 'n';
            l--;
        }else{
            new_nums[r--] = new_nums[l]; 
            l--;
        }
    }
    
    for(int i = 0; i < new_nums.size(); i++){
        cout << new_nums[i];
    }
    return 0;
}

151：翻转字符串中的单词

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

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

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

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

示例 1：

输入：s = "the sky is blue"
输出："blue is sky the"

class Solution {
public: 
    void reverse(string& s, int start, int end){
        int l = start, r = end;
        while(l < r){
            swap(s[l++], s[r--]);
        }
    }
    void removeextrablank(string& s){
        // 先去除头部的空白
        int slow = 0, fast = 0; 
        while(fast < s.size() && s[fast] == ' '){
            fast++;
        }
        // 处理单词之间多余的空格
        for(;fast < s.size(); fast++){
            if(fast - 1 > 0 && s[fast] == ' ' && s[fast - 1] == s[fast]){
                continue;
            }else{
                s[slow++] = s[fast];
            }
        }
        if(slow - 1 > 0 && s[slow - 1] == ' '){
            s.resize(slow - 1);
        }else{
            s.resize(slow);
        }
    }
    string reverseWords(string s) {
        removeextrablank(s);
        reverse(s, 0, s.size() - 1);
        int left = 0;
        for(int i = 0; i <= s.size(); i++){
            if(s[i] == ' ' || i == s.size()){
                reverse(s, left, i - 1);
                if(i != s.size() - 1){
                    left = i + 1;         
                }
            }
        }
        return s;
    }
};

 先进行对冗余空格的处理，使用双指针来进行，快指针通过while循环越过所有头部的空格，后续用slow和fast互换完成对空格的覆盖，然后对单词间的冗余空格进行处理，还是同样的操作当判断连续两个空格以上的时候使用continue越过冗余的空格，然后通过后续的互换来覆盖，最后通过慢指针判断末尾的空格，如果末尾有空格则将数组大小控制在slow - 1，不然控制在slow。

在主函数中，我们先进行冗余空格的处理，然后反转字符串，通过一个for循环对逐个单词进行翻转。

55:右旋字符串

字符串的右旋转操作是把字符串尾部的若干个字符转移到字符串的前面。给定一个字符串 s 和一个正整数 k，请编写一个函数，将字符串中的后面 k 个字符移到字符串的前面，实现字符串的右旋转操作。 

例如，对于输入字符串 "abcdefg" 和整数 2，函数应该将其转换为 "fgabcde"。

输入描述

输入共包含两行，第一行为一个正整数 k，代表右旋转的位数。第二行为字符串 s，代表需要旋转的字符串。

输出描述

输出共一行，为进行了右旋转操作后的字符串。

输入示例

2
abcdefg

输出示例

fgabcde

就是找规律然后翻转特定区间内的字符串，现将整体反过来，然后换分为两个区域进行翻转即可。 

#include<bits/stdc++.h>
using namespace std;
void reverse(string& s, int start, int end){
    int l = start, r = end;
    while(l < r){
        swap(s[l++], s[r--]);
    }
}
int main(){
    int k;
    string s;
    cin >> k >> s;
    int n = s.size();
    reverse(s, 0, n - 1);
    reverse(s, 0, k - 1);
    reverse(s, k, n - 1);
    for(int i = 0; i < n; i++){
        cout << s[i];
    }    
    return 0;
}

子串匹配：（连续字符串）

KMP算法：

28:找出字符串中第一个匹配项的下标

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回  -1 。

示例 1：

输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。

NEXT数组的建立：

设置两个指针：前缀指针指向公共前后缀中前缀的最后一个字符，后缀指针指向公共前后缀中后缀的最后一个字符。

遍历过程：比较两个指针所指向的元素如果相同，两个指针一起向前移动，并将前缀指针的下标复制给next[i]表示当前前缀指针指向的元素所在的前面的子串中公共前后缀的字符数为j，如果不同就需要对前缀指针回退并检查。这里我们检查当前两个指针所遍历过得最长公共前后缀中是否含有子公共前后缀，这样前缀指针就不需要回退到0

处重现开始检查而是缩小了公共前后缀的长度（父到子的关系）再检查j此时的字符是否与i相等，如果不等接着回退到上一级公共前缀的位置知到j到了初始位置0处停止回退。

模式串与字符串的比较：

与next数组的建立过程一致，只不过少了对next数组的赋值过程。保证遍历字符串的指针i稳定前移，遇到相等的字符，模式串指针和字符串指针一起前进，当两指针指向的字符不同时，此时next[ j ]表示当前模式串遍历过去的子串中公共前后缀中前缀的最后一位的下一位位置，也就是说当前字符串指针遍历过的i， j指向元素相等的这个子串中去除当前不同元素的子串中公共前后缀中公共前缀的下一位，从这一位直接开始比较而不需要从头开始比较。

为了防止字符串每移动一位就需要遍历一遍模式串，会不断的缩小比较的范围，当前位不一致时，从前面已经遍历过的子串中回退到子串的公共前缀的下一位再开始比较，避免回退到初始位置进行比较。

class Solution {
public:
    // &:引用  
    void get_next(const string& s, int* next){
        int j = 0;
        next[0] = 0;
        for(int i = 1; i < s.size(); i++){
            // 前缀指针指向元素与后缀指针指向元素不一致，前缀指针回退到前一个存放的下标的的值
            while(j > 0 && s[i] != s[j]){
                j = next[j - 1];
            }
            // 后缀指针指向元素与前缀指针指向元素一致，两指针一起向前移动
            if(s[i] == s[j]){
                j++;
            }
            next[i] = j; // next的赋值是在对j处理全部完成之后
        }
    }
    int strStr(string haystack, string needle) {
        if(needle.size() == 0){
            return 0;
        }
        vector<int> next(needle.size());
        get_next(needle, &next[0]);
        int j = 0;
        for(int i = 0; i < haystack.size(); i++){
            while(j > 0 && needle[j] != haystack[i]){
                j = next[j - 1];
            }
            if(needle[j] == haystack[i]){
                j++;
            }
            // 当模式串与主串比较完最后一个模式串的字符时j进行了加1操作
            if(j == needle.size()){
                return i - needle.size() + 1;
            }
        }
        return -1;
    }
};

注意if和while的顺序，如果两者顺序颠倒就会出现j指针跑到i指针的前面去了会导致两者从开始一直同步向前走时，在最后一处相同的位置比较完成之后j进行自增操作导致此时j+1和i不同导致错位，提前进入while的错误循环。

 子序列匹配：（非连续字符串）