KMP 字符串匹配详解

一、KMP 的作用

KMP 用于解决字符串匹配问题，当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了。

二、题目

链接：28. 找出字符串中第一个匹配项的下标 - 力扣（LeetCode）

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

用例：
输入：haystack = “aabaabaaf”, needle = “aabaaf”
输出：3
解释：“aabaaf” 在下标 3 处匹配。第一个匹配项的下标是 3 ，所以返回 3 。

三、KMP 算法的思路

1、基本术语

先介绍一些词，后面要用：

• 文本串：上一节题目中的 haystack，比如 “aabaabaaf”
• 模式串：上一节题目中的 needle，比如 “aabaaf”
• 前缀：一个字符串中，包含首字母，但不包含尾字母的所有子串
• 后缀：一个字符串中，包含尾字母，但不包含首字母的所有子串
• 最长公共前后缀：一个字符串中，最长的相等的前缀和后缀。比如 “aaba” 的最长公共前后缀是 “a”，“aabaa” 的最长公共前后缀是 “aa”，“aabaaf” 不存在最长公共前后缀
• 前缀表：长度和「模式串」相同，每一位存储「模式串」对应位置及其之前所有字符所组成的字符串中，最长公共前后缀长度

2、求前缀表

原理

前缀表长度和「模式串」相同，每一位存储「模式串」对应位置及其之前所有字符所组成的字符串中，最长公共前后缀长度。比如我们用数组 next 表示前缀表，如果模式串为 “aabaaf”，那么：
next[0] = 0 ← a
next[1] = 1 ← aa
next[2] = 0 ← aab
next[3] = 1 ← aaba
next[4] = 2 ← aabaa
next[5] = 0 ← aabaaf
所以 next = {0, 1, 0, 1, 2, 0}。

代码实现

用代码实现上述过程，总体思路是：

• 用 i 指向模式串后缀末尾，j 指向前缀末尾
• 先处理前缀末尾不等于后缀末尾的情况（根据 next[j - 1] 调整前缀末尾 j 的位置）
• 再处理前缀末尾等于后缀末尾的情况（前缀末尾 j 后移）
• 最后把最长公共前后缀的长度记录在前缀表 next 中
  代码如下：

void getNext(int* next, string& s) {
    next[0] = 0;  // 只有一个字符时，无公共前后缀
    int j = 0;  // j 是前缀末尾的位置，同时承担着记录最长公共前后缀的职责
    for (int i = 1; i < s.size(); ++i) {  // i 是后缀末尾的位置，从下标 1 的位置开始
        while (j > 0 && s[j] != s[i]) {  // 当此时的前缀末尾字符和后缀末尾字符不相等时
            j = next[j - 1];  // 调整前缀末尾的位置，原理见图 1
        }
        if (s[j] == s[i]) {  // 当此时的前缀末尾字符等于后缀末尾字符时
            ++j;  // 前缀末尾后移，同时由于 j 记录着公共前后缀的长度，所以长度也加 1
        }
        next[i] = j;  // next[i] 记录前 i 个字符构成的字符串的最长公共前后缀长度
    }
}

其中，代码中前缀末尾字符和后缀末尾字符不相等时的处理方法，可以结合图 1 来理解：

图1

3、寻找匹配的字符串

在理解了求前缀表的思路后，利用前缀表去寻找匹配字符串的思路就很容易理解了，因为它们俩的思路是一样的：

• 对模式串用 getNext 生成前缀表 next
• 用 i 指向文本串 haystack 当前字符位置，用 j 指向模式串 needle 当前字符位置
• 先处理文本串当前字符与模式串当前字符不相等的情况（根据 next[j - 1]调整 j 的位置）
• 再处理文本串当前字符与模式串当前字符相等的情况（j 后移）
• 如果 j 等于模式串长度，说明匹配成功

代码如下：

    int strStr(string haystack, string needle) {
        if (needle.size() > haystack.size())  // 模式串比文本串还长
            return -1;
        if (needle.size() == 0) // 模式串是空的
            return 0;
        int* next = new int[needle.size()];  // 创建动态数组
        getNext(next, needle);  // 根据模式串生成前缀表
        int j = 0;
        for (int i = 0; i < haystack.size(); ++i) {
            while (j > 0 && needle[j] != haystack[i]) {  // 字符不相等
                j = next[j - 1];  // 调整 j 的位置
            }
            if (needle[j] == haystack[i]) { // j 后移
                ++j;
            }
            if (j == needle.size()) {  // j 走到头了，说明匹配成功
                delete [] next; // 退出前释放动态数组
                return i - j + 1;
            }
        }
        delete [] next; // 退出前释放动态数组
        return -1;
    }

其中文本串当前字符与模式串当前字符不相等的情况，可以结合图 2 来理解，和图 1 有许多共同之处：

图 2

完整代码：

class Solution {
public:
    void getNext(int* next, string& s) {
        next[0] = 0;  // 只有一个字符时，无公共前后缀
        int j = 0;  // j 是前缀末尾的位置，同时承担着记录最长公共前后缀的职责
        for (int i = 1; i < s.size(); ++i) {  // i 是后缀末尾的位置，从下标 1 的位置开始
            while (j > 0 && s[j] != s[i]) {  // 当此时的前缀末尾字符和后缀末尾字符不相等时
                j = next[j - 1];  // 调整前缀末尾的位置，原理见图 1
            }
            if (s[j] == s[i]) {  // 当此时的前缀末尾字符等于后缀末尾字符时
                ++j;  // 前缀末尾后移，同时由于 j 记录着公共前后缀的长度，所以长度也加 1
            }
            next[i] = j;  // next[i] 记录前 i 个字符构成的字符串的最长公共前后缀长度
        }
    }

    int strStr(string haystack, string needle) {
        if (needle.size() > haystack.size())  // 模式串比文本串还长
            return -1;
        if (needle.size() == 0) // 模式串是空的
            return 0;
        int* next = new int[needle.size()];  // 创建动态数组
        getNext(next, needle);  // 根据模式串生成前缀表
        int j = 0;
        for (int i = 0; i < haystack.size(); ++i) {
            while (j > 0 && needle[j] != haystack[i]) {  // 字符不相等
                j = next[j - 1];  // 调整 j 的位置
            }
            if (needle[j] == haystack[i]) { // j 后移
                ++j;
            }
            if (j == needle.size()) {  // j 走到头了，说明匹配成功
                delete [] next; // 退出前释放动态数组
                return i - j + 1;
            }
        }
        delete [] next; // 退出前释放动态数组
        return -1;
    }
};

使用 vector 替代动态数组：

class Solution {
public:
    vector<int> getNext(string& s) {
	    vector<int> next(s.size());
        next[0] = 0;  // 只有一个字符时，无公共前后缀
        int j = 0;  // j 是前缀末尾的位置，同时承担着记录最长公共前后缀的职责
        for (int i = 1; i < s.size(); ++i) {  // i 是后缀末尾的位置，从下标 1 的位置开始
            while (j > 0 && s[j] != s[i]) {  // 当此时的前缀末尾字符和后缀末尾字符不相等时
                j = next[j - 1];  // 调整前缀末尾的位置，原理见图 1
            }
            if (s[j] == s[i]) {  // 当此时的前缀末尾字符等于后缀末尾字符时
                ++j;  // 前缀末尾后移，同时由于 j 记录着公共前后缀的长度，所以长度也加 1
            }
            next[i] = j;  // next[i] 记录前 i 个字符构成的字符串的最长公共前后缀长度
        }
    }

    int strStr(string haystack, string needle) {
        if (needle.size() > haystack.size())  // 模式串比文本串还长
            return -1;
        if (needle.size() == 0) // 模式串是空的
            return 0;
        vector<int> next = getNext(needle);  // 根据模式串生成前缀表
        int j = 0;
        for (int i = 0; i < haystack.size(); ++i) {
            while (j > 0 && needle[j] != haystack[i]) {  // 字符不相等
                j = next[j - 1];  // 调整 j 的位置
            }
            if (needle[j] == haystack[i]) { // j 后移
                ++j;
            }
            if (j == needle.size()) {  // j 走到头了，说明匹配成功
                return i - j + 1;
            }
        }
        return -1;
    }
};