Boyer-Moore 字符串匹配算法

字符串匹配问题的形式定义：

• 文本（Text）是一个长度为 n 的数组 T[1..n]；
• 模式（Pattern）是一个长度为 m 且 m≤n 的数组 P[1..m]；
• T 和 P 中的元素都属于有限的字母表 Σ 表；
• 如果 0≤s≤n-m，并且 T[s+1..s+m] = P[1..m]，即对 1≤j≤m，有 T[s+j] = P[j]，则说模式 P 在文本 T 中出现且位移为 s，且称 s 是一个有效位移（Valid Shift）。

比如上图中，目标是找出所有在文本 T = abcabaabcabac 中模式 P = abaa 的所有出现。该模式在此文本中仅出现一次，即在位移 s = 3 处，位移 s = 3 是有效位移。

解决字符串匹配的算法包括：朴素算法（Naive Algorithm）、Rabin-Karp 算法、有限自动机算法（Finite Automation）、 Knuth-Morris-Pratt 算法（即 KMP Algorithm）、Boyer-Moore 算法、Simon 算法、Colussi 算法、Galil-Giancarlo 算法、Apostolico-Crochemore 算法、Horspool 算法、Shift-Or 算法和 Sunday 算法等。本文中我们将主要介绍 Boyer-Moore 算法（即 BM Algorithm）。

在 1977 年，Robert S. Boyer (Stanford Research Institute) 和 J Strother Moore (Xerox Palo Alto Research Center) 共同发表了文章《A Fast String Searching Algorithm》，介绍了一种新的快速字符串匹配算法。这种算法在逻辑上相对于现有的算法有了显著的改进，它对要搜索的字符串进行倒序的字符比较，并且当字符比较不匹配时无需对整个模式串再进行搜索。 

Boyer-Moore 算法的主要特点有：

1. 对模式字符的比较顺序时从右向左；
2. 预处理需要 O(m + σ) 的时间和空间复杂度；
3. 匹配阶段需要 O(m × n) 的时间复杂度；
4. 匹配阶段在最坏情况下需要 3n 次字符比较；
5. 最优复杂度 O(n/m)；

下面是几种常见的字符串匹配算法的性能比较。

在 Naive 算法中，对文本 T 和模式 P 字符串均未做预处理。而在 KMP 算法中则对模式 P 字符串进行了预处理操作，以预先计算模式串中各位置的最长相同前后缀长度的数组。Boyer–Moore 算法同样也是对模式 P 字符串进行预处理。

我们知道，在 Naive 算法中，如果发现模式 P 中的字符与文本 T 中的字符不匹配时，需要将文本 T 的比较位置向后滑动一位，模式 P 的比较位置归 0 并从头开始比较。而 KMP 算法则是根据预处理的结果进行判断以使模式 P 的比较位置可以向后滑动多个位置。Boyer–Moore 算法的预处理过程也是为了达到相同效果。

Boyer–Moore 算法在对模式 P 字符串进行预处理时，将采用两种不同的启发式方法。这两种启发式的预处理方法称为：

1. 坏字符（Bad Character Heuristic）：当文本 T 中的某个字符跟模式 P 的某个字符不匹配时，我们称文本 T 中的这个失配字符为坏字符。
2. 好后缀（Good Suffix Heuristic）：当文本 T 中的某个字符跟模式 P 的某个字符不匹配时，我们称文本 T 中的已经匹配的字符串为好后缀。

Boyer–Moore 算法在预处理时，将为两种不同的启发法结果创建不同的数组，分别称为 Bad-Character-Shift（or The Occurrence Shift）和 Good-Suffix-Shift（or Matching Shift）。当进行字符匹配时，如果发现模式 P 中的字符与文本 T 中的字符不匹配时，将比较两种不同启发法所建议的移动位移长度，选择最大的一个值来对模式 P 的比较位置进行滑动。

此外，Naive 算法和 KMP 算法对模式 P 的比较方向是从前向后比较，而 Boyer–Moore 算法的设计则是从后向前比较，即从尾部向头部方向进行比较。

下面，我们将以 J Strother Moore 提供的例子作为示例。

   Text T : HERE IS A SIMPLE EXAMPLE
Pattern P : EXAMPLE

首先将文本 T 与模式 P 头部对齐，并从尾部开始进行比较。（注1）

这样如果尾部的字符不匹配，则前面的字符也就无需比较了，直接跳过。我们看到，"S" 与 "E" 不匹配，我们称文本 T 中的失配字符 "S" 为坏字符（Bad Character）。

由于字符 "S" 在模式 "EXAMPLE" 中不存在，则可将搜索位置滑动到 "S" 的后面。

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

由此总结坏字符启发法的规则是：

模式后移位数 = 坏字符在模式中失配的位置 - 坏字符在模式中最后一次出现的位置

坏字符启发法规则中的特殊情况：

1. 如果坏字符不存在于模式中，则最后一次出现的位置为 -1。
2. 如果坏字符在模式中的位置位于失配位置的右侧，则此启发法不提供任何建议。

The bad character shift means to shift the pattern so that the text character of the mismatch is aligned to the last occurrence of that character in the initial part of the pattern (pattern minus last pattern character), if there is such an occurrence, or one position before the pattern if the mismatched character doesn't appear in the initial part of the pattern at all.

以上面示例中坏字符 "P" 为例，它的失配位置为 "E" 的位置 6 （位置从 0 开始），在模式中最后一次出现的位置是 4，则模式后移位数为 6 - 4 = 2 位。模式移动的结果就是使模式中最后出现的 "P" 与文本中的坏字符 "P" 进行对齐。

实际上，前面的坏字符 "S" 出现时，其失配位置为 6，最后一次出现位置为 -1，所以模式后移位数为 6 - (-1) = 7 位。也就是将模式整体移过坏字符。

我们继续上面的过程，仍然从尾部开始比较。

仍然从尾部开始比较，发现 "E" 与 "E" 匹配，则继续倒序比较。

发现 "L" 与 "L" 匹配，则继续倒序比较。

发现 "P" 与 "P" 匹配，则继续倒序比较。

发现 "M" 与 "M" 匹配，则继续倒序比较。

发现 "I" 与 "A" 不匹配，则 "I" 是坏字符。对于前面已经匹配的字符串 "MPLE"、"PLE"、"LE"、"E"，我们称它们为好后缀（Good Suffix）。

The good suffix shift, aligns the matched part of the text with the rightmost occurrence of that character sequence in the pattern that is preceded by a different character (including none, if the matched suffix is also a prefix of the pattern) than the matched suffix of the pattern - if there is such an occurrence.

而好后缀启发法的规则是：

模式后移位数 = 好后缀在模式中的当前位置 - 好后缀在模式中最右出现且前缀字符不同的位置

好后缀在模式中的当前位置以其最后一个字符为准。如果好后缀不存在于模式中，则最右出现的位置为 -1。

这样，我们先来找出好后缀在模式中上一次出现的位置。

• "MPLE" : 未出现，最右出现的位置为 -1；
• "PLE" : 未出现在头部，最右出现的位置为 -1；
• "LE" : 未出现在头部，最右出现的位置为 -1；
• "E" : 出现在头部，补充虚拟字符 'MPL'E，前缀字符为空，最右出现的位置为 0；

由于只有 "E" 在模式中出现，其当前位置为 6，上一次出现的位置为 0，则依据好后缀启发法规则，模式后移位数为 6 - 0 = 6 位。

而如果依据坏字符启发法规则，模式后移位数为 2 - (-1) = 3 位。

Boyer–Moore 算法的特点就在于此，选择上述两种启发法规则计算结果中最大的一个值来对模式 P 的比较位置进行滑动。这里将选择好后缀启发法的计算结果，即将模式向后移 6 位。

此时，仍然从尾部开始比较。

发现 "P" 与 "E" 不匹配，则 "P" 是坏字符，则模式后移位数为 6 - 4 = 2 位。

发现 "E" 与 "E" 匹配，则继续倒序比较，直到发现全部匹配，则匹配到的第一个完整的模式 P 被发现。

继续下去则是依据好后缀启示法规则计算好后缀 "E" 的后移位置为 6 - 0 = 6 位，然后继续倒序比较时发现已超出文本 T 的范围，搜索结束。

从上面的示例描述可以看出，Boyer–Moore 算法的精妙之处在于，其通过两种启示规则来计算后移位数，且其计算过程只与模式 P 有关，而与文本 T 无关。因此，在对模式 P 进行预处理时，可预先生成 "坏字符规则之向后位移表" 和 "好后缀规则之向后位移表"，在具体匹配时仅需查表比较两者中最大的位移即可。

下面是 Boyer–Moore 算法的示例代码，使用 C# 语言实现。

namespace StringMatching
{
  class Program
  {
    static void Main(string[] args)
    {
      char[] text1 = "BBC ABCDAB ABCDABCDABDE".ToCharArray();
      char[] pattern1 = "ABCDABD".ToCharArray();

      int firstShift1;
      bool isMatched1 = BoyerMooreStringMatcher.TryMatch(
        text1, pattern1, out firstShift1);
      Contract.Assert(isMatched1);
      Contract.Assert(firstShift1 == 15);

      char[] text2 = "ABABDAAAACAAAABCABAB".ToCharArray();
      char[] pattern2 = "AAACAAAA".ToCharArray();

      int firstShift2;
      bool isMatched2 = BoyerMooreStringMatcher.TryMatch(
        text2, pattern2, out firstShift2);
      Contract.Assert(isMatched2);
      Contract.Assert(firstShift2 == 6);

      char[] text3 = "ABAAACAAAAAACAAAABCABAAAACAAAAFDLAAACAAAAAACAAAA"
        .ToCharArray();
      char[] pattern3 = "AAACAAAA".ToCharArray();

      int[] shiftIndexes3 = BoyerMooreStringMatcher.MatchAll(text3, pattern3);
      Contract.Assert(shiftIndexes3.Length == 5);
      Contract.Assert(string.Join(",", shiftIndexes3) == "2,9,22,33,40");

      char[] text4 = "GCATCGCAGAGAGTATACAGTACG".ToCharArray();
      char[] pattern4 = "GCAGAGAG".ToCharArray();

      int firstShift4;
      bool isMatched4 = BoyerMooreStringMatcher.TryMatch(
        text4, pattern4, out firstShift4);
      Contract.Assert(isMatched4);
      Contract.Assert(firstShift4 == 5);

      char[] text5 = "HERE IS A SIMPLE EXAMPLE AND EXAMPLE OF BM.".ToCharArray();
      char[] pattern5 = "EXAMPLE".ToCharArray();

      int firstShift5;
      bool isMatched5 = BoyerMooreStringMatcher.TryMatch(
        text5, pattern5, out firstShift5);
      Contract.Assert(isMatched5);
      Contract.Assert(firstShift5 == 17);
      int[] shiftIndexes5 = BoyerMooreStringMatcher.MatchAll(text5, pattern5);
      Contract.Assert(shiftIndexes5.Length == 2);
      Contract.Assert(string.Join(",", shiftIndexes5) == "17,29");

      Console.WriteLine("Well done!");
      Console.ReadKey();
    }
  }

  public class BoyerMooreStringMatcher
  {
    private static int AlphabetSize = 256;

    private static int Max(int a, int b) { return (a > b) ? a : b; }

    static int[] PreprocessToBuildBadCharactorHeuristic(char[] pattern)
    {
      int m = pattern.Length;
      int[] badCharactorShifts = new int[AlphabetSize];

      for (int i = 0; i < AlphabetSize; i++)
      {
        //badCharactorShifts[i] = -1;
        badCharactorShifts[i] = m;
      }

      // fill the actual value of last occurrence of a character
      for (int i = 0; i < m; i++)
      {
        //badCharactorShifts[(int)pattern[i]] = i;
        badCharactorShifts[(int)pattern[i]] = m - 1 - i;
      }

      return badCharactorShifts;
    }

    static int[] PreprocessToBuildGoodSuffixHeuristic(char[] pattern)
    {
      int m = pattern.Length;
      int[] goodSuffixShifts = new int[m];
      int[] suffixLengthArray = GetSuffixLengthArray(pattern);

      for (int i = 0; i < m; ++i)
      {
        goodSuffixShifts[i] = m;
      }

      int j = 0;
      for (int i = m - 1; i >= -1; --i)
      {
        if (i == -1 || suffixLengthArray[i] == i + 1)
        {
          for (; j < m - 1 - i; ++j)
          {
            if (goodSuffixShifts[j] == m)
            {
              goodSuffixShifts[j] = m - 1 - i;
            }
          }
        }
      }

      for (int i = 0; i < m - 1; ++i)
      {
        goodSuffixShifts[m - 1 - suffixLengthArray[i]] = m - 1 - i;
      }

      return goodSuffixShifts;
    }

    static int[] GetSuffixLengthArray(char[] pattern)
    {
      int m = pattern.Length;
      int[] suffixLengthArray = new int[m];

      int f = 0, g = 0, i = 0;

      suffixLengthArray[m - 1] = m;

      g = m - 1;
      for (i = m - 2; i >= 0; --i)
      {
        if (i > g && suffixLengthArray[i + m - 1 - f] < i - g)
        {
          suffixLengthArray[i] = suffixLengthArray[i + m - 1 - f];
        }
        else
        {
          if (i < g)
          {
            g = i;
          }
          f = i;

          // find different preceded character suffix
          while (g >= 0 && pattern[g] == pattern[g + m - 1 - f])
          {
            --g;
          }
          suffixLengthArray[i] = f - g;
        }
      }

      return suffixLengthArray;
    }

    public static bool TryMatch(char[] text, char[] pattern, out int firstShift)
    {
      firstShift = -1;
      int n = text.Length;
      int m = pattern.Length;
      int s = 0; // s is shift of the pattern with respect to text
      int j = 0;

      // fill the bad character and good suffix array by preprocessing
      int[] badCharShifts = PreprocessToBuildBadCharactorHeuristic(pattern);
      int[] goodSuffixShifts = PreprocessToBuildGoodSuffixHeuristic(pattern);

      while (s <= (n - m))
      {
        // starts matching from the last character of the pattern
        j = m - 1;

        // keep reducing index j of pattern while characters of
        // pattern and text are matching at this shift s
        while (j >= 0 && pattern[j] == text[s + j])
        {
          j--;
        }

        // if the pattern is present at current shift, then index j
        // will become -1 after the above loop
        if (j < 0)
        {
          firstShift = s;
          return true;
        }
        else
        {
          // shift the pattern so that the bad character in text
          // aligns with the last occurrence of it in pattern. the
          // max function is used to make sure that we get a positive
          // shift. We may get a negative shift if the last occurrence
          // of bad character in pattern is on the right side of the
          // current character.
          //s += Max(1, j - badCharShifts[(int)text[s + j]]);
          // now, compare bad char shift and good suffix shift to find best
          s += Max(goodSuffixShifts[j], badCharShifts[(int)text[s + j]] - (m - 1) + j);
        }
      }

      return false;
    }

    public static int[] MatchAll(char[] text, char[] pattern)
    {
      int n = text.Length;
      int m = pattern.Length;
      int s = 0; // s is shift of the pattern with respect to text
      int j = 0;
      int[] shiftIndexes = new int[n - m + 1];
      int c = 0;

      // fill the bad character and good suffix array by preprocessing
      int[] badCharShifts = PreprocessToBuildBadCharactorHeuristic(pattern);
      int[] goodSuffixShifts = PreprocessToBuildGoodSuffixHeuristic(pattern);

      while (s <= (n - m))
      {
        // starts matching from the last character of the pattern
        j = m - 1;

        // keep reducing index j of pattern while characters of
        // pattern and text are matching at this shift s
        while (j >= 0 && pattern[j] == text[s + j])
        {
          j--;
        }

        // if the pattern is present at current shift, then index j
        // will become -1 after the above loop
        if (j < 0)
        {
          shiftIndexes[c] = s;
          c++;

          // shift the pattern so that the next character in text
          // aligns with the last occurrence of it in pattern.
          // the condition s+m < n is necessary for the case when
          // pattern occurs at the end of text
          //s += (s + m < n) ? m - badCharShifts[(int)text[s + m]] : 1;
          s += goodSuffixShifts[0];
        }
        else
        {
          // shift the pattern so that the bad character in text
          // aligns with the last occurrence of it in pattern. the
          // max function is used to make sure that we get a positive
          // shift. We may get a negative shift if the last occurrence
          // of bad character in pattern is on the right side of the
          // current character.
          //s += Max(1, j - badCharShifts[(int)text[s + j]]);
          // now, compare bad char shift and good suffix shift to find best
          s += Max(goodSuffixShifts[j], badCharShifts[(int)text[s + j]] - (m - 1) + j);
        }
      }

      int[] shifts = new int[c];
      for (int y = 0; y < c; y++)
      {
        shifts[y] = shiftIndexes[y];
      }

      return shifts;
    }
  }
}

参考资料

• Fast String Searching Algorithm Example
• Boyer–Moore string search algorithm
• Pattern Searching | Set 7 (Boyer Moore Algorithm – Bad Character Heuristic)
• The Boyer-Moore-Horspool Algorithm
• 字符串匹配的Boyer-Moore算法
• Boyer-Moore algorithm
• What are the shift rules for Boyer–Moore string search algorithm?
• CS 312 Lecture 27 - String matching
• Boyer-Moore good-suffix heuristics
• Boyer Moore Exact Pattern Matching Algorithms

注1：文章中部分示例图片来自阮一峰的博客文章《字符串匹配的Boyer-Moore算法》，这篇文章已经写的足够透彻了，但是我还是希望通过自己叙述的理解来加深记忆。

注2：本文《Boyer-Moore 字符串匹配算法》由 Dennis Gao 发表自博客园博客，任何未经作者本人允许的人为或爬虫转载均为耍流氓。