# LeetCode 208. Implement Trie (Prefix Tree)

Implement a trie with insertsearch, and startsWith methods.

Note:
You may assume that all inputs are consist of lowercase letters a-z.

Trie 是一种数据结构，用来做字典查找，是一种用于快速检索的多叉数结构。例如，英文字母的字典树是26叉数，数字的字典树是10叉树。

Trie树的基本性质有三点，归纳为：

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

Time Complexity: insert, O(m). search, O(m). startsWith, O(m). m = word.length().

Space: O(n*m). n是总共有多少词.

AC Java:

 1 class Trie {
2     TrieNode root;
3
4     /** Initialize your data structure here. */
5     public Trie() {
6         root = new TrieNode();
7     }
8
9     /** Inserts a word into the trie. */
10     public void insert(String word) {
11         TrieNode p = root;
12         for(char c : word.toCharArray()){
13             if(p.next[c-'a'] == null){
14                 p.next[c-'a'] = new TrieNode();
15             }
16
17             p = p.next[c-'a'];
18         }
19
20         p.val = word;
21     }
22
23     /** Returns if the word is in the trie. */
24     public boolean search(String word) {
25         TrieNode p = root;
26         for(char c : word.toCharArray()){
27             if(p.next[c-'a'] == null){
28                 return false;
29             }
30
31             p = p.next[c-'a'];
32         }
33
34         return p.val.equals(word);
35     }
36
37     /** Returns if there is any word in the trie that starts with the given prefix. */
38     public boolean startsWith(String prefix) {
39         TrieNode p = root;
40         for(char c : prefix.toCharArray()){
41             if(p.next[c-'a'] == null){
42                 return false;
43             }
44
45             p = p.next[c-'a'];
46         }
47
48         return true;
49     }
50 }
51
52 class TrieNode{
53     String val;
54     TrieNode [] next;
55
56     public TrieNode(){
57         val = "";
58         next = new TrieNode[26];
59     }
60 }
61
62 /**
63  * Your Trie object will be instantiated and called as such:
64  * Trie obj = new Trie();
65  * obj.insert(word);
66  * boolean param_2 = obj.search(word);
67  * boolean param_3 = obj.startsWith(prefix);
68  */

AC Python:

 1 class Trie:
2
3     def __init__(self):
4         """
5         Initialize your data structure here.
6         """
7         self.root = TrieNode()
8
9
10     def insert(self, word: str) -> None:
11         """
12         Inserts a word into the trie.
13         """
14         p = self.root
15         for c in word:
16             if c not in p.next:
17                 p.next[c] = TrieNode()
18             p = p.next[c]
19         p.val = word
20
21
22     def search(self, word: str) -> bool:
23         """
24         Returns if the word is in the trie.
25         """
26         p = self.root
27         for c in word:
28             if c not in p.next:
29                 return False
30             p = p.next[c]
31         return p.val == word
32
33
34     def startsWith(self, prefix: str) -> bool:
35         """
36         Returns if there is any word in the trie that starts with the given prefix.
37         """
38         p = self.root
39         for c in prefix:
40             if c not in p.next:
41                 return False
42             p = p.next[c]
43         return True
44
45 class TrieNode:
46     def __init__(self):
47         self.val = ""
48         self.next = {}
49
50
51 # Your Trie object will be instantiated and called as such:
52 # obj = Trie()
53 # obj.insert(word)
54 # param_2 = obj.search(word)
55 # param_3 = obj.startsWith(prefix)

Note: search() 和 startsWith() 有所不同，search时还需要注意跳出loop时是否已经打了Trie树的叶子节点.

AC Java:

 1 class TrieNode {
2     //Mark if this node is the end of the word
3     boolean isLeaf;
4     HashMap<Character,TrieNode> nexts;
5     public TrieNode() {
6         nexts = new HashMap<Character,TrieNode>();
7     }
8 }
9
10 public class Trie {
11     private TrieNode root;
12
13     public Trie() {
14         root = new TrieNode();
15     }
16
17     // Inserts a word into the trie.
18     public void insert(String word) {
19         TrieNode p = root;
20         char [] s = word.toCharArray();
21         int len = s.length;
22         int i = 0;
23         //traverse the existing character
24         while(i<len){
25             if(p.nexts.containsKey(s[i])){
26                 p = p.nexts.get(s[i]);
27                 i++;
28             }else{
29                 break;
30             }
31         }
32         //append new nodes
33         while(i<len){
34             TrieNode newNode = new TrieNode();
35             p.nexts.put(s[i],newNode);
36             p = newNode;
37             i++;
38         }
39         //Set the end of the word
40         p.isLeaf = true;
41     }
42
43     // Returns if the word is in the trie.
44     public boolean search(String word) {
45         TrieNode p = root;
46         char [] s = word.toCharArray();
47         int len = s.length;
48         int i = 0;
49         while(i<len){
50             TrieNode nextNode = p.nexts.get(s[i]);
51             if(nextNode == null){
52                 return false;
53             }
54             p = nextNode;
55             i++;
56         }
57         //return if this is a leaf node
58         return p.isLeaf;
59     }
60
61     // Returns if there is any word in the trie
62     // that starts with the given prefix.
63     public boolean startsWith(String prefix) {
64         TrieNode p = root;
65         char [] s = prefix.toCharArray();
66         int len = s.length;
67         int i = 0;
68         while(i<len){
69             TrieNode nextNode = p.nexts.get(s[i]);
70             if(nextNode == null){
71                 return false;
72             }
73             p = nextNode;
74             i++;
75         }
76         return true;
77     }
78 }
79
80 // Your Trie object will be instantiated and called as such:
81 // Trie trie = new Trie();
82 // trie.insert("somestring");
83 // trie.search("key");
posted @ 2015-10-18 07:14  Dylan_Java_NYC  阅读(522)  评论(0编辑  收藏  举报