字符串反转与KMP算法：双指针与模式匹配实战

1. 字符串反转基础：双指针原地交换

字符串反转是算法中最基础但最常考的操作之一。这道题目要求我们原地修改字符数组，意味着不能使用额外的数组空间，只能通过交换字符位置来实现。

1.1 双指针法的实现原理

双指针法之所以能高效解决这个问题，是因为它同时从字符串的首尾向中间移动，每次交换两个指针所指的字符。这种方法的时间复杂度是O(n/2)，也就是O(n)，空间复杂度是O(1)，完全符合题目要求。

具体实现时需要注意几个关键点：

1. 循环终止条件是i < j而不是i <= j，因为当i=j时，中间字符不需要交换
2. 使用标准库的swap函数可以简化代码，但要注意包含头文件
3. 指针移动要同步进行，i++和j--要放在同一个循环中

1.2 代码实现与优化

cpp复制void reverseString(vector<char>& s) {
    for (int i = 0, j = s.size() - 1; i < j; i++, j--) {
        swap(s[i], s[j]);
    }
}

这个版本比原代码更简洁，因为：

1. 循环条件改为i < j更直观
2. 不需要计算s.size()/2，直接比较i和j即可
3. 减少了不必要的计算

提示：在实际面试中，即使题目允许使用reverse函数，也建议先展示手动实现的能力，再提到可以使用STL函数。

2. 进阶反转：间隔反转字符串

2.1 问题分析与解决思路

这道题目要求每隔2k个字符就反转前k个字符，需要考虑多种边界情况：

1. 字符串长度正好是2k的整数倍
2. 剩余字符不足2k但大于等于k
3. 剩余字符不足k

解决这个问题的关键在于：

1. 确定反转的区间范围
2. 处理各种边界条件
3. 复用之前实现的反转函数

2.2 详细实现与边界处理

cpp复制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) {
        // 情况1：剩余字符≥k个
        if (i + k <= s.size()) {
            reverse(s, i, i + k - 1);
            continue;
        }
        // 情况2：剩余字符<k个
        reverse(s, i, s.size() - 1);
    }
    return s;
}

关键点解析：

1. 循环步长设为2k，确保每次处理一个完整的区间
2. i + k <= s.size()判断是否有足够的字符进行完整反转
3. continue语句优化了逻辑流程，避免不必要的判断

2.3 常见错误与调试技巧

在实际编码中容易犯的错误包括：

1. 区间计算错误，特别是结束位置应该是i+k-1而不是i+k
2. 忘记处理剩余字符不足k的情况
3. 循环条件设置不当导致数组越界

调试时可以：

1. 打印中间结果，观察每次反转后的字符串状态
2. 使用边界测试用例，如k=0，k=1，k=s.size()等
3. 单步调试观察指针移动情况

3. 字符串中的单词反转

3.1 问题复杂性与解决思路

这道题目比简单反转复杂得多，需要处理：

1. 去除首尾空格
2. 去除单词间多余空格
3. 反转整个字符串
4. 反转每个单词

解决这个问题的关键在于分步骤处理：

1. 先清理空格
2. 整体反转
3. 逐个单词反转

3.2 代码实现与细节处理

cpp复制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;
    for (int fast = 0; 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);
}

string reverseWords(string s) {
    removeExtraSpaces(s);
    reverse(s, 0, s.size() - 1);
    int start = 0;
    for (int i = 0; i <= s.size(); ++i) {
        if (i == s.size() || s[i] == ' ') {
            reverse(s, start, i - 1);
            start = i + 1;
        }
    }
    return s;
}

关键技巧：

1. 快慢指针法去除多余空格，时间复杂度O(n)
2. 整体反转后，单词顺序颠倒但单词内部字母顺序正确
3. 逐个单词反转恢复单词内部原始顺序

3.3 性能优化与注意事项

优化点：

1. 原地操作，避免创建新字符串
2. 一次遍历完成空格去除
3. 复用反转函数减少代码重复

注意事项：

1. 字符串可能全为空格
2. 单词间可能有多个空格
3. 反转单词时要准确确定单词边界

4. KMP算法实现strStr()

4.1 KMP算法核心思想

KMP算法的精髓在于利用部分匹配信息（next数组）避免不必要的比较：

1. 预处理模式串，构建next数组
2. next数组记录最长相同前后缀长度
3. 匹配失败时根据next数组跳过已知匹配部分

4.2 next数组构建详解

cpp复制void getNext(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;
    }
}

next数组构建过程：

1. 初始化j=0，next[0]=0
2. 遍历字符串，i从1开始
3. 不匹配时回退j到next[j-1]
4. 匹配时j前进，记录next[i]=j

4.3 完整KMP实现

cpp复制int strStr(string haystack, string needle) {
    if (needle.empty()) return 0;
    vector<int> next(needle.size());
    getNext(&next[0], 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 - needle.size() + 1;
        }
    }
    return -1;
}

匹配过程要点：

1. 主串指针i只前进不回退
2. 模式串指针j根据next数组调整
3. 完全匹配时返回正确位置

4.4 KMP算法复杂度分析

时间复杂度：

• 构建next数组：O(m)，m为模式串长度
• 匹配过程：O(n)，n为主串长度
• 总复杂度：O(m+n)

空间复杂度：O(m)，用于存储next数组

5. 重复子字符串判断

5.1 问题转化与数学证明

关键结论：如果字符串s由重复子串构成，那么s的长度一定是子串长度的整数倍，且s的最长相同前后缀长度与s长度差就是最小重复子串长度。

数学关系：
len % (len - next[len-1]) == 0

5.2 代码实现与验证

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

验证步骤：

1. 构建next数组
2. 计算最小重复子串长度n = len - next[len-1]
3. 检查len是否能被n整除

5.3 特殊情况处理

需要考虑的特殊情况：

1. 空字符串
2. 单字符字符串
3. 全部相同字符的字符串
4. 无重复模式的字符串

测试用例示例：

1. "abab" → true
2. "aba" → false
3. "abcabcabc" → true
4. "a" → false

6. 字符串操作综合技巧

6.1 性能优化策略

1. 尽量减少字符串拷贝操作
2. 合理使用reserve预分配空间
3. 能用引用传递尽量不用值传递
4. 避免在循环中进行字符串拼接

6.2 调试与测试方法

1. 单元测试：为每个函数编写测试用例
2. 边界测试：测试空串、单字符串等边界情况
3. 性能测试：测试长字符串下的性能表现
4. 内存检查：确保没有内存泄漏

6.3 常见面试问题准备

1. 解释KMP算法原理
2. 分析字符串反转的时间复杂度
3. 如何处理包含unicode字符的字符串
4. 多线程环境下的字符串操作注意事项

在实际开发中，字符串操作是最基础也是最容易出问题的部分。理解这些算法的底层原理，不仅可以帮助我们通过面试，更能写出高效可靠的代码。特别是在处理用户输入、文件解析等场景时，正确的字符串处理方式可以避免很多潜在的安全问题和性能瓶颈。