|
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算法：
|
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 = max(bmGs[i], bmBc[T[i]]-（m-1-i))； |
|
8 |
} |
考慮模式串匹配不上母串的最壞情況，後綴蠻力匹配算法的時間複雜度最差是O(n×m)，最好是O(n),其中n爲母串的長度，m爲模式串的長度。
#include
#include
#define XSIZE 8
#define ASIZE 256
void preBmBc(char *x, int bmBc[])
{
int m;
int i;
m = strlen(x);
for (i = 0; i < ASIZE; i )
{
bmBc[i]=m;
}
for (i = 0; i < m - 1; i )
{
bmBc[x[i]]=m-1-i;
}
}
void suffixes(char *x, int *suff)
{
int i;
int f;
int g;
int m;
m = strlen(x);
f = 0;
suff[m-1] = m;
g = m - 1;
for (i = m - 2; i >= 0; --i)
{
if (i > g && suff[(m-1)-(f-i)] < i - g)
{
suff[i] = suff[(m-1)-(f-i)];
}
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 bmGs[])
{
int i;
int j;
int suff[XSIZE];
int m;
m=strlen(x);
suffixes(x, suff);
for (i = 0; i < m; i)
{
bmGs[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;
}
}
}
}
for (i = 0; i <= m-2; i)
{
bmGs[m - 1 -suff[i]]= m - 1 - i;
}
}
int BM(char *x,char *y)
{
int m;//模式串的長度
int n;//目標串的長度
int i;//模式串中匹配的位置
int j;//目標串中匹配的位置
int bmGs[XSIZE];//好後綴表
int bmBc[ASIZE];//壞字符表
preBmBc(y, bmBc);
preBmGs(y, bmGs);
m = strlen(y);
n = strlen(x);
j=0;
while (j < n-m )
{
for (i = m - 1; i >= 0 && y[i] == x[i j]; --i);
if (i < 0)
{
return j;
}
else
{
j = (bmGs[i]) > (bmBc[x[i j]] -m 1 i) ? (bmGs[i]) : (bmBc[x[i j]] -m 1 i);
}
}
if (j>=n-m)
{
return -1;
}
}
int main(int argc,char **argv)
{
int ret;
ret=BM(argv[1],argv[2]);
printf("ret is %d\n",ret);
return 0;
}