KMP算法 算法摘记

字符串匹配的KMP算法

1.

　　首先，字符串"BBC ABCDAB ABCDABCDABDE"的第一个字符与搜索词"ABCDABD"的第一个字符，进行比较。因为B与A不匹配，所以搜索词后移一位。

　　2.

　　因为B与A不匹配，搜索词再往后移。

　　3.

　　就这样，直到字符串有一个字符，与搜索词的第一个字符相同为止。

　　4.

　　接着比较字符串和搜索词的下一个字符，还是相同。

　　5.

　　直到字符串有一个字符，与搜索词对应的字符不相同为止。

　　6.

　　这时，最自然的反应是，将搜索词整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把"搜索位置"移到已经比较过的位置，重比一遍。

　　7.

　　一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是"ABCDAB"。KMP算法的想法是，设法利用这个已知信息，不要把"搜索位置"移回已经比较过的位置，继续把它向后移，这样就提高了效率。

　　8.

　　怎么做到这一点呢？可以针对搜索词，算出一张《部分匹配表》（Partial Match Table）。这张表是如何产生的，后面再介绍，这里只要会用就可以了。

　　9.

　　已知空格与D不匹配时，前面六个字符"ABCDAB"是匹配的。查表可知，最后一个匹配字符B对应的"部分匹配值"为2，因此按照下面的公式算出向后移动的位数：

　　移动位数 = 已匹配的字符数 - 对应的部分匹配值

　　因为 6 - 2 等于4，所以将搜索词向后移动4位。

　　10.

　　因为空格与Ｃ不匹配，搜索词还要继续往后移。这时，已匹配的字符数为2（"AB"），对应的"部分匹配值"为0。所以，移动位数 = 2 - 0，结果为 2，于是将搜索词向后移2位。

　　11.

　　因为空格与A不匹配，继续后移一位。

　　12.

　　逐位比较，直到发现C与D不匹配。于是，移动位数 = 6 - 2，继续将搜索词向后移动4位。

　　13.

　　逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。如果还要继续搜索（即找出全部匹配），移动位数 = 7 - 0，再将搜索词向后移动7位，这里就不再重复了。

　　14.

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

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

　　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"的位置。

总的来讲，KMP算法有2个难点：

              一是这个前缀函数的求法。

              二是在得到前缀函数之后，怎么运用这个函数所反映的有效信息避免不必要的检测。

void CptPfFunc( ElemType Pattern[], int PrefixFunc[] )                
{      
        register int iLen = 0;    // Length of Pattern[]            
        while( '\0' != Pattern[iLen] )            
                iLen++;      
                      
        int LOLP = 0;     // Lenth of longest prefix            
        PrefixFunc[1] = 0;            
         
        for( int NOCM=2; NOCM<iLen+1; NOCM++ )     // NOCM represent the number of characters matched            
        {            
                while( LOLP>0 && (Pattern[LOLP] != Pattern[NOCM-1]) )            
                        LOLP = PrefixFunc[LOLP];            
                if( Pattern[LOLP] == Pattern[NOCM-1] )            
                        LOLP++;            
                PrefixFunc[NOCM] = LOLP;            
        }            
}

不妨设模式串Pattern = "a  b  c  c  a  b  c  c  a  b  c  a"

      Pattern 数组编号： 0  1  2  3  4  5  6  7  8  9 10 11

NOCM 表示 已经匹配的字符数

LOLP 表示 既是自身真后缀又是自身最长前缀的字符串长度

以下是计算流程：

PrefixFunc[1] = 0； //只匹配一个字符就失配时，显然该值为零

LOLP = 0；   NOCM = 2；   LOLP = 0;    PrefixFunc[2] = 0;

LOLP = 0；   NOCM = 3；   LOLP = 0;    PrefixFunc[3] = 0;

LOLP = 0；   NOCM = 4；   LOLP = 0;    PrefixFunc[4] = 0;

LOLP = 0；   NOCM = 5；   LOLP = 1;    PrefixFunc[5] = 1;

LOLP = 1；   NOCM = 6；   LOLP = 2;    PrefixFunc[6] = 2;

LOLP = 2；   NOCM = 7；   LOLP = 3;    PrefixFunc[7] = 3;

LOLP = 3；   NOCM = 8；   LOLP = 4;    PrefixFunc[8] = 4;

LOLP = 4；   NOCM = 9；   LOLP = 5;    PrefixFunc[9] = 5;

LOLP = 5；   NOCM = 10； LOLP = 6;    PrefixFunc[10] = 6;

LOLP = 6；   NOCM = 11； LOLP = 7;    PrefixFunc[11] = 7;

LOLP = 7；   NOCM = 12；

主要是（Pattern[LOLP] != Pattern[NOCM-1]）

不等就是LOLP= PrefixFunc[LOCP] =;//当前的部分匹配值

//递归调用PrefixFunc函数，直到整个P字串都再无最长前缀或者找到一个之前的满足条件的最长前缀。

相等就是++；

PrefixFunc[NOCM] = LOCP;// 更新当前的匹配值，就是自身真后缀又是自身最长前缀，就是前缀和真后缀相等元素的最长长度

 

void KMPstrMatching( ElemType Target[], ElemType Pattern[] )            
{            
        int PrefixFunc[MAX_SIZE];            
        register int TarLen = 0;            
        register int PatLen = 0;            
         
        // Compute the length of array Target and Pattern   计算长度         
        while( '\0' != Target[TarLen] )            
                TarLen++;            
        while( '\0' != Pattern[PatLen] )            
                PatLen++;            
                    
        // Compute the prefix function of Pattern     计算部分匹配值      
        CptPfFunc( Pattern, PrefixFunc );            
         
        int NOCM = 0;  //匹配的长度
         
        for( int i=0; i<TarLen; i++ )    //整个目标串长度        
        {            
                while( NOCM>0 && Pattern[NOCM] != Target[i] )   // 不匹配
                        NOCM = PrefixFunc[NOCM];  //更新 当前匹配的为计算得出的部分匹配值          
                if( Pattern[NOCM] == Target[i] )   //匹配         
                        NOCM++;            
                if( NOCM == PatLen ) //完成匹配          
                {            
                        cout<<"KMP String Matching,pattern occurs with shift "<<i - PatLen + 1<<endl; //输出位置           
                        NOCM = PrefixFunc[NOCM];            
                }            
        }            
}