字符串匹配算法详解(下)

字符串匹配算法详解(上)介绍了BF算法和KMP算法，这一篇接着来介绍Horspool算法和BM算法。其中Horspool算法相当于是BM算法的特例，或者说是简化版的BM算法。

算法三：Horspool算法

Horspool是后缀搜索，有点创新啊，大家都从左往右匹配，它反着来。也就是搜索已读入文本中是否含有模式串的后缀；如果有，是多长，显然，当后缀长度等于模式串的长度时，我们就找到了一个匹配。

Horspool算法思想：模式串从右向左进行匹配。对于每个文本搜索窗口，将窗口内的最后一个字符（C）与模式串的最后一个字符进行比较。如果相等，则继续从后向前验证其他字符，直到完全相等或者某个字符不匹配。然后，无论匹配与否，都将根据在模式串的下一个出现位置将窗口向右移动。模式串与文本串口匹配时，模式串的整体挪动，是从左往右，但是，每次挪动后，从模式串的最后一个字符从右往左进行匹配。

下面我们来看一个实例：

加上匹配串和模式串如下：

1.

匹配串：abcbcsdLinac-codecbcac

模式串：cbcac

首先从右向左进行匹配，c与c匹配成功，接着第二个字符b与a，匹配失败（失配位置为3）。于是，从模式串当前位置往左寻找匹配失败的那个字符，也即在模式串中寻找字符b上一次出现的位置(注意这里的“上一次”是指在模式串中从当前失配位置往左找到的第一个与失配位置相同的字符)；结果我们在模式串中找到了字符b，其位置为1，那么就将模式串整体往右挪动，把刚才找到的字符b与之前与匹配串中失配的字符b对齐。总共移动了多少位呢？移动了（3-1）位。

2.

匹配串：abcbcsdLibac-codecbcac

模式串：     cbcac

模式串整体挪动到b处对齐后，再从右向左开始匹配，此时发现其第一个需要匹配的字符d与c就匹配失败（失配位置为4），尼玛，坑爹啊！那接下来怎么办？当然是跟上一步的方法一样，在模式串中去找失配的那个字符d，如果在模式串中找到了d，将模式串平移，使其d字符与匹配串的d对齐。结果发现模式串中根本就没有字符d。那接下来怎么办？直接将模式串平移到刚才失配字符d后面的。这是因为模式串中没有字符d，那么就不可能在匹配串中的d及其前面的字符中匹配成功。这一次我们移动的位数是4-（-1）=5位。

3.

匹配串：abcbcsdLibac-codecbcac

模式串：                cbcac

然后，又回到第1步的那种状态，从模式串的最后一个字符开始匹配，即c与c匹配，a与a匹配啊，然后发现b与c不匹配，从而我们在模式串中找b字符上一次出现的位置，发现其位置为1，移动模式串，将b字符与b字符对齐（如下图），这次我们移动的位数是2-1=1位。

4.

匹配串：abcbcsdLibac-codecbcac

模式串：                    cbcac

发现模式串中不含-，则模式串移动到-后面那个字符。

5.

匹配串：abcbcsdLibac-codecbcac

模式串：                                cbcac

这一次，在e与a处出现不匹配，而且e也没在模式串中出现过，那么模式串再右移到e的后面，这次移动的位数为：3-(-1)=4位。（为毛是减去-1？因为我们将模式串移动到失配字符的后面那个字符位置处去了，即相当将失配字符e与与模式串的第一个字符的前一个位置（-1处）对齐，懂否？）

6.

匹配串：abcbcsdLibac-codecbcac

模式串：                                            cbcac

终于，在经历第五步的那次挪动后，我们匹配成功了，是不是感觉匹配速度特别快？

有了以上实例，我们现在来抽取其一般规则，以方便编码实现：

我们得到的规则只有一条，即：

字符串后移位数=失配字符位置-失配字符上一次出现的位置

如果失配字符根本就没有出现在模式串中，我们将“失配字符上一次出现的位置”的值视为-1。

#include <stdio.h>
#include <string.h>
int horspool_match(char *src,char *pattern){
     int len1=strlen(src);
     int len2=strlen(pattern);
     int i,j,k;
     char misch;
     int mispos=0;
	for(i=0;i<=len1-len2;){
          for(j=len2-1;j>=0;--j){
            if(src[i+j]!=pattern[j]){
                   misch=src[i+j];//mismatch char
		   mispos=j;//position of mismatch
                   break;
            }
            if(j==0)//匹配成功了
              return i;
           }
           for(k=mispos-1;k>=0;k--){// 在模式串中寻找失配字符
             if(pattern[k]==misch){             
                  i+=(mispos-k);
		  printf("i is %d\n",i);
                  break;
             }
            if(k==0){//找到最后，硬是没找着失配字符
               i+=(mispos+1);
	    printf("i is %d\n",i);
	    }
         }
     }
     return -1;//最后的最后也没匹配成功，忧伤的返回-1。
} 
int main(){
	char src[32]="abcbcsdLibac-codecbcac";
	char p[10]="cbcac";
        printf("%d\n",horspool_match(src,p));
}

运行结果如下：我们可以看到i的移动速度还是很快的。

linux-code@ubuntu$ ./horspool 
i is 2
i is 7
i is 8
i is 13
i is 17
matched position is:17

算法四：：BM(Boyer-Moore)算法

KMP算法虽然很有名，但其应用不是最广泛的，实践当中，BM算法用得更多。关于BM算法的讲解，阮一峰博士有一篇文章写得很优雅，很简洁，因此就不必我唧唧歪歪去讲解了，直接拿来主义。原文地址：http://www.ruanyifeng.com/blog/2013/05/boyer-moore_string_search_algorithm.html

Boyer-Moore算法不仅效率高，而且构思巧妙，容易理解。1977年，德克萨斯大学的Robert S. Boyer教授和J Strother Moore教授发明了这种算法。

下面，我根据Moore教授自己的例子来解释这种算法。

1.

假定字符串为"HERE IS A SIMPLE EXAMPLE"，搜索词为"EXAMPLE"。

2.

首先，"字符串"与"搜索词"头部对齐，从尾部开始比较。

这是一个很聪明的想法，因为如果尾部字符不匹配，那么只要一次比较，就可以知道前7个字符（整体上）肯定不是要找的结果。

我们看到，"S"与"E"不匹配。这时，"S"就被称为"坏字符"（bad character），即不匹配的字符。我们还发现，"S"不包含在搜索词"EXAMPLE"之中，这意味着可以把搜索词直接移到"S"的后一位。

3.

依然从尾部开始比较，发现"P"与"E"不匹配，所以"P"是"坏字符"。但是，"P"包含在搜索词"EXAMPLE"之中。所以，将搜索词后移两位，两个"P"对齐。

4.

我们由此总结出"坏字符规则"：

后移位数 = 坏字符的位置 - 搜索词中的上一次出现位置

如果"坏字符"不包含在搜索词之中，则上一次出现位置为 -1。

以"P"为例，它作为"坏字符"，出现在搜索词的第6位（从0开始编号），在搜索词中的上一次出现位置为4，所以后移 6 - 4 = 2位。再以前面第二步的"S"为例，它出现在第6位，上一次出现位置是 -1（即未出现），则整个搜索词后移 6 - (-1) = 7位。

5.

依然从尾部开始比较，"E"与"E"匹配。

6.

比较前面一位，"LE"与"LE"匹配。

7.

比较前面一位，"PLE"与"PLE"匹配。

8.

比较前面一位，"MPLE"与"MPLE"匹配。我们把这种情况称为"好后缀"（good suffix），即所有尾部匹配的字符串。注意，"MPLE"、"PLE"、"LE"、"E"都是好后缀。

9.

比较前一位，发现"I"与"A"不匹配。所以，"I"是"坏字符"。

10.

根据"坏字符规则"，此时搜索词应该后移 2 - （-1）= 3 位。问题是，此时有没有更好的移法？

11.

我们知道，此时存在"好后缀"。所以，可以采用"好后缀规则"：

后移位数 = 好后缀的位置 - 搜索词中的上一次出现位置

举例来说，如果字符串"ABCDAB"的后一个"AB"是"好后缀"。那么它的位置是5（从0开始计算，取最后的"B"的值），在"搜索词中的上一次出现位置"是1（第一个"B"的位置），所以后移 5 - 1 = 4位，前一个"AB"移到后一个"AB"的位置。

再举一个例子，如果字符串"ABCDEF"的"EF"是好后缀，则"EF"的位置是5 ，上一次出现的位置是 -1（即未出现），所以后移 5 - (-1) = 6位，即整个字符串移到"F"的后一位。

这个规则有三个注意点：

（1）"好后缀"的位置以最后一个字符为准。假定"ABCDEF"的"EF"是好后缀，则它的位置以"F"为准，即5（从0开始计算）。

（2）如果"好后缀"在搜索词中只出现一次，则它的上一次出现位置为 -1。比如，"EF"在"ABCDEF"之中只出现一次，则它的上一次出现位置为-1（即未出现）。

（3）如果"好后缀"有多个，则除了最长的那个"好后缀"，其他"好后缀"的上一次出现位置必须在头部。比如，假定"BABCDAB"的"好后缀"是"DAB"、"AB"、"B"，请问这时"好后缀"的上一次出现位置是什么？回答是，此时采用的好后缀是"B"，它的上一次出现位置是头部，即第0 位。这个规则也可以这样表达：如果最长的那个"好后缀"只出现一次，则可以把搜索词改写成如下形式进行位置计算"(DA)BABCDAB"，即虚拟加入最前面的"DA"。

回到上文的这个例子。此时，所有的"好后缀"（MPLE、PLE、LE、E）之中，只有"E"在"EXAMPLE"还出现在头部，所以后移 6 - 0 = 6位。

12.

可以看到，"坏字符规则"只能移3位，"好后缀规则"可以移6位。所以，Boyer-Moore算法的基本思想是，每次后移这两个规则之中的较大值。

更巧妙的是，这两个规则的移动位数，只与搜索词有关，与原字符串无关。因此，可以预先计算生成《坏字符规则表》和《好后缀规则表》。使用时，只要查表比较一下就可以了。

13.

继续从尾部开始比较，"P"与"E"不匹配，因此"P"是"坏字符"。根据"坏字符规则"，后移 6 - 4 = 2位。

14.

从尾部开始逐位比较，发现全部匹配，于是搜索结束。如果还要继续查找（即找出全部匹配），则根据"好后缀规则"，后移 6 - 0 = 6位，即头部的"E"移到尾部的"E"的位置。

至此，Horspool算法和BM算法就讲解完了，至于BM算法的代码，很晚了。就不贴了，我们写出了Horspool算法的代码，BM的算法也不是难事。自己动手实践下呗，亲！

本文作者：Viidiot  微信公众号：linux-code

转载请保留作者、链接