KMP 模式匹配算法的简单说明

KMP 模式匹配算法的简单说明

KMP 是三位大牛：D.E.Knuth、J.H.Morris和V.R.Pratt 发明用于解决在一个主的字符串（主串）中搜索一个字符串（模式串）定位的算法。（也就是关键字搜索）

定义：主串—S 模式串—T

假设不使用KMP 模式匹配算法，我们用最简单的算法去解决 在S中搜索 T 的位置，结果就是使用暴力的方式将所有的情况进行遍历一遍

//最差时间复杂度O(n*m)
    public static int simpleGetSTIndex(String s,String t){
        char[] schars = s.toCharArray();//主串
        char[] tchars = t.toCharArray();//模式串
        int i= 0;
        int j =0;
//        for (i = 0;i<schars.length;){
//            for (j = 0; j < tchars.length ;) {
//                if(schars[i]==tchars[j]){
//                    i++;
//                    j++;
//                }else{
//                    i=i-j+1;//回溯
//                    j=0;
//                    break;
//                }
//            }
//        }

        while (i<schars.length &&j < tchars.length ){
            if(schars[i]==tchars[j]){
                    i++;
                    j++;
                }else{
                    i=i-j+1;//回溯
                    j=0;
                }
        }
        if(j==tchars.length){
            //找到了
            return i-j;
        }else{
            return -1;
        }


    }

上面的算法就是暴力的破解，效率很低

在研究S 和 T 我们可以分为两种情况

1. T串中的每个字符都不相等

定义: 同一时间内 i 为 S 的 遍历情况下标，j 为 T 遍历的情况下标

发现在原有的暴力破解的算法中，可以省略中间2345步骤 只需要1和6步骤，这样一来 不用回溯 i （不用做代码中 i=i-j+1;//回溯 这一个步骤） ，使得我们可以从S[i] 开始继续和T进行比较

2. T 串中有重复的字符

定义: 同一时间内 i 为 S 的 遍历情况下标，j 为 T 遍历的情况下标，k 取值[1-j-1]

发现在原有的暴力破解的算法中，可以省略中间2345步骤 只需要1和6步骤，这样一来 不用回溯 i （不用做代码中 i=i-j+1;//回溯 这一个步骤） ，此时我们可以从S[i] 和 T[j!] 处开始遍历比较。注意是j!, 为了不和在步骤1中的j 弄混，我们将其称为j!。

在观察T串中，我们发现在j 之前我们有一个从 T[1 ~ k-1] （前缀，必须包含T[1]）和 T[j-k ~ j-1]（后缀 必须包含最后一个字符T[j-1]）的最大相同串，长度为2。而 j! = 2 + 1 (如果代码中下标从0开始，就不用加1了)。也就是说当步骤1发生S[i] != T[j] ,可以从步骤6 S[i] 和 T[j!] 开始比较

发现i 可以不用回溯，但是j得根据遍历的情况进行回溯，而j的取值是T 的长度。(读友可以试着自已验证一下是不是这样一会事)

一般问题化：发生S[i] != T[j]，可以从S[i] 和 T[j!] 开始比较。而 j! 为 T[1 ~ j-1] 中最大前缀和最大后缀 相同的时候前缀或后缀的长度+1，可以用next[] 数组进行保存 j! 的取值

如何获得next 数组

定义: 同一时间内 i 为 S 的 遍历情况下标，j 为 T 遍历的情况下标，k 取值[0-j-1]
由上面的分析我们知道，next 的数组的获取基本和S没多大关系，只和T有关系，即在j处S[i] != T[j]，找出T[0 ~ j-1] 中最大前缀和最大后缀的相同串并且长度小于j-1
**1. j =0，j-1<=0 ,所以令 next[0在这里插入代码片] = -1 **

注意:求T[0 ~ j-1] 的 最大前缀后缀共同串T[0~k-1] == T[j-k ~ j-1] , next[j] = k, 可以将问题转化为在T[j-k ~ j] 中搜索 T[0 ~ k],
2.当 S[i]!=T[j],T[k] == T[j] 时
已知 ：T[0~k-1] == T[j-k ~ j-1] , next[j] ==k
那么 ：T[0~k-1] + T[k] == T[j-k ~ j-1] + T[j] ==》T[0~k] == T[j-k ~ j] ， next[j+1] ==k+1 == next[j] +1
如下图，可以发现 next[j+1] = next[j] + 1

3. 当 S[i]!=T[j],T[k] != T[j] 时
由于是求前缀T[0~k]和后缀T[j-k ~ j-1] 的最大共同串,
因为S[i]!=T[j],T[k] != T[j]
那么可以将问题转化为在T[j-k ~ j] 中搜索 T[0 ~ k],
而T[k] != T[j] ，求T[0~k-1] 的最大前缀后缀共同串next[k]
因为k<j,所以求next[k]必然已知，
所以有 next[j] = next[k] (k<j)

具体实现

public static int[] Kmpnext(String t){
        int[] next = new int[t.length()] ;
        char[] tchars = t.toCharArray();
        int k = -1;
        int j = 0;
        next[0] = -1;
        while (j<tchars.length-1){
            if( k==-1 ||tchars[j]==tchars[k]){
                next[++j] = ++k;//已知旧数据得出新数据
            }else{
                k = next[k];
            }


        }
        return next;
    }


    public static int KmpGetSTIndex(String s,String t){
        char[] schars = s.toCharArray();//主串
        char[] tchars = t.toCharArray();//模式串
        int i= 0;
        int j =0;
        int[] kmpnext = Kmpnext(t);
        while (i<schars.length){

            if(j==-1 ||schars[i] == tchars[j] ){
                //j==-1 代表第一个比较久不相等，i，j 都要+1
                i++;
                j++;
            }else{
                j=kmpnext[j];
            }



        }
        if(j==tchars.length){
            //找到了
            return i-j;
        }else{
            return -1;
        }
    }

但是会发现有一种特殊的情况

发现 即便求了next数组简化，步骤2345也是可以省略的，这是因为T[j]==T[next[j]]
相当于在S[i] != T[j] 时 有 S[i] != T[next[j]] ,那么此时可以看成 求T[0 ~ next[j] ] 的最大前后缀
所以此时的在S[i] != T[j]，T[j]==T[next[j]] 时 ，可以优化成 next[j] = next[next[j]]

public static int[] Kmpnext(String t){
        int[] next = new int[t.length()] ;
        char[] tchars = t.toCharArray();
        int k = -1;
        int j = 0;
        next[0] = -1;
        while (j<tchars.length-1){
            if( k==-1 ||tchars[j]==tchars[k]){
                ++j;k++;
                if(tchars[j]==tchars[k]){
                    next[j] = next[k];
                }else{
                    next[j] = k;//
                }
            }else{
                k = next[k];
            }


        }
        return next;
    }

如果看不懂，这篇博客很详细