C++ KMP 算法：原理、实现与应用全解析

标题

[C++ KMP 算法：原理、实现与应用全解析](#C++ KMP 算法：原理、实现与应用全解析)
- [一、KMP 算法的核心背景与优势](#一、KMP 算法的核心背景与优势)
- - [1.1 问题引入：暴力匹配的瓶颈](#1.1 问题引入：暴力匹配的瓶颈)
  - [1.2 KMP 的核心改进：利用「部分匹配信息」](#1.2 KMP 的核心改进：利用「部分匹配信息」)
- [二、KMP 的核心：部分匹配表（next 数组）](#二、KMP 的核心：部分匹配表（next 数组）)
- - [2.1 next 数组的定义](#2.1 next 数组的定义)
  - [2.2 next 数组的构建逻辑](#2.2 next 数组的构建逻辑)
  - [2.3 next 数组的 C++ 实现](#2.3 next 数组的 C++ 实现)
  - [2.4 优化版 next 数组（避免重复匹配）](#2.4 优化版 next 数组（避免重复匹配）)
- [三、KMP 匹配流程（核心实现）](#三、KMP 匹配流程（核心实现）)
- - [3.1 匹配逻辑](#3.1 匹配逻辑)
  - [3.2 完整 KMP 实现（基于基础版 next 数组）](#3.2 完整 KMP 实现（基于基础版 next 数组）)
  - [3.3 基于优化版 next 数组的匹配实现](#3.3 基于优化版 next 数组的匹配实现)
- [四、KMP 算法的关键细节解析](#四、KMP 算法的关键细节解析)
- - [4.1 next 数组的本质](#4.1 next 数组的本质)
  - [4.2 匹配位置的计算](#4.2 匹配位置的计算)
  - [4.3 边界条件处理](#4.3 边界条件处理)
- [五、KMP 算法的扩展应用](#五、KMP 算法的扩展应用)
- - [5.1 应用1：判断字符串是否为另一字符串的子串](#5.1 应用1：判断字符串是否为另一字符串的子串)
  - [5.2 应用2：查找字符串的最长重复子串](#5.2 应用2：查找字符串的最长重复子串)
  - [5.3 应用3：字符串的最小循环节](#5.3 应用3：字符串的最小循环节)
  - [5.4 应用4：替换文本中的模式串](#5.4 应用4：替换文本中的模式串)
- 六、常见错误与最佳实践
- - [6.1 常见错误](#6.1 常见错误)
  - [6.2 最佳实践](#6.2 最佳实践)
- [七、KMP 与其他匹配算法的对比](#七、KMP 与其他匹配算法的对比)
- 八、总结

C++ KMP 算法：原理、实现与应用全解析

KMP（Knuth-Morris-Pratt）算法是解决单模式串匹配问题的经典高效算法，核心优势是通过预处理模式串生成「部分匹配表（next 数组）」，避免匹配失败时文本串指针的回溯，将时间复杂度从暴力匹配的 (O(n \cdot m)) 降至 (O(n + m))（(n) 为文本串长度，(m) 为模式串长度）。本文将从核心原理、next 数组构建、匹配流程到实战优化，全面解析 KMP 算法的设计思想与 C++ 实现技巧。

一、KMP 算法的核心背景与优势

1.1 问题引入：暴力匹配的瓶颈

字符串匹配的核心需求是：在文本串 s 中查找模式串 p 的所有出现位置。

暴力匹配的逻辑是：逐字符比对，一旦失配，文本串指针回退到「起始位置+1」，模式串指针回退到0。

cpp 复制代码

// 暴力匹配示例（效率低）
vector<int> bruteForce(const string& s, const string& p) {
    vector<int> res;
    int n = s.size(), m = p.size();
    for (int i = 0; i <= n - m; ++i) {
        bool match = true;
        for (int j = 0; j < m; ++j) {
            if (s[i+j] != p[j]) {
                match = false;
                break;
            }
        }
        if (match) res.push_back(i);
    }
    return res;
}

缺陷：文本串指针频繁回退，最坏情况下（如 s=aaaaaab，p=aaab）时间复杂度为 (O(n \cdot m))，数据量大时完全不可用。

1.2 KMP 的核心改进：利用「部分匹配信息」

KMP 的关键洞察是：失配时，模式串不必从头匹配，而是回退到「最长相等前后缀」的末尾位置。

前缀：字符串的头部子串（不包含最后一个字符），如 abcde 的前缀为 a, ab, abc, abcd。
后缀：字符串的尾部子串（不包含第一个字符），如 abcde 的后缀为 e, de, cde, bcde。
最长相等前后缀（LPS） ：前缀和后缀中最长的相等子串长度，如 ababc 的 LPS 为 2（ab）。

示例：文本串 ababcabcacbab，模式串 abcabc。

当匹配到第5个字符（s[4]=b vs p[4]=b 匹配，s[5]=c vs p[5]=c 匹配，s[6]=a vs p[6] 越界？不，若失配发生在 p[3]，则模式串回退到 LPS[2] 位置，而非0。

二、KMP 的核心：部分匹配表（next 数组）

2.1 next 数组的定义

next 数组是 KMP 的核心，next[j] 表示模式串 p[0...j] 的「最长相等前后缀长度」，也可理解为：失配时模式串指针应回退到的位置。

模式串 p	a	b	c	a	b	c
索引 j	0	1	2	3	4	5
next[j]	0	0	0	1	2	3

解释：

p[0...3] = "abca"：最长相等前后缀为 "a"，长度1 → next[3]=1。
p[0...5] = "abcabc"：最长相等前后缀为 "abc"，长度3 → next[5]=3。

2.2 next 数组的构建逻辑

构建 next 数组采用「双指针法」，时间复杂度 (O(m))：

初始化：i=1（当前处理的位置），j=0（最长相等前后缀的长度），next[0]=0（单个字符无前后缀）。
匹配：若 p[i] == p[j]，则 j++，next[i] = j，i++。
失配：若 p[i] != p[j]，则 j = next[j-1]（回退到上一个最长相等前后缀位置），直到 j=0 或匹配成功。

2.3 next 数组的 C++ 实现

cpp 复制代码

// 构建 next 数组（版本1：存储最长相等前后缀长度）
vector<int> buildNext(const string& p) {
    int m = p.size();
    vector<int> next(m, 0);  // next[0] 固定为0
    int j = 0;  // 最长相等前后缀的长度

    for (int i = 1; i < m; ++i) {
        // 失配：回退 j 到 next[j-1]
        while (j > 0 && p[i] != p[j]) {
            j = next[j - 1];
        }
        // 匹配：j 加1，记录 next[i]
        if (p[i] == p[j]) {
            j++;
            next[i] = j;
        }
        // 若 j=0 且失配，next[i] 保持0
    }
    return next;
}

2.4 优化版 next 数组（避免重复匹配）

上述 next 数组存在一个问题：若 p[i] == p[next[i]]，失配时回退到 next[i] 仍会失配，需进一步优化：

cpp 复制代码

// 构建优化版 next 数组（版本2：直接指向最终回退位置）
vector<int> buildNextOpt(const string& p) {
    int m = p.size();
    vector<int> next(m, -1);  // 初始化为-1，简化匹配逻辑
    int i = 0, j = -1;

    while (i < m - 1) {
        if (j == -1 || p[i] == p[j]) {
            i++;
            j++;
            // 优化：避免重复匹配
            if (p[i] != p[j]) {
                next[i] = j;
            } else {
                next[i] = next[j];
            }
        } else {
            j = next[j];
        }
    }
    return next;
}

说明：优化版 next 数组将 next[0] 设为-1，匹配时逻辑更简洁，是工业界常用版本。

三、KMP 匹配流程（核心实现）

3.1 匹配逻辑

初始化：文本串指针 i=0，模式串指针 j=0，next 数组已预处理。
匹配：若 s[i] == p[j]，则 i++，j++；若 j == m（模式串匹配完成），记录位置并回退 j = next[j-1]（继续查找下一个匹配）。
失配：若 s[i] != p[j]，则 j = next[j-1]（j>0时），否则 i++（j=0时直接移动文本串）。

3.2 完整 KMP 实现（基于基础版 next 数组）

cpp 复制代码

#include <iostream>
#include <vector>
#include <string>
using namespace std;

// 构建基础版 next 数组
vector<int> buildNext(const string& p) {
    int m = p.size();
    vector<int> next(m, 0);
    int j = 0;

    for (int i = 1; i < m; ++i) {
        while (j > 0 && p[i] != p[j]) {
            j = next[j - 1];
        }
        if (p[i] == p[j]) {
            j++;
            next[i] = j;
        }
    }
    return next;
}

// KMP 匹配：返回模式串在文本串中所有起始位置
vector<int> kmpMatch(const string& s, const string& p) {
    vector<int> res;
    int n = s.size(), m = p.size();
    if (m == 0 || n < m) return res;

    vector<int> next = buildNext(p);
    int j = 0;  // 模式串指针

    for (int i = 0; i < n; ++i) {
        // 失配：回退模式串指针
        while (j > 0 && s[i] != p[j]) {
            j = next[j - 1];
        }
        // 匹配：移动模式串指针
        if (s[i] == p[j]) {
            j++;
        }
        // 匹配完成：记录位置，回退模式串指针继续查找
        if (j == m) {
            res.push_back(i - m + 1);  // 计算起始位置
            j = next[j - 1];           // 回退，查找下一个匹配
        }
    }
    return res;
}

// 测试代码
int main() {
    string s = "ababcabcacbab";
    string p = "abcabc";

    vector<int> res = kmpMatch(s, p);
    cout << "文本串：" << s << endl;
    cout << "模式串：" << p << endl;
    cout << "匹配位置：";
    for (int pos : res) {
        cout << pos << " ";  // 输出：2（s[2:8] = "abcabc"）
    }
    cout << endl;

    return 0;
}

3.3 基于优化版 next 数组的匹配实现

cpp 复制代码

// 构建优化版 next 数组
vector<int> buildNextOpt(const string& p) {
    int m = p.size();
    vector<int> next(m, -1);
    int i = 0, j = -1;

    while (i < m - 1) {
        if (j == -1 || p[i] == p[j]) {
            i++;
            j++;
            if (p[i] != p[j]) {
                next[i] = j;
            } else {
                next[i] = next[j];
            }
        } else {
            j = next[j];
        }
    }
    return next;
}

// 优化版 KMP 匹配
vector<int> kmpMatchOpt(const string& s, const string& p) {
    vector<int> res;
    int n = s.size(), m = p.size();
    if (m == 0 || n < m) return res;

    vector<int> next = buildNextOpt(p);
    int i = 0, j = 0;

    while (i < n) {
        if (j == -1 || s[i] == p[j]) {
            i++;
            j++;
            if (j == m) {
                res.push_back(i - m);
                j = next[j];  // 回退
            }
        } else {
            j = next[j];  // 失配回退
        }
    }
    return res;
}

四、KMP 算法的关键细节解析

4.1 next 数组的本质

next 数组的核心是「最长相等前后缀长度」，其作用是：失配时，模式串指针不必回退到0，而是回退到最长相等前缀的末尾，利用已匹配的前缀信息避免重复比对。

4.2 匹配位置的计算

当模式串完全匹配（j == m）时，文本串的当前位置是 i，因此模式串的起始位置为 i - m（优化版）或 i - m + 1（基础版），需根据指针逻辑统一。

4.3 边界条件处理

模式串为空：直接返回空结果。
文本串长度小于模式串：直接返回空结果。
模式串只有一个字符：退化为暴力匹配（next[0]=0，失配时 j 回退到0，i 加1）。

五、KMP 算法的扩展应用

5.1 应用1：判断字符串是否为另一字符串的子串

cpp 复制代码

bool isSubstring(const string& s, const string& p) {
    vector<int> res = kmpMatch(s, p);
    return !res.empty();
}

5.2 应用2：查找字符串的最长重复子串

利用 KMP 的 next 数组，字符串 s 的最长重复子串长度为 next.back()（前提是 next.back() * 2 >= s.size()）：

cpp 复制代码

int longestRepeatedSubstring(const string& s) {
    vector<int> next = buildNext(s);
    int maxLen = next.back();
    // 验证：最长重复子串需满足长度*2 <= 原串长度
    return (maxLen > 0 && maxLen * 2 <= s.size()) ? maxLen : 0;
}

5.3 应用3：字符串的最小循环节

若字符串 s 由循环节重复构成，则最小循环节长度为 s.size() - next.back()：

cpp 复制代码

int minCycleLength(const string& s) {
    int n = s.size();
    vector<int> next = buildNext(s);
    int cycle = n - next.back();
    // 验证：是否能被循环节整除
    return (n % cycle == 0) ? cycle : n;
}

// 测试：s = "abcabcabc" → cycle = 3

5.4 应用4：替换文本中的模式串

cpp 复制代码

string replacePattern(const string& s, const string& p, const string& replaceStr) {
    vector<int> posList = kmpMatch(s, p);
    string res = s;
    int offset = 0;  // 替换后长度变化的偏移量

    for (int pos : posList) {
        int realPos = pos + offset;
        res.replace(realPos, p.size(), replaceStr);
        offset += replaceStr.size() - p.size();
    }
    return res;
}

// 测试：s="ababc", p="ab", replaceStr="xx" → res="xxxxc"

六、常见错误与最佳实践

6.1 常见错误

next 数组初始化错误：基础版 next[0] 应设为0，优化版应设为-1，混淆会导致匹配失败。
匹配位置计算错误：未正确计算起始位置（如漏减1），导致返回的位置偏移。
失配回退逻辑错误 ：基础版中 j = next[j-1] 需加 j>0 的判断，否则 j=-1 会访问 next[-1] 导致崩溃。
忽略多匹配场景：匹配完成后未回退 j，导致只能找到第一个匹配位置。

6.2 最佳实践

选择合适的 next 数组版本 ：
- 学习/理解原理：用基础版 next 数组（直观体现最长相等前后缀）。
- 实际开发：用优化版 next 数组（效率更高，逻辑更简洁）。
边界条件优先处理：匹配前先判断模式串为空、文本串更短等情况，避免后续逻辑出错。
统一字符集处理：若需处理大小写不敏感匹配，先将文本串和模式串统一转为小写/大写。

性能优化 ：对于超长字符串，可预先 reserve 向量空间，避免频繁扩容：

cpp 复制代码

vector<int> buildNext(const string& p) {
    int m = p.size();
    vector<int> next;
    next.reserve(m);  // 预分配空间
    next.push_back(0);
    // ... 后续逻辑
}

七、KMP 与其他匹配算法的对比

算法	时间复杂度	空间复杂度	适用场景	优势
暴力匹配	(O(n \cdot m))	(O(1))	短字符串匹配	实现简单，无额外空间
KMP 算法	(O(n + m))	(O(m))	长文本+长模式串匹配	无文本串回溯，效率稳定
BM 算法	(O(n + m))	(O(m))	实际场景（如文本编辑器）	平均效率高于 KMP
AC 自动机	(O(n + \sum m))	(O(\sum m))	多模式串匹配	一次预处理，匹配多个模式

选择建议：

单模式串匹配：优先用 KMP（实现简单，效率稳定）。
多模式串匹配：用 AC 自动机（基于 Trie + 失败指针）。
极致性能需求：用 BM 算法（工业界常用，如 grep 工具）。

八、总结

KMP 算法是单模式串匹配的经典算法，核心要点可总结为：

核心思想：利用「最长相等前后缀」构建 next 数组，避免文本串指针回溯，将时间复杂度优化到线性。
next 数组：基础版存储最长相等前后缀长度，优化版直接指向最终回退位置，后者更适合实际开发。
匹配流程：双指针遍历文本串和模式串，失配时仅回退模式串指针，匹配完成后回退继续查找多匹配。
扩展应用：可解决子串判断、最长重复子串、最小循环节等问题，是字符串处理的基础算法。

掌握 KMP 的关键：

理解 next 数组的构建逻辑（双指针法 + 失配回退）。
区分基础版和优化版 next 数组的差异与适用场景。
注意边界条件（如空串、短文本）和匹配位置的计算。

KMP 算法是 C++ 开发者必须掌握的核心算法之一，其「利用已匹配信息避免重复计算」的思想，也广泛应用于其他算法设计中。