5、KMP算法

朴灿烈づ我的快乐病毒、 2022-05-27 09:44 14阅读 0赞

字符串匹配。给你两个字符串，寻找其中一个字符串是否包含另一个字符串，如果包含，返回包含的起始位置。  
如下面两个字符串：

char str = "bacbababadababacambabacaddababacasdsd";
    char ptr = "ababaca";

str有两处包含ptr  
分别在str的下标10，26处包含ptr。  
![SouthEast][]

## 算法说明 ##

一般匹配字符串时，我们从目标字符串str（假设长度为n）的第一个下标选取和ptr长度（长度为m）一样的子字符串进行比较，如果一样，就返回开始处的下标值，不一样，选取str下一个下标，同样选取长度为n的字符串进行比较，直到str的末尾（实际比较时，下标移动到n-m）。这样的时间复杂度是O(n\*m)。

KMP算法：可以实现复杂度为O(m+n)

为何简化了时间复杂度：  
充分利用了目标字符串ptr的性质（比如里面部分字符串的重复性，即使不存在重复字段，在比较时，实现最大的移动量）。  
察目标字符串ptr：  
ababaca  
这里我们要计算一个长度为m的转移函数next。

next数组的含义就是一个固定字符串的最长前缀和最长后缀相同的长度。

比如：abcjkdabc，那么这个数组的最长前缀和最长后缀相同必然是abc。  
cbcbc，最长前缀和最长后缀相同是cbc。  
abcbc，最长前缀和最长后缀相同是不存在的。

> 注意最长前缀：是说以第一个字符开始，但是不包含最后一个字符。  
> 比如aaaa相同的最长前缀和最长后缀是aaa。

对于目标字符串ptr，ababaca，长度是7，所以next\[0\]，next\[1\]，next\[2\]，next\[3\]，next\[4\]，next\[5\]，next\[6\]分别计算的是  
a，ab，aba，abab，ababa，ababac，ababaca的相同的最长前缀和最长后缀的长度。由于a，ab，aba，abab，ababa，ababac，ababaca的相同的最长前缀和最长后缀是“”，“”，“a”，“ab”，“aba”，“”，“a”,所以next数组的值是\[-1,-1,0,1,2,-1,0\]，**这里-1表示不存在，0表示存在长度为1，2表示存在长度为3,类推**。

public static  void cal_next(char[] str, int[]  next, int len)
        {
            next[0] = -1;//next[0]初始化为-1，-1表示不存在相同的最大前缀和最大后缀
            int k = -1;//k初始化为-1
            for (int q = 1; q <= len-1; q++)
            {
                while (k > -1 && str[k + 1] != str[q])//如果下一个不同，那么k就变成next[k]，注意next[k]是小于k的，无论k取任何值。
                {
                    System.out.println(k +"_" + q);
                    k = next[k];//往前回溯
                    System.out.println(k +"_" + q);
                }
                if (str[k + 1] == str[q])//如果相同，k++ s[0] = s[2] k =0 ;
                {
                    k = k + 1;
                }
                next[q] = k;//这个是把算的k的值（就是相同的最大前缀和最大后缀长）赋给next[q]
                //System.out.println(k +"_" + q);
            }
        }
    
    
        public static void main(String[] args) {
            String sttt = "bcoabcabco" ;
            int len = sttt.length();
            char[] str = sttt.toCharArray() ;
            int[] next = new int[len] ;
            cal_next(str,next,len);
            System.out.println(Arrays.toString(next));
        }

kmp

static  int   KMP(char []str, int slen, char []ptr, int plen)
        {
            int []next = new int[plen];
            cal_next(ptr, next, plen);//计算next数组
            int k = -1;
            for (int i = 0; i < slen; i++)
            {
                while (k >-1&& ptr[k + 1] != str[i])//ptr和str不匹配，且k>-1（表示ptr和str有部分匹配）
                    k = next[k];//往前回溯
                if (ptr[k + 1] == str[i])
                    k = k + 1;
                if (k == plen-1)//说明k移动到ptr的最末端
                {
                    //cout << "在位置" << i-plen+1<< endl;
                    System.out.println("在位置: "+ (i-plen+1) );
                    k = -1;//重新初始化，寻找下一个
                    i = i - plen + 1;//i定位到该位置，外层for循环i++可以继续找下一个（这里默认存在两个匹配字符串可以部分重叠）
                    //return i-plen+1;//返回相应的位置
                }
            }
            return 0;
        }
    
        public static void main(String[] args) {
            char []str2 = "bacbababadababacambabacaddababacasdsd".toCharArray();
            char []ptr2 = "ababaca".toCharArray();
            int a = KMP(str2, 36, ptr2, 7);
        }

cal\_next函数计算复杂度是(m)

cal\_next

while (k > -1 && str[k + 1] != str[q]) {
          k = next[k];
    }
    next[q] = k;

ababac，q=4时，next\[4\]=2（k=2，表示该字符串的前5个字母组成的子串ababa存在相同的最长前缀和最长后缀的长度是3，所以k=2,next\[4\]=2。 对于k= 2 ,q = 6时 ，str\[k + 1\] != str\[q\]，b!=c 进入while()里面，我们往前找一个k，使str\[k + 1\]==str\[q\]，是往前一个一个找呢，还是有更快的找法呢？ （一个一个找必然可以，即你把 k = next\[k\] 换成k– ,也是完全能运行的（+长度判度）。但是程序给出了一种更快的找法，那就是 k = next\[k\]。 程序的意思是说，一旦str\[k + 1\] != str\[q\]，即在后缀里面找不到时，我是可以直接跳过中间一段，跑到前缀里面找，next\[k\]就是相同的最长前缀和最长后缀的长度。所以，k=next\[k\]就变成，k=next\[2\]，即k=0。此时再比较str\[0+1\]和str\[5\]是否相等，不等，则k=next\[0\]=-1。跳出循环。

参考：[https://blog.csdn.net/starstar1992/article/details/54913261][https_blog.csdn.net_starstar1992_article_details_54913261]

[SouthEast]: /images/20220527/7de259f174f64d1fbba842747fdb8088.png
[https_blog.csdn.net_starstar1992_article_details_54913261]: https://blog.csdn.net/starstar1992/article/details/54913261