Boyer-Moore 算法详解

写在前面：我的本意是想以通俗的语言来介绍Boyer-Moore，可是“学术”一点的语言毕竟有它存在的合理性，所以，额……

我的另一个意图是想详细介绍good-suffix
shift的计算方法——因为中文世界中看不到对其完整的介绍：涉及到good-suffix的地方不是被直接跳过，就是仅仅给出一段代码——而这个部分的算法其实相对于Boyer-Moore本身来说更是精巧。

可惜对
Good-suffix
计算的介绍写出来之后因为格式比较复杂，又正赶上CSDN封图自宫，不易发表在博客上，故导出为PDF，感兴趣者可以前往查看：

http://docs.google.com/leaf?id=0B9sqyhyu5n-UM2ZmMzYxMTYtZDY5YS00ZTE5LWIxMTYtYTcyMmJiY2M3ODQ1&hl=zh_CN

BTW.
Boyer-Moore这算法对我而言算是复杂的了，可是在 grep 的 src/kwset.c 中我看到了这样的东西：/* Build the
Boyer Moore delta. Boy that's easy compared to CW.
*/
，很是郁闷，下一步就看看CW感受一下去。

下面正式开始——

Boyer-Moore算法是
Bob Boyer
与
J Strother Moore
在
1977
年提出的一种字符串严格匹配（
Exact String Matching
）算法，它据说是常规应用中效率最高的

[3]

，其时间复杂度可以达到亚线性，而且对于没有周期规律的模式串，最差情况下也只需要3

n
次比较。

约定和术语

约定

字符串和数组的下标均以0
为起始，下标为负代表倒数

变量使用
斜体

强调使用
粗体

在区间的表示中，
S
[
a
:
b
] 代表在

S
处于区间 [

a
,
b
) 的部分

在区间的表示中，
S
[
a
..
b
] 代表

S
处于区间 [

a
,
b
] 的部分

术语

pattern
：模式串，即要查找的目标

m
:
pattern
的长度

text
：文本串，字符串匹配算法将在
text
中查找
pattern
出现的位置

n
:
text
的长度

一、原理

1.
1、概述

Boyer-Moore算法从右向左扫描模式串中的字符；当遇到不匹配的字符时，它通过预先计算的
Bad-character
跳转表以及
Good-suffix
跳转表寻找最大的跳转长度

。

其思想简单表示如下：

计算bad-character
跳转表

计算good-suffix
跳转表

n

←

|
text
|

m
←

|
pattern
|

j

←
0

While
j

≤

n
-
m
:

从右向左匹配
pattern
与
text
的子串
text
[
j

:

j
+
m
]

若匹配成功：

报告一次成功匹配

令
j

←

j
+
good-suffix-table[0]

否则：

根据匹配失败的位置
i
得到good-suffix
跳转长度；

根据匹配失败的位置
i
和导致匹配失败的字符
c
得到

bad-character跳转的长度

比较上面两个长度，选择较大的一个，令其为
k

令
j

←

j
+
k

1.
2、

B
ad-character跳转原理说明

当匹配过程中遇到了不匹配的字符时，可以移动窗口使文本串中不匹配的字符a
与模式串中字符
a
最后出现的位置对齐。

考虑如下情况：

text

a

u

pattern

b

u

图1.1

不匹配的情况

将模式串中的a
与文本串中的对齐，我们得到：

text

a

u

pattern

a

不

包

含

a

图1.2

发生不匹配，且pattern
中含有
a

而若a
在模式串中不存在，我们则可以将窗口移动到
a
出现的位置之后：

Text

a

u

pattern

不

包

含

a

图1.3

发生不匹配，且pattern
中不含有
a

这样做的意义很明显：

text

a

u

pattern

a

不

包

含

a

1

a

不

包

含

a

2

a

不

包

含

a

3

a

不

包

含

a

4

图1.4

常规的窗口移动方法

如图1.4
所示，若第一次匹配在遇到字符

a
的时候失败了，那么按照常规的、顺序的窗口移动方法，第2
次和第
3
次尝试也

不可能
得到正确的匹配，而只有将
pattern
中的
a
与
text
对齐，才
有可能
实现正确的匹配。

同样的道理，若整个
pattern
中不含有
a
，则可以安全的将窗口移动到
a
出现的位置之后。

通过将
每个字符最后出现的位置
记录在表
bcTable
中（没有出现的字符则令其处于-1
位置），可以方便的将不匹配字符与模式串中该字符出现的最后位置对齐；因此定义

bcTable
为：

对于字符集中的每一个字符c
：

bcTable
[c]
= m
ax
{
i

:

0
≤
i
<

m

且

pattern
[
i
]=c}
若c
存在于

pattern
中，其他情况为 -1
。

注意
B
ad-character跳转表中记录的只是每个字符最后出现的地方，因此不难观察发现，对于多次出现的字符，
bad-character
跳转表反而可能导致负的跳转

；
为此，
[2]

提出了一种“扩展的bad-character
规则”

：
记录
pattern
中每一个位置
i
上，字符
c
先于
i
出现最后位置，即对于0

≤

i
<
m
，记录
bcTable’
[
i
,
c
] = max{
j
:
pattern
[
j
] =
c
且
j
<
i
}
。对于小的字符集而言，这会对效率起到很大程度的改进，但由于很多实际情况下这个做法反而会导致性能的损失，因此较少采用。

为了更加便于理解，这里给出根据定义求bad-character
跳跃表的
Python
代码：

def

bmbc
( p, charset=r
'
agct
'
):

bc = {}

lp = len(p)

for

c

in
charset:

bc[
c
] = -
1

for
i
in
range(lp-
1
):

bc[ p[i] ] = i

return
bc

其中，参数p
为模式串，参数
charset
为字符集（默认为
DNA
碱基序列
agct
）；返回值为字符集对应的坏字符跳转表。

1.
3、

G
ood-suffix跳转原理说明

假设通过自右向左的匹配，已经得到了
pattern
[
i

:

m
] =
text
[
j
+
i

:

j
+
m
] =
u
，且
pattern
[
i
-1 ]
≠
text
[
j
+
i
-1 ]
，那么可以分两种情况：

情况一
，
pattern
中，在
i
之前还存在子串
u
，并且子串
u
之前的字符不等于
pattern
[
i
-1 ]：

Text

a

u

pattern

b

u

← shift →

c

u

图1.5

u在匹配失败的地方之前重现，并且
u
前面的字符不为
b

不妨定义R(

i
)：
R(

i
)
是能使
pattern
[
i
:
m
] 成为

pattern
[ 0 : R(
i
) ] 的后缀、且这样一个后缀前的字符不为

pattern
[
i
-1 ] 的最大值；若这样的值不存在，则令
R(

i
) 为
-1
。

在图1.5
表示的这种情况下，我们可以移动窗口使
R(

i
) 对齐模式串尾部当前所在的地方。

情况二
，
pattern
中，
i
之前不存在子串
u
，但
pattern
的一个前缀
v
与
u
的一个后缀相匹配：

text

a

u

pattern

b

u

←

shift

→

v

图1.6

u的后缀
v
在字符串中重现

不妨定义
R'(
i
)：
R'(

i
) 是

pattern
[
i
:
m
] 的能成为

pattern
一个前缀的后缀（图示
v
）的最大长度，若这样的值不存在，则为 -1
。

图1.6

这种情况下，我们同样可以通过
移动窗口使R'(

i
) 对齐模式串尾部当前所在的地方。

定义这样的good-suffix
跳转规则同样是为了避免不必要的比较操作，以模式串
gcagagag
为例，若末位的
g
成功匹配了，而倒数第二位的
a
没有匹配上，那么可以将窗口右移
7
位：

g

c

a

g

a

g

a

g

g

c

a

g

a

g

a

g

#1

g

c

a

g

a

g

a

g

#2

g

c

a

g

a

g

a

g

#3

g

c

a

g

a

g

a

g

#4

g

c

a

g

a

g

a

g

#5

g

c

a

g

a

g

a

g

#6

g

c

a

g

a

g

a

g

#7

图1.7

仅末位匹配时的good-suffix
跳转情况示意

因为，如图1.7
所示，若右移一位（情况
#1
），则位置
-2
的
a
注定不匹配；若右移两位（
#2
），则位置
-4
的
a
注定不匹配；依此类推。

同样的道理，若仅有末位的ag
得到匹配，那么可以安全的将当前窗口右移
4
位：

g

c

a

g

a

g

a

g

g

c

a

g

a

g

a

g

#1

g

c

a

g

a

g

a

g

#2

g

c

a

g

a

g

a

g

#3

g

c

a

g

a

g

a

g

#4

g

c

a

g

a

g

a

g

#5

g

c

a

g

a

g

a

g

#6

g

c

a

g

a

g

a

g

#7

图1.8

末两位匹配的good-suffix
跳转情况示意

这里，#4
和
#7
都是可能得到正确匹配的情况，因此选择相对较小的跳转，以避免漏过匹配。

为了更便于理解，这里给出根据定义求good-suffix
跳跃表的
Python
代码：

def

bmgs
( p ):

lp = len(p)

gs = [lp] * lp

j = lp

while
j>
0
:

ls = lp - j

for
i
in
range(-ls+
1
,
1
):
# 情况二

if
p[
0
:ls+i] == p[j-i:lp]:

gs[j-
1
] = j-i

for
i
in
range(
1
,j):
# 情况一

if
p[i:i+ls] == p[j:lp]
and
p[i-
1
] != p[j-
1
] :

gs[j-
1
] = j-i

j = j-
1

return
gs

其参数为模式串pattern
，返回值为对应的
good-suffix
跳转表。

1.4、完整的
Boyer-Moore
查找示例

以在字符串agcatagcatacaagagaagagacagtagagactatta
中查找
agagacagtag
为例，

Bad-character跳转表为：
{'a': 9, 'c': 5, 't': 8, 'g': 7}

Good-suffix跳转表为：
[9, 9, 9, 9, 9, 9, 9, 9, 3, 11, 1]

查找过程如下图：

a

g

c

a

t

a

g

c

a

t

a

c

a

a

g

a

g

a

a

g

a

g

a

c

a

g

t

a

g

a

g

a

c

t

a

t

t

a

a

g

a

g

a

c

a

g

t

a

g

a

g

a

g

a

c

a

g

t

a

g

a

g

a

g

a

c

a

g

t

a

g

a

g

a

g

a

c

a

g

t

a

g

a

g

a

g

a

c

a

g

t

a

g

a

g

a

g

a

c

a

g

t

a

g

a

g

a

g

a

c

a

g

t

a

g

a

g

a

g

a

c

a

g

t

a

g

图1.9

Boyer-Moore算法运行过程示例

从图1.9
中可以看出，在查找过程中，
Boyer-Moore
算法做了
8
次尝试，总共
22
次比较操作；而常规的字串查找算法则会需要
(

n
-
m
)

m
= 297次比较操作，这个差距应该说是非常大的。

使用后面实现的
Python
代码(

http://docs.google.com/leaf?id=0B9sqyhyu5n-UM2ZmMzYxMTYtZDY5YS00ZTE5LWIxMTYtYTcyMmJiY2M3ODQ1&hl=zh_CN
)，通过调用
bm ('agcatagcatacaagagaagagacagtagagactatta', 'agagacagtag')
可以验证这个过程。