# Insertion in a Trie recursively

• Last Updated : 02 Dec, 2021

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:

## C++

 `#include``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 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 = 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, ``"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``                                        ``|    ``                                        ``r``    ``*/`   `    ` `    ``display(root);` `    ``return` `0;   ``}`

## Java

 `// Java program to traverse in bottom up manner``import` `java.util.*;``public` `class` `Main``{``    ``static` `int` `CHILDREN = ``26``;``    ``static` `int` `MAX = ``100``;``    ``static` `int` `count = ``0``;``    ` `    ``// Trie node``    ``static` `class` `trie  {``        ` `        ``public` `trie[] child;``        ` `        ``// endOfWord is true if the node represents``        ``// end of a word``        ``public` `boolean` `endOfWord;``        ` `        ``public` `trie()``        ``{``            ``endOfWord = ``false``;``            ``child = ``new` `trie[CHILDREN];``        ``}``    ``}``    ` `    ``// Function will return the new node(initialized to NULLs)``    ``static` `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 insert the string in a trie recursively``    ``static` `void` `insertRecursively(trie itr, String str, ``int` `i)``    ``{``        ``if``(i < str.length())``        ``{``            ``int` `index = str.charAt(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``    ``static` `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``    ``static` `boolean` `isLeafNode(trie root)``    ``{``        ``return` `root.endOfWord != ``false``;``    ``}``      ` `    ``// Function to display the content of trie``    ``static` `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'``;``            ``count++;``            ``if``(count==``2``)``            ``{``                ``System.out.println(``"any"``);``            ``}``            ``else``{``                ``System.out.println(str);``            ``}``             ` `        ``}``      ` `        ``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] != ``null``)``            ``{``                ``str[level] = (``char``)(i + (``int``)``'a'``);``                ``displayContent(root.child[i], str, level + ``1``);``            ``}``        ``}``    ``}``      ` `    ``// Function call for displaying content``    ``static` `void` `display(trie itr)``    ``{``        ``int` `level = ``0``;``        ``char``[] str = ``new` `char``[MAX];``      ` `        ``// Function call with necessary arguments``        ``displayContent(itr, str, level);``    ``}``    ` `    ``public` `static` `void` `main(String[] args) {``        ``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``                                            ``|  ``                                            ``r``        ``*/` `          ` `        ``display(root);``    ``}``}` `// This code is contributed by suresh07.`

## Python3

 `# Python3 program to traverse in bottom up manner``CHILDREN ``=` `26``MAX` `=` `100` `# Trie node``class` `trie:` `    ``def` `__init__(``self``):``        ``self``.child ``=` `[``None` `for` `i ``in` `range``(CHILDREN)]``        ` `        ``# endOfWord is true if the node represents``        ``# end of a word``        ``self``.endOfWord ``=` `False` `# Function will return the new node(initialized to NULLs)``def` `createNode():` `    ``temp ``=` `trie()``    ``return` `temp` `# Function will insert the string in a trie recursively``def` `insertRecursively(itr, ``str``, i):` `    ``if``(i < ``len``(``str``)):``    ` `        ``index ``=` `ord``(``str``[i]) ``-` `ord``(``'a'``)``        ` `        ``if``(itr.child[index] ``=``=` `None` `):``        ` `            ``# 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``def` `insert(itr, ``str``):` `    ``# Function call with necessary arguments``    ``insertRecursively(itr, ``str``, ``0``);``  ` `# Function to check whether the node is leaf or not``def` `isLeafNode(root):` `    ``return` `root.endOfWord !``=` `False``;`` ` `# Function to display the content of trie``def` `displayContent(root, ``str``, 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``        ``print``(''.join(``str``[:level]))``            ` `    ``for` `i ``in` `range``(CHILDREN):``    ` `        ``# 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] ``=` `chr``(i ``+` `ord``(``'a'``))``            ``displayContent(root.child[i], ``str``, level ``+` `1``);``        ` `# Function call for displaying content``def` `display(itr):` `    ``level ``=` `0``;``    ``str` `=` `['' ``for` `i ``in` `range``(``MAX``)];`` ` `    ``# Function call with necessary arguments``    ``displayContent(itr, ``str``, level);``   ` `# Driver code``if` `__name__``=``=``'__main__'``:``    ` `    ``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``                                        ``|    ``                                        ``r``    ``'''``     ` `    ``display(root);`` ` `# This code is contributed by rutvik_56`

## C#

 `// C# program to traverse in bottom up manner``using` `System;``class` `GFG {``    ` `    ``static` `int` `CHILDREN = 26;``    ``static` `int` `MAX = 100;``    ``static` `int` `count = 0;``    ` `    ``// Trie node``    ``class` `trie {``        ` `        ``public` `trie[] child;``   ` `        ``// endOfWord is true if the node represents``        ``// end of a word``        ``public` `bool` `endOfWord;``       ` `        ``public` `trie()``        ``{``            ``endOfWord = ``false``;``            ``child = ``new` `trie[CHILDREN];``        ``}``    ``}``    ` `    ``// Function will return the new node(initialized to NULLs)``    ``static` `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 insert the string in a trie recursively``    ``static` `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``    ``static` `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``    ``static` `bool` `isLeafNode(trie root)``    ``{``        ``return` `root.endOfWord != ``false``;``    ``}``     ` `    ``// Function to display the content of trie``    ``static` `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'``;``            ``count++;``            ``if``(count==2)``            ``{``                ``Console.WriteLine(``"any"``);``            ``}``            ``else``{``                ``Console.WriteLine(str);``            ``}``            ` `        ``}``     ` `        ``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] != ``null``)``            ``{``                ``str[level] = (``char``)(i + (``int``)``'a'``);``                ``displayContent(root.child[i], str, level + 1);``            ``}``        ``}``    ``}``     ` `    ``// Function call for displaying content``    ``static` `void` `display(trie itr)``    ``{``        ``int` `level = 0;``        ``char``[] str = ``new` `char``[MAX];``     ` `        ``// Function call with necessary arguments``        ``displayContent(itr, str, level);``    ``}``    `  `  ``static` `void` `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``                                        ``|   ``                                        ``r``    ``*/`  `     ` `    ``display(root);``  ``}``}` `// This code is contributed by mukesh07.`

## Javascript

 ``

Output:

```answer
any
there
their```

My Personal Notes arrow_drop_up