快速字符串匹配一: 看毛片算法（KMP）

前言##

由于需要做一个快速匹配敏感关键词的服务，为了提供一个高效，准确，低能耗的关键词匹配服务，我进行了漫长的探索。这里把过程记录成系列博客，供大家参考。

在一开始，接收到快速敏感词匹配时，我就想到了 KMP 翻译过来叫“看毛片“的算法，因为大学的时候就学过它。听说到它的效率非常高。把原本字符串匹配效率 O(n*m) 缩短到了O(n+m)，把✖️变成了➕，真是了不得。

每次我回顾 KMP 算法时，都会发现自己是个小白，或者每次回顾时，都发现上次因为回顾而写的总结居然是错的！所以为了学习快速字符串匹配，并再次温故 KMP ，所以我决定使用 KMP 算法试一试。如果以后在面试的时候，可以将KMP 完整的写出来，那岂不是很牛逼？

孔子说过的“温故而知新” 真的是很有道理的，经过这次回顾，我觉得是时候为此写一篇全新的博客了，因为这次的理解肯定是正确的！

KMP 快是因为啥呢？是因为利用了字符串公共前后缀的特性，加快了匹配速度，但是转念一想，敏感关键词公共前后缀相等的情况可是很少的呀。那还有必要用KMP 吗？

当然有必要了，所谓技多不压身，了解掌握一种算法准没坏处，而且还可以比较 KMP 和 C# 中String.Contains() 的效率，开拓自己的眼界。

KMP##

以前在学习 KMP 的时候，我也看了网上很多博客，关于这个算法讲解的博客是非常多的，而且讲解的都很细致。奈何我每看过一次，就会忘记一次。所以这次温故，我是完全在纸上画画，自己理解的。毕竟自己的思路不容易忘，而别人的思路总是很容易忘的。并且，理解一个算法，得找到适合自己的角度。

因此我理解 KMP 算法的角度，就是 字符串前缀和后缀，在我的脑子里，用前缀和后缀去理解 KMP 是很容易的。

公共前后缀长度##

前缀和后缀，很容易理解，就是一个字符串的前半部分和后半部分。比如字符串 a b c x y a b c 的前缀有

a

a b

a b c 等等，后缀有

c

b c

a b c等等。

那么公共前后缀的意思就是，前缀和后缀相等。在上面这个例子中，公共前后缀 就是 a b c，长度为3。请注意，公共前后缀 和 回文串是不一样的哦。

a b c x y c b a 的公共前后缀，只是a ,而不是a b c。

原始的字符串匹配##

了解完 公共前后缀后。暂且放在一旁，去了解一下，原始的字符串匹配。

首先我们把 待匹配的字符串叫做 文本字符串，匹配的字符串叫做匹配字符串，比如我们要在 a b c x y a b c x y a 中匹配 a b c x y a b c y 是否存在。

于是 文本字符串 S 就是 ：a b c x y a b c x y a

**匹配字符串 ** P 就是： a b c x y a b c y

从肉眼看出来，匹配一定是失败的，因为 匹配字符串 最后一个字母 y 不匹配。

那么原始的字符串匹配过程就是 暴力的一位一位去比。首先，从第一位开始比较：

   0   1   2   3   4   5   6   7   8   9  10
   ↓
S  a   b   c   x   y   a   b   c   x   y   a
P  a   b   c   x   y   a   b   c   y
   ↑

第一位，相同比较第二位，一直比到第 8 位

   0   1   2   3   4   5   6   7   8   9  10
                                   ↓
S  a   b   c   x   y   a   b   c   x   y   a
P  a   b   c   x   y   a   b   c   y
                                   ↑

发现不相同，匹配失败，于是把 匹配字符串 向右移动一位。

   0   1   2   3   4   5   6   7   8   9  10
       ↓
S  a   b   c   x   y   a   b   c   x   y   a
P      a   b   c   x   y   a   b   c   y
       ↑

继续重复上面的过程，直到 文本字符串全部遍历完。 这种方法的效率最差的时候是 O( n*m ) ，就是那种每次都是最后一个字符匹配不了的情况。

快速移动##

有没有更快的方法呢？ 肯定是有的。但是不着急，我们还是按照上面的步骤，继续走下去。

当 匹配字符串 一直向右移动，移动到第 5 位的时候，终于发现首字母是匹配的情况了。，如下

   0   1   2   3   4   5   6   7   8   9  10
                       ↓
S  a   b   c   x   y   a   b   c   x   y   a
P                      a   b   c   x   y   a   b   c   y
                       ↑

其实我们发现，从 文本字符串 第一位之后的 b c x y 其实都没必要匹配的，因为它们和 匹配字符串首字母都不一样，如果可以直接跳过就好了。

那么有什么依据可以直接跳过吗？当然有，之前的 公共前后缀 就发挥作用了。

a b c x y a b c y 中的子串 a b c x y a b c 的公共前后缀是 a b c，

当一开始，我们发现第 8 位不匹配时，

    0   1   2   3   4   5   6   7   8   9  10
                                    ↓
 S  a   b   c   x   y   a   b   c   x   y  a
 P  a   b   c   x   y   a   b   c   y
                                    ↑

我们可以直接将 匹配字符串向右移到第五位，然后再从第 8 位继续进行判断

   0   1    2   3   4   5   6   7   8   9  10
                        |           ↓
S  a   b   c    x   y   a   b   c   x   y   a
P                       a   b   c   x   y   a   b   c   y
                        |           ↑

为什么呢？

因为a b c = a b c啊，在0 - 7 位的字符串中，它有公共前后缀a b c，所以我们可以把匹配字符串直接移到 公共后缀的起始位置，也就是 第 5位。

因为前面都不用去看，是一定不匹配的!，只有在第五位开始匹配，才有可能成功。

移动的结果，起始就是将一个字符串的前缀部分，移到和后缀部分对齐。这是成功匹配的前提。你可以想象成 ：匹配字符串的子串一直在找自己的后缀，然后靠上去，去匹配。

如下

          后缀
a b c x y a b c
          a b c  x y a b c
          前缀

那么这样移动之后，咱们就可以接着 第 8 位 继续往下匹配，而不用从头再来了。所以这种方法下，文本字符串只遍历一次，它不会倒退的。

这就是我所理解的 KMP 算法的核心思想。** KMP 就是利用字符串的前缀和后缀做文章**

具体过程##

KMP 算法的物理核心思想理解了，接下来就是代码实现了。如果保存 匹配字符串的公共前后缀信息，以及它的子串的公共前后缀信息呢？一旦匹配不成功，我怎么确定匹配字符串的子串移动多少位，恰好靠上后缀呢？

第一个问题，用一个数组就可以维护，这是大家都耳熟能详的Next数组

Next 数组，Next[i] 表示的是 从 0 开始到 i 结束的子串 的最长公共前后缀的长度 ，咱们举个栗子就很好理解了。比如下面的字符串 s :

a   b   a   b   c   a   b

Next [ 0 ] => a ，只有一个字符，前缀和后缀的概念这里就不存在了，所以 Next [ 0 ] = 0

Next [ 1 ] => a b，前缀 a 不等于后缀 b ，所以也是 0，Next[ 1 ] = 0

Next [ 2 ] => a b a，前缀 a 等于后缀b，但是前缀a b不等于后缀b a ，所以 Next[ 2 ] = 1

Next [ 3 ] => a b a b，前缀 a b等于后缀 a b，所以Next[ 3 ] = 3

经过上面的栗子，大概就可以知道 Next 数组是干嘛的了吧。回到之前的匹配字符串 P：

P  a b c x y a b c y

它的 Next 数组是啥呢？看着字符串算法一下就可以得出了

Next[9]= { 0 , 0 , 0 , 0 , 0 , 1 , 2 , 3, 0 }

当我们匹配到第8位，也就是最后一个字符的时候，发现不匹配了

    0   1   2   3   4   5   6   7   8   9  10
                                    ↓
S   a   b   c   x   y   a   b   c   x   y   a
P   a   b   c   x   y   a   b   c   y
                                    ↑

于是我们可以直接将 匹配字符串 向右移动 5位，

   0   1    2   3   4   5   6   7   8   9  10
                        |           ↓
S  a   b   c    x   y   a   b   c   x   y   a
P                       a   b   c   x   y   a   b   c   y
                        |           ↑
                        0   1   2   3   4   5   6   7   8

这个过程其实就是，当 S [ 8 ] != P [ 8 ] 时 ，S [ 8 ] 直接继续和 P [ 3 ] 进行比较，依据就是 Next [ 7 ] 的值是 3

因为子串 P[ 0-7 ] 的最大公共前后缀长度是 3，所以S[ 8 ] 只要和 公共前缀的下一个字符P[ Next[ 7 ] ] （Next[ i ] 同样也是公共前缀的下一个字符的下标，这很好理解）进行比较，也就是 P[ 3 ]，这么做的的原因是 P[ 0 ],P[ 1 ],P[ 2 ] 和 S[ 5 ] ,S[ 6 ],S[ 7 ] 是公共前后缀，它们都是一样的！

以上，就是经典 KMP 算法的全部过程。

代码实现##

先是要求 Next[] 数组，怎么求呢？很简单，咱们利用动态规划的思想。Next[ i ]的值要么是在已有最长公共前后缀的字符串基础上 +1 ，要么子串一个符合的都没有，自己另起炉灶。

Next[ i ] 的值有两种情况：

• Next [ i - 1 ]不为 0，说明子串 中有公共前后缀，那我就去字符串中公共前缀的下一个字符串 P[ Next [ i-1 ] ]，如果P[ i ] == P [ Next [ i - 1] ]，那么公共前后缀长度就+1 也就是 Next [ i ] = Next[ i -1 ]+1。那如果不相等呢？那就去找 P [ Next [ i-1 ] ] 的 Next 值，重复上面的过程，有点递归的意思。其实这个过程就是在找字符串里的公共前缀，看看有没有符合条件的（即P [ i ] == P[Next [ k] ]），没有的话，就在前缀里再去找前缀，直到找到为止，或者发现已经没用公共前缀了，那就跳出来。
• 发现子串没有符合条件，让自己+1的，于是只能从自己开始，看看P[ i ] == P[ 0 ] 如果相等，那就是1 ，如果不相等，那就只能是0 了。

代码实现如下，理解了其实还是很简单的，随时都能手写出来，也不会忘记。

    void getNext(string str)
    {
        next[0]=0;
        for(int i=1;i<str.length();i++)
        {
            int k=next[i-1];
            while(k!=0&&str[i]!=str[k])
            {
                k=next[k-1];
            }

            if(str[i]==str[k])
                next[i]=k+1;
            else
                next[i]=0;

        }
    }

这就是我对Next 数组的理解，我觉得这样理解，我能记得住。

还有一种很精简版的Next 数组实现，我不打算贴出来，乱我心志，我就用我能理解，能看懂的代码。

Next 数组求出来，就是字符串匹配了。也很简单哦。

int KMP(string content,string str)
    {
        getNext(str);

        int i=0,j=0;
        while(i<content.length()&&j<str.length())
        {
            if (j==0 ||content[i]==str[j])
            {
                if(content[i]==str[j])
                    j++;
                i++;
            }
            else
            {
                j=next[j-1];
            }
        }

        if(j>=str.length())
        {
            return i-str.length();
        }
        else
            return -1;
    }

j = next [j-1] 就是我上面所有的，移动的过程，其他的也很好理解的。

然后可以用KMP 去通过LeetCode 的一道题目，以检测自己写的代码是否正确：https://leetcode.com/problems/implement-strstr/

总结

KMP 算法就介绍到这里了，关于KMP 还有很多升级的版本。

字符串快速匹配，第一弹，看毛片。回顾一下，感觉以后应该都不会忘记了吧。

开头说的 把 KMP 和C#的 String.Contains 进行PK ,要留到下一篇博文里。下一篇博文将对 字符串的匹配的性能来个大排序，并且见识一下微软的黑科技。