18 KiB
Do you know how the "auto-completion feature" provided by different software like IDEs, Search Engines, command-line interpreters, text editors, etc works?
The basic data structure behind all these scenes is Trie.
Spell checkers can also be designed using Trie.
Trie
String processing is widely used across real-world applications, for example data analytics, search engines, bioinformatics, plagiarism detection, etc.
Trie is a very useful and special kind of data structure for string processing.
Introduction
Trie is a tree of nodes, where the specifications of a node can be given as below:
Each node has,
- An array of size of the alphabet(see the note below).
- A boolean variable.
Note: For an easy understanding purpose, we are assuming that all strings contain lowercase alphabet letters, i.e. alphabet_size is 26. We can convert characters to a number by using c-'a', c is a lowercase character.
We will see usages of these two variables soon.
struct trie_node
{
// Array of pointers of type
// trie_node
vector<trie_node*> links;
bool isEndofString;
// Constructor
trie_node()
{
links.assign(alphabet_size, nullptr);
isEndofString = false;
}
};
Now, we have seen how a trie node looks like. Let's see how we are going to store strings in a trie using this kind of node.
How to insert a string in a trie?
Look at the image below, which represents a string "act" stored in a trie. Observe something!
Note: Empty places in the array have null values(nullptr in c++).
What did you observe?
Observations:
- Other than the root node, each node in trie represents a single character.
- We set isEndofString to true in the node at which the string ends.
Therefore, now for the shake of ease we are going to represent the nodes of trie as below.
And therefore representation of trie containing string "act" will be as below.
.jpg)
Note: Root node will be shown empty, as it only represents an empty string, so to speak.
Now, observe the trie below, which contains two strings "act" and "ace".
.jpg)
Note that the node representing character c in the above trie, in a magnified sense would look as below:
What did you observe?
A common prefix of "ace" and "act" is "ac" and therefore we are having the same nodes until we traverse "ac" and then we create a new node for character e.
Therefore, we are not creating any new node until we need one and Trie is a very efficient data storage, when we have a large list of strings sharing common prefixes. It is also known as prefix tree.
Now, observe the trie below, which contains three strings "act", "ace" and "cat".
.jpg)
Let's see a proper algorithm to insert a string in a trie.
- Starting from the root, if there is already a node representing the corresponding character of a string, then simply traverse.
- Otherwise, create a new node representing the corresponding character.
- At the end of the string, set
isEndofStringto true in the last ending node.
void insert(trie_node* root, string s)
{
trie_node* temp = root;
int n = s.size();
for(int i = 0; i < n; i++){
if(temp->link[s[i]-'a'] == nullptr)
temp->link[s[i]-'a'] = new trie_node();
// Traverse using link
temp = temp->link[s[i]-'a'];
}
temp->isEndofString = true;
}
Time Complexity: O(N), where N is the length of the string we are inserting.
Searching in Trie
Can you figure out, how can we check whether the given string is present in trie or not, from whatever we have discussed so far?
For example, if you are searching "aco" in the trie below, then how will you do?
Can you see, why isEndofString is needed?
Observe the trie given below and try to search whether "on" is present or not.
.jpg)
If you don't have isEndofString variable, then you will not be able to correctly check whether on is present or not. Because it is the prefix of once.
Algorithm:
- Starting from the root, try to traverse the corresponding character of the string. If a link is present, then go ahead.
- Otherwise, simply given string is not present in the trie.
- If you are successfully able to traverse all corresponding characters of the string, then check whether the query string is present or not via
isEndofStringvariable of the last node.
bool search(trie_node* root, string s)
{
trie_node* temp = root;
int n = s.size();
for(int i = 0; i < n; i++){
// There is not further link
if(temp->link[s[i]-'a'] == nullptr)
return false;
temp = temp->link[s[i]-'a'];
}
return temp->isEndofString;
}
Can you find recursive version of the above function?
Recursive version:
// @param: root -> root of the trie
// @param: s -> the string we are deleting
// @param: i -> index of s currently reached via recursive traversal
bool Rec_search(trie_node* root, string& s, int i = 0)
{
// No link present
// so string is not present
if(root == nullptr)
return false;
if(i == s.size()) {
// present
if(root->isEndofString)
return true;
else
return false;
}
// Recusively traverse using links
return Rec_search(root->link[s[i]-'a'], s, i+1);
}
Time Complexity: O(N), where N is the length of the string we are searching for.
Delete
How will you delete "ace" from the trie below?
Things to take care about while you are deleting a string from the trie,
- It should not affect any other string present in the trie.
- Therefore, we are only going to delete the nodes which are present only due to the presence of the given string. And no other string is passing through them.
We are going to use a recursive procedure. If the string is not present, then we will return false and true otherwise. Recursive procedure for delete is a modified version of the recursive search procedure and therefore make sure you understand that.
Can you figure it out on your own?
Procedure:
- We are traversing the trie recursively, the same way as in
Rec_search()procedure. - While traversing, if we find that no link is present(
root == nullptr) for the current character, then the string is not present in the trie and returnfalse. - If we are successfully able to traverse the whole string until
i==s.size(), then finally checkisEndofStringof the last node. If the string is present(isEndofString = true), then set it tofalseand returntrue. Otherwise, returnfalse-not present. - Now, while backtracking stage of the recursion, delete nodes if it is no longer needed after deletion of the given string.
Now, go through the code below with very intuitive comments.
// Checks whether any link is present
bool isEmptyNode(trie_node* node)
{
for(auto i:node->link)
if(i != nullptr)
return false;
return true;
}
// Returns true if the string is successfully deleted
// And if the string is not present in the trie then returns false.
bool deleteString(trie_node* root, string& s, int i = 0)
{
if(root == nullptr)
return false;
if(i == s.size()) {
// present
if(root->isEndofString) {
// delete it
root->isEndofString = false;
return true;
}
else
return false;
}
bool ans = deleteString(root->link[s[i]-'a'], s, i+1);
// String is present
if(ans) {
// Check whether any other string
// passes through this link node
// If not passing, then delete it
if(isEmptyNode(root->link[s[i]-'a'])) {
// Deallocate used memory
delete root->link[s[i]-'a'];
root->link[s[i]-'a'] = nullptr;
}
return true;
}
// Not present the return false
return false;
}
Time Complexity: O(N), where N is the length of the string we are deleting.
Trie as an array
The availability of dynamic arrays allows us to create Trie without using pointers.
Now, we are going to store trie as a dynamic array of TrieNodes. In this implementation, we are going to use an array of integers instead of pointers in TrieNode and as a link, we are going to store the index of a node rather than the address of a node in the former case.
See the below implementation of trie as an array, which is quite similar and intuitive as the previous implementation.
struct TrieNode
{
vector<int> id_link;
bool isEndofString;
TrieNode(bool end = false)
{
end = isEndofString;
id_link.assign(26,-1);
}
};
void insert(vector<TrieNode>& trie, string s)
{
int temp = 0;
int n = s.size();
for(int i = 0; i < n; i++) {
if(trie[temp].id_link[s[i]-'a'] == -1) {
trie[temp].id_link[s[i]-'a'] = (int)trie.size();
trie.push_back(TrieNode());
}
temp = trie[temp].id_link[s[i]-'a'];
}
trie[temp].isEndofString = true;
}
bool search(vector<TrieNode>& trie, string s)
{
int temp = 0;
int n = s.size();
for(int i = 0; i < n; i++) {
if(trie[temp].id_link[s[i]-'a'] == -1)
return false;
temp = trie[temp].id_link[s[i]-'a'];
}
return trie[temp].isEndofString;
}
But it has a downside that you can not generally delete strings present in the trie. Why?
Try deleting a single node(other than last one), you will realize that indexes of each subsequent node will change, and also deleting in an array has a very bad performance.
It is an easy implementation, but with a single downside. Therefore, use as per the requirement.
Count the total number of words present in a Trie
How will you find the number of words(strings) present in the trie below?
Ultimately, It means to find the total number of nodes having true value of isEndofString. Which can be easily done using recursive traversal of all the nodes present in the trie.
The basic idea of the recursive procedure is as follow:
Start from the \text{root} node and go through all 26 positions of the link array. For each not-null link, recursively call countWords() considering that linked node as a \text{root}. And therefore formula will be as below:
\text{TotalWords} = \text{TotalWords} + \text{countWords}(link_i), do it for all not-null links.
Finally, add 1 to \text{TotalWords} if the current node has isEndofString = true.
int countWords(trie_node* root)
{
int total = 0;
if(root == nullptr)
return 0;
for(auto i:root->link)
if(i != nullptr)
total += countWords(i);
total += root->isEndofString;
return total;
}
Time complexity: O(\text{Number of nodes present in the trie}), as we are visiting each and every node.
Space complexity: O(1)
Print all words stored in Trie
It is similar to finding the total number of words but instead of adding 1 for each isEndofString's true value, we are going to store the word representing that particular end.
The code is similar to finding the total number of words.
void printAllWords(trie_node* root, vector<string>& ans, string s="")
{
if(root == nullptr)
return;
for(int i = 0; i < alphabet_size; i++) {
if(root->link[i] != nullptr) {
char c = 'a' + i;
string temp = s;
temp += c;
printAllWords(root->link[i], ans, temp);
}
}
if(root->isEndofString)
ans.push_back(s);
}
Time complexity: O(\text{Number of nodes present in the trie}), as we are visiting each and every node.
Space Complexity: O(\text{Total length of all words present in the trie})
Auto-suggestion features
How will you design the autocompletion feature using Trie?
For example, we have stored C++ keywords in a trie. Now, when you type "n" it should show all keywords starting from "n". For simplicity, only keywords starting from "n" are shown in the trie below,
.jpg)
How will you print all keywords starting from "n"? OR how will you print all keywords having "n" as a prefix?
Simply use printAllWords() on node n, and the problem is solved!
A common procedure is as below:
-
Traverse nodes in trie according to the given uncomplete string
s. If we are successfully able to traverses, then there are keywords having a prefix ofs. Otherwise, there will be nothing to suggest. -
Now, use
printAllWords()considering the last node(after traversal of trie according tos) as a root.
void autocomplete(trie_node* root, string s)
{
int n = s.size();
trie_node* temp = root;
for(int i = 0; i < n; i++) {
if(temp->link[s[i]-'a'] == nullptr)
return;
temp = temp->link[s[i]-'a'];
}
vector<string> suggest;
printWords(temp, suggest, s);
for(auto i:suggest)
cout << i << endl;
/*
OR
printWords(temp, suggest);
for(auto i:suggest)
cout << s << i << endl;
*/
}
Time complexity: O(\text{Length of S + Total length of all suggestions excluding common prefix(S) from all}), where s is the string you want suggestions for.
Space complexity: O(\text{Total length of all possible suggestions})
It is a widely used feature, as discussed at the start of the article.
There is also something called "Ternary Search Tree". When each node in the trie has most of its links used(having many similar prefix words), a trie is substantially more space-efficient and time-efficient than the ternary search tree.
But, If each node stores a few links, then the ternary search tree is much more space-efficient, because we are using 26 pointers in each node of trie and many of them may be unused.
Therefore, use as per the requirements.
Dictionary using Trie
What are the common features of an English dictionary?
- Efficient Lookup of words
- As the dictionary is very large, Lesser memory usages
Hashtable can be used to implement a dictionary. After precomputation of hash for each word in O(M), where M is the total length of all words in the dictionary, we can have efficient lookups if we design a very efficient hashtable.
But as the dictionary is very large there will be collisions between two or more words. Still, you can design a hash table to have efficient look-ups.
But space usages is very high, as we simply store each word. But what if we design it using a trie?
As in a dictionary we have many common-prefix words, trie will save a substantial amount of memory consumption. Trie supports look-up in O(\text{word length}), which is higher than a very efficient hash table.
Other advantages of the trie are as below:
- Auto-complete feature
- It also supports ordered traversal of words with given prefix
- No need for complex hash functions
So, if you want some of the above features then using trie is good for you. Also, we don't have to deal with collisions.
Note that in the dictionary along with a word, we have explanations or meanings of that word. That can be handled by separately maintaining an array that stores all those extra stuff. Then store one integer in the TrieNode structure to store the index of the corresponding data in the array.
struct trie_node
{
// Array of pointers of type
// trie_node
vector<trie_node*> links;
bool isEndofString;
// To store id of data
int idOfData;
};
The below image shows a typical trie structure for the dictionary.
