字符串模式匹配算法系列（三）：Trie树及AC改进算法

Trie树的python实现（leetcode 208）

 #!/usr/bin/env python
 #-*- coding: utf-8 -*-
 import sys
 import pdb

 reload(sys)
 sys.setdefaultencoding('utf-8')

 class TrieNode(object):
     """Trie节点

     Attributes:
         _val: 本节点的值（非None即作为结束判断条件）
         _next: 后继节点
     """
     def __init__(self, value=None):
         self._val = value
         self._next = {}

     def set_value(self, value=None):
         """为当前节点设置值
         """
         self._val = value

     def get_value(self):
         """获取当前节点的值
         """
         return self._val

     def set_next(self, key, value=None):
         """为当前节点添加一个后继节点
         """
         if key not in self._next:
             self._next[key] = TrieNode(value)
         return self._next[key]

     def get_next(self, key):
         """从当前节点获取指定的后继节点
         """
         if key not in self._next:
             return None
         return self._next[key]

 class Trie(object):
     """Trie树
     Attribures:
         _root: 根节点
     """
     def __init__(self):
         # 生成root节点
         self._root = TrieNode()

     def insert(self, word):
         """将一个单词插入trie树
         """
         curr = self._root

         for char in word:
             curr = curr.set_next(char)
         curr.set_value(True)

     def search(self, word):
         """检索一个单词是否trie树中存在
         """
         curr = self._root
         ret = False

         for i, c in enumerate(word):
             curr = curr.get_next(c)
             if curr is None:
                 break
             if i + 1 == len(word) and curr.get_value() is True:
                 ret = True
                 break
         return ret

     def startsWith(self, prefix):
         """检索trie树中是否有prefix开头的单词
         """
         curr = self._root
         ret = True

         for c in prefix:
             curr = curr.get_next(c)
             if curr is None:
                 ret = False
                 break
         return ret

 def main():
     trie = Trie()
     trie.insert("app")
     trie.insert("apple")
     print trie.search("app")

 if __name__ == '__main__':
     main()

AC改进算法python实现

 #!/usr/bin/env python
 #-*- coding: utf-8 -*-
 import sys
 import pdb

 reload(sys)
 sys.setdefaultencoding('utf-8')

 class ACTrieNode(object):
     """ACTrie节点

     Attributes:
         val: 本节点的值（非None即作为结束判断条件）
         children: 孩子节点
         fail: 失配跳转指针
     """
     def __init__(self, value=None):
         self.val = value
         self.children = {}
         self.fail = None

     def get_next(self, key):
         """从本节点开始，找到children中包含key的节点，如果找不到就返回根节点
         """
         if key in self.children.keys():
             return self.children[key]
         if self.fail is None:
             # fail为None就是根节点
             return self
         return self.fail.get_next(key)

 class ACTrie(object):
     """ACTrie树

     Attribures:
         _root: 根节点
     """
     def __init__(self):
         self._root = ACTrieNode() # 生成root节点

     def insert(self, word):
         """将一个单词插入trie树
         """
         curr = self._root
         for char in word:
             if char not in curr.children:
                 curr.children[char] = ACTrieNode()
             curr = curr.children[char]
         curr.val = word

     def update_failure(self):
         """更新failure跳转
         """
         bfs_queue = [self._root] # 利用list作为bfs缓存队列

         while len(bfs_queue) > 0:
             father = bfs_queue.pop(0) # 取出队列头部元素

             # BFS遍历父节点的所有子节点，为他们设置failure
             for key, child in father.children.items():
                 bfs_queue.append(child) # 将当前元素放入队列尾部

                 if father == self._root:
                     # 当前父节点是root时，其子节点的failure也指向root
                     child.fail = self._root
                 else:
                     # 当前父节点不是root时，其子节点的failure尝试指向"(迭代)父节点的failure的同名子节点"
                     child.fail = father.fail.get_next(key)

     def search(self, text):
         """从源字符串中寻找目标字符串
         """
         match_set = set()
         curr = self._root

         for char in text:
             curr = curr.get_next(char)
             # 搜集匹配上的单词
             tmp_node = curr
             while tmp_node:
                 if tmp_node.val:
                     match_set.add(tmp_node.val)
                 tmp_node = tmp_node.fail
         return match_set

 def main():
     trie = ACTrie()
     trie.insert("abcd")
     trie.insert("ab")
     trie.insert("bc")
     trie.insert("cf")
     trie.insert("cde")

     trie.update_failure()

     text = 'abcdefg'
     ret = trie.search(text)
     print ret

 if __name__ == '__main__':
     main()