# Dictionary Tree trie Tree - Class Panton's Graphical Notes

Trie tree, also known as dictionary tree, Prefix Tree, and word search tree, is a multifork tree structure.

# The role of trie trees

The core idea of Trie Tree is to change time by space and reduce unnecessary string comparisons by using common prefixes of strings to improve query efficiency.

Core Applications

- String Retrieval
- word frequency count
- String Sort
- Prefix matching (search associations, don't know if autocomplete in element-ui is made from a trie tree, it's cool to use anyway)

## trie tree node

Each letter takes up a trie tree node. There is no essential difference between the root node and the child node. There are several main attributes.

- Root:Is it a root node
- dict:hash table with child nodes
- flag: Is it the end of a word
- value: The complete content of the word (only if flag is True)
- count: The number of times the word appears (only if flag is True)
- list: is a dictionary used to traverse stored things (only root nodes)

class Trie(object): def __init__(self, root=None,flag=False,count=None,value=None): self.root = root # root node is used to load content self.count = count # Count counts are used for counting and can count word frequencies self.dict = {} # dict is used to load child nodes, child nodes or trie trees self.flag = flag # flag is used to determine whether or not to end self.value = value # value means what the word is self.list = {}

## General operation

First, implement the four most basic operations:

- insert: increase, notice the last letter and handle it
- search:
- Delete:delete
- startsWith: Determines if a prefix exists

increase

def insert(self, word): """ :type word: str :rtype: None """ trie = self for j,i in enumerate(word): # Traverse (or add) if it is not the last letter if j != len(word) - 1: if i not in trie.dict: trie.dict[i] = Trie(root=i) trie = trie.dict[i] else: # Is the last letter and flag is true counts if i in trie.dict and trie.dict[i].flag: trie = trie.dict[i] trie.count += 1 # Is the last letter but flag is false modifies flag to change count to 1 elif i in trie.dict and not trie.dict[i].flag: trie = trie.dict[i] trie.flag = True trie.count = 1 trie.value = word # If trie. Add if not in Dict else: trie.dict[i] = Trie(root=i,flag=True,count=1,value=word)

check

def search(self, word): """ :type word: str :rtype: bool """ trie = self for i in word: if i in trie.dict: trie = trie.dict[i] else: return False return trie.flag

Delete

def delete(self, word): ''' :type word: str :rtype: None ''' if self.search(word): trie = self for i in word: if len(trie.dict) == 1: trie.dict.pop(i) break else: trie = trie.dict[i] else: print('The word is not present trie In a tree')

Determine if a prefix exists

def startsWith(self, prefix): """ :type prefix: str :rtype: bool """ trie = self for i in prefix: if i in trie.dict: trie = trie.dict[i] else: return False return True

## Traversal operation

Traversal operation prefers DFS depth-first search, and prefix is added to the parameters for the purpose of subsequent association operations, which can be omitted if only traversal is done; It is worth mentioning that my storage of child nodes is in the form of a dictionary, and the sorting of the results just happens to be the dictionary order, which also implements the string dictionary order mentioned earlier (in fact, to sort the dictionary order directly, there is no need to use a trie tree).

def dfs(self,path,trie,prefix=''): # If you come to the end of a word for the truth if trie.flag: self.list[prefix + ''.join(path)] = trie.count if trie.dict == {}: return for i in trie.dict: path.append(i) self.dfs(path,trie.dict[i],prefix) path.pop()

Create iterative methods for trie trees

def __iter__(self): self.list = {} # Reset self.list self.dfs([],self) return iter(self.list)

## Association Operation

Lenovo business should be like this: users enter the first few letters, and then match out the complete words, the more frequently used words should be placed first;

So the overall idea is as follows: find the trie tree node where the last letter of the prefix is located according to the prefix, start DFS traversal from that node, add a prefix before the traversal result, sort the result by count and output the result as a list;

Implement the sorting algorithm first, using quick sorting here, note that the value of comparison is count, and the word is left behind.

def quick_sorted(self,dict): ''' :type dict: dict :rtype: list ''' if len(dict) >= 2: nums = list(dict.keys()) mid = nums[len(nums) // 2] left, right = {}, {} nums.remove(mid) for d in nums: if dict[d] < dict[mid]: left[d] = dict[d] else: right[d] = dict[d] return self.quick_sorted(right) + [mid] + self.quick_sorted(left) return list(dict.keys())

Re-implement Association Operation

def dream(self,prefix): ''' :type prefix: str :rtype: list ''' trie = self for i in prefix: if i in trie.dict: trie = trie.dict[i] elif dict[d] == dict[mid]: if d > mid: right[d] = dict[d] else: left[d] = dict[d] else: return [] self.list = {} # Reset self.list self.dfs([],trie,prefix) return self.quick_sorted(self.list)

## Some simple test cases

if __name__ == '__main__': trie = Trie() for i in ["ogz","eyj","e","ey","ey","hmn","v","hm","ogznkb","ogzn","hmnm","eyjuo","vuq","ogznk","og","eyjuoi","d"]: trie.insert(i) a = trie.dream('e') print(a) for j in trie: print(j)

# Actual Warfare - LeetCode

Question 208: Simply add, check and determine if a prefix exists, it's very simple...

Question 720: The longest word in a dictionary, which requires returning the longest word formed by gradually adding a letter to other words in the dictionary;

Idea 1: Make a judgment about the prefix of each word, and then choose the longest word to pass the judgment (no additional action is required)

import Trie class Solution(object): def longestWord(self, words): """ :type words: List[str] :rtype: str """ trie = Trie() words = sorted(list(set(words))) for i in words: trie.insert(i) result = '' for i in words: flag = True # Determine if all prefixes for this word are in the trie tree for j in range(len(i)): if not trie.search(i[:j+1]): flag = False break # If all prefixes of this word are in this trie tree if flag and len(i) > len(result): result = i return result if __name__ == '__main__': words = ["a", "banana", "app", "appl", "ap", "apply", "apple"] print(Solution().longestWord(words))

Idea 2: Direct use of DFS to find the longest one, much faster but still not ideal

#%% trie + depth first search class Solution(object): def __init__(self): self.result = '' def longestWord(self, words): """ :type words: List[str] :rtype: str """ trie = Trie(root=True) words = sorted(list(set(words))) for i in words: trie.insert(i) self.dfs([],trie) return self.result def dfs(self, path, trie): # When it is not the root node and the end of the word (because you have already decided whether it is the end of the word when you come in, you do not need to repeat your decision) if trie.root != True: temp = ''.join(path) if len(temp) > len(self.result): self.result = temp if trie.dict == {}: return for i in trie.dict: # Pruning: skip directly if it is not the end of a word if not trie.dict[i].flag: continue path.append(i) self.dfs(path,trie.dict[i]) path.pop() if __name__ == '__main__': words = ["a", "banana", "app", "appl", "ap", "apply", "apple"] print(Solution().longestWord(words))

Question 692: The first K high frequency words. The Title is: Give a list of non-empty words and return the first k words that appear the most. Answers returned should be sorted by word frequency from high to low. If different words have the same frequency, sort them alphabetically.

That's not very similar to the associative function we wrote...

import Trie class Solution(object): def topKFrequent(self, words, k): """ :type words: List[str] :type k: int :rtype: List[str] """ trie = Trie() for i in words: trie.insert(i) result = trie.dream('') return result[:k] if __name__ == '__main__': words = ["i","love","leetcode","i","love","coding"] k = 2 print(Solution().topKFrequent(words.k))