串的匹配

1 求子串位置的定位函数Index(S,T,pos)

子串的定位操作通常称作串的模式匹配(其中T被称为模式串),是各种串处理系统中最

重要的操作之一。在以前借用串的其他基本操作给出了定位函数的一种算法。根据以前算法的基本思想,采用定长顺序存储结构,可以写出不依赖于其他串操作的匹配算法,如算法1所示。

int Index(Sstring S, Sstring T,int pos){

//返回子串T在主串s中第pos个字符之后的位置。若不存在,则函数值为0。

//其中,T非空,1≤Pos≤StrLength(S)。

i=pos；

j=1；

while(i<=S[0]&&j<=T[0]) {

if(s[i]==T[j]) { i++; j++; } //继续比较后继字符 ·

else { i=i-j+2； j=1；} //指针后退重新开始匹配

}

if(i>T[0]) return i-T[0]；

else return 0；

} //Index

算法 1

在算法1的函数过程中,分别利用计数指针i和j指示主串S和模式串T中当前正待比较的字符位置。算法的基本思想是：从主串S的第pos个字符起和模式的第一个字符比较之, 若相等,则继续逐个比较后续字符,否则从主串的下一个字符起再重新和模式的字符比较之。依次类推,直至模式T中的每个字符依次和主串S中的一个连续的字符序列相等,则称匹配成功,函数值为和模式T中第一个字符相等的字符在主串S中的序号,否则称匹配不成功,函数值为零。图1展示了模式T="abcac"和主串S的匹配过程(pos=1)。

算法1的匹配过程易於理解,且在某些应用场合,如文本编辑等,效率也较高,例如,在检查模式"STING"是否存在於下列主串中时,

"A STRING SEARCHING EXAMPLE CONSISTING OF SIMPLE TEXT"

上述算法中的WHILE循环次数(即进行单个字符比较的次数)为41,恰好为

(Index+T[0]-1)+4这就是说，除了主串中呈黑体的四个字符，每个字符比较了两次以外，其它字符均只和模式进行一次比较。在这种情况下，此算法的时间复杂度为O(n+m)。其中n 和m分别为主串和模式的长度。然而，在有些情况下，该算法的效率却很低。例如，当模式串为"00000001"，而主串为"00000000000000000000000000000000000000000000000000001"时，由于模式中前7个字符均为"0"，又，主串中前52个字符均为"0"，每趟比较都在模式的最后一个字符出现不等，此时需将指针i回溯到i-6的位置上，并从模式的第一个字符开始重新比较，整个匹配过程中指针i需回溯45次，则WHILE循环次数为46* 9(index*m)。可见，算法1在最坏情况下的时间复杂度为O(n*m)。这种情况在只有0、1两种字符的文本串处理中经常出现，因为在主串中可能存在多个和模式串“部分匹配”的子串，因而引起指针i的多次回溯。01串可以

用在许多应用之中。比如，一些计算机的图形显示就是把画面表示为一个01串，一页书就

是一个几百万个0和1组成的串。在二进位计算机上实际处理的都是01串。一个字符的ASCII 码也可以看成是八个二进位的01串。包括汉字存储在计算机中处理

时也是作为一个01串和其它的字符串一样看待。因此在下一节，我们将介绍另一种较好的

模式匹配算法。

2 模式匹配的一种改进算法

这种改进算法是D．E．Knuth与V．R．Pratt和J．H．Morris同时发现的，因此人们称它

为克努特-莫里斯-普拉特操作(简称为KMP算法)。此算法可以在O(n+m)的时间数量级上完

成串的模式匹配操作。其改进在於: 每当一趟匹配过程中出现字符比较不等时，不需回溯i

指针，而是利续进行比较。下面先从具体例子看起。

回顾图1中的匹配过程示例，在第三趟的匹配中，当i=7,j=5字符比较不等时，又从i=4，

j=1重新开始比较。然后，经仔细观察可发现，在i=4和j=1;i=5和j=1以及i=6和j=1这三

次比较都是不必进行的。因为从第三趟部分匹配的结果就可得出，主串中第4、5和6个字

符必然是…b?、…c?和…a?(即模式串中第2、3和4个字符)。因为模式中的第一个字符是

a，因此它无需再和这三个字符进行比较，而仅需将模式向右滑动三个字符的位置继续进行

i=7、j=2时的字符比较即可。同理，在第一趟匹配中出现字符不等时，仅需将模式向右移动

二个字符的位置继续进行i=3、j=1时的字符比较。由此，在整个匹配的过程中，i指针没有回溯。

现在讨论一般情况。假设主串为s[1..n]，模式串为p[1..m]，从上例的分析可知，为了实现改进算法，需要解决下述问题：当匹配过程中产生“失配”(即s[i]!=p[j])时，模式串“向

右滑动??可行的距离多远，换句话说，当主串中第i个字符与模式中第j个字符“失配??

(即比较不等)时，主串中第i字符(i指针不回溯)应与模式中哪个字符再比较?

假设此时应与模式中第k(kk满足下列关系式而已经得到的“部分匹配”的结果推得下列等

式

p[1..k-1]==s[i-k+1..i-1]

而已经得到的部分结果是

p[j-k+1..j-1]==s[i-k+1..i-1]

推得以下结果

p[1..k-1]==p[j-k+1..j-1]

反之，若模式串中存在满足式的两个子串，则当匹配过程中，主串中第i个字符与模式中第j个字符比较不等时，仅需将模式向右滑动至模式中第是个字符和主串中第i个字符对齐，此时，模式中头是k-1个字符的子串p[1..k-1]必定与主串中第i个字符之前长度为k-1的子

串s[i-k+1..i-1]相等，由此，匹配仅需从模式中第i个字符与主串中第j个字符比较起继续进行。

若令next[j]=k，则next[j]表明当模式中第j个字符与主串中相应字符“失配”时，在模

式中需重新和主串中该字符进行比较的字符的位置。由此可引出模式串的next函数的定义：

next[j]=0 当j=1时

next[j]=Max{k|1

next[j]=1 其它情况

由此定义可推出下列模式串的next函数值：

在求得模式的next函数之后，匹配可如下进行：假设以指针i和j分别指示主串和模式

中正待比较的字符，令i的初值为pos，j的初值为1。若在匹配过程中s[i]==p[j]，则i和j 分别增1，否则，i不变，而j退到next[j]的位置再比较，若相等，则指针各自增1，否则j 再退到下一个next值的位置，依次类推，直至下列两种可能：一种是j退到某个next值(next[next ... next[j]...])时字符比较相等，则指针各自增1继续进行匹配；另一种是j退到值为零(即模式的第一个字符“失配”)，则此时需将模式继续向右滑动一个位置，即从主串的下一个字符s[i+1]，起和模式重新开始匹配。下图所示正是上述匹配过程的一个例子。KMP算法如算法2所示，它在形式上和算法1极为相似。不同之处仅在於：当匹配过

程中产生“失配”时，指针i不变，指针j退回到next[j]所指示的位置上重新进行比较，并

且当指针j退至零时，指针i和指针j需同时增1。即若主串的第i个字符和模式的第1个字符不等，应从主串的第i+1个字符起重新进行匹配。

int Index_KMP( SString S，SString T，int pos){

//利用模式串T的next函数求T在主串s中第pos个字符之后的位置的

//KMP算法。其中，T非空，1≤pos≤StrLength(S)。

i=pos；

j=1;

while(i<=S[0]&&j<=T[0]){

if(j=0||S[i]==T[j]) { ++i；++j; } ／／继续比较后继字符

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

}

if(i>T[0]) return i-T[0]；／／匹配成功

else return 0；．

} //Index_KMP

算法2

KMP算法是在已知模式串的next函数值的基础上执行的，那么，如何求得模式串的next函数值呢?

从上述讨论可见，此函数值仅取决于模式串本身而和相匹配的主串无关。

分析其定义出发用递推的方法求得next函数值。

由定义得知

next[1]=0

设next[j]=k, 这表明在模式串中存在下列关系：

p[1..k-1] == p[j-k+1..j-1]

其中k为满足1k满足等式。此时next[j+1]=?可能有两种情况：

(1) 若p[k]==p[j]，则表明在模式串中

p[1..k]==p[j-k+1..j]

并且不可能存在kk>k满足等式，这就是说next[j+1]==k+1，即

next[j+1]==next[j]+1

(2) 若p[k]!=p[j]，则表明在模式串中

p[1..k]!=p[j-k+1..j] 此时可把求next函数值的问题看成是一个模式匹配的

问题，整个模式串既是主串又是模

式串，而当前在匹配的过程中，已有p[j-k+1]==p[1]，p[j-k+1]=p[2],…，p[j-1]=p[k-1]，则当p[j]!=p[k]时应将模式向右滑动至以模式中的第next[k]个字符和主串中的第j个字符相比较。若next[k]==kk，且p[j]==p[kk]，则说明在主串中第j+1个字符之前存在一个长度为kk，(即next[k])的最长子串，和模式串中从首字符起长度为kk的子串相等，即

p[1..kk]==p[j-kk+1..j] (1

这就是说 next[j+1]=kk+1即

next[j+1] == next[k]+1

同理，若p[j]!=p[kk]，则将模式继续向右滑动直至将模式中第next[kk]个字符和p[j]对齐，……，依次类推，直至p[j]和模式中某个字符匹配成功或者不存在任何kk(1

next[j+1]=1

例如：图4中的模式串，已求得前6个字符的next函数值，现求next[7]，因为next[6]=3，

又p[6]!=p[3]，则需比较p[6]和p[1](因为next[3]=1)，这相当于将子串模式向右滑动。

由于P[6]!=p[1]，而且next[1]=0，所以next[7]=1，而因为p[7]=p[1]，则next[8]=2。

根据上述分析所得结果，仿照KMP算法，可得到求next函数值的算法，如算法3所示。 void get_next( SString T，int &next[] ) {

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

i=1；

next[l]=O；

j=0；

while(i

if(j==0||T[i]==T[j]) { ++i；++j；next[i]=j；}

else j=next[j]；

}

} //get_next

算法3

算法3的时间复杂度为O(m)。通常，模式串的长度m比主串的长度n要小得多，因此，

对整个匹配算法来说，所增加的这点时间是值得的。

最后，要说明两点：

1) 虽然算法1的时间复杂度是O(n*m)，但在一般情况下，其实际的执行时间近似于

O(n+m)，因此至今仍被采用。KMP算法仅当模式与主串之间存在许多“部分匹配”的情况

下才显得比算法1快得多。但是KMP算法的最大特点是指示主串的指针不需回溯，整个匹配过程中，对主串仅需从头至尾扫描一遍，这对处理从外设输入的庞大文件很有效，可以边读入边匹配，而无需回头重读。

2) 前面定义的next函数在某些情况下尚有缺陷。例如模式"aaaab"在和主串"aaabaaaab"

匹配时，当i=4，j=4时s.ch[4]!=t.ch[4]，由next[j]的指示还需进行i=4、j=3,i=4、j=2,i=4、j=1 等三次比较。实际上，因为模式中第1、2、3个字符和第4个字符都相等，因此不需要再和主串中第4个字符相比较，而可以将模式一气向右滑动4个字符的位置直接进行i=5，j=1

时的字符比较。这就是说，若按上述定义得到next[j]=k，而模式中p[j]==p[k]，则当主串中字符s[i]和p[j]比较不等时，不需要再和p[k]进行比较，而直和P[next[k]]进行比较，换句话说，此时的next[j]应和next[k]相同。由此可得计算next函数修正值的算法如算法4所示。

此时匹配算法不变。

void get_nextval(SString T，int &nextval[] ){

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

i=1；

nextval[1]=0；

i=0； while(i

if(j=0 || T[i]==T[j]) {

++i; ++j；

if(T[i])!=T[j]) nextval[i] = j；

else nextval[I] = nextval[j]； }

else j=nextval[j]；

}

}

(End)

第1页第2页第3页第4页