Python3 duas maneiras de criar um trie de

Trie Essa árvore de prefixo ou trie , usando a seqüência de prefixo comum reduzir o tempo de pesquisa. A velocidade é O (k), k é o comprimento da cadeia de entrada.

1. Crie um trie usando defaultdict

a partir de colecções importar defaultdict 
de functools importar reduzir 
TrieNode = lambda: defaultdict (TrieNode) 
classe Trie: 
    def __init __ (self): 
        self.trie = TrieNode () 
    def inserir (auto, palavra): 
        reduzir (Dict .__ getitem__, palavra, auto. trie) [ 'end'] = True 
    pesquisa def (self, palavra): 
        retorno reduzir (lambda d, k: d [k] se k em d outra TrieNode (), palavra, self.trie) .get ( 'end' , False) 
    def startsWith (self, palavra): 
        bool retorno (reduzir (lambda d, k: d [k] se k em d outra TrieNode (), palavra, self.trie) .Keys ())

 2. Usando estrutura dicionário

# Definir estrutura trie

classe TrieNode (object): 
    def __init __ (self): 
        "" " 
        Inicializar sua estrutura de dados aqui. 
        """ 
        self.data = {} 
        self.is_word = false 
 
classe Trie (object): 
    def __init __ (self): 
        self.root = TrieNode () 
 
    def inserir (self, palavra): 
        "" " 
        insere uma palavra para o trie. 
        : tipo de palavra: str 
        : Rtype: void 
        """ 
        nó = self.root 
        por carta na palavra: 
            criança = node.data. get (carta) 
            se não for criança: 
                node.data [carta] = TrieNode ()
            nó = node.data [carta] 
        : tipo de prefixo: str 
        : Rtype: BOOL 
        """ 
        nó.is_word = True
 
    def procurar (self, palavra): 
        "" " 
        Retorna se a palavra está no trie. 
        : tipo de palavra: str 
        : Rtype: bool 
        """ 
        nó = self.root 
        por carta na palavra: 
            nó = node.data.get ( carta) 
            se não nó: 
                retornar False 
        retorno node.is_word #判断单词是否是完整的存在在trie树中
 
    def starts_with (self, prefixo): 
        """ 
        Retorna se houver qualquer palavra no trie 
        que começa com o prefixo dado . 
        nó = self.root 
        para carta em prefixo: 
            nó = node.data.get (carta) 
            se não nó:
                retornar False 
        retornar verdadeiro 
 
    get_start def (self, prefixo): 
        "" " 
        Retorna palavras iniciados com prefixo 
        : param prefixo: 
        : Regresso: palavras (lista) 
        """ 
        def _get_key (pré, pre_node): 
            words_list = [] 
            se pre_node.is_word : 
                words_list.append (pré) 
            para x em pre_node.data.keys (): 
                words_list.extend (_get_key (pré + str (x), pre_node.data.get (x))) 
            retorno words_list 
 
        palavras = [] 
        , se não self.starts_with (prefixo):
            regresso palavras 
        se self.search (prefixo): 
            words.append (prefixo) 
            palavras de retorno 
        nó = self.root 
        para carta em prefixo: 
            nó = node.data.get (carta) 
        retorno _get_key (prefixo, nó)