代码随想录第八天：反转单词、右旋字符串、kmp算法

1.反转单词

题目链接：. - 力扣（LeetCode）

讲解链接：代码随想录 (programmercarl.com)

视频链接：字符串复杂操作拿捏了！ | LeetCode:151.翻转字符串里的单词_哔哩哔哩_bilibili

本体要注意的点比较多，要反转单词顺序，还要删除多余空格。

反转单词涉及一个很经典的算法，首先将整个字符串反转，再反转各个单词。所以涉及多次反转功能，可以定义反转函数。

删除多余空格操作比较复杂，也可以自定义一个函数实现。

实际上删除多余空格的操作可以使用双指针法实现。快指针遍历字符串，当快指针遇到第一个字母时，如果此时慢指针不是0（说明在上一个单词的末尾下一位），就在慢指针位置添加空格，再让它移动一位。然后逐个将后一个单词的字母移动到慢指针的位置，即快指针所指不是空格时，将快指针内容复制到慢指针处，再将两个指针同时右移，一直循环到快指针遇到空格为止，而此时慢指针就又停在了单词末尾下一位。而快指针遇到空格时只需继续循环让快指针自动右移即可。

要注意删除多余空格后，可以使用resize改变字符串长度。

反转字符串与去除空格的操作顺序可以任意。随后遍历字符串，每遇到一个单词将其反转即可。

代码如下：

void reverseString(string& s, int a, int b) {
    for (int i = a, j = b; i < j ; ++i,--j) {
        swap(s[i], s[j]);
    }
}

void removeExtraSpaces(string& s){
    int slow = 0, fast = 0;
    while (fast < s.size()){
        if (s[fast] != ' '){
            if (slow != 0)
                s[slow++] = ' ';
            while(fast < s.size() && s[fast] != ' '){
                s[slow++] == s[fast++];
            }
        }
        fast++;
    }
    s.resize(slow);
}

string reverseWords(string& s) {
    reverseString(s , 0, s.size());
    removeExtraSpaces(s);
    int slow = 0, fast = 0;
    while (fast < s.size()){
        if (s[fast] == ' ' || fast == s.size()){
            reverseString(s, slow, fast - 1);
            fast++;
            slow = fast;
        }else
            fast++;
    }
    return s;
}

2.右旋字符串

题目链接：55. 右旋字符串（第八期模拟笔试）

讲解链接：右旋字符串 | 代码随想录 (programmercarl.com)

本题同样适用多次反转方法，不再赘述。

代码如下：

#include<iostream>
#include<algorithm>
using namespace std;
int main() {
    int n;
    string s;
    cin >> n;
    cin >> s;
    int len = s.size(); //获取长度
    reverse(s.begin(), s.begin() + len - n); // 先反转前一段，长度len-n ，注意这里是和版本一的区别
    reverse(s.begin() + len - n, s.end()); // 再反转后一段
    reverse(s.begin(), s.end()); // 整体反转
    cout << s << endl;

}

3.kmp算法

题目链接：. - 力扣（LeetCode）

讲解链接：代码随想录 (programmercarl.com)

视频链接：帮你把KMP算法学个通透！（理论篇）_哔哩哔哩_bilibili、帮你把KMP算法学个通透！（求next数组代码篇）_哔哩哔哩_bilibili

本体要较低的时间复杂度，需要使用kmp算法。

kmp算法的理论基础见代码随想录讲解链接。

主要是next数组的求法，以next数组对前缀表不做处理为例（模式串指针回退根据上一位的next数组元素来回退）。

需要两个指针i和j，i用于遍历模式串，j则是填写next数组的内容。j初始化为0，next[0]也初始化为j的内容即0.而i的遍历要从1开始，因为next[0]已经填写。

每次循环时，不断检查i与j位置元素是否相同（whlie循环），不相同j则要向后回退，回退内容是next[j-1]，然后再次判定直至i与j对于元素相同或者j回退到0.然后判定i和j元素是否相同（如果j回退到0则不一定相同），相同则将j+1。最后填写next[i]的内容为j，进行下一次的循环。

得到next数组后就可以进行字符串匹配，每次匹配失败时模式串根据next数组内容进行回退。

代码如下：

void getNext(int* next, const string& s){
    int j = 0;
    next[0] = j;
    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;
    }
}

int strStr(string haystack, string needle) {
    if (needle.size() == 0)
        return 0;
    vector<int> next(needle.size());
    getNext(&next[0], needle);
    for (int i = 0, j = 0; i < haystack.size(); ++i) {
        while (j > 0 && haystack[i] != needle[j]){
            j = next[j - 1];
        }
        if(haystack[i] == needle[j]){
            j++;
        }
        if (j == needle.size())
            return (i - needle.size() + 1);
    }
    return -1;
}

4.判定重复子串

题目链接：. - 力扣（LeetCode）

讲解链接：代码随想录 (programmercarl.com)

视频链接：字符串这么玩，可有点难度！ | LeetCode：459.重复的子字符串_哔哩哔哩_bilibili

本体的关键逻辑是：如果一个字符串可以由重复子串构成，那么将两个该字符串组合，在合并的字符串中间一定能找到一个原字符串。

知道该逻辑后，就可以使用kmp算法进行模式串匹配了。

代码如下：

void getNext(int* next, const string& s){
    int j = 0;
    next[0] = j;
    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;
    }
}

bool repeatedSubstringPattern(string s) {
    if(s.size() == 1)
        return false;
    string str = s + s;
    str.erase(str.begin());
    str.erase(str.end() - 1);
    vector<int> next(s.size());
    getNext(&next[0], s);
    for (int i = 0, j = 0; i < str.size(); ++i) {
        while (j > 0 && str[i] != s[j]){
            j = next[j - 1];
        }
        if(str[i] == s[j]){
            j++;
        }
        if (j == s.size())
            return true;
    }
    return false;
}