Boyer Moore算法实现(坏字符规则)

根据阮一峰的博客

http://www.ruanyifeng.com/blog/2013/05/boyer-moore_string_search_algorithm.html

试写算法。

使用好后缀的方法比较复杂，暂未实现。

只实现了通过坏字符的方法，事实上Boyer-Moore-Horspool算法是简化版的Boyer-Moore算法，它只使用坏字符规则。

具体代码如下：

class Program
  {
      static void Main(string[] args)
      {
          string source = "HERE IS A SIMPLE EXAMPLE";
          string pattern = "EXAMPLE";

          BoyerMoore(source.ToCharArray(), pattern.ToCharArray());
      }

      static int BoyerMoore(char[] source, char[] pattern)
      {
          Dictionary<char, int> PostionDictionary = GetPostionDictionary(pattern);
          int pattern_length = pattern.Length;
          int start_pointer = 0;
          int end_pointer = start_pointer + pattern_length - 1;
          int offset = 0;

          int offset_for_print = 0;

          while (end_pointer <= source.Length)
          {
              Console.WriteLine(source);
              Console.WriteLine(new String(pattern).PadLeft(offset_for_print + pattern_length,'-'));

              char[] Chars = subChars(source, start_pointer, end_pointer);
              char badChar;
              int badPostion;
              if (checkIsEqual_badChar(pattern, Chars, out badChar, out badPostion))
              {
                  Console.WriteLine(start_pointer + "," + end_pointer);

                  start_pointer += pattern_length;
                  end_pointer = start_pointer + pattern_length - 1;
                  offset_for_print += pattern_length;

                  continue;
              }
              else
              {
                  if (PostionDictionary.ContainsKey(badChar))
                  {
                      //计算偏移量
                      offset = badPostion - PostionDictionary[badChar];
                  }
                  else
                  {
                      offset = badPostion + 1;
                  }
                  start_pointer += offset;
                  end_pointer = start_pointer + pattern_length - 1;
                  offset_for_print += offset;
              }
          }
          return 0;
      }

      static bool checkIsEqual_badChar(char[] pattern, char[] Chars, out char badChar, out int badPostion)
      {
          if (pattern.Length != Chars.Length)
          {
              throw new Exception("length error");
          }

          for (int i = pattern.Length - 1; i >= 0; i--)
          {
              if (pattern[i] != Chars[i])
              {
                  badChar = Chars[i];
                  badPostion = i;
                  return false;
              }
          }
          badChar = '\0';
          badPostion = -1;
          return true;
      }


      /// <summary>
      /// 根据起始位置和结束位置，给出子串
      /// </summary>
      /// <param name="source"></param>
      /// <param name="start"></param>
      /// <param name="end"></param>
      /// <returns></returns>
      static char[] subChars(char[] source, int start, int end)
      {
          char[] c = new char[end - start + 1];

          for (int i = start; i <= end; i++)
          {
              c[i - start] = source[i];
          }

          return c;

      }

      /// <summary>
      /// 生成坏字符位置表
      /// </summary>
      /// <param name="chars"></param>
      /// <returns></returns>
      static Dictionary<char, int> GetPostionDictionary(char[] chars)
      {
          Dictionary<char, int> d = new Dictionary<char, int>();

          for (int i = 0; i < chars.Length; i++)
          {
              if (d.ContainsKey(chars[i]) == false)
              {
                  d.Add(chars[i], i);
              }
              else//存在则覆盖
              {
                  d[chars[i]] = i;
              }
          }
          return d;
      }
  }

测试数据输出图: