`

KMP算法详解

阅读更多

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] != '\0'&& T[j] != '\0')

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

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

else

{

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

}

if ( T[j] == '\0')

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中相应的字符匹配了。函数返回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]
定义
1next[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.       表示S[m]和T[0]间接比较过了,不相等,下一次 比较 S[m+1] 和T[0] next[n]= -1
2.       表示比较过程中产生了不相等,下一次比较 S[m] 和T[0]。 next[n]=0
3.       但k<n, 表示,S[m]的前k个字符与T中的开始k个字符已经间接比较相等了,下一次比较S[m]和T[k]相等吗? next[n]= k >0
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*/] != '\0' )

     {

            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] != '\0')

     {

            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]=='\0' || Text[0]=='\0' )//

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

     int len=0;

     const char * c=Pattern;

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

     {    

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

     }

     int *next=new int[len+1];
     get_nextval(Pattern,next); // 求Pattern的next函数值
    

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

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

     {

            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]=='\0')

            return index; // 匹配成功

     else

            return -1;   </spa

分享到:
评论

相关推荐

    KMP算法详解KMP算法详解

    KMP 算法详解 KMP 算法是字符串模式匹配的一种高效算法,解决了字符串中模式匹配的问题。该算法可以在 O(m+n) 的时间复杂度内完成字符串模式匹配。 简单匹配算法 简单匹配算法的思想是直截了当的,将主串 S 中...

    KMP算法详解 KMP算法详解

    KMP算法详解 KMP算法详解 KMP算法详解

    kmp算法详解及练习

    ### KMP算法详解 #### 一、KMP算法概述 KMP算法,全称为Knuth-Morris-Pratt算法,是一种高效的字符串匹配算法,由Donald Knuth、James H. Morris和Vaughan Pratt三位计算机科学家共同提出。该算法主要用于解决在主...

    kmp算法详解

    "kmp算法详解" KMP 字符串模式匹配算法是高效的字符串匹配算法,时间复杂度为 O(m+n),其中 m 和 n 分别是主串和模式串的长度。KMP 算法的核心思想是利用已经得到的部分匹配信息来进行后面的匹配过程。 KMP 算法的...

    关于数据结构中的kmp算法详解

    ### KMP算法详解:原理与应用 #### 引言 KMP算法,全称为Knuth-Morris-Pratt算法,是一种高效的字符串匹配算法,由Donald E. Knuth、James H. Morris以及Vaughan Pratt三位计算机科学家共同提出。相较于传统的模式...

    模式匹配的KMP算法详解.

    ### 模式匹配的KMP算法详解 #### 一、KMP算法背景及传统模式匹配算法 KMP算法,即Knuth-Morris-Pratt算法,是由Donald E. Knuth、James H. Morris和Vaughan R. Pratt三位计算机科学家在1977年共同提出的一种高效的...

    严蔚敏数据结构kmp算法详解PPT学习教案.pptx

    严蔚敏数据结构kmp算法详解PPT学习教案.pptx 本资源摘要信息将对严蔚敏数据结构kmp算法的学习教案进行详细的讲解和分析。KMP算法是字符串匹配算法中的一种重要算法,它可以高效地进行字符串匹配。 首先,我们需要...

    字符串模式匹配KMP算法详解.doc

    ### 字符串模式匹配KMP算法详解 #### 一、引言 在计算机科学领域,字符串模式匹配是一项基本且重要的任务。它涉及到在一个较大的文本字符串(通常称为“主串”或“目标串”)中寻找一个较小的字符串(称为“模式串...

    严蔚敏-数据结构-kmp算法详解.ppt

    严蔚敏-数据结构-kmp算法详解.ppt该文档详细且完整,值得借鉴下载使用,欢迎下载使用,有问题可以第一时间联系作者~

    KMP算法详解-彻底清楚了.pdf

    《KMP算法详解》 KMP(Knuth-Morris-Pratt)算法是一种在字符串中查找子串出现位置的高效算法,由Donald Knuth、James H. Morris和 Vaughan Pratt共同提出。该算法避免了在匹配过程中对已匹配部分的重新比较,显著...

    KMP算法详解.doc

    "KMP算法详解" 一、KMP字符串模式匹配算法 KMP字符串模式匹配算法是一种高效的字符串模式匹配算法,能够在一个字符串中快速地定位另一个字符串。该算法的时间复杂度为O(m+n),远远优于简单匹配算法的时间复杂度O(m...

    KMP算法详解.mhtml

    KMP算法详解.mhtml

    模式匹配的KMP算法详解

    【KMP算法详解】 KMP(Knuth-Morris-Pratt)算法是一种高效地进行字符串模式匹配的算法,由D.E.Knuth、J.H.Morris和V.R.Pratt三位学者独立提出。它解决了在主串(S)中查找模式串(T)出现的位置问题,避免了在匹配...

    KMP、Mancher和扩展KMP算法详解

    KMP、Mancher和扩展KMP算法详解,但是其中的参考代码有一点小错误,请自行参考网络

    KMP算法详解够详细了

    相比于简单的暴力匹配算法,KMP算法显著提高了性能,避免了不必要的字符回溯。它的核心在于构造一个模式函数next,也称为部分匹配表,用于存储模式串中每个位置的最长前缀和后缀的公共长度。 简单匹配算法,也称为...

    【基础】KMP算法详解.pdf

    本文介绍了KMP算法的原理和基本实现方法,附带算法模板的代码和详解。如想了解更多内容,欢迎关注微信公众号:信息学竞赛从入门到巅峰。

    KMP算法详解0.0.doc

    KMP算法的核心在于构建一个称为“部分匹配表”或“next数组”,用于存储模式串中每个位置的前缀和后缀的最大公共长度。 在构建next数组的过程中,我们需要遵循以下两个条件: 1. 当比较到某个位置时,如果模式串的...

Global site tag (gtag.js) - Google Analytics