KMP算法

来源：互联网发布：c语言计算器程序代码编辑：程序博客网时间：2024/05/18 02:45

1、KMP算法由来

字符串匹配问题描述：参见

LeetCode OJ:Implement strStr()

关于这个问题，最简单的想法就是扫描字符串s，一个一个进行比对，具体实现参见问题解答

2、简单匹配算法，BF算法，思想较简单，不做解释

class Solution {  public:      int BF(char *S ,char *T) {                    int slen = strlen(S);          int tlen = strlen(T);          int i = 0 ,j = 0;                    while ( i+j < slen && j < tlen){              if ( S[i+j] == T[j] ){                  j ++;              }              else              {                  i ++;                  j = 0;              }          }          if ( j >= tlen)              return i;          else              return -1;      }  };

3、KMP算法

（1）由来：

因为BF算法时间复杂度为O(M*N)，每一次不匹配后都需要跳回S字符串的下一个字符出进行

举个例子，假设T字符串中的字符两两不同，那么当循环到某一位置不匹配时，压根就不需要回到S的下一个i位置处进行，直接从当前位置处向后循环比对就可以了，因为T字符串两两不同，前面的字符根本不可能作为第一个匹配的字符，所以，从这来看，可以设计这样一种算法，该算法时间复杂度取决于T字符串中相同字符的个数，因此，KMP算法应运而生。时间复杂度可提高为O(M+N)

（2）模式值next[n]

简单地说，模式值next[n]就是当字符串不匹配时，不是回到字符串的起点，而是回到某个位置，next[n]记录第n位置元素不匹配时应该反回到的位置，然后向后进行匹配

（3）next[n]函数

至此，主要问题归结于求模式值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]

即

下标

-1

若T=“abcab”将是这样：

下标

-1

为什么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]

即

下标

-1

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

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

下标

-1

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].

下标

-1

意义：

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. 其他值，不可能。

所以next[n]函数为

void get_nextval(char const* ptrn, int plen, int* nextval)          {              int i = 0;               nextval[i] = -1;              int j = -1;              while( i < plen-1 )              {                  if( j == -1 || ptrn[i] == ptrn[j] )                  {                      ++i;                      ++j;                                           if( ptrn[i] != ptrn[j] )                           nextval[i] = j;                            else                          nextval[i] = nextval[j];                  }                  else                                                       j = nextval[j];              }          }

当next[n]生成后，其他的和BF就一样了，j=0换成j=nextval[j]而已

class Solution {  public:            void get_nextval(char const* ptrn, int plen, int* nextval)          {              int i = 0;               nextval[i] = -1;              int j = -1;              while( i < plen-1 )              {                  if( j == -1 || ptrn[i] == ptrn[j] )                 {                      ++i;                      ++j;                                           if( ptrn[i] != ptrn[j] )                           nextval[i] = j;                            else                          nextval[i] = nextval[j];                  }                  else                                                       j = nextval[j];              }          }      int KMP(char *S, char *T) {                    int slen = strlen(S);          int tlen = strlen(T);          int i = 0 ,j = 0;                    int *nextval=new int[tlen];          get_nextval(T,tlen,nextval);                    while ( i+j < slen && j < tlen){              if ( j == -1 || S[i+j] == T[j] ){                  j ++;              }              else              {                  i ++;                  j = nextval[j];              }          }          if ( j >= tlen)              return i;          else              return -1;      }  };

0 0