Print Strings In Reverse Dictionary Order Using Trie

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

Given an array of strings. The task is to print all strings in reverse dictionary order using Trie. If there are duplicates in the input array, we need to print them only once.

Examples:

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

                                       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: cat
        candy
        calling
        caller
                                        root
                                         |    
                                         c            
                                         |            
                                         a            
                                      /   | \        
                                     l    n  t       
                                     |    |       
                                     l    d       
                                     | \  |      
                                     e  i y      
                                     |  |
                                     r  n
                                        |
                                        g 

Approach:

To solve the problem mentioned above, first, construct a Trie using all strings then print a string of rightmost subtree from top to bottom then print a string of second right subtree from top to bottom then print for third right subtree and so on. It is similar to preorder traversal of a tree from right to left.



Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ programm to print array of string
// in reverse dictionary order using trie
  
#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 NULL
trie* createNode()
{
    trie* temp = new trie();
  
    temp->endOfWord = false;
  
    for (int i = 0; i < CHILDREN; i++) {
  
        // Initialize null to the all child
        temp->child[i] = NULL;
    }
    return temp;
}
  
// Function will insert 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 = CHILDREN - 1; i >= 0; i--) {
  
        // check 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];
  
    displayContent(itr, str, level);
}
  
// Driver code
int main()
{
    trie* root = createNode();
    insert(root, "their");
    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:

there
their
any
answer

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




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.