字符串匹配的Boyer-Moore算法 詳解 加 C# 實現

上一篇文章，我介紹了KMP算法。

　　可是，它並非效率最高的算法，實際採用並很少。各類文本編輯器的"查找"功能（Ctrl+F），大多采用Boyer-Moore算法。

　　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"的位置。

 

     聲明：BM算法的詳解文章來阮一峯的博客，我這裏沒有侵權的意思，只是用來學習，望做者諒解！
     原文地址：
     http://www.ruanyifeng.com/blog/2013/05/boyer-moore_string_search_algorithm.html

     下面是我用C#實現的上述算法：

 1         public static int Arithmetic_BM(string operateStr, string findStr)
 2         {
 3             //i：匹配開始的索引，j：operateStr字符串的索引迭代，k：findStr字符串索引迭代
 4             int i = 0, j = findStr.Length - 1, k = j;
 5             int n, m = 0; //n:壞字符規則計算出的移動位數，m:好後綴計算出的移動位數
 6 
 7             while (k >= 0 && j < operateStr.Length)
 8             {
 9                 if (k == 0) //所有匹配，return
10                 {
11                     return i;
12                     break;
13                 }
14                 if (operateStr[j] == findStr[k]) //匹配，next
15                 {
16                     j--;
17                     k--;
18                 }
19                 else
20                 {
21                     //當k<要匹配的字符串長度時，說明已經有匹配的字符了，即有「好後綴」
22                     if (k < findStr.Length - 1)
23                     {
24                         //採用"好後綴規則"，先找出「全好後綴」有沒有在前面存在
25                         var goodSuffix = findStr.Substring(k + 1); //分割出全好後綴
26                         var tempStr = findStr.Substring(0, k + 1); //去掉好綴後的字符串
27                         //最全好後綴在剩下的字符串中出現
28                         if (tempStr.Contains(goodSuffix))
29                         {
30                             var lastGoodSuffix = char.Parse(goodSuffix.Substring(goodSuffix.Length - 1)); //好後綴的最後一個字符
31                             //找出 該字符的出現位置
32                             IList<int> indexs = new List<int>();
33                             for (int x = 0; x < tempStr.Length; x++)
34                             {
35                                 if (lastGoodSuffix == tempStr[x])
36                                 {
37                                     indexs.Add(x);
38                                 }
39                             }
40                             //找出 好後綴在搜索詞中的上一次出現位置
41                             var result = -1;
42                             for (int x = indexs.Count - 1; x >= 0; x--)
43                             {
44                                 if (indexs[x] >= goodSuffix.Length &&
45                                     tempStr.Substring(indexs[x] - goodSuffix.Length + 1, goodSuffix.Length) == goodSuffix)
46                                 {
47                                     result = indexs[x];
48                                     break;
49                                 }
50                             }
51                             //好後綴規則結果
52                             m = findStr.Length - 1 - result;
53                         }
54                         //最長好後綴沒有沒出現，可是好後綴最後一個字符，出如今頭部
55                         //後移位數 = 好後綴的位置 - (0)搜索詞中的上一次出現位置
56                         else if (findStr.Substring(0, 1) == findStr.Substring(findStr.Length - 1))
57                         {
58                             m = findStr.Length - 1;
59                         }
60                         else //好後綴只出現一次  (後移位數 = 好後綴的位置 - (-1)搜索詞中的上一次出現位置)
61                         {
62                             m = findStr.Length;
63                         }
64                     }
65                     //壞字符規則：後移位數 = 壞字符的位置 - 搜索詞中的上一次出現位置
66                     n = (j - i) - findStr.LastIndexOf(operateStr[j]);
67                     //比較壞字符規則和好後綴規則移動的位數，得出最終移動位數
68                     if (n > m)
69                     {
70                         i += n;
71                         j = i + findStr.Length - 1;
72                     }
73                     else
74                     {
75                         i += m;
76                         j = i + findStr.Length - 1;
77                     }
78                     k = findStr.Length - 1;
79                     m = 0; //清零
80                 }
81             }
82             return -1;
83         }

分享給你們，這是我本身寫的不排除有問題，若有更好的實現，請提出。