C#实现前向最大匹、字典树（分词、检索）

　　场景：现在有一个错词库，维护的是错词和正确词对应关系。比如：错词“我门”对应的正确词“我们”。然后在用户输入的文字进行错词校验，需要判断输入的文字是否有错词，并找出错词以便提醒用户，并且可以显示出正确词以便用户确认，如果是错词就进行替换。

　　首先想到的就是取出错词List放在内存中，当用户输入完成后用错词List来foreach每个错词，然后查找输入的字符串中是否包含错词。这是一种有效的方法，并且能够实现。问题是错词的数量比较多，目前有10多万条，将来也会不断更新扩展。所以pass了这种方案，为了让错词查找提高速度就用了字典树来存储错词。

字典树

　　Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较。

Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。

通常字典树的查询时间复杂度是O(logL)，L是字符串的长度。所以效率还是比较高的。而我们上面说的foreach循环则时间复杂度为O(n)，根据时间复杂度来看，字典树效率应该是可行方案。

字典树原理

　　根节点不包含字符，除根节点外每一个节点都只包含一个字符； 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串； 每个节点的所有子节点包含的字符都不相同。

　　比如现在有错词：“我门”、“旱睡”、“旱起”。那么字典树如下图

　　 其中红色的点就表示词结束节点，也就是从根节点往下连接成我们的词。

　　实现字典树：

 public class Trie
 {
     private class Node
     {
         /// <summary>
         /// 是否单词根节点
         /// </summary>
         public bool isTail = false;

         public Dictionary<char, Node> nextNode;

         public Node(bool isTail)
         {
             this.isTail = isTail;
             this.nextNode = new Dictionary<char, Node>();
         }
         public Node() : this(false)
         {
         }
     }

     /// <summary>
     /// 根节点
     /// </summary>
     private Node rootNode;
     private int size;
     private int maxLength;

     public Trie()
     {
         this.rootNode = new Node();
         this.size = ;
         this.maxLength = ;
     }

     /// <summary>
     /// 字典树中存储的单词的最大长度
     /// </summary>
     /// <returns></returns>
     public int MaxLength()
     {
         return maxLength;
     }

     /// <summary>
     /// 字典树中存储的单词数量
     /// </summary>
     public int Size()
     {
         return size;
     }

     /// <summary>
     /// 获取字典树中所有的词
     /// </summary>
     public List<string> GetWordList()
     {
         return GetStrList(this.rootNode);
     }

     private List<string> GetStrList(Node node)
     {
         List<string> wordList = new List<string>();

         foreach (char nextChar in node.nextNode.Keys)
         {
             string firstWord = Convert.ToString(nextChar);
             Node childNode = node.nextNode[nextChar];

             if (childNode == null || childNode.nextNode.Count == )
             {
                 wordList.Add(firstWord);
             }
             else
             {

                 if (childNode.isTail)
                 {
                     wordList.Add(firstWord);
                 }

                 List<string> subWordList = GetStrList(childNode);
                 foreach (string subWord in subWordList)
                 {
                     wordList.Add(firstWord + subWord);
                 }
             }
         }

         return wordList;
     }

     /// <summary>
     /// 向字典中添加新的单词
     /// </summary>
     /// <param name="word"></param>
     public void Add(string word)
     {
         //从根节点开始
         Node cur = this.rootNode;
         //循环遍历单词
         foreach (char c in word.ToCharArray())
         {
             //如果字典树节点中没有这个字母，则添加
             if (!cur.nextNode.ContainsKey(c))
             {
                 cur.nextNode.Add(c, new Node());
             }
             cur = cur.nextNode[c];
         }
         cur.isTail = true;

         if (word.Length > this.maxLength)
         {
             this.maxLength = word.Length;
         }
         size++;
     }

     /// <summary>
     /// 查询字典中某单词是否存在
     /// </summary>
     /// <param name="word"></param>
     /// <returns></returns>
     public bool Contains(string word)
     {
         return Match(rootNode, word);
     }

     /// <summary>
     /// 查找匹配
     /// </summary>
     /// <param name="node"></param>
     /// <param name="word"></param>
     /// <returns></returns>
     private bool Match(Node node, string word)
     {
         if (word.Length == )
         {
             if (node.isTail)
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }
         else
         {
             char firstChar = word.ElementAt();
             if (!node.nextNode.ContainsKey(firstChar))
             {
                 return false;
             }
             else
             {
                 Node childNode = node.nextNode[firstChar];
                 return Match(childNode, word.Substring(, word.Length - ));
             }
         }
     }
 }

　　测试下：

　　现在我们有了字典树，然后就不能以字典树来foreach，字典树用于检索。我们就以用户输入的字符串为数据源，去字典树种查找是否存在错词。因此需要对输入字符串进行取词检索。也就是分词，分词我们采用前向最大匹配。

前向最大匹配

　　我们分词的目的是将输入字符串分成若干个词语，前向最大匹配就是从前向后寻找在词典中存在的词。

　　例子：我们假设maxLength= 3,即假设单词的最大长度为3。实际上我们应该以字典树中的最大单词长度，作为最大长度来分词（上面我们的字典最大长度应该是2）。这样效率更高，为了演示匹配过程就假设maxLength为3，这样演示的更清楚。

　　用前向最大匹配来划分“我们应该早睡早起” 这句话。因为我是错词匹配，所以这句话我改成“我门应该旱睡旱起”。

　　第一次：取子串 “我门应”，正向取词，如果匹配失败，每次去掉匹配字段最后面的一个字。

　　“我门应”，扫描词典中单词，没有匹配，子串长度减 1 变为“我门”。

　　“我门”，扫描词典中的单词，匹配成功，得到“我门”错词，输入变为“应该旱”。

　　第二次：取子串“应该旱”

　　“应该旱”，扫描词典中单词，没有匹配，子串长度减 1 变为“应该”。

　　“应该”，扫描词典中的单词，没有匹配，输入变为“应”。

　　“应”，扫描词典中的单词，没有匹配，输入变为“该旱睡”。

　　第三次：取子串“该旱睡”

　　“该旱睡”，扫描词典中单词，没有匹配，子串长度减 1 变为“该旱”。

　　“该旱”，扫描词典中的单词，没有匹配，输入变为“该”。

　　“该”，扫描词典中的单词，没有匹配，输入变为“旱睡旱”。

　　第四次：取子串“旱睡旱”

　　“旱睡旱”，扫描词典中单词，没有匹配，子串长度减 1 变为“旱睡”。

　　“旱睡”，扫描词典中的单词，匹配成功，得到“旱睡”错词，输入变为“早起”。

　　以此类推，我们得到错词 我们/旱睡/旱起。

　　因为我是结合字典树匹配错词所以一个字也可能是错字，则匹配到单个字，如果只是分词则上面的到一个字的时候就应该停止分词了，直接字符串长度减1。

　　这种匹配方式还有后向最大匹配以及双向匹配，这个大家可以去了解下。

　　实现前向最大匹配，这里后向最大匹配也可以一起实现。

  public class ErrorWordMatch
     {
         private static ErrorWordMatch singleton = new ErrorWordMatch();
         private static Trie trie = new Trie();
         private ErrorWordMatch()
         {

         }

         public static ErrorWordMatch Singleton()
         {
             return singleton;
         }

         public void LoadTrieData(List<string> errorWords)
         {
             foreach (var errorWord in errorWords)
             {
                 trie.Add(errorWord);
             }
         }

         /// <summary>
         /// 最大 正向/逆向 匹配错词
         /// </summary>
         /// <param name="inputStr">需要匹配错词的字符串</param>
         /// <param name="leftToRight">true为从左到右分词，false为从右到左分词</param>
         /// <returns>匹配到的错词</returns>
         public List<string> MatchErrorWord(string inputStr, bool leftToRight)
         {
             if (string.IsNullOrWhiteSpace(inputStr))
                 return null;
             if (trie.Size() == )
             {
                 throw new ArgumentException("字典树没有数据,请先调用 LoadTrieData 方法装载字典树");
             }
             //取词的最大长度
             int maxLength = trie.MaxLength();
             //取词的当前长度
             int wordLength = maxLength;
             //分词操作中，处于字符串中的当前位置
             int position = ;
             //分词操作中，已经处理的字符串总长度
             int segLength = ;
             //用于尝试分词的取词字符串
             string word = "";

             //用于储存正向分词的字符串数组
             List<string> segWords = new List<string>();
             //用于储存逆向分词的字符串数组
             List<string> segWordsReverse = new List<string>();

             //开始分词，循环以下操作，直到全部完成
             while (segLength < inputStr.Length)
             {
                 //如果剩余没分词的字符串长度<取词的最大长度，则取词长度等于剩余未分词长度
                 if ((inputStr.Length - segLength) < maxLength)
                     wordLength = inputStr.Length - segLength;
                 //否则，按最大长度处理
                 else
                     wordLength = maxLength;

                 //从左到右 和 从右到左截取时，起始位置不同
                 //刚开始，截取位置是字符串两头，随着不断循环分词，截取位置会不断推进
                 if (leftToRight)
                     position = segLength;
                 else
                     position = inputStr.Length - segLength - wordLength;

                 //按照指定长度，从字符串截取一个词
                 word = inputStr.Substring(position, wordLength);

                 //在字典中查找，是否存在这样一个词
                 //如果不包含，就减少一个字符，再次在字典中查找
                 //如此循环，直到只剩下一个字为止
                 while (!trie.Contains(word))
                 {
                     //如果最后一个字都没有匹配，则把word设置为空，用来表示没有匹配项(如果是分词直接break)
                     if (word.Length == )
                     {
                         word = null;
                         break;
                     }

                     //把截取的字符串，最边上的一个字去掉
                     //从左到右 和 从右到左时，截掉的字符的位置不同
                     if (leftToRight)
                         word = word.Substring(, word.Length - );
                     else
                         word = word.Substring();
                 }

                 //将分出匹配上的词，加入到分词字符串数组中，正向和逆向不同
                 if (word != null)
                 {
                     if (leftToRight)
                         segWords.Add(word);
                     else
                         segWordsReverse.Add(word);
                     //已经完成分词的字符串长度，要相应增加
                     segLength += word.Length;
                 }
                 else
                 {
                     //没匹配上的则+1，丢掉一个字（如果是分词 则不用判断word是否为空，单个字也返回）
                     segLength += ;
                 }
             }

             //如果是逆向分词，对分词结果反转排序
             if (!leftToRight)
             {
                 for (int i = segWordsReverse.Count - ; i >= ; i--)
                 {
                     //将反转的结果，保存在正向分词数组中 以便最后return 同一个变量segWords
                     segWords.Add(segWordsReverse[i]);
                 }
             }

             return segWords;
         }
     }

　　这里使用了单例模式用来在项目中共用，在第一次装入了字典树后就可以在其他地方匹配错词使用了。

　　这个是结合我具体使用，简化了些代码，如果只是分词的话就是分词那个实现方法就行了。最后分享就到这里吧，如有不对之处，请加以指正。