zoukankan      html  css  js  c++  java
  • KMP算法

    作者:海子

    出处:http://www.cnblogs.com/dolphin0520/

    根据博主自己理解,有部分修改

      在介绍KMP算法之前,先介绍一下BF算法。

    一.BF算法

        BF算法是普通的模式匹配算法,BF算法的思想就是将目标串S的第一个字符与模式串P的第一个字符进行匹配,若相等,则继续比较S的第二个字符和P的第二个字符;若不相等,则比较S的第二个字符和P的第一个字符,依次比较下去,直到得出最后的匹配结果。

        举例说明:

        S:  ababcababa

        P:  ababa

      BF算法匹配的步骤如下

               i=0                                   i=1                             i=2                         i=3                          i=4

      第一趟:ababcababa         第二趟:ababcababa      第三趟:ababcababa    第四趟:ababcababa      第五趟:ababcababa

               ababa                           ababa                        ababa                      ababa                        ababa

                j=0                                   j=1                            j=2                         j=3                         j=4(i和j回溯)

     

                  i=1                                 i=2                           i=3                            i=4                        i=3

     第六趟:ababcababa         第七趟:ababcababa       第八趟:ababcababa     第九趟:ababcababa      第十趟:ababcababa

                ababa                             ababa                         ababa                      ababa                          ababa

                 j=0                                  j=0                           j=1                           j=2(i和j回溯)            j=0

     

                  i=4                                    i=5                          i=6                           i=7                          i=8

    第十一趟:ababcababa       第十二趟:ababcababa    第十三趟:ababcababa   第十四趟:ababcababa   第十五趟:ababcababa

                       ababa                             ababa                         ababa                        ababa                       ababa

                   j=0                                    j=0                         j=1                            j=2                         j=3

     

                        i=9

    第十六趟:ababcababa

                         ababa

                        j=4(匹配成功)

    代码实现:

    int BFMatch(char *s,char *p)
    {
        int i,j;
        i=0;
        while(i<strlen(s))
        {
            j=0;
            while(s[i]==p[j]&&j<strlen(p))
            {
                i++;
                j++;
            }
            if(j==strlen(p))
                return i-strlen(p);
            i=i-j+1;                //指针i回溯
        }
        return -1;    
    }
       其实在上面的匹配过程中,有很多比较是多余的。在第五趟匹配失败的时候,在第六趟,i可以保持不变,j值为2。因为在前面匹配的过程中,对于串S,已知s0s1s2s3=p0p1p2p3,又因为p0!=p1!,所以第六趟的匹配是多余的。又由于p0==p2,p1==p3,所以第七趟和第八趟的匹配也是多余的。在KMP算法中就省略了这些多余的匹配。

    二.KMP算法

        KMP算法之所以叫做KMP算法是因为这个算法是由三个人共同提出来的,就取三个人名字的首字母作为该算法的名字。其实KMP算法与BF算法的区别就在于KMP算法巧妙的消除了指针i的回溯问题,只需确定下次匹配j的位置即可,使得问题的复杂度由O(mn)下降到O(m+n)。

      在KMP算法中,为了确定在匹配不成功时,下次匹配时j的位置,引入了next[]数组,next[j]的值表示P[0...j-1]中最长后缀的长度等于相同字符序列的前缀。

      对于next[]数组的定义如下:

     1) next[j] = -1  j = 0

     2) next[j] = max(k): 0<k<j   P[0...k-1]=P[j-k,j-1]

     3) next[j] = 0  其他

     如:

     P      a    b   a    b   a

     j      0    1   2    3   4

     next    -1   0   0    1   2

     即next[j]=k>0时,表示P[0...k-1]=P[j-k,j-1]

     因此KMP算法的思想就是:在匹配过程称,若发生不匹配的情况,如果next[j]>=0,则目标串的指针i不变,将模式串的指针j移动到next[j]的位置继续进行匹配;若next[j]=-1,则将i右移1位,并将j置0,继续进行比较。

    代码实现如下:

    int KMPMatch(char *s,char *p)
    {
        int next[100];
        int i=0,j=0;
        getNext(p,next);
        while(i<strlen(s))                   //
        {                                    //
            if(j==-1||s[i]==p[j])            //此处便于理解可以写成:if(s[i] == p[j])
            {                                //                   {}
                i++;                         //                   else if( j == -1 ) 
                j++;                         //                   {}
            }                                //                   else
            else                             //                   {}
            {
                j=next[j];       //消除了指针i的回溯
            }
            if(j==strlen(p))
                return i-strlen(p);
        }
        return -1;
    }

      因此KMP算法的关键在于求算next[]数组的值,即求算模式串每个位置处的最长后缀与前缀相同的长度, 而求算next[]数组的值有两种思路,第一种思路是用递推的思想去求算,还有一种就是直接去求解。 

    1.按照递推的思想:

       根据定义next[0]=-1,假设next[j]=k, 即P[0...k-1]==P[j-k,j-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]。

       因此可以这样去实现:

    void getNext(char *p,int *next)
    {
        int j=0,k=-1;
        next[0]=-1;
    while(j<strlen(p)-1) { if(k==-1||p[j]==p[k]) //匹配的情况下,p[j]==p[k] { j++; k++; next[j]=k; } else //p[j]!=p[k] k=next[k]; } }

    2,直接求解法

    void getNext(char *p,int *next)
    {
        int i,j,temp;
        for(i=0;i<strlen(p);i++)
        {
            if(i==0)
            {
                next[i]=-1;     //next[0]=-1
            }
            else if(i==1) 
            {
                next[i]=0;      //next[1]=0
            }
            else
            {
                temp=i-1;
                for(j=temp;j>0;j--)
                {
                    if(equals(p,i,j))
                    {
                        next[i]=j;   //找到最大的k值
                        break;
                    }
                }
                if(j==0)
                    next[i]=0;
            }
        }
    }
    
    bool equals(char *p,int i,int j)     //判断p[0...j-1]与p[i-j...i-1]是否相等  
    {
        int k=0;
        int s=i-j;
        for(;k<=j-1&&s<=i-1;k++,s++)
        {
            if(p[k]!=p[s])
                return false;
        }
        return true;
    }

    --------------------------------------------------我是分割线(*^__^*) 嘻嘻……---------------------------------------------

    下面摘自阮一峰老师的博客,以助理解next数组,http://www.ruanyifeng.com/blog/2013/05/Knuth–Morris–Pratt_algorithm.html

    下面介绍《部分匹配表》是如何产生的。

    首先,要了解两个概念:"前缀"和"后缀"。 "前缀"指除了最后一个字符以外,一个字符串的全部头部组合;"后缀"指除了第一个字符以外,一个字符串的全部尾部组合。

    15.

    "部分匹配值"就是"前缀"和"后缀"的最长的共有元素的长度。以"ABCDABD"为例,

      - "A"的前缀和后缀都为空集,共有元素的长度为0;

      - "AB"的前缀为[A],后缀为[B],共有元素的长度为0;

      - "ABC"的前缀为[A, AB],后缀为[BC, C],共有元素的长度0;

      - "ABCD"的前缀为[A, AB, ABC],后缀为[BCD, CD, D],共有元素的长度为0;

      - "ABCDA"的前缀为[A, AB, ABC, ABCD],后缀为[BCDA, CDA, DA, A],共有元素为"A",长度为1;

      - "ABCDAB"的前缀为[A, AB, ABC, ABCD, ABCDA],后缀为[BCDAB, CDAB, DAB, AB, B],共有元素为"AB",长度为2;

      - "ABCDABD"的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB],后缀为[BCDABD, CDABD, DABD, ABD, BD, D],共有元素的长度为0。

    16.

    "部分匹配"的实质是,有时候,字符串头部和尾部会有重复。比如,"ABCDAB"之中有两个"AB",那么它的"部分匹配值"就是2("AB"的长度)。搜索词移动的时候,第一个"AB"向后移动4位(字符串长度-部分匹配值),就可以来到第二个"AB"的位置。

    根据阮一峰老师的博客,next[0]可以设置为0,不一定非得设成-1,按照阮老师博客生成next数组的方法,我也做过测试,得到的结果是一样的。阮老师就是牛气,听说阮老师翻译过《黑客与画家》,且评价很高,可惜没时间看。

    最后附上数学牛人Matrix67的讲解http://www.matrix67.com/blog/archives/115

     
  • 相关阅读:
    Redis常见的应用场景解析
    技术知识和稳定的系统之间,可能还差这些?
    学会数据库读写分离、分表分库——用Mycat,这一篇就够了!
    程序员也是弱势群体?——从WePhone开发者事件说起
    系统日志管理那点事
    我的Markdown的利器——Markdown Here、有道云笔记、iPic
    推荐几本产品类的书
    华为云的API调用实践(python版本)
    阿里云 API调用实践(python语言)
    HA总结:AWS 网络连接
  • 原文地址:https://www.cnblogs.com/theCambrian/p/3643369.html
Copyright © 2011-2022 走看看