5、KMP算法

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

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

str有两处包含ptr
分别在str的下标10,26处包含ptr。

算法说明

一般匹配字符串时,我们从目标字符串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/llianlianpay/article/details/79962307
个人分类: 算法分析
上一篇23、 聊聊akka(三) 集群&持久化
下一篇6、求数组中最长递增子序列
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭