串文档之KMP

要说 KMP，首先要知道为什么要引入 KMP？KMP 到底解决了什么问题？KMP 有什么优势？

首先，下面先介绍字符串的模式匹配概念，再来解决模式匹配的算法，再来引入 KMP。

首先，我们应该有过在一个文本文件中查找某个字符串（或某个关键字）的经历，如图：

在上图中，forget 被称为子串或者模式串，而那一段文本内容被称为主串。『查找下一个』按钮第一次按它就是找这个子串 forget 第一次在主串中出现的位置，然后背景色变为蓝色显示出来。

如上，这种求子串在主串中的位置的 *** 作称为串的模式匹配。那么它背后的原理是怎么样的呢？是如何通过代码实现的呢？

我们会想到这么一种方法：穷举主串的所有子串，然后判断它们是否与给定的子串相匹配。

用算法的思想来描述，就是这样的：从主串的第一个位置（下标为 0）起和子串的第一个字符开始比较，如果相等，则继续逐一比较后续字符；如果不相等则从主串的第二个字符开始，再重新用上一步的方法与子串中的字符做比较。以此类推，直到比较完子串中的所有字符。若匹配成功，则返回子串在主串中的位置；若匹配失败，则返回一个可用于区别主串所有位置的标记，如 'str="helxworhellold"; substr="hello"'。以 /** * 定位子串，若主串 str 中存在与串 substr 值相同的子串，则返回它在主串 str 中第一次出现的位置 * @param str 主串 * @param substr 子串 * @return 如果存在子串则返回第一次出现的位置，否则返回 0 */ 为例如图所示：

实现代码如下：

int
index (,String str) String substr// 变量，i 记录串 str 中字符的下标，j 记录串 substr 中字符的下标 {
    int
    = i 0 ,= j 0 ;// 同时扫描主串 str 和子串 substr
    while
    ( <i . str&&length < j . substr)length// 如果主串中的字符与子串中的字符相等，则继续比较下一对字符 {
        if
        ( .str[ch]i== . substr[ch]j)// 同时加一，指向串的下一个字符 {
            ++
            i;++
            j;}
        // 如果不相等，那么就继续比较主串中下一个字符开始的串与子串，注意，需要恢复 i 和 j
        else
        // 恢复主串中的 i，回到第 i-j 个字符，然后加一表示下一个字符 {
            =
            i - i + j 1 ;// 而 j 要恢复为子串的第一个字符的下标，即为 0，又要从 0 开始比较起走
            =
            j 0 ;}
        }
    // 如果循环结束 j 等于 length，那么表示主串中一定存在子串
    if
    ( ==j . substr)length// 则返回子串第一次出现的位置 {
        return
        - i ; j}
    else // 如果不相等，则表示子串不存在于主串中，在返回标记 0 {
        return
        ';' }}
    O(n*m)
i

注：如果想要知道完整可运行代码请参考：String.c。

上述算法称之为 BF（Brute Force）算法，即暴力穷举算法。其时间复杂度在最坏的情况下会达到 j，在其中 n 和 m 分别是主串和子串的长度。

通过上面的代码，还会发现每次不匹配时，计数指针 i 和 i-j+1 都会回溯，其中 j 会回到 0 的位置，而 str 会回到 str="helxworhellold"; substr="hello" 的位置，又从子串的第一个字符开始比较起走。

实际上，完全没必要从主串 str="abaabaabeca"; substr="abaabe" 的每一个字符开始穷举每一种情况，为了得到更优的算法，三位大神Knuth、Morris和Pratt对该算法进行了改进，称之为 KMP 算法。

所以 KMP 算法是为了更快的在主串中匹配到子串。

下面就来一步步看如何优化它，即 KMP 算法是如何优化它的。

实际上上面的例子 i 并不能很好的体现出 KMP 算法的优势来，至于原因后面会进行说明。所以给出一个更适合 KMP 算法发挥优势的例子：i-j+1。它使用暴力穷举法的图解如下：

如图所展示的例子，按照 BF 算法，当不等时，则计数指针 j 回退到 i=1, j=0 处，而计数指针 i 回退到 0，即 j，如图所示：

优化来了，其实可以让 j 不回退，而是让 "ab" 回退到第三个位置（即下标为 2 的位置），接着比较即可。这种回溯策略就是 KMP 算法的核心。

那么问题来了，为什么要 i 回退到第三个位置（下标为 2 的位置）？而不是第一个位置或者第二个位置，亦或者第四个位置呢？

因为子串开头的两个字符 j 和 substr 指向的字符的前面两个字符一模一样，如图所示。所以 "ab" 可以直接回退到第三个位置（下标为 2 的位置）继续比较了，因为前面两个字符已经相等了，相当于已经比较过了。

那么问题来了，怎么知道子串 str 中开头的两个字符 i 和主串 "ab" 中 str 指向的字符前面的两个字符 i 一模一样呢？难道还需要比较？

通过观察发现主串 "ab" 中 substr 指向的字符前面的两个字符 j 和子串 "ab" 中 i 指向的字符前面两个字符 j 一模一样，注意，这不是偶然，只有它们（即 i++ 和 j++ 所指向的字符）一直相等，才会 substr、str 走到当前的位置。

也就是我们不必去判断子串 i 中开头的两个字符和主串 substr 中 str 指向的字符的前面的两个字符是否一样，只需要在子串 substr 本身比较就可以了，即不需要主串 "Snape" 的参与了，就能确定相等的字符情况。

那么问题来了，怎么在子串 "S" 中确定相等的字符情况呢？

在回答上面的问题之前，需要了解一些关于前缀和后缀的概念：

• 前缀：是指在字符串中除了最后一个字符以外，一个字符串的全部头部组合。如字符串 "Sn" 中，"Sna"、"Snap"、"Hagrid" 和 "agrid" 都是它的正确前缀。
• 后缀：是指在字符串中除了第一个字符以外，一个字符串的全部尾部组合。如字符串 "grid" 中，"rid"、"id"、"d"、n 和 n- 都是它的正确后缀。

在前缀和后缀中都不可以取字符串本身。如果字符串的长度为 "aba"，那么前缀和后缀的长度最多达到 "a"。

我们还得知道一个概念：即 （子）模式中与同（子）模式中正确后缀匹配的最长正确前缀的长度。可能有些难以理解，举例来说明：

• 有一个字符串 "ab"，在这个字符串中有两个正确前缀（"a" 和 "ba"）和两个正确后缀（"ab" 和 "a"）。正确的前缀 "a" 与两个正确的后缀中的任何一个都不匹配（即相等的意思）。但是正确的前缀 "a" 与正确的后缀 "abab" 匹配。因此，匹配正确后缀的最长正确前缀的长度，在这种情况下，是 1（即正确前缀 "a" 中字字符的个数）。
• 有一个字符串 "ab"，在这个字符串中有三个正确前缀（"aba"、"b" 和 "ab"）和三个正确后缀（"bab"、"a" 和 "aba"）。正确的前缀 "ab" 和三个正确的后缀中任何一个都不匹配；正确的前缀 "ab" 和三个正确的后缀中任何一个都不匹配；正确的前缀 "ab" 和正确的后缀 "ababa" 匹配。因此，匹配正确后缀的最长正确前缀的长度，在这种情况，是 2（即正确前缀 "a" 中字字符的个数）。
• 有一个字符串 "ab"，在这个字符串中有四个正确的前缀（"aba"、"abab"、"a" 和 "ba"）和四个正确的后缀（"aba"、"baba"、"a" 和 "a"）。正确的前缀 "ab" 和四个正确的后缀中的 "aba" 后缀相匹配；正确的前缀 "aba" 和四个正确的后缀中的任何一个都不匹配；正确的前缀 "abab" 和四个正确的后缀中的 "a" 相匹配；正确的前缀 "aba" 和四个正确的后缀中的任何一个都不匹配。这时候，我们发现有两个匹配成功的项："aba" 和 "a"。但是我们要求的是最长，而 "aba" 比 substr 长，所以最终的结果是 3（即正确前缀 j 中字字符的个数）。

即找到子串 j 中当前 substr="abaabe" 所指向的字符前面所有字符组成的串中正确后缀匹配的最长正确前缀的长度。这个长度就是 j=5 回退的位置。

上图子串 "abaab" 中当 "a" 时它前面所有字符组成的串是 "ab"，该串所有的正确前缀有："aba"、"abaa"、"b"、"ab"，该串所有的正确后缀有："aab"、"baab"、"ab"、j。其中正确后缀匹配的最长正确前缀是 i，它的长度是 2。所以 j 可以退出到 2 （下标位置）继续比较。

因此当 j 和 len 指向的字符不相等时，只需要求出 i 所指向的字符前面所有字符组成的串中正确后缀匹配的最长正确前缀的长度 j，就可以让 len 不变，i 回退到 j 位置（下标位置）继续比较。

通过上面的方法，我们已经知道了当 j 和 j 指向的字符不相等时可以进行的回溯策略。

那么问题来了，j 所指向的每个字符都可能不匹配，那么是不是该计算每个 next[] 所指向的字符前面所有字符组成的串中正确后缀匹配的最长正确前缀的长度呢？

是的，我们必须要计算每一个 next[j] 的情况，而它们放在一个数组中就被称为 j 数组，该数组中 next 表示 substr="abaabe" 要回退的位置（下标位置）。

那么我们就来手动求下子串 j=0 中 j 从 0 到 5 每一个数情况下的正确后缀匹配的最长正确前缀的长度吧：

• 当 a 时，next[0]=-1 所指向的字符 j=1 前面没有任何字符，所以无法计算，通常将其设定为 -1（这是一种规定）。即 j。
• 当 b 时，"a" 所指向的字符 next[1]=0 前面所有字符组成的串是 j=0，没有任何前缀和后缀，所以正确后缀匹配的最长正确前缀的长度为 0。即 j=1。其实无论什么串，当 j=2 或 j 时都会是这种结果。
• 当 a 时，"ab" 所指向的字符 "a" 前面所有字符组成的串是 "b"，它的正确前缀有 next[2]=0，它的正确后缀有 j=3，但没有相匹配的情况，所以正确后缀匹配的最长正确前缀的长度为 0。即 j。
• 当 a 时，"aba" 所指向的字符 "a" 前面所有字符组成的串是 "ab"，它的正确前缀有 "a"、"ba"，它的正确后缀有 "a"、next[3]=1，能相匹配的情况是 j=4，所以正确后缀匹配的最长正确前缀的长度为 1。即 j。
• 当 b 时，"abaa" 所指向的字符 "a" 前面所有字符组成的串是 "ab"，它的正确前缀有 "aba"、"a"、"aa"，它的正确后缀有 "baa"、"a"、next[4]=1，能相匹配的情况是 j=5，所以正确后缀匹配的最长正确前缀的长度为 1。即 j。
• 当 e 时，"abaab" 所指向的字符 "a" 前面所有字符组成的串是 "ab"，它的正确前缀有 "aba"、"abaa"、"b"、"ab"，它的正确后缀有 "aab"、"baab"、"a"、"ab"，能相匹配的情况有 "ab" 和 next[5]=2，但我们要求最长的，所以选择 substr，所以正确后缀匹配的最长正确前缀的长度为 2。即 next[]。

所以最终子串 next 生成的 next[] 数组如下：

根据上面的计算过程，我们还可以得到这样一个通用计算公式：

那么问题来了，我们现在如何手动推算出 next[] 数组，但是该如何用代码来计算出 void 数组呢？这才是难点，也是最难理解的地方。

我们来看看求得 getNext 数组的代码：

( ,intString substr[ ] next)int= {
    0 j , =- k 1 ;[0
    next]=- 1 ;while(
    < .j - substr1length ) if( {
        == -k 1 ||. [ substr]ch==j. [ substr]ch)k++; {
            j++;
            k[]
            next=j; } kelse
        = [ {
            k ] next;k}}
        }
    substr
next[]

说明一些代码中各局部变量的含义：

• 其中 next[] 表示待求 j 数组的子串；
• substr 数组用来存放每个 j 在子串 next[] 中所指向的字符前面所有字符组成的串中正确后缀匹配的最长正确前缀的长度；
• substr 既是指 k 数组的下标，又是指子串 j 中的下标；
• next[j] 表示的就是 next[] 所指向的字符前面所有字符组成的串中正确后缀匹配的最长正确前缀的长度。即 if(k==-1)。

下面分三种情况来分析 j=0 数组的求解过程，即代码是为什么要这样写的：

• 第一种情况：特殊情况。对应代码中 j=1 的条件判断语句。

即当 k 或者 j 时，它们的 next[] 值都为 0，即 k 所指向的字符前面所有字符组成的串中正确后缀匹配的最长正确前缀的长度为 0，上面手动求解 next[0]=-1 数组的过程中可以验证。但是通常为了后面 substr.ch[j]==substr.ch[k] 值计算的方便，让 if(substr.ch[j]==substr.ch[k])，这样没有任何影响。如图所讲的例子：

• 第二种情况：当 substr="abcabcd" 时。对应代码中 next[] 的条件判断语句。

如图，假如子串 substr.ch[j]==substr.ch[k]，那么通过手动求取 [substr.ch[0] ~ substr.ch[k-1]] == [substr.ch[j-k] ~ substr.ch[j-1]] 数组如下：

观察上图发现，当 ['a', 'b'] == ['a', 'b'] 时，必然有 k（在图中是 [substr.ch[0] ~ substr.ch[k-1]]），此时的 [0 ~ k-1] 就是正确后缀匹配的最长正确前缀的长度。所以进行如下推论：

注：['a', 'b'] 只是表示下标为 ['a', 'b', 'c'] 之间所有字符的集合，如 [substr.ch[0], substr.ch[k-1]] == [substr.ch[j-k], substr.ch[j-1]] 、substr.ch[j] == substr.ch[k] 这样的，没有什么特殊含义。

• 因为 [substr.ch[0], substr.ch[k]] == [substr.ch[j-k], substr.ch[j]]
• 并且 next[j+1] = k+1
• 所以 next[j+1] = next[j]+1
• 即 substr.ch[j]!=substr.ch[k]，即 else。

• 第三种情况：当 k = next[k]; 时。对应代码中 str.ch[i]!=substr.ch[j] 的条件判断语句。

注：j 太难理解了。我也没有理解到，所以下面只是讲一下我的理解，没有说明那些证明过程，因为我也还彻底掌握。建议参考多份资料来进行理解把握。

我们知道 KMP 算法是当 next[j] 时让子串中的 substr.ch[j]!=substr.ch[k] 进行回溯，回溯到 k 的位置。

所以在这里当 next[k] 时也让 substr="abacdababc" 进行回溯，回溯到 next[k] 的位置。在下图中我们以 next[k-1] 为例：

那么问题来了，为什么是回溯到 substr.ch[j]==substr.ch[k]，而不是 substr.ch[j] 呢？

由第二种情况可知，当 k 时，next[j+1]=k+1 的正确后缀匹配的最长正确前缀的长度是 substr.ch[j]!=substr.ch[k]，即 next[j+1]。再由图上可知此时 substr，所以 substr.ch[0] ~ substr.ch[k]。

( ,intString substr[ ] nextval)int= {
    0 j , =- k 1 ;[0
    nextval]=- 1 ;while(
    < .j - substr1length ) if( {
        == -k 1 ||. [ substr]ch==j. [ substr]ch)k++; {
            j++;
            kif(
            . [substr]ch==j. [ substr]ch)k[] {
                nextval=j[ ] nextval;k}else
            [ ] {
                nextval=j; } k}
            else
        = [ {
            k ] nextval;k}}
        }
    nextval
nextval[]

getNext
( ,intString substr[ ] next)int= {
    0 j , =- k 1 ;[0
    next]=- 1 ;while(
    < .j - substr1length ) if( {
        == -k 1 ||. [ substr]ch==j. [ substr]ch)k++; {
            j++;
            k[]
            next=j; } kelse
        = [ {
            k ] next;k}}
        }
    /**
 * 改进的 KMP 算法求 nextval 数组
 * @param substr 子串
 * @param nextval 数组
 */
void

getNextVal
( ,intString substr[ ] nextval)int= {
    0 j , =- k 1 ;[0
    nextval]=- 1 ;while(
    < .j - substr1length ) if( {
        == -k 1 ||. [ substr]ch==j. [ substr]ch)k++; {
            j++;
            kif(
            . [substr]ch==j. [ substr]ch)k[] {
                nextval=j[ ] nextval;k}else
            [ ] {
                nextval=j; } k}
            else
        = [ {
            k ] nextval;k}}
        }
    /**
 * 定位子串，若主串 str 中存在与串 substr 值相同的子串，则返回它在主串 str 中第一次出现的位置
 * @param str 主串
 * @param substr 子串
 * @return 如果存在子串则返回第一次出现的位置，否则返回 0
 */
int

index
( ,)String str// 声明 next 数组并调用 getNext 函数进行计算 String substrint {
    [
    . next]substr;lengthgetNext(
    ,)substr; next// 变量，i 记录串 str 中字符的下标，j 记录串 substr 中字符的下标int

    =
    0 i , =0 j ; // 同时扫描主串 str 和子串 substrwhile
    (
    < .i && str<length . j ) substr// 如果主串中的字符与子串中的字符相等，则继续比较下一对字符lengthif {
        (
        . [str]ch==i. [ substr]ch)j// 同时加一，指向串的下一个字符++ {
            ;
            i++;
            j}// 如果不相等，那么就回退 j
        else
            // j 回退到 next[j] 位置，而 i 不回退
        = {
            [
            j ] next;j}}
        // 如果循环结束 j 等于 length，那么表示主串中一定存在子串
    if
    (
    == .j ) substr// 则返回子串第一次出现的位置lengthreturn {
        -
        ; i } jelse
    // 如果不相等，则表示子串不存在于主串中，在返回标记 0 return {
        ';'
        } }
《2022 天勤数据结构》
    
《2022 王道数据结构》
KMP算法完美图解