Trie | (Display Content) - GeeksforGeeks

07 Mar, 2022
Trie is an efficient information retrieval data structure. In our previous post on trie we have discussed about basics of trie and how to insert and search a key in trie. In this post we will discuss about displaying all of the content of a trie. That is, to display all of the keys present in the Trie.Examples:  
Input: If Trie is      root
                    /   \    \
                    t   a     b
                    |   |     |
                    h   n     y
                    |   |  \  |
                    e   s  y  e
                 /  |   |
                 i  r   w
                 |  |   |
                 r  e   e
                        |
                        r
Output: Contents of Trie:
        answer
        any
        bye
        their
        there
 
The idea to do this is to start traversing from the root node of trie, whenever we find a NON-NULL child node, we add parent key of child node in the “string str” at the current index(level) and then recursively call the same process for the child node and same goes on till we find the node which is a leafnode, which actually marks the end of the string. Below is the C++ implementation of above idea:  
CPP
Python3
// CPP program to display content of Trie#include <iostream>#include <string.h>#define alpha_size 26#define ARRAY_SIZE(a) sizeof(a) / sizeof(a[0]) using namespace std; // Trie nodestruct TrieNode{    struct TrieNode* children[alpha_size];     bool isLeaf;}; // Returns new trie node (initialized to NULLs)struct TrieNode* createNode(){    struct TrieNode* pNode = new TrieNode;     for (int i = 0; i < alpha_size; i++)        pNode->children[i] = NULL;     pNode->isLeaf = false;     return pNode;}; // function to insert a node in Trievoid insert_node(struct TrieNode* root, char* key){    int level;    int length = strlen(key);    struct TrieNode* pCrawl = root;     for (level = 0; level < length; level++)    {        int index = key[level] - 'a';         if (pCrawl->children[index] == NULL)            pCrawl->children[index] = createNode();         pCrawl = pCrawl->children[index];    }     pCrawl->isLeaf = true;} // function to check if current node is leaf node or notbool isLeafNode(struct TrieNode* root){    return root->isLeaf != false;} // function to display the content of Trievoid display(struct TrieNode* 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))    {        str[level] = '\0';        cout << str << endl;    }     int i;    for (i = 0; i < alpha_size; i++)    {        // if NON NULL child is found        // add parent key to str and        // call the display function recursively        // for child node        if (root->children[i])        {            str[level] = i + 'a';            display(root->children[i], str, level + 1);        }    }} // Driver program to test above functionsint main(){    // Keys to be inserted in Trie    char keys[][8] = { "the", "a", "there", "answer",                       "any", "by", "bye", "their" };     struct TrieNode* root = createNode();     // Inserting keys in Trie    for (int j = 0; j < ARRAY_SIZE(keys); j++)        insert_node(root, keys[j]);     int level = 0;    char str[20];     // Displaying content of Trie    cout << "Content of Trie: " << endl;    display(root, str, level);}
##Display words in a trie (recursive approach)class TrieNode:    def __init__(self):        self.children=[None]*26        self.isEndOfWord=False         class Trie:    def __init__(self):        self.root=self.getNode()             def getNode(self):        return TrieNode()         def _charToIndex(self,ch):        return ord(ch)-ord('a')         def search(self,key):        pCrawl=self.root        length=len(key)        for level in range(length):            index=self._charToIndex(key[level])            if not pCrawl.children[index]:                return False            pCrawl=pCrawl.children[index]                     return pCrawl.isEndOfWord         def insert(self,key):        pCrawl=self.root        length=len(key)        for level in range(length):            index=self._charToIndex(key[level])            if not pCrawl.children[index]:                pCrawl.children[index]=self.getNode()                             pCrawl=pCrawl.children[index]                     pCrawl.isEndOfWord=True             def delete(self,key):        queue=[]        pCrawl=self.root        prev=self.root        length=len(key)        for level in range(length):            index=self._charToIndex(key[level])            if not pCrawl.children[index]:                return            if pCrawl.isEndOfWord:                queue.append([pCrawl,level])                             pCrawl=pCrawl.children[index]                     if pCrawl.isEndOfWord == False:            return        ##If is a prefix of another tree, just change leaf        flag=False        for i in range(26):            if pCrawl.children[index]:                flag=True        if flag:            pCrawl.isEndOfWord==False            return        ##If not a prefix but a tree longer than others, delete until isEndOfWord == True again/reach root(a unique trie)        if len(queue)==0:            index=self._charToIndex(key[0])            self.root.children[index]=None            return        pCrawl,level=queue.pop()        index=self._charToIndex(key[level])        pCrawl.children[index]=None             def haschild(self,node):        for i in range(26):            if node.children[i]:                return True        return False         def displayUtil(self,visited,node,str):        index=0        while index<26:            if node.children[index]:                str+=chr(97+index)                #print(2,str)                if node.children[index].isEndOfWord == False:                    self.displayUtil(visited,node.children[index],str)                    str=str[0len(str)-1)]                else:                    if str not in visited:                        visited.append(str)                    if self.haschild(node.children[index]):                        self.displayUtil(visited,node.children[index],str)                        str=str[0len(str)-1)]                                 index+=1         def display(self):        visited=[]        str=''        self.displayUtil(visited,self.root,str)        print("Content of Trie:")        for i in range(len(visited)):            print(visited[i])                                keys = ["the","a","there","bye","any",            "by","their","answer"]output = ["Not present in trie","Present in trie"]t=Trie()for key in keys:    t.insert(key) t.display() #This code is contributed by Zhaoxin Ban
Output:  
Content of Trie:
a
answer
any
by
bye
the
their
there
NOTE: The above algorithm displays the content of Trie in Lexicographically Sorted order.Some useful applications of Trie are:  
Implementing Auto-Correct and Auto complete Features
Implementing a Dictionary
This article is contributed by Yash Singla. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
ManasChhabra2
banzhaoxin24
simranarora5sos
Trie
Advanced Data Structure
Trie
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Ordered Set and GNU C++ PBDS
Red-Black Tree | Set 2 (Insert)
Disjoint Set Data Structures
Design a data structure that supports insert, delete, search and getRandom in constant time
Binary Indexed Tree or Fenwick Tree
Insert Operation in B-Tree
Design a Chess Game
Binomial Heap
2-3 Trees | (Search, Insert and Deletion)
Red-Black Tree | Set 3 (Delete)