[转]模式匹配之Brute-Force、KMP

（Brute-Force）

 一、与串相关的概念

1、串（或字符串）是由零个或多个字符组成的有限序列。一般记作：s=〃c₀c₁c₂…c_n-1〃(n≥0)。零个字符的串称为空串，通常以两个相邻的双引号来表示空串，仅由空格组成的的串称为空格串，如：s=〃    〃；

2、串与线性表的异同。字符串一般简称为串，可以将它看作是一种特殊的线性表，这种线性表的数据元素的类型总是字符型的，字符串的数据对象约束为字符集。在线性表的基本操作中，大多以“单个元素”作为操作对象，而在串中，则是以“串的整体”或一部分作为操作对象。因此，线性表和串的操作有很大的不同。

3、当两个串的长度相等且各对应位置上的字符都相同时，这两个串是相等的。串中任意个连续字符组成的序列称为该串的子串。包含子串的串被称为主串。

4、模式匹配：子串定位运算称为模式匹配(Pattern Matching)或串匹配(String Matching)。模式匹配成功是指在目标串s中找到一个模式串t；模式匹配不成功则指目标串s中不存在模式串t。在串匹配中，一般将主串称为目标串，子串称之为模式串。

二、串的几种表示方法

1、顺序存储结构 （静态）

分配一组地址连续的存储单元存放串值的字符序列。

        #define MAXSTRLEN  255

         typedef unsigned char SString[MAXSTRLEN+1];

2、串的块链存储表示

块，一组连续的字符。块链存储表示，把串分成指定等长的块，每一块用一个结点表示，把各块链成一个链表。当一个结点不满时，用特殊字符（如‘#’）填充。若块的长度为1，就是以单字符为结点的链表结构。

#define CHUNKSIZE  <结点的大小> ;  //定义结点的大小

  typedef struct Chunk {               //结点结构

　  char str[CHUNKSIZE];

　  struct Chunk  *next;

                    } Lstring;

块的大小与存储密度有关：

3、堆分配存储表示（常用）

堆存储结构的特点是，仍以一组空间足够大的、地址连续的存储单元存放串值字符序列，但它们的存储空间是在程序执行过程中动态分配的。所以也称为动态存储分配的顺序表。每当产生一个新串时，系统就从剩余空间的起始处为串值分配一个长度和串值长度相等的存储空间。

在C语言中，存在一个称为“堆”的自由空间，由动态分配函数malloc()分配一块实际串长所需的存储空间，如果分配成功，则返回这段空间的起始地址，作为串的基址。由free()释放串不再需要的空间。      

C语言对堆分配存储结构的定义如下：

typedef struct{

   char *str;

   int  curlen;

 }Hstring;

三、Brute-Force算法的思想

Brute-Force算法的基本思想是：从目标串s 的第一个字符起和模式串t的第一个字符进行比较，若相等，则继续逐个比较后续字符，否则从串s 的第二个字符起再重新和串t进行比较。依此类推，直至串t 中的每个字符依次和串s的一个连续的字符序列相等，则称模式匹配成功，此时串t的第一个字符在串s 中的位置就是t在s中的位置，否则模式匹配不成功。

四、Brute-Force算法的C语言描述

五、Brute-Force算法的C语言实现

#include "stdio.h"

#include "stdlib.h"

#include "string.h"

#include "ctype.h"

#define OK 1

#define ERROR 0

typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等

typedef int Boolean; // Boolean是布尔类型,其值是TRUE或false

#define N 16 // 数据元素个数

#define MAXKEYLEN 16 // 关键字的最大长度

#define STACK_INIT_SIZE 10 // 存储空间初始分配量

#define STACKINCREMENT 2 // 存储空间分配增量

typedef struct

{

char *ch;

int length;

}HString;

void InitString(HString &T)

 { // 初始化(产生空串)字符串T

   T.length=0;

   T.ch=NULL;

 }//InitString

int StrAssign(HString &T,char *chars)

{// 生成一个其值等于串常量chars的串T

int i,j;

if(T.ch)

      free(T.ch); //释放T原有空间

i=strlen(chars);//求chars的长度i

if(!i)

   {//chars的长度为0

    T.ch=NULL;

      T.length=0;

   }//if

else

   {

    T.ch=(char*)malloc(i*sizeof(char));//分配串空间

      if(!T.ch) exit(-1); //失败

      for(j=0;j<i;j++)

             T.ch[j]=chars[j];

      T.length=i;

   }//else

return OK;

}//StrAssign

void StrPrint(HString &T)

{

int i;

for(i=0;i<T.length;i++)

      printf("%c",T.ch[i]);

printf(" ");

}//StrPrint

 

int Index(HString s,HString t,int pos)

{

int i,j;

i=pos;                         //指向串s的第1个字符

j=0;                         //指向串t的第1个字符

while((i<s.length)&&(j<t.length))

  if(s.ch[i]==t.ch[j])     //比较两个子串是否相等

   { ++i;                     //继续比较后继字符

     ++j;

   }//if

  else

    { 

      i=i-j+1;                 //串s指针回溯重新开始寻找串t，注意，在算法中我们的存储结构是数组，我//们在此实现中，采用的是堆，导致语句有点小不一样。

    j=0;

      }//else

if(j>=t.length) return(i-t.length+1);  //匹配成功，返回模式串t在串s中的起始位置

else  return 0;                  //匹配失败返回0

}

void OutprintS(HString &t)

{

printf("串t为: ");

StrPrint(t);

}//OutprintS

void InputS(HString &s)

{

char ch[80];

printf("input the String: ");

scanf("%s",ch);

StrAssign(s,ch);

}//InputS

int main()

{

int i,pos=1;

HString t,s;

InitString(s);//由于HSring定义了指针，所以必须初始化

InitString(t);

InputS(s);

InputS(t);

OutprintS(s);

OutprintS(t);

i=Index(s,t,pos);

printf("the location is: %d ",i);

return 1;

}

六、Brute-Force算法的复杂度分析

最好的情况：算法时间复杂度为：O（Strlen(T)）;

        最坏的情况：算法时间复杂度为：O（Strlen(S)×Strlen(T)）。

（之二）

模式匹配

模式匹配的具体含义是在主串s中从start开始查找一个与模式串t相同的子串。如果找到则返回模式串t的第一个字符在主串中的下标；如果未找到则返回-1。

1.模式匹配的Brute-Force算法

Brute-Force算法实现模式匹配的思想是：从主串s=”s₀s₁…s_n-1”的第一个字符开始和模式串t=”t₀t₁…t_n-1”的第一个字符比较，若相等，则继续比较后续字符；否则从主串s的第二个字符开始重新与模式串t的第一个字符比较。如此不断继续，若存在模式串中的每个字符依次和主串中的一个连续字符序列相等，则匹配成功，返回模式串t的第一个字符在主串中的下标；否则匹配失败，返回-1。

int Index_BF ( char S [ ], char T [ ], int pos )

{

    /* 若串 S 中从第pos(S 的下标0≤pos<StrLength(S))个字符

    起存在和串 T 相同的子串，则称匹配成功，返回第一个

    这样的子串在串 S 中的下标，否则返回 -1    */

 

    int i = pos, j = 0;

     

    while ( S[i+j] != ''&& T[j] != '')

        if ( S[i+j] == T[j] )

            j ++; // 继续比较后一字符

        else

        {

            i ++; j = 0; // 重新开始新的一轮匹配

        }

         

    if ( T[j] == '')

        return i; // 匹配成功   返回下标

    else

        return -1; // 串S中(第pos个字符起)不存在和串T相同的子串

} // Index_BF

2.模式匹配的 KMP 算法

KMP 算法的思想是：设s为主串，t为模式串，设i为主串s当前比较字符的下标，j为模式串t当前比较字符的下标，另i和j的初值为0. 当s_i= t_j时，i和j分别增1再继续比较；否则i不变，j改变为等于next[j]，再继续比较。依次类推，直到下列两种情况之一：一种是j退回到某个j = next[j] 时有s_i = t_j；则i和j分别增1再继续比较；另一种是j退回到j = -1，此时令主串和模式串的下标各增1（此时模式串下标便退回0：j = j + 1 = -1 + 1 = 0），再继续比较。

其中，我们把模式串中从第一个字符开始到任一个字符为止的模式串中的真子串定义为next[j]函数，则next[j]函数定义为：

①next[j]= max{ k | 0<k<j 且“t₀t₁…t_k-1” = “t_j-kt_j-k+1…t_j-1”}     当此集合非空时

②next[j]= 0                                         其他情况

③next[j]= -1                                        当 j = 0 时

若模式串t中存在真子串“t₀t₁…t_k-1” = “t_j-kt_j-k+1…t_j-1”，且满足0<k<j，则next[j]表示当模式串t中的t_j与主串s的s_i比较不相等时，模式串t中需重新和主串s的s_i比较的字符下标为k，即下一次开始比较s_i和t_k；若模式串t中不存在如上所说的真子串，有next[j] = 0，则下一次开始比较s_i和t₀；当j = 0时，令next[j] = -1，此处-1为一标记，表示下一次开始比较s_i+1和t₀.

简而言之，KMP算法对Brute-Force算法的改进就是利用已经得到的部分匹配结果将模式串t右滑一段距离再继续比较，从而无需回退主串s的下标值。

#include <iostream>

#include <string>

using namespace std;

 

void get_nextval(const char *T, int next[])

{

    // 求模式串T的next函数值并存入数组 next

    int j = 0, k = -1;

    next[0] = -1;

     

    while ( T[j] != '' )

    {

        if (k == -1 || T[j] == T[k])

        {

            ++j;

            ++k;

            next[j] = k;

        }// if

        else

            k = next[k];

    }// while

     

    ////这里是我加的显示部分

    // for(int  i=0;i<j;i++)

    //{

    //     cout<<next[i];

    //}

    //cout<<endl;

 

}// get_nextval　

 

int KMP(const char *Text,const char* Pattern)

{

    if( !Text||!Pattern||  Pattern[0]==''  ||  Text[0]=='' )

        return -1;//空指针或空串，返回-1

 

    int len=0;

    const char * c=Pattern;

     

    while(*c++!='')//计算模式串长度

    {

        ++len;

    }

     

    int *next=new int[len+1];

    get_nextval(Pattern,next);//求Pattern的next函数值

     

    int index=0,i=0,j=0;

    while(Text[i]!=''  && Pattern[j]!='' )

    {

        if(Text[i]== Pattern[j])

        {

            ++i;// 继续比较后继字符

            ++j;

        }

        else

        {

            index += j-next[j];

            if(next[j]!=-1)

                j=next[j];// 模式串向右移动

            else

            {

                j=0;

                ++i;

            }

        }

    }//while

     

    delete []next;

    if(Pattern[j]=='')

        return index;// 匹配成功

    else

        return -1;

}

 

int main()//abCabCad

{

    char* text="bababCabCadcaabcaababcbaaaabaaacababcaabc";

    char*pattern="abCabCad";

     

    cout<<KMP(text,pattern)<<endl;

    return 0;

}

(KMP)

在介绍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,j;
    i=0;
    j=0;
    getNext(p,next);
    while(i<strlen(s))
    {
        if(j==-1||s[i]==p[j])
        {
            i++;
            j++;
        }
        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,k;
    next[0]=-1;
    j=0;
    k=-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;
}













（KMP）

KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);KMP匹配算法。可以证明它的时间复杂度为O(m+n).。

一．  简单匹配算法

先来看一个简单匹配算法的函数：

int Index_BF ( char S [ ], char T [ ], int pos )

{

/* 若串 S 中从第pos(S 的下标0≤pos<StrLength(S))个字符

起存在和串 T 相同的子串，则称匹配成功，返回第一个

这样的子串在串 S 中的下标，否则返回 -1    */

int i = pos, j = 0;

while ( S[i+j] != ''&& T[j] != '')

if ( S[i+j] == T[j] )

j ++; // 继续比较后一字符

else

{

i ++; j = 0; // 重新开始新的一轮匹配

}

if ( T[j] == '')

return i; // 匹配成功   返回下标

else

return -1; // 串S中(第pos个字符起)不存在和串T相同的子串

} // Index_BF

   此算法的思想是直截了当的：将主串S中某个位置i起始的子串和模式串T相比较。即从 j=0 起比较 S[i+j] 与 T[j]，若相等，则在主串 S 中存在以 i 为起始位置匹配成功的可能性，继续往后比较( j逐步增1 )，直至与T串中最后一个字符相等为止，否则改从S串的下一个字符起重新开始进行下一轮的"匹配"，即将串T向后滑动一位，即 i 增1，而 j 退回至0，重新开始新一轮的匹配。

例如：在串S=”abcabcabdabba”中查找T=” abcabd”（我们可以假设从下标0开始）:先是比较S[0]和T[0]是否相等，然后比较S[1] 和T[1]是否相等…我们发现一直比较到S[5] 和T[5]才不等。如图：

 

 

 

当这样一个失配发生时，T下标必须回溯到开始，S下标回溯的长度与T相同，然后S下标增1,然后再次比较。如图：

 

这次立刻发生了失配，T下标又回溯到开始，S下标增1,然后再次比较。如图：

 

这次立刻发生了失配，T下标又回溯到开始，S下标增1,然后再次比较。如图：

 

又一次发生了失配，所以T下标又回溯到开始，S下标增1,然后再次比较。这次T中的所有字符都和S中相应的字符匹配了。函数返回T在S中的起始下标3。如图：

二. KMP匹配算法

还是相同的例子，在S=”abcabcabdabba”中查找T=”abcabd”，如果使用KMP匹配算法，当第一次搜索到S[5] 和T[5]不等后，S下标不是回溯到1，T下标也不是回溯到开始，而是根据T中T[5]==’d’的模式函数值（next[5]=2，为什么？后面讲），直接比较S[5] 和T[2]是否相等，因为相等，S和T的下标同时增加;因为又相等，S和T的下标又同时增加。。。最终在S中找到了T。如图：

KMP匹配算法和简单匹配算法效率比较，一个极端的例子是：

在S=“AAAAAA…AAB“(100个A)中查找T=”AAAAAAAAAB”, 简单匹配算法每次都是比较到T的结尾，发现字符不同，然后T的下标回溯到开始，S的下标也要回溯相同长度后增1，继续比较。如果使用KMP匹配算法，就不必回溯.

对于一般文稿中串的匹配，简单匹配算法的时间复杂度可降为O (m+n)，因此在多数的实际应用场合下被应用。

KMP算法的核心思想是利用已经得到的部分匹配信息来进行后面的匹配过程。看前面的例子。为什么T[5]==’d’的模式函数值等于2（next[5]=2），其实这个2表示T[5]==’d’的前面有2个字符和开始的两个字符相同，且T[5]==’d’不等于开始的两个字符之后的第三个字符（T[2]=’c’）.如图：

也就是说，如果开始的两个字符之后的第三个字符也为’d’,那么，尽管T[5]==’d’的前面有2个字符和开始的两个字符相同，T[5]==’d’的模式函数值也不为2，而是为0。

   前面我说：在S=”abcabcabdabba”中查找T=”abcabd”，如果使用KMP匹配算法，当第一次搜索到S[5] 和T[5]不等后，S下标不是回溯到1，T下标也不是回溯到开始，而是根据T中T[5]==’d’的模式函数值，直接比较S[5] 和T[2]是否相等。。。为什么可以这样？

刚才我又说：“（next[5]=2），其实这个2表示T[5]==’d’的前面有2个字符和开始的两个字符相同”。请看图  ：因为，S[4] ==T[4]，S[3] ==T[3]，根据next[5]=2，有T[3]==T[0]，T[4] ==T[1]，所以S[3]==T[0]，S[4] ==T[1]（两对相当于间接比较过了），因此，接下来比较S[5] 和T[2]是否相等。。。

有人可能会问：S[3]和T[0]，S[4] 和T[1]是根据next[5]=2间接比较相等，那S[1]和T[0]，S[2] 和T[0]之间又是怎么跳过，可以不比较呢？因为S[0]=T[0]，S[1]=T[1]，S[2]=T[2]，而T[0]  !=  T[1], T[1]  !=  T[2],==>  S[0]  != S[1],S[1] != S[2],所以S[1]  != T[0],S[2] != T[0].  还是从理论上间接比较了。

有人疑问又来了，你分析的是不是特殊轻况啊。

假设S不变，在S中搜索T=“abaabd”呢？答：这种情况，当比较到S[2]和T[2]时，发现不等，就去看next[2]的值，next[2]=-1，意思是S[2]已经和T[0] 间接比较过了，不相等，接下来去比较S[3]和T[0]吧。

假设S不变，在S中搜索T=“abbabd”呢？答：这种情况当比较到S[2]和T[2]时，发现不等，就去看next[2]的值，next[2]=0，意思是S[2]已经和T[2]比较过了，不相等，接下来去比较S[2]和T[0]吧。

假设S=”abaabcabdabba”在S中搜索T=“abaabd”呢？答：这种情况当比较到S[5]和T[5]时，发现不等，就去看next[5]的值，next[5]=2，意思是前面的比较过了，其中，S[5]的前面有两个字符和T的开始两个相等，接下来去比较S[5]和T[2]吧。

总之，有了串的next值，一切搞定。那么，怎么求串的模式函数值next[n]呢？（本文中next值、模式函数值、模式值是一个意思。）

三. 怎么求串的模式值next[n]

定义：

（1）next[0]= -1  意义：任何串的第一个字符的模式值规定为-1。

（2）next[j]= -1   意义：模式串T中下标为j的字符，如果与首字符

相同，且j的前面的1—k个字符与开头的1—k

个字符不等（或者相等但T[k]==T[j]）（1≤k<j）。

如：T=”abCabCad” 则 next[6]=-1，因T[3]=T[6]

（3）next[j]=k    意义：模式串T中下标为j的字符，如果j的前面k个

字符与开头的k个字符相等，且T[j] != T[k] （1≤k<j）。

                       即T[0]T[1]T[2]。。。T[k-1]==

T[j-k]T[j-k+1]T[j-k+2]…T[j-1]

且T[j] != T[k].（1≤k<j）;

(4) next[j]=0   意义：除（1）（2）（3）的其他情况。

 

举例：

01）求T=“abcac”的模式函数的值。

     next[0]= -1  根据（1）

     next[1]=0   根据 (4)   因（3）有1<=k<j;不能说，j=1,T[j-1]==T[0]

     next[2]=0   根据 (4)   因（3）有1<=k<j;（T[0]=a）!=（T[1]=b）

     next[3]= -1  根据 (2)

     next[4]=1   根据 (3)  T[0]=T[3] 且 T[1]=T[4]

    即   

 

下标	0	1	2	3	4
T	a	b	c	a	c
next	-1	0	0	-1	1

若T=“abcab”将是这样：

 

下标	0	1	2	3	4
T	a	b	c	a	b
next	-1	0	0	-1	0

为什么T[0]==T[3],还会有next[4]=0呢, 因为T[1]==T[4], 根据 (3)” 且T[j] != T[k]”被划入（4）。

02）来个复杂点的，求T=”ababcaabc” 的模式函数的值。

next[0]= -1    根据（1）

         next[1]=0    根据(4)

         next[2]=-1   根据 (2)

next[3]=0   根据 (3) 虽T[0]=T[2] 但T[1]=T[3] 被划入（4）

next[4]=2   根据 (3) T[0]T[1]=T[2]T[3] 且T[2] !=T[4]

next[5]=-1  根据 (2) 

next[6]=1   根据 (3) T[0]=T[5] 且T[1]!=T[6]

next[7]=0   根据 (3) 虽T[0]=T[6] 但T[1]=T[7] 被划入（4）

next[8]=2   根据 (3) T[0]T[1]=T[6]T[7] 且T[2] !=T[8]

 即

 

下标	0	1	2	3	4	5	6	7	8
T	a	b	a	b	c	a	a	b	c
next	-1	0	-1	0	2	-1	1	0	2

只要理解了next[3]=0，而不是=1，next[6]=1，而不是= -1，next[8]=2，而不是= 0，其他的好象都容易理解。

03)   来个特殊的，求 T=”abCabCad” 的模式函数的值。

 

下标	0	1	2	3	4	5	6	7
T	a	b	C	a	b	C	a	d
next	-1	0	0	-1	0	0	-1	4

         

next[5]= 0  根据 (3) 虽T[0]T[1]=T[3]T[4],但T[2]==T[5]

next[6]= -1  根据 (2) 虽前面有abC=abC,但T[3]==T[6]

next[7]=4   根据 (3) 前面有abCa=abCa,且 T[4]!=T[7]

若T[4]==T[7]，即T=” adCadCad”,那么将是这样：next[7]=0, 而不是= 4,因为T[4]==T[7].

 

下标	0	1	2	3	4	5	6	7
T	a	d	C	a	d	C	a	d
next	-1	0	0	-1	0	0	-1	0

 

如果你觉得有点懂了，那么

练习：求T=”AAAAAAAAAAB” 的模式函数值，并用后面的求模式函数值函数验证。

 

意义：

 next 函数值究竟是什么含义，前面说过一些，这里总结。

设在字符串S中查找模式串T，若S[m]!=T[n],那么，取T[n]的模式函数值next[n],

1.       next[n]=  -1 表示S[m]和T[0]间接比较过了，不相等，下一次比较 S[m+1] 和T[0]

2.       next[n]=0 表示比较过程中产生了不相等，下一次比较 S[m] 和T[0]。

3.       next[n]= k >0 但k<n, 表示,S[m]的前k个字符与T中的开始k个字符已经间接比较相等了，下一次比较S[m]和T[k]相等吗？

4.       其他值，不可能。

四. 求串T的模式值next[n]的函数

说了这么多，是不是觉得求串T的模式值next[n]很复杂呢？要叫我写个函数出来，目前来说，我宁愿去登天。好在有现成的函数，当初发明KMP算法，写出这个函数的先辈，令我佩服得六体投地。我等后生小子，理解起来，都要反复琢磨。下面是这个函数:

void get_nextval(const char *T, int next[])

{

       // 求模式串T的next函数值并存入数组 next。

       int j = 0, k = -1;

       next[0] = -1;

       while ( T[j/*+1*/] != '' )

       {

              if (k == -1 || T[j] == T[k])

              {

                     ++j; ++k;

                     if (T[j]!=T[k])

                            next[j] = k;

                     else

                            next[j] = next[k];

              }// if

              else

                     k = next[k];

       }// while

    ////这里是我加的显示部分

   // for(int  i=0;i<j;i++)

       //{

       //     cout<<next[i];

       //}

       //cout<<endl;

}// get_nextval　

另一种写法，也差不多。

void getNext(const char* pattern,int next[])

{

       next[0]=   -1;

       int k=-1,j=0;

       while(pattern[j]  !=  '')

       {

              if(k!=  -1  &&  pattern[k]!=  pattern[j] )

                     k=next[k];

              ++j;++k;

              if(pattern[k]==  pattern[j])

                     next[j]=next[k];

              else

                     next[j]=k;

       }

       ////这里是我加的显示部分

   // for(int  i=0;i<j;i++)

       //{

       //     cout<<next[i];

       //}

       //cout<<endl;

}

下面是KMP模式匹配程序，各位可以用他验证。记得加入上面的函数

#include <iostream.h>

#include <string.h>

int KMP(const char *Text,const char* Pattern) //const 表示函数内部不会改变这个参数的值。

{

       if( !Text||!Pattern||  Pattern[0]==''  ||  Text[0]=='' )//

              return -1;//空指针或空串，返回-1。

       int len=0;

       const char * c=Pattern;

       while(*c++!='')//移动指针比移动下标快。

       {    

              ++len;//字符串长度。

       }

       int *next=new int[len+1];

       get_nextval(Pattern,next);//求Pattern的next函数值

   

       int index=0,i=0,j=0;

       while(Text[i]!=''  && Pattern[j]!='' )

       {

              if(Text[i]== Pattern[j])

              {

                     ++i;// 继续比较后继字符

                     ++j;

              }

              else

              {

                     index += j-next[j];

                     if(next[j]!=-1)

                            j=next[j];// 模式串向右移动

                     else

                     {

                            j=0;

                            ++i;

                     }

              }

       }//while

   

       delete []next;

       if(Pattern[j]=='')

              return index;// 匹配成功

       else

              return -1;      

}

int main()//abCabCad

{

       char* text="bababCabCadcaabcaababcbaaaabaaacababcaabc";

    char*pattern="adCadCad";

       //getNext(pattern,n);

    //get_nextval(pattern,n);

      cout<<KMP(text,pattern)<<endl;

       return 0;

}

五．其他表示模式值的方法

 

    上面那种串的模式值表示方法是最优秀的表示方法，从串的模式值我们可以得到很多信息，以下称为第一种表示方法。第二种表示方法，虽然也定义next[0]= -1,但后面绝不会出现 -1，除了next[0]，其他模式值next[j]=k(0≤k<j)的意义可以简单看成是：下标为j的字符的前面最多k个字符与开始的k个字符相同，这里并不要求T[j] != T[k]。其实next[0]也可以定义为0（后面给出的求串的模式值的函数和串的模式匹配的函数，是next[0]=0的），这样，next[j]=k(0≤k<j)的意义都可以简单看成是：下标为j的字符的前面最多k个字符与开始的k个字符相同。第三种表示方法是第一种表示方法的变形，即按第一种方法得到的模式值，每个值分别加1，就得到第三种表示方法。第三种表示方法，我是从论坛上看到的，没看到详细解释，我估计是为那些这样的编程语言准备的：数组的下标从1开始而不是0。

 下面给出几种方法的例子：

      表一。

 

下标	0	1	2	3	4	5	6	7	8
T	a	b	a	b	c	a	a	b	c
(1) next	-1	0	-1	0	2	-1	1	0	2
(2) next	-1	0	0	1	2	0	1	1	2
(3) next	0	1	0	1	3	0	2	1	3

第三种表示方法,在我看来，意义不是那么明了，不再讨论。

           表二。

 

下标	0	1	2	3	4
T	a	b	c	a	c
(1)next	-1	0	0	-1	1
(2)next	-1	0	0	0	1

      表三。

 

下标	0	1	2	3	4	5	6	7
T	a	d	C	a	d	C	a	d
(1)next	-1	0	0	-1	0	0	-1	0
(2)next	-1	0	0	0	1	2	3	4

 

对比串的模式值第一种表示方法和第二种表示方法，看表一：

第一种表示方法next[2]= -1,表示T[2]=T[0]，且T[2-1] !=T[0]

第二种表示方法next[2]= 0,表示T[2-1] !=T[0],但并不管T[0] 和T[2]相不相等。

第一种表示方法next[3]= 0,表示虽然T[2]=T[0]，但T[1] ==T[3]

第二种表示方法next[3]= 1,表示T[2] =T[0],他并不管T[1] 和T[3]相不相等。

第一种表示方法next[5]= -1,表示T[5]=T[0]，且T[4] !=T[0]，T[3]T[4] !=T[0]T[1]，T[2]T[3]T[4] !=T[0]T[1]T[2]

第二种表示方法next[5]= 0,表示T[4] !=T[0]，T[3]T[4] !=T[0]T[1] ，T[2]T[3]T[4] !=T[0]T[1]T[2]，但并不管T[0] 和T[5]相不相等。换句话说：就算T[5]==’x’,或 T[5]==’y’,T[5]==’9’,也有next[5]= 0 。

从这里我们可以看到：串的模式值第一种表示方法能表示更多的信息，第二种表示方法更单纯，不容易搞错。当然，用第一种表示方法写出的模式匹配函数效率更高。比如说，在串S=“adCadCBdadCadCad 9876543”中匹配串T=“adCadCad”, 用第一种表示方法写出的模式匹配函数,当比较到S[6] != T[6] 时，取next[6]= -1（表三）,它可以表示这样许多信息： S[3]S[4]S[5]==T[3]T[4]T[5]==T[0]T[1]T[2]，而S[6] != T[6]，T[6]==T[3]==T[0]，所以S[6] != T[0],接下来比较S[7]和T[0]吧。如果用第二种表示方法写出的模式匹配函数,当比较到S[6] != T[6] 时，取next[6]= 3（表三）,它只能表示：S[3]S[4]S[5]== T[3]T[4]T[5]==T[0]T[1]T[2]，但不能确定T[6]与T[3]相不相等，所以，接下来比较S[6]和T[3];又不相等，取next[3]= 0，它表示S[3]S[4]S[5]== T[0]T[1]T[2]，但不会确定T[3]与T[0]相不相等，即S[6]和T[0] 相不相等，所以接下来比较S[6]和T[0]，确定它们不相等，然后才会比较S[7]和T[0]。是不是比用第一种表示方法写出的模式匹配函数多绕了几个弯。

为什么，在讲明第一种表示方法后，还要讲没有第一种表示方法好的第二种表示方法？原因是：最开始，我看严蔚敏的一个讲座，她给出的模式值表示方法是我这里的第二种表示方法，如图：

她说：“next 函数值的含义是：当出现S[i] !=T[j]时，下一次的比较应该在S[i]和T[next[j]]  之间进行。”虽简洁，但不明了，反复几遍也没明白为什么。而她给出的算法求出的模式值是我这里说的第一种表示方法next值，就是前面的get_nextval()函数。匹配算法也是有瑕疵的。于是我在这里发帖说她错了：

    http://community.csdn.net/Expert/topic/4413/4413398.xml?temp=.2027246

   

    现在看来，她没有错，不过有张冠李戴之嫌。我不知道，是否有人第一次学到这里，不参考其他资料和明白人讲解的情况下，就能搞懂这个算法（我的意思是不仅是算法的大致思想，而是为什么定义和例子中next[j]=k(0≤k<j)，而算法中next[j]=k(-1≤k<j)）。凭良心说：光看这个讲座，我就对这个教受十分敬佩，不仅讲课讲得好，声音悦耳，而且这门课讲得层次分明，恰到好处。在KMP这个问题上出了点小差错，可能是编书的时候，在这本书上抄下了例子，在那本书上抄下了算法，结果不怎么对得上号。因为我没找到原书，而据有的网友说，书上已不是这样，也许吧。说起来，教授们研究的问题比这个高深不知多少倍，哪有时间推演这个小算法呢。总之，瑕不掩玉。

     书归正传，下面给出我写的求第二种表示方法表示的模式值的函数,为了从S的任何位置开始匹配T，“当出现S[i] !=T[j]时，下一次的比较应该在S[i]和T[next[j]]  之间进行。”    定义next[0]=0 。

 void myget_nextval(const char *T, int next[])

{

     // 求模式串T的next函数值（第二种表示方法）并存入数组 next。                

     int j = 1, k = 0;

     next[0] = 0;

       while ( T[j] != '' )

     {    

                   if(T[j] == T[k])

                   {

                         next[j] = k;

                         ++j; ++k;                 

                   }

                   else if(T[j] != T[0])

                   {

                  next[j] = k;

                  ++j;

                            k=0;

                   }

                   else

                   {

                          next[j] = k;

                  ++j;

                             k=1;

                   }

     }//while

    for(int  i=0;i<j;i++)

     {

            cout<<next[i];

     }

     cout<<endl;

}// myget_nextval

 

下面是模式值使用第二种表示方法的匹配函数（next[0]=0）

 

int my_KMP(char *S, char *T, int pos)

{

int i = pos,  j = 0;//pos(S 的下标0≤pos<StrLength(S))

while ( S[i] != '' && T[j] != '' )

{

    if (S[i] == T[j] )

     {

         ++i;

             ++j; // 继续比较后继字符

     }

   else             // a  b  a  b  c  a  a  b  c

                    // 0  0  0  1  2  0  1  1  2

   {              //-1  0  -1  0  2 -1  1  0  2

      i++;

     j = next[j];     /*当出现S[i] !=T[j]时，

              下一次的比较应该在S[i]和T[next[j]]  之间进行。要求next[0]=0。

在这两个简单示范函数间使用全局数组next[]传值。*/

   }

}//while

if ( T[j] == '' )

    return (i-j); // 匹配成功

else

     return -1;

} // my_KMP

 

 

六．后话--KMP的历史

[这段话是抄的]

Cook于1970年证明的一个理论得到，任何一个可以使用被称为下推自动机的计算机抽象模型来解决的问题，也可以使用一个实际的计算机（更精确的说，使用一个随机存取机）在与问题规模对应的时间内解决。特别地，这个理论暗示存在着一个算法可以在大约m+n的时间内解决模式匹配问题，这里m和n分别是存储文本和模式串数组的最大索引。Knuth 和Pratt努力地重建了 Cook的证明，由此创建了这个模式匹配算法。大概是同一时间，Morris在考虑设计一个文本编辑器的实际问题的过程中创建了差不多是同样的算法。这里可以看到并不是所有的算法都是“灵光一现”中被发现的，而理论化的计算机科学确实在一些时候会应用到实际的应用中。