Insertion in a Trie recursively

Trie is an efficient information retrieval data structure. Using Trie, search complexities can be brought to an optimal limit (key length).

Given multiple strings. The task is to insert the string in a Trie using recursion.

Examples:

Input : str = {"cat", "there", "caller", "their", "calling"}
Output : caller
         calling
         cat
         there
         their

                                       root
                                      /     \    
                                     c       t     
                                     |       |     
                                     a       h     
                                     | \     |     
                                     l  t    e      
                                     |       |  \
                                     l       i   r
                                     | \     |   |
                                     e  i    r   e
                                     |  |
                                     r  n
                                        |
                                        g 

Input : str = {"Candy", "cat", "Caller", "calling"}
Output : caller
         calling
         candy
         cat
                                        root
                                         |    
                                         c            
                                         |            
                                         a            
                                      /   | \        
                                     l    n  t       
                                     |    |       
                                     l    d       
                                     | \  |      
                                     e  i y      
                                     |  |
                                     r  n
                                        |
                                        g 

Approach: An efficient approach is to treat every character of the input key as an individual trie node and insert it into the trie. Note that the children are an array of pointers (or references) to next level trie nodes. The key character acts as an index into the array of children. If the input key is new or an extension of the existing key, we need to construct non-existing nodes of the key, and mark end of the word for the last node. If the input key is a prefix of the existing key in Trie, we simply mark the last node of the key as the end of a word. The key length determines Trie depth.

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

#include<bits/stdc++.h>
using namespace std;
# define CHILDREN 26
# define MAX 100
  
// Trie node
struct trie
{
    trie *child[CHILDREN];
    // endOfWord is true if the node represents 
    // end of a word 
    bool endOfWord;
};
  
// Function will return the new node(initialized to NULLs)
trie* createNode()
{
    trie *temp = new trie();
    temp->endOfWord = false;
    for(int i=0 ; i<CHILDREN ; i++)
    {
            //Initially , initialize null to the all child
        temp->child[i] = NULL;
    }
    return temp;
}
  
// Function will inert the string in a trie recursively
void insertRecursively(trie* itr, string str, int i)
{
    if(i < str.length())
    {
        int index = str[i] - 'a';
        if(itr->child[index] == NULL )
        {
                        //Create a new node
            itr->child[index] = createNode();
        }
            // Recursive call for insertion of string
        insertRecursively(itr->child[index], str, i+1);
    }
    else
    {
                // Make the endOfWord true which represents
                // the end of string
        itr->endOfWord = true;
    }
}
  
// Function call to insert a string
void insert(trie* itr, string str)
{
        // Function call with necessary arguments
    insertRecursively(itr, str, 0);
  
}
  
// Function to check whether the node is leaf or not
bool isLeafNode(trie* root)
{
    return root->endOfWord != false;
}
  
// Function to display the content of trie 
void displayContent(trie* root, char str[], int level)
{
    // If node is leaf node, it indicates end
    // of string, so a null character is added
    // and string is displayed
    if (isLeafNode(root))
    {
            // Assign a null character in temporary string 
        str[level] = '\0';
        cout << str << endl;
    }
  
    for (int i = 0; i < CHILDREN; i++)
    {
        // If NON NULL child is found
        // add parent key to str and
        // call the display function recursively
        // for child node
        if (root->child[i])
        {
            str[level] = i + 'a';
            displayContent(root->child[i], str, level + 1);
        }
    }
}
  
// Function call for displaying content 
void display(trie* itr)
{
    int level = 0;
    char str[MAX];
  
    // Function call with necessary arguments
    displayContent(itr, str, level);
}
  
// Driver code
int main()
{
    trie *root = createNode();
    insert(root, "thier"); 
    insert(root, "there");
    insert(root, "answer");
    insert(root, "any");
  
      
    /* After inserting strings, trie will look like
                                        root
                                        / \ 
                                        a     t     
                                        |     |     
                                        n     h     
                                        | \ | 
                                        s y e     
                                        |     | \ 
                                        w     i r
                                        |     | |
                                        e     r e
                                        |     
                                        
    */    
      
    display(root);
  
    return 0;    

chevron_right


Output:

answer
any
there
their


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : Akanksha_Rai