大话数据结构(五)字符匹配算法C++实现(朴素、KMP等)
C++ 实现
1 朴素的模式匹配算法
1.1 原理
串的模式匹配:子串的定位操作。
- 算法思想
假设从主串S = “goodgoogle”中找T = “google”这个子串的位置。要按以下步骤:(竖线表示相同,折线表示不同)
简单地说,就是对主串的每一个字符作为子串开头,与要匹配的字符串进行匹配。此过程中,对主串做大循环,每个字符开头做T的长度的小循环,直到匹配成功或全部遍历完成为止。假设主串S和匹配的子串T的长度存在S[0]与T[0]中,该算法实现如下:
/* 返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数返回值为0。 */
/* 其中,T非空,1≤pos≤StrLength(S)。 */
int Index(String S, String T, int pos)
{
int i = pos; /* i用于主串S中当前位置下标值,若pos不为1,则从pos位置开始匹配 */
int j = 1; /* j用于子串T中当前位置下标值 */
while (i <= S[0] && j <= T[0]) /* 若i小于S的长度并且j小于T的长度时,循环继续 */
{
if (S[i] == T[j]) /* 两字母相等则继续 */
{
++i;
++j;
}
else /* 指针后退重新开始匹配 */
{
i = i-j+2; /* i退回到上次匹配首位的下一位 */
j = 1; /* j退回到子串T的首位 */
}
}
if (j > T[0])
return i-T[0];
else
return 0;
}
该算法中最关键的步骤是回退过程:
- 两字母相等时,在小循环内继续循环比较。
- 两字母不等时,则回退。对于i,回退的位置是i = i - j +2。对于j,回退到1,重新从开始比较待匹配串。
有读者可能不理解i的回退位置如何计算的,且看以下图示,假设pos = 3。
图中,①开始进入while循环,因为n ≠ d,进入else回退。此时应该从i的下一位 d 再开始比较,i - j 回退到o位置,再加 2 则恰好进到 d 位置;j = 1,即j位置不变。如图②。
②中因为d = d,进入小循环,i、j不断累加(while ->if -> while -> if -> while …),直到图③,f ≠ r,再回退,此时应该从开始进入小循环的i的下一位 e 再开始比较,i - j 回退到n位置,再加 2 则恰好进到 e 位置;j = 1,即j回到最初位置。如图④。以同样方式,再继续循环比较,不再赘述。
综上,i - j +2就是主串长度减去已匹配的子串长度,再加2,则进位到下一个要匹配的主串位置。(加1就是进入小循环的位置)
1.2 时间复杂度
朴素模式匹配算法时间复杂度分析如下:(n为主串长度,m为模式串长度)
情况 | 时间复杂度 | 备注 |
---|---|---|
最好情况 | O ( 1 ) O(1) O(1) | 一开始就匹配成功 |
最坏情况 | O ( ( n − m + 1 ) ∗ m ) O((n-m+1)*m) O((n−m+1)∗m) | 每次不成功的匹配都发生在模式串的最后一个字符 |
平均情况 | O ( n + m ) O(n+m) O(n+m) | 根据等概率原则,平均是(n+m)/2次查找 |
1.3 c++代码实现
此处实现模板串从第一个位置与主串比较,且i,j代表字符串的索引值(类似数组),故与上面算法实现相差1位。
此处串的第一位不存储长度,改由length函数获取,故i的回溯求法为i-j+1;
//在主串s中找子串t,若找到返回字串在主串中的索引;若没找到返回-1
#include <iostream>
#include <string>
using namespace std;
//输入串s,模板串t,返回匹配成功时,在串s的索引
int index(string s, string t)
{
int s_len = s.length(); //计算串s、t的长度
int t_len = t.length();
int i = 0; //i为主串索引
int j = 0; //j为模板串索引
while ( i < s_len && j < t_len )//如果i、j都各自小于lens和lent
{
if (s[i] == t[j]) // 如果子串的t[j]和主串的s[i]相等
{
++i; //各自索引都自增
++j;
}
else //否则,主串的索引比刚开始后移一个;子串的索引变为0 两个索引都回溯
{
i = i - j + 1;
j = 0;
}
}
if (j == t_len) //如果j和lent的大小一样,证明找到了,返回子串在主串中的索引
{
return i - t_len;
}
else // 否则返回 - 1
{
return -1;
}
}
int main()
{
string s = "goodgoogle";
string t = "google";
int pos = index(s, t);
if (pos != -1)
{
cout << "find index: " << pos << " of " << s << endl;
}
else
{
cout << "not find!" << endl;
}
system("pause");
return 0;
}
运行结果:
2 KMP模式匹配算法
2.1 原理,参考:https://www.bilibili.com/video/BV1jb411V78H?from=search&seid=14906988811959903401
- 算法关键
如果主串S= “abcdefgab”,子串T= “abcdex”,用上面的朴素算法的话,前5个字母,两串完全相等,直到第6个字母,“f”与“x”不等,如下图。接下来进行②③④⑤⑥的步骤,而T中“a”与后边的每一位都不同,对于①中,前5位已经相同,所以,T中“a”也不会与S中的第2-5位相同,则②③④⑤的判断是多余的。只用保留①⑥,之所以保留⑥,是因为在①中T[6]≠S[6],尽管我们已经知道T[1]≠T[6],但也不能断定T[1]一定不等于S[6],因此需要保留⑥。
假设主串S= “abcabcabc”,子串T= “abcabx”,前5个相对,第6个不等。根据刚刚的经验,T的首字符“a”与第二位“b”、第三位“c”均不相等,所以不需要做判断,下图中②③是多余的。又因为T的首位与第四位相等,T的第二位与第五位相等,而在①中,子串中第四位的“a”与第五位的“b”已经与主串S中相应的位置比较过了,是相等的,因此可以断定,T的首字符“a”、第二位的“b”与S的第四、第五位字符也不需要比较了,肯定也是相等的——之前比较过了,不需要再次判断,所以④⑤这两个步骤也可以省略。(即T前部=T后部,T后部=S后部,则T前部=S后部)
对比发现,i的值从6-2-3-4-5-6,即在朴素的模式匹配算法中,主串的i值是不断地回溯来完成的,而我们分析发现,这种回溯过程是可以不需要的。KMP算法就是为了让没必要的回溯不发生。既然i不回溯(不会变小),我们就要考虑j值的变化了。对比上面两图,我们发现,j的变化与T串的首字符和自身后面字符是否相等有关,而与主串无关,即j值的变化关键取决于T串的结构中是否有重复的问题。如一图中,T=“abcdex”,当中没有任何重复字符,所以j由6变为1,二图中,T=“abcabx”,前缀“ab”与最后“x”前的“ab”相等,因此j就由6变成了3。因此可以得出规律,j值的多少取决于当前字符之间的串的前后缀的相似度。我们把T串各位置的j值的变化定义为一个数组next,那么next的长度就是T串的长度,则有如下函数定义:
- ①当j=1,next[1]为0;
- ②当当前子串匹配位置的前面存在最大公共子串,则next为最大公共子串长度+1;
- ③当其他情况,next为0
2.2 next数组值推导
看两个例子。(取自书中)
2.3 KMP模式匹配算法实现
/* 通过计算返回子串T的next数组。 */
void get_next(String T, int *next)
{
int i,j;
i=1;
j=0;
next[1]=0;
while (i<T[0]) /* 此处T[0]表示串T的长度 */
{
if(j==0 || T[i]== T[j]) /* T[i]表示后缀的单个字符,T[j]表示前缀的单个字符 */
{
++i;
++j;
next[i] = j;
}
else
j= next[j]; /* 若字符不相同,则j值回溯 */
}
}
这段代码的目的就是为了计算出当前要匹配的串T的next数组。
/* 返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数返回值为0。 */
/* T非空,1≤pos≤StrLength(S)。 */
int Index_KMP(String S, String T, int pos)
{
int i = pos; /* i用于主串S中当前位置下标值,若pos不为1,则从pos位置开始匹配 */
int j = 1; /* j用于子串T中当前位置下标值 */
int next[255]; /* 定义一next数组 */
get_next(T, next); /* 对串T作分析,得到next数组 */
while (i <= S[0] && j <= T[0]) /* 若i小于S的长度并且j小于T的长度时,循环继续 */
{
if (j==0 || S[i] == T[j]) /* 两字母相等则继续,与朴素算法增加了j=0判断 */
{
++i;
++j;
}
else /* 指针后退重新开始匹配 */
j = next[j];/* j退回合适的位置,i值不变 */
}
if (j > T[0])
return i-T[0];
else
return 0;
}
2.4 KMP的时间复杂度
3中相对于朴素匹配算法增加的代码,主要去掉了i的回溯部分。首先分析KMP的核心算法流程,假设现在文本串S匹配到 i 位置,模式串T匹配到 j 位置:
- 如果当前字符匹配成功(即S[i] == T[j]),则令++i,++j,继续匹配下一个字符;
- 如果当前字符匹配失败(即S[i] != T[j]),则令 i 不变,j = next[j]。意味着匹配失配时,模式串T相对于文本串S向右移动了j - next [j] 位。
正如前文,若主串S= “abcabcabc”,子串T= “abcabx”,由T得next[j] = [0,1,1,1,2,3],因为S[6](这里下标i、j从1开始)≠T[6],所以,j=next[6]=3,T相当于移动了6-3=3个位置。如图:
对于get_next函数而言,若T的长度为m,因只涉及简单的单循环,其时间复杂度为O(m),而由于i不回溯,使得index_KMP算法效率得到了提高,while循环的时间复杂度为O(n),以上两个函数先后线性执行,因此,整个算法的时间复杂度为O(n+m)。相较于朴素模式匹配算法的O((n-m+1)*m)来说,是要好一些。需要说明的是,KMP算法仅当模式与主串之间存在许多“部分匹配”的情况下才体现出它的优势,否则和朴素模式匹配算法相比,差异并不明显。
3 KMP模式匹配算法改进
后来有人发现,KMP还是有缺陷的。比如,如果我们的主串S = “aaaabcde”,子串T = “aaaaax”,其next数组值分别为012345,在开始时,当i=5、j=5时,我们发现“b”与“a”不相等,如下图①,因此j=next[5]=4,如图②,此时“b”与第4位置的“a”依然不等,j=next[4]=3,如图③,后依次是④⑤,直到j=next[1]=0时,根据算法,此时i++、j++,得到i=6、j=1,如图⑥。
我们发现,当中的②③④⑤其实是多余的,由于T的第二、三、四、五位的字符与首位“a”相等,那么可以用首位next[1]的值去取代与它相等的字符后续next[]的值,这是个很好的办法,对next数组进行优化。假设取代的数组为nextval,增加了部分,如下:
/* 求模式串T的next函数修正值并存入数组nextval */
void get_nextval(String T, int *nextval)
{
int i,j;
i=1;
j=0;
nextval[1]=0;
while (i<T[0]) /* 此处T[0]表示串T的长度 */
{
if(j==0 || T[i]== T[j]) /* T[i]表示后缀的单个字符,T[j]表示前缀的单个字符 */
{
++i;
++j;
if (T[i]!=T[j]) /* 若当前字符与前缀字符不同 */
nextval[i] = j; /* 则当前的j为nextval在i位置的值 */
else
nextval[i] = nextval[j]; /* 如果与前缀字符相同,则将前缀字符的 */
/* nextval值赋值给nextval在i位置的值 */
}
else
j= nextval[j]; /* 若字符不相同,则j值回溯 */
}
}
nextval数组值推导
改良后,nextval值就与next值不完全相同了,如下例子:
总结改进过的KMP算法,它是在计算出next值的同时,如果a位字符与它next值指向的b位字符相等,则该a位的nextval 就指向b位的nextval值,如果不等,则该a位的nextval值就是它自己a位的next的值。