字符串模式匹配算法，通俗点说，就是一种在一个字符串中定位另一个串的高效算法。KMP(Knuth-Morris-Pratt)算法是一种基于前缀搜索的方法。简单匹配算法的时间复杂度为O(m*n);KMP匹配算法在搜索阶段的最坏时间复杂度和平均时间复杂度都是O(n),在预处理阶段的时间复杂度是O(m)，所以它的时间复杂度为O(m+n)。

一.BF算法：简单匹配算法

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

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]才不等。如图一：

图一

图二

图三

图四

BF 算法最为简单与原始，通常作为对照算法，被用来作正确性验证等目的。

二. 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。如图五：

图五

图六

有人可能会问：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]

四. 求串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;
 //}
 //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;
 //}
 //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!='�' && Pattern[j]!='�' )
 {
  if(Text== 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，就得到第三种表示方法。

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

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

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

书归正传，下面给出求第二种表示方法表示的模式值的函数,为了从S的任何位置开始匹配T，“当出现S!=T[j]时，下一次的比较应该在S和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 ;
}
 cout<<endl;
} // myget_nextval

附：KMP算法C语言实现源码

//KMP算法的实现：（注意在D盘里建个txt.txt文件，里头随便打上一些字符）                                     
#include <stdio.h> 
#include <stdlib.h>
#include <string.h>
#include <time.h>
int* GetPrefixValue(char* strPattern, int iPatternLen)
{
    int i, j; /* i runs through the string, j counts the hits*/
    int* prefix = (int*)malloc(iPatternLen*sizeof(int));

    i = 1; j = 0;
    prefix[0] = 0;

    while(i<iPatternLen)
    {
        if(strPattern == strPattern[j])
        {
            prefix = ++j;
        }
        else
        {
            j = 0;
            prefix = j;
        }
        i++;
    }
    return prefix;           
}   

//返回target串在pattern串中第一次匹配的index 
int KMPStringMatch(char* strPattern, int iPatternLen, char* strTarget, int iTargetLen, int* prefix)
{
    int i = 0;
    int j = 0;
    while(i<iPatternLen && j<iTargetLen)
    {
        if(j==0 || strPattern==strTarget[j])
        {
            i++;  j++;
        }
        else
        {
            j = prefix[j];
        }
    }
    free(prefix);
    if(j==iTargetLen)
    {
        return i-j;
    }
    else
    {
        return -1;
    }         
}        

int KMP(char* strPattern, char* strTarget)
{
    int* prefix = GetPrefixValue(strPattern, strlen(strPattern)); 
    int index = KMPStringMatch(strPattern, strlen(strPattern), strTarget, strlen(strTarget), prefix);
    return index; 
}

//在文本文件中查找target串出现的行数 
int SearchInTxtFile(char* fileName, char* strTarget)
{
    FILE* hFile = fopen(fileName, "r");
    char str[1024]; 
    int count = 0;

    while(fgets(str, 1024, hFile)) 
    { 
        if(KMP(str, strTarget)!=-1)
        {
            count++; 
        }    
    }     

    fclose(hFile);
    hFile=NULL;

    return count; 
}    

int main()
{
    char ch;
    char str1[] = "abcabcabctasksb,abTo";

    char str2[] = "abc";
    double t=clock();
    printf("%dn", KMP(str1,str2)); 
    printf("耗时：%f毫秒！n", (clock()-t));

    t=clock(); 
    //printf("find %d n", SearchInTxtFile("d:\txt.txt", "NULL"));
    printf("find %d n", SearchInTxtFile("d:\txt.txt", "abc")); 
    printf("耗时：%f毫秒！n", (clock()-t));
    scanf("%c", &ch);

    return 0;
}

KMP算法C语言实现源码下载：点击下载此文件

相关文章:

WM(Wu-Manber)算法详解及C语言实现程序代码解析参考 常见经典字符串匹配算法简要介绍 & 柔性的字符串匹配pdf下载地址 位并行算法与shift-and、shift-or算法 精确单字符串匹配BM算法及其在snort中的C语言实现代码解析 windows平台上运行的unix模拟环境cygwin：cygwin的安装配置与使用介绍 分布式文件系统Andrew file system运行机制简介 多模式串匹配之AC自动机算法（Aho-Corasick算法）简介与C语言程序实现源码参考 True CDP与 Near CDP LVM磁盘镜像同步备份：实现LVM镜像的详细方法与步骤 LVM+iSCSI磁盘远程镜像配置步骤