A trie is a tree-like data structure in which every node stores a character. After building the trie, strings or substrings can be retrieved by traversing down a path of the trie. Insert a word in trie, search a word and delete a word by key all takes O(n) time, at the expense of storage. Trie’s node can be implemented with array, linked list, HashMap. Each implementation has its pros and cons.
In this post, the trie is implemented in hash map. The character is used as key to find the pointer to the child node. Using HashMap is preferred if you can use the library provided by the language. Please checkout the array and linked list implementation if you are interested.
Table of Content
Define classes
The trie node class has tree variables: data stores a character, children is a data structure that points to the children (branches) nodes (here the data structure is hash map); isEnd is to mark whether this is the last node to compose a word. The trie class, there is one class level variable – root. The operation of insert, search or delete always starts from the root.
Java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
public class TrieMap { static class TrieNode { char data; HashMap<Character, TrieNode> children = new HashMap<>(); boolean isEnd = false; //Constructor, Time O(1), Space O(1) TrieNode(char c) { this.data = c; } } static class Trie { TrieNode root = new TrieNode(' '); } |
Javascript
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
class TrieNode { //Constructor, Time O(1), Space O(1) constructor(c) { this.data = c; this.isEnd = false; this.children = new Map(); //map } } class Trie { //Constructor, Time O(1), Space O(1) constructor() { this.root = new TrieNode(''); } } |
Python
|
1 2 3 4 5 6 7 8 9 10 11 12 |
class TrieNode: #constructor, Time O(1) Space O(1) def __init__(self, c): self.data = c self.isEnd = False self.children = {} #map class Trie: #constructor, Time O(1) Space O(1) def __init__(self): self.root = TrieNode('') |
Insert
To insert a word, first check whether the word is in the trie so that we don’t insert duplicate word. Then we loop through each character in the word. A pointer node starts from the root node. If the character is not in the node‘s children, a child node is created. Then the node moves to the child node. When the node is at the last character of the word, we mark the node‘s isEnd to be true.
Java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
//Add a word to trie, Iteration, Time O(s), Space O(s), s is word length void insert(String word) { if (search(word) == true) { System.out.println(word + " is already in trie."); return; } TrieNode node = root; for (char ch : word.toCharArray()) { if (!node.children.containsKey(ch)) node.children.put(ch, new TrieNode(ch)); node = node.children.get(ch); } node.isEnd = true; } |
Javascript
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
//inserts a word into the trie. Time O(s), Space O(s), s is word length insert (word) { if (this.search(word) == true) { System.out.println(word + " is already in trie."); return; } var node = this.root; for (let ch of word) { if (!node.children.has(ch)) node.children.set(ch, new TrieNode(ch)); node = node.children.get(ch); } node.isEnd = true; } |
Python
|
1 2 3 4 5 6 7 8 9 10 11 |
#Add a word to trie, Time O(s) Space O(1), s is word length def insert(self, word): if self.search(word) == True: print(word + " is already in trie.") return node = self.root for ch in word: if not ch in node.children: node.children[ch] = TrieNode(ch) node = node.children[ch] node.isEnd = True |
Doodle
Delete
To delete a word from the trie, first check whether the word exists in the trie. If not, the method can return. The same as insert, loop through each character in the word. A pointer node starts from the root node. If the character is not in the node‘s children, the method returns directly. Otherwise, the node moves to the child node. When the node is at the last character of the word, mark the node‘s isEnd to be false.
Java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
//Remove a word from trie, Iteration, Time O(s), Space O(1), s is word length void delete(String word) { if (this.search(word) == false) { System.out.println(word + " does not exist in trie."); return; } TrieNode node = root; for (char ch : word.toCharArray()) { if (!node.children.containsKey(ch)) return; node = node.children.get(ch); } node.isEnd = false; } |
Javascript
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
//Remove a word from trie, Iteration, Time O(s), Space O(1), s is word length delete(word) { if (this.search(word) == null) { console.log(word + " does not exist in trie."); return; } let node = this.root; for (let ch of word) { if (!node.children.has(ch)) return; node = node.children.get(ch); } node.isEnd = false; } |
Python
|
1 2 3 4 5 6 7 8 9 10 11 |
#Remove a word from trie, Iteration, Time O(s), Space O(1), s is word length def delete(self, word) : if self.search(word) == False: print(word + " does not exist in trie.") return node = self.root for ch in word: if not ch in node.children: return node = node.children.get(ch) node.isEnd = False |
Search
To search a word in the trie, loop through each character in the word. A pointer node starts from the root node. If the character is not in the node‘s children, the method returns false. Otherwise, the node moves to the child node. When the node is at the last character of the word, return the node‘s isEnd value, which can be true or false(deleted).
Java
|
1 2 3 4 5 6 7 8 9 10 |
//Search a word in trie, Iteration, Time O(s), Space O(1), s is word length boolean search(String word) { TrieNode node = root; for (char ch : word.toCharArray()) { if (!node.children.containsKey(ch)) return false; node = node.children.get(ch); } return node.isEnd; } |
Javascript
|
1 2 3 4 5 6 7 8 9 10 |
//Search a word in trie, Iteration, Time O(s), Space O(1), s is word length search(word) { let node = this.root; for(let ch of word) { if (!node.children.has(ch)) return false; node = node.children.get(ch); } return node.isEnd; } |
Python
|
1 2 3 4 5 6 7 8 |
#Search a word in trie, Iteration, Time O(s), Space O(1), s is word length def search(self, word): node = self.root for ch in word: if not ch in node.children: return False node = node.children.get(ch) return node.isEnd |
Print
To print all words in the trie, recursion is used to traverse all nodes in trie. This is similar to pre-order (DFS, depth first search) of the tree. When visiting the node, the method concatenates characters from previously visited nodes with the character of the current node. When the node‘s isEnd is true, the recursion reaches the last character of the word, and add the word to the result list.
Java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
//Print all words in trie, call recursion function //Time O(n), Space O(n), n is number of nodes in trie void print() { List<String> res = new ArrayList<String>(); helper(root, res, ""); System.out.println(res); } //recursive function, Time O(n), Space O(n), n is number of nodes in trie void helper(TrieNode node, List<String> res, String prefix) { if (node.isEnd) { String word = prefix + node.data; res.add(word.substring(1)); //skip the first space from root } for (Character ch : node.children.keySet()) helper(node.children.get(ch), res, prefix + node.data); } |
Javascript
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
//Print all words in trie, call recursion function //Time O(n), Space O(n), n is number of nodes in trie print() { let res = []; this.helper(this.root, res, ""); console.log(res); } //recursion function, Time O(n), Space O(n), n is number of nodes in trie helper (node, arr, perfix) { if (node.isEnd) arr.push(perfix + node.data); for (let c of node.children.keys()) this.helper(node.children.get(c), arr, perfix + node.data); } |
Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
#Print all words in trie, call recursion function #Time O(n), Space O(n), n is number of nodes in trie def print (self) : res = [] self.helper(self.root,res, "") print(res) #recursion function, Time O(n), Space O(n), n is number of nodes in trie def helper(self, node, res, prefix): if node.isEnd: res.append(prefix + node.data) for child in node.children.values(): self.helper(child, res, prefix + node.data) |
Download Java, JavaScript and Python code
Trie (part 1) – array implementation
Trie (part 2) – linked list implementation
Trie animated visual
Data structures and Java collections