BM算法

后缀匹配，是指模式串的比较从右到左，模式串的移动也是从左到右的匹配过程，经典的BM算法其实是对后缀蛮力匹配算法的改进。所以还是先从最简单的后缀蛮力匹配算法开始。下面直接给出伪代码，注意这一行代码：j ；BM算法所做的唯一的事情就是改进了这行代码，即模式串不是每次移动一步，而是根据已经匹配的后缀信息，从而移动更多的距离。

1

j = 0；

2	while (j <= strlen(T) - strlen(P)) {

3	for (i = strlen(P) - 1; i >= 0 && P[i] ==T[i j]; --i)

4	if (i < 0)

5

match；

6

else

7

j；

8

}

为了实现更快移动模式串，BM算法定义了两个规则，好后缀规则和坏字符规则，如下图可以清晰的看出他们的含义。利用好后缀和坏字符可以大大加快模式串的移动距离，不是简单的 j，而是j =max (shift(好后缀), shift(坏字符))





先来看如何根据坏字符来移动模式串，shift(坏字符)分为两种情况：

坏字符没出现在模式串中，这时可以把模式串移动到坏字符的下一个字符，继续比较，如下图：





坏字符出现在模式串中，这时可以把模式串第一个出现的坏字符和母串的坏字符对齐，当然，这样可能造成模式串倒退移动，如下图：





为了用代码来描述上述的两种情况，设计一个数组bmBc['k']，表示坏字符‘k’在模式串中出现的位置距离模式串末尾的最大长度，那么当遇到坏字符的时候，模式串可以移动距离为： shift(坏字符) = bmBc[T[i]]-（m-1-i)。如下图：





数组bmBc的创建非常简单，直接贴出代码如下：

1	void preBmBc(char *x, int m, int bmBc[]) {

2

int i;

3	for (i = 0; i < ASIZE; i)

4	bmBc[i] = m;

5	for (i = 0; i < m - 1; i)

6	bmBc[x[i]] = m - i - 1;

7

}

再来看如何根据好后缀规则移动模式串，shift（好后缀）分为三种情况：

模式串中有子串匹配上好后缀，此时移动模式串，让该子串和好后缀对齐即可，如果超过一个子串匹配上好后缀，则选择最靠左边的子串对齐。





模式串中没有子串匹配上后后缀，此时需要寻找模式串的一个最长前缀，并让该前缀等于好后缀的后缀，寻找到该前缀后，让该前缀和好后缀对齐即可。





模式串中没有子串匹配上后后缀，并且在模式串中找不到最长前缀，让该前缀等于好后缀的后缀。此时，直接移动模式到好后缀的下一个字符。





为了实现好后缀规则，需要定义一个数组suffix[]，其中suffix[i] = s 表示以i为边界，与模式串后缀匹配的最大长度，如下图所示，用公式可以描述：满足P[i-s, i] == P[m-s, m]的最大长度s。





构建suffix数组的代码如下：

1	suffix[m-1]=m;

2	for (i=m-2；i>=0；--i){

3

q=i;

4	while(q>=0&&P[q]==P[m-1-i q])

5

--q;

6	suffix[i]=i-q;

7

}

有了suffix数组，就可以定义bmGs[]数组，bmGs[i] 表示遇到好后缀时，模式串应该移动的距离，其中i表示好后缀前面一个字符的位置（也就是坏字符的位置），构建bmGs数组分为三种情况，分别对应上述的移动模式串的三种情况

模式串中有子串匹配上好后缀





模式串中没有子串匹配上好后缀，但找到一个最大前缀





模式串中没有子串匹配上好后缀，但找不到一个最大前缀





构建bmGs数组的代码如下：

01	void preBmGs(char *x, int m, int bmGs[]) {

02	int i, j, suff[XSIZE];

03	suffixes(x, m, suff);

04	for (i = 0; i < m; i)

05	bmGs[i] = m;

06

j = 0;

07	for (i = m - 1; i >= 0; --i)

08	if (suff[i] == i 1)

09	for (; j < m - 1 - i; j)

10	if (bmGs[j] == m)

11	bmGs[j] = m - 1 - i;

12	for (i = 0; i <= m - 2; i)

13	bmGs[m - 1 - suff[i]] = m - 1 - i;

14	} 再来一遍：BM算法

void preBmBc(char *x, int m, int bmBc[]) {
int i;

for (i = 0; i < ASIZE; ++i)
bmBc[i] = m;
for (i = 0; i < m - 1; ++i)
bmBc[x[i]] = m - i - 1;//不断更新离右边的最小距离
}

void suffixes(char *x, int m, int *suff) {
int f, g, i;

suff[m - 1] = m;
g = m - 1;
for (i = m - 2; i >= 0; --i)
{
if (i > g && suff[i + m - 1 - f] < i - g)
suff[i] = suff[i + m - 1 - f];
/*时间优化，如果前面与后缀匹配到了，而且包含到这个字符
，那么如果在后缀的这个字符的匹配量是小于前面的匹配量，
那么这个字符的匹配量就是等于前面字符匹配量，从而做到时间的优化
*/
else
{
if (i < g)
g = i;
f = i;
while (g >= 0 && x[g] == x[g + m - 1 - f])
--g;
suff[i] = f - g;
}
}
}

void preBmGs(char *x, int m, int bmGs[]) {
int i, j, suff[XSIZE];

suffixes(x, m, suff);

for (i = 0; i < m; ++i)
bmGs[i] = m;
for (i = 0; i <= m - 2; ++i)
bmGs[m - 1 - suff[i]] = m - 1 - i;//后缀到m-1-suff[i]时不匹配时，模式串所要滑动的距离
/*
上述还漏了一种情况，就是当i之后的所以数都能与后缀匹配时，他们要移动的距离并不是m。
*/
j = 0;
for (i = m - 1; i >= 0; --i)
if (suff[i] == i + 1)
for (; j < m - 1 - i; ++j)
if (bmGs[j] == m)
bmGs[j] = m - 1 - i;//此时i之后的每个数所以移动的距离等于还剩下多少没有匹配到的字母，模拟下就可以知道
}

void BM(char *x, int m, char *y, int n) {
int i, j, bmGs[XSIZE], bmBc[ASIZE];

/* Preprocessing */
preBmGs(x, m, bmGs);
preBmBc(x, m, bmBc);

/* Searching */
j = 0;
while (j <= n - m) {
for (i = m - 1; i >= 0 && x[i] == y[i + j]; --i);
if (i < 0) {
OUTPUT(j);
j += bmGs[0];//成功匹配退出
}
else
j += MAX(bmGs[i], bmBc[y[i + j]] -(m-1-i) );
//当遇到坏字符时，比较坏字符数组和好后缀所要移动的距离最大的
}
}

博文转载于

点击打开链接

参考博文

参考博文