KMP算法小结

今天又把KMP算法看了一遍，特此小结。

扯淡的话：

KMP算法主要用来模式匹配。正如Implement strStr() 中形容的一样，“大海捞针”，当时看到题中变量如此命名，真的感觉实在是再贴切不过了。

在介绍KMP算法之前，先介绍一下BF算法，叫的这么暧昧（who is GF？），其实就是最low的暴力算法。这个男票略暴力。

事实上，JDK1.7中String的contains的源码用的就是BF算法。（1.7中调用了indexOf，我记得1.6中是直接写的contains接口来着）

截取了一部分，并稍稍改动一下下

public boolean contains(String p){
 char[] source ;
 char[] target = p.toCharArray();
 char fist = p.charAt(0);
 int end = p.length() ;
 int max = s.length() - 1;
 for (int i = 0; i <= max;  i++) {
            /* Look for first character. */
            if (source[i] != first) {
                while (++i <= max && source[i] != first);
            }
            /* Found first character, now look at the rest of v2 */
            if (i <= max) {
                int j = i + 1;
                int end = j + targetCount - 1;
                for (int k = 1; j < end && source[j] == target[k]; j++, k++);
                if (j == end) {
                    /* Found whole string. */
                    return true;
                }
            }
        }
        return false;
    }

 

 

可能网上很多实现不太一样，但是总体的算法思路都相同。看不懂也不要紧，因为看懂也不会有人问你这个。模式匹配算法是非常实用的算法之一，例如论文查重，字符串的模式匹配就是其中一种实现，虽然现在已经有更高大上的“树匹配” 和 “图匹配” 了，但是文本匹配也是一个非常重要的应用。BF算法是模式匹配中最low的算法时间之一，复杂度是O(m*n)，这是非常恐怖的，试想，论文查重将你的论文与数据库中所有论文进行匹配.....准备延毕吧。因此BF算法貌似并没有太大的应用价值。

 

下面来看KMP算法，这是一个线性算法，复杂度是O(n + m)【一般情况下，n >> m，因此你也可以说是O(n)】，同AVL树一样，KMP算法的命名是由Knuth、Morris、Pratt三位作者的首字母组成的。不再多说。

 

在开讲之前，首先要来了解该算法中应用的几个概念：前缀 & 后缀

 

其实看到前缀、后缀字眼大家就能猜到是啥意思，但是对于KMP来讲，这里的前缀和后缀指的是绝对前缀、绝对后缀。不能包含其自身。

还是看图说话吧。

这里我就不讲了，大家先仔细看图说话

这里发现了不一致，BF算法是酱紫的：

但是仔细观察会发现，其实不必要，可以这样：

再对比一下这两种情况：（上下为一组）

--------------------------------------↑为BF算法，↓为KMP算法-------------------------------------

 

你会发现：BF回溯了　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　而KMP，相对于字符串s而言，是一路向前的，因此，从这里粗略来看，时间复杂度是O(n)。

这里我们开始编码，即：遇到不同的字符，s的指针不变，p向右移动x个位置，这个x到底是多少，这里先不管，一会儿再讲。

        while(i < s.length()){
            if(p.charAt(j) == s.charAt(i)){
                i++;
                j++;
            }else{
                j = next[j];//这里这个next[j]表示上面说的x个位置
            }
            if(j == p.length()) return i - p.length();
        }

 

具体的代码框架应该是这样的，当两个字符相同时，继续比较s和p的下一个位置，如果不同，i不变，j向右移动next[j]步。当j == p.length 的时候，即表示在s中找到了一个子串为p。因此返回其实下标。

 

好了，回到问题的核心，这个x，具体是多少。还记得上面讲的前缀后缀吗？没错，这里要用到。

再来看这个图：

图中在上面虚线框处（当前s的下标是10）发生了失配，然后我们把p移动了x个位置（本例中，x == 4），到了下图的虚线框，现在有没有意识到为什么要移动x个位置，而不是x + 1或者x - 1个位置了吧？注意实线框。

还不明白？

KMP算法比BF算法高效的一点就是，s只需要一路向前，不能回溯，当发生失配时，为保证s的下标指针 i 不回溯，那么就要保证 i 之前的元素要么与p匹配，或者为空。因此这里移动了x个位置，使得虚线框之前的子串与p匹配。如果还不明白，那就去看july的博客吧，上面讲的炒鸡详细。

再看p

 

第一次匹配的是我用黑圈围起来的AB，移动之后匹配的是红圈围起来的AB，这两个AB对 “D之前的子串” 来讲是什么东东？bingo：前缀 & 后缀 啊！准确来讲，是 最长前缀 和 最长后缀 。

有点明白了吧？

移动的距离其实是与 最长匹配前后缀 的长度有关的。

例如上图中ABCDABD中的D，其最长相等前后缀是AB，长度为2，因此将p.charAt(2)移动到虚线框的位置，并从这里往后比较。

因此这里就可以看出上段代码中的 next[j] 实际上只与字符串p中的 j 相关，与s并无关系。

然而，next数组，该如何得到呢？

首先结合上面的图片来确认一下next数组表达的含义：

next[j]的值表示p[0 ~ j - 1]中最长匹配前后缀的长度。（所谓匹配前后缀是指：前缀.equals(后缀)）

如上图中的

　　　　ABCDAB D

next                  2

即表示：p[0 ~ j - 1]即ABCDAB：其前缀有：A 、AB、ABC、ABCD、ABCDA

　　　　　　　　　　　　　　　　其后缀有： B、AB、DAB、CDAB、BCDAB

很容易看出：最长匹配前后缀是AB，长度为2，因此next[6] = 2;

特别的，约定next[0] = -1;

这样看来，next数组直接求解是很容易的，只需要对每一个子串的所有前后缀进行检查即可。然而，这个复杂度最小也是O(m^2)，可以优化：

递推版本：由next[0 ~ i - 1]，求出next[i]

算法思想：假设next[j] = k，即：P[0..k - 1] = P[j - k .. j - 1](前k个，后k个相等)

根据定义next[0] = - 1。(下面是摘自海子版的递推公式)

1) 如P[j] = P[k]，因此P[0 ~ k] = P[j - k ~ j]：即有next[j + 1] = next[j] + 1 = k + 1;

2) 如P[j] != P[k]，则可以把其看做模式匹配问题，即匹配失败的时候，k值如何移动，显然k = next[k]。

我智商比较拙计，怎么“显然”：而且P[j] = P[k] => next[j + 1] = next[j] + 1 = k + 1，是如何保证P[0..k - 1] = P[j - k .. j - 1] 的？

这里，我简单的将二者给解释一下：

关于第一点：

 如P[j] = P[k]，因此P[0 ~ k] = P[j - k ~ j]：即有next[j + 1] = next[j] + 1 = k + 1;

在求next[j]时，已经能确保此时k的值是 k = next[j - 1]；不明白？请点击下面展开

当你求next[j]的时候，是不是上一步刚刚求过next[j - 1] ？ 
即next[j - 1] = k
这说明什么？
是不是说明p[0 ~ k - 1] = p[j - k, j - 1]？

 

这里有一种特殊情况，即当k = -1时，next[j] = 0（注意：k = -1 时，并不一定以为着仅仅在求next[1]时用到，下面就会讲到）

第二点：

如P[j] != P[k]，则可以把其看做模式匹配问题，即匹配失败的时候，k值如何移动，显然k = next[k]。

“显然” 这两个字用的感觉有点推卸责任，但是没关系，自己剖析一下:

来看这个栗子:当前状态为:

　　　　　　      k      j

　　　　　　　　↓      ↓

　　　　a  b  a  b  a  a  b  e

next    -1 0  0  1  2  3

此时已知的条件有，红色字体标记的前缀和绿色阴影标记的后缀是最长匹配的，k= 3，j = 5，现在求b的next值

如果这里p[j] == p[k]，那么很好办了，b直接next[j + 1] = next[j] + 1 = k + 1 = 4；这里可以很直观的看出，为什么next[j + 1] = next[j] + 1;

可惜这里p[j] != p[k]，肿么办？按照上面的算法：k = next[k]，即k = 1；然后再比较p[1] ? p[j]，如果还不相等，继续k = next[k]；

为什么？当你没有思路的时候，回到起点吧，定义是普适的。

首先俩看下next[k]表示什么意义？k之前的子串的最长匹配，即表示b之前的aba子串的最长匹配。

因此这里的next[k] = 1表示的是aba中的最长匹配前缀（后缀）长度为1，即next[k]表示红色字体标记的前缀 的最长前缀

而我们在不断的k = next[k]，是为了寻找什么？是为了找b之前的最长前缀啊，找到了又怎样？还要跟后缀匹配啊！

进一步剖析一下b之前的子串 a b a b a a（将其命名为sub）

我们要找这个子串的最长匹配前后缀，首先我们已经确定了，后缀的最一个字母是a，先不看这个a，继续往前看， a  b  a。如果sub的后缀长度 > 1的话，倒数第2个字符一定是a，倒数第3个一定是b，倒数第4个一定是a，有没有倒数第5个？ 不可能！！因为如果有倒数第5个字符的话，那么a b a b a 的最长匹配前后缀的长度至少是4，先把这个理解了再往下看吧。

即next[j + 1] <= next[j] + 1。

再来看sub : a b a b a a

继续不看最后的a，看前面的 a b a b a 我们要找这里面的最长匹配前后缀，只有在这个子串中匹配了，才可能在sub中匹配

又回到了原点：a b a是这里的一个前缀，a b a ，此时k 指向了前缀的下一个字符b，后缀的下一个字符是a，不匹配，再继续寻找，怎么找？k = next[k]

注意，next[k]表示啥？上面说过了，表示红色字体标记的 字符串的 最长前缀。同时。也表示：红色字体标记的字符串的最长匹配后缀。

再观察一下发现：红色字体跟绿色阴影是完全相等的，那么红色字体标记的前缀，岂不是就等于绿色阴影的后缀了吗？

因此每一次next[k]其实是在红色字体中 寻找 与 绿色阴影后缀 匹配的 前缀啊！比较拗口，理解了再往下看。

每查找一下，k都指向前缀后面的字符，然后将其与a作比较，如果相等，则next[j + 1] = k + 1;否则要继续往前找合适的前缀，最极端的情况就是：直到p[0]，发现p[0] != p[j]，next[j] = 0。

理解到这里，再看代码，将next[0]初始化为-1 ，并与p[j] = p[k]的处理合并到一起，实在是太巧妙了。。

分析到这里，就可以看代码了

 

public void setNext(String m,int[] next){
        char[] s = m.toCharArray();
        int length = m.length(), j = 0, k = -1;
        next[0] = -1;
        while(j < length - 1){//注意这里是length - 1，原因自己理解
            if(k == - 1 || s[j] == s[k]){//将k = -1与s[j] = s[k]放一起处理了，看起来好优美
                next[++j] = ++k;
            }else{
                k = next[k];
            }
        }
    }

 

 

 

这里就得到了next数组

再来看怎么用next数组。

刚才的图：

上面的setNext运行过后，匹配到D时候，发生失配，此时next[6] = 2，因此我们将i不变，j = next[j]，让空格与C继续匹配。

 

　　　　ABCDAB D

 

next                  2

 

代码如下：

 

    public int match(String s,String p){
        int[] next = new int[p.length()];
        int i = 0 , j = 0;
        setNext(p, next);
        while(i < s.length()){
            if(j == -1 || p.charAt(j) == s.charAt(i)){//这里j = -1 的处理其实跟上面setNext有异曲同工之妙的，你体会一下
                i++;
                j++;
            }else{//失配时，j = next[j]
                j = next[j];
            }
            if(j == p.length()) return i - p.length();
        }
        return -1;
    }

 

 

 

合并之后的代码：附test case

package Algorithme;

import java.util.ArrayList;
import java.util.List;

public class KMP {
    public void setNext(String m,int[] next){
        char[] s = m.toCharArray();
        int length = m.length(), j = 0, k = -1;
        next[0] = -1;
        while(j < length - 1){
            if(k == - 1 || s[j] == s[k]){
                next[++j] = ++k;
            }else{
                k = next[k];
            }
        }
    }
    public int match(String s,String p){
        int[] next = new int[p.length()];
        int i = 0 , j = 0;
        setNext(p, next);
        while(i < s.length()){
            if(j == -1 || p.charAt(j) == s.charAt(i)){
                i++;
                j++;
            }else{
                j = next[j];
            }
            if(j == p.length()) return i - p.length();
        }
        return -1;
    }
    
    public static void main(String[] args) {
        KMP test = new KMP();
        List<String> list = new ArrayList<String>();
        String s1 = "i love qiqi";
        String s2 = "qiqi is my girl friend";
        String s3 = "we have been together for five years";
        list.add(s1);
        list.add(s2);
        list.add(s3);
        String p = "qiqi";
        for(String s : list)
            System.out.println(test.match(s, p));
    }
}

 

 

截止到这里，KMP算法基本算解释完了，如果没听懂，欢迎留言讨论。

 

 

参考资料：

July版：http://blog.csdn.net/v_july_v/article/details/7041827（优点，很详细。缺点：太啰嗦；吐槽：他的书肯定很厚，很贵￣へ￣）

海子版：http://www.cnblogs.com/dolphin0520/archive/2011/08/24/2151846.html?ADUIN=313359714&ADSESSION=1410660113&ADTAG=CLIENT.QQ.5353_.0&ADPUBNO=26381（优点：很精练，缺点：有的地方一笔带过，太糙）

OI版：http://www.matrix67.com/blog/archives/115（以一种非主流的方式讲了KMP，很厉害，据说是作者当时是一名高中生）