字符串操作技巧：右旋与模式匹配算法解析

楚沐风

1. 字符串操作实战：右旋与模式匹配解析

今天分享三个LeetCode字符串题目的解题思路和实现细节，包含右旋字符串、strStr()实现以及重复子串判断。这些题目看似基础，但涉及字符串处理的核心技巧，对提升编程基本功很有帮助。

1.1 右旋字符串的优雅解法

右旋字符串的题目要求将字符串末尾的n个字符移动到开头。比如"abcdef"右旋2位得到"efabcd"。最直观的做法可能是逐个字符移动，但这样时间复杂度会达到O(n^2)。

更高效的做法是三次反转：

反转整个字符串
反转前n个字符
反转剩余字符

cpp复制void reverse(string& s, int start, int end) {
    while(start < end) {
        swap(s[start], s[end]);
        start++;
        end--;
    }
}

string rightRotate(string s, int k) {
    k %= s.length(); // 处理k大于字符串长度的情况
    reverse(s, 0, s.length()-1);
    reverse(s, 0, k-1);
    reverse(s, k, s.length()-1);
    return s;
}

注意：k可能大于字符串长度，需要先取模。STL的reverse函数使用左闭右开区间，手动实现时要注意边界条件。

这种方法的优势在于：

时间复杂度O(n)，只需遍历字符串三次
空间复杂度O(1)，原地操作不需要额外空间
代码简洁，逻辑清晰

1.2 strStr()的多种实现方式

strStr()要求在haystack字符串中找出needle第一次出现的位置。这个问题看似简单，但能考察多种编程技巧。

1.2.1 暴力匹配法

最直接的方法是逐个字符比较：

cpp复制int strStr(string haystack, string needle) {
    int m = haystack.size(), n = needle.size();
    if(n == 0) return 0;
    if(m < n) return -1;
    
    for(int i = 0; i <= m - n; i++) {
        int j = 0;
        while(j < n && haystack[i+j] == needle[j]) j++;
        if(j == n) return i;
    }
    return -1;
}

时间复杂度O(m*n)，最坏情况下需要比较所有可能的位置。虽然效率不高，但代码直观易懂，适合小规模数据。

1.2.2 使用STL内置函数

C++的string类提供了find方法：

cpp复制int strStr(string haystack, string needle) {
    return haystack.find(needle);
}

简洁但隐藏了实现细节，不利于理解算法本质。

1.2.3 KMP算法初探

KMP算法通过预处理模式串(needle)构建next数组，将时间复杂度优化到O(m+n)。虽然代码更复杂，但值得深入理解：

cpp复制void getNext(vector<int>& next, const string& s) {
    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;
    }
}

int strStr(string haystack, string needle) {
    if(needle.empty()) return 0;
    vector<int> next(needle.size());
    getNext(next, needle);
    
    int j = 0;
    for(int i = 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 - j + 1;
    }
    return -1;
}

KMP的核心思想是利用已匹配的信息避免不必要的回溯。next数组记录了模式串的"自匹配"信息，当匹配失败时可以直接跳到可能匹配的位置继续比较。

实际调试时发现：理解KMP最好手动模拟几个例子，观察next数组的变化和指针移动规律。

1.3 重复子字符串的判断技巧

判断字符串是否由某个子串重复多次构成，有多种解法各具特色。

1.3.1 暴力枚举法

最直观的方法是枚举所有可能的子串长度：

cpp复制bool repeatedSubstringPattern(string s) {
    int n = s.length();
    for(int len = 1; len <= n/2; len++) {
        if(n % len != 0) continue;
        string pattern = s.substr(0, len);
        bool match = true;
        for(int i = len; i < n; i += len) {
            if(s.substr(i, len) != pattern) {
                match = false;
                break;
            }
        }
        if(match) return true;
    }
    return false;
}

时间复杂度O(n^2)，空间复杂度O(1)。虽然效率不高，但思路清晰，适合作为基准实现。

1.3.2 字符串拼接法

更巧妙的解法是将字符串s与自身拼接，然后去掉首尾字符，检查s是否存在于新字符串中：

cpp复制bool repeatedSubstringPattern(string s) {
    string t = s + s;
    t = t.substr(1, t.size()-2);
    return t.find(s) != string::npos;
}

这个方法的正确性基于数学推导：如果s由子串重复构成，那么s一定是s+s的子串，且不会出现在首尾位置。

1.3.3 KMP解法

利用KMP的next数组可以更高效地解决这个问题：

cpp复制bool repeatedSubstringPattern(string s) {
    vector<int> next(s.size());
    getNext(next, s);
    int n = s.size();
    return next[n-1] != 0 && n % (n - next[n-1]) == 0;
}