# Print all possible joints of a Trie constructed from a given list of strings

Given a set of strings str, the task is to print all the joints of the Trie constructed from the given set of strings.

Joints of a Trie is the nodes in a trie that have more than one child.

Examples:

```Input:
str = {"cat", "there", "caller",
"their", "calling"}
Output: l, a, e
Explanation:
root
/     \
c       t
|       |
a       h
/ |       |
t  l       e
|       | \
l       i   r
| \     |   |
e  i    r   e
|  |
r  n
|
g

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:
Follow the steps given below to solve the problem:

• Traverse the Trie, and take a currChild variable as zero.
• Increment the currChild by 1, when the current node has a child and while returning from current node check if currChild is greater than 1 or not. If so, print this character or joint. Otherwise, skip to next character.

Below is the implementation of the above approach:

## C++

 `// C++ program to print all the ` `// joints of a Trie constructed ` `// from a given set of strings ` ` `  `#include ` `using` `namespace` `std; ` `#define CHILDREN 26 ` `#define MAX 100 ` ` `  `// Trie node ` `struct` `trie { ` `    ``trie* child[CHILDREN]; ` `    ``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++) { ` `        ``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 Joints of trie ` `void` `display(trie* root, trie* itr, ` `             ``char` `str[], ``int` `level) ` `{ ` `    ``// Count current child ` `    ``int` `currChild = 0; ` ` `  `    ``for` `(``int` `i = 0; i < CHILDREN; i++) ` ` `  `    ``{ ` `        ``// Check for NON NULL child is found ` `        ``// add parent key to str and ` `        ``// call the display function ` `        ``// recursively for child node ` `        ``if` `(itr->child[i]) { ` `            ``str[level] = i + ``'a'``; ` `            ``display(root, itr->child[i], ` `                    ``str, level + 1); ` `            ``currChild++; ` `        ``} ` `    ``} ` ` `  `    ``// Print character if it has more ` `    ``// than 1 child ` `    ``if` `(currChild > 1 && itr != root) { ` `        ``cout << str[level - 1] << endl; ` `    ``} ` `} ` ` `  `// Function call for displaying Joint ` `void` `displayJoint(trie* root) ` `{ ` `    ``int` `level = 0; ` `    ``char` `str[MAX]; ` `    ``display(root, root, str, level); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``trie* root = createNode(); ` `    ``vector s = { ``"geek"``, ``"geeky"``, ` `                         ``"geeks"``, ``"gel"` `}; ` ` `  `    ``for` `(string str : s) { ` `        ``insert(root, str); ` `    ``} ` ` `  `    ``displayJoint(root); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to print all the ` `// joints of a Trie constructed ` `// from a given set of Strings ` `import` `java.util.*; ` ` `  `class` `GFG{ ` `static` `final` `int` `CHILDREN = ``26``; ` `static` `final` `int` `MAX = ``100``; ` ` `  `// Trie node ` `static` `class` `trie  ` `{ ` `    ``trie []child = ``new` `trie[CHILDREN]; ` `    ``boolean` `endOfWord; ` `}; ` ` `  `// 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++)  ` `    ``{ ` `        ``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 Joints of trie ` `static` `void` `display(trie root, trie itr, ` `                    ``char` `str[], ``int` `level) ` `{ ` `    ``// Count current child ` `    ``int` `currChild = ``0``; ` ` `  `    ``for` `(``int` `i = ``0``; i < CHILDREN; i++) ` `    ``{ ` `        ``// Check for NON null child is found ` `        ``// add parent key to str and ` `        ``// call the display function ` `        ``// recursively for child node ` `        ``if` `(itr.child[i] != ``null``)  ` `        ``{ ` `            ``str[level] = (``char``) (i + ``'a'``); ` `            ``display(root, itr.child[i], ` `                    ``str, level + ``1``); ` `            ``currChild++; ` `        ``} ` `    ``} ` ` `  `    ``// Print character if it has more ` `    ``// than 1 child ` `    ``if` `(currChild > ``1` `&& itr != root) ` `    ``{ ` `        ``System.out.print(str[level - ``1``] + ``"\n"``); ` `    ``} ` `} ` ` `  `// Function call for displaying Joint ` `static` `void` `displayJoint(trie root) ` `{ ` `    ``int` `level = ``0``; ` `    ``char` `[]str = ``new` `char``[MAX]; ` `    ``display(root, root, str, level); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``trie root = createNode(); ` `    ``String []s = { ``"geek"``, ``"geeky"``, ` `                   ``"geeks"``, ``"gel"` `}; ` ` `  `    ``for` `(String str : s)  ` `    ``{ ` `        ``insert(root, str); ` `    ``} ` ` `  `    ``displayJoint(root); ` `} ` `} ` ` `  `// This code is contributed by sapnasingh4991 `

## C#

 `// C# program to print all the ` `// joints of a Trie constructed ` `// from a given set of Strings ` `using` `System; ` ` `  `class` `GFG{ ` `     `  `static` `readonly` `int` `CHILDREN = 26; ` `static` `readonly` `int` `MAX = 100; ` ` `  `// Trie node ` `class` `trie  ` `{ ` `    ``public` `trie []child = ``new` `trie[CHILDREN]; ` `    ``public` `bool` `endOfWord; ` `}; ` ` `  `// 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++)  ` `    ``{ ` `       ``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 Joints of trie ` `static` `void` `display(trie root, trie itr, ` `                    ``char` `[]str, ``int` `level) ` `{ ` `     `  `    ``// Count current child ` `    ``int` `currChild = 0; ` ` `  `    ``for``(``int` `i = 0; i < CHILDREN; i++) ` `    ``{ ` `        `  `       ``// Check for NON null child is found ` `       ``// add parent key to str and ` `       ``// call the display function ` `       ``// recursively for child node ` `       ``if` `(itr.child[i] != ``null``)  ` `       ``{ ` `           ``str[level] = (``char``)(i + ``'a'``); ` `           ``display(root, itr.child[i],  ` `                   ``str, level + 1); ` `           ``currChild++; ` `       ``} ` `    ``} ` ` `  `    ``// Print character if it has more ` `    ``// than 1 child ` `    ``if` `(currChild > 1 && itr != root) ` `    ``{ ` `        ``Console.Write(str[level - 1] + ``"\n"``); ` `    ``} ` `} ` ` `  `// Function call for displaying Joint ` `static` `void` `displayJoint(trie root) ` `{ ` `    ``int` `level = 0; ` `    ``char` `[]str = ``new` `char``[MAX]; ` `    ``display(root, root, str, level); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``trie root = createNode(); ` `    ``String []s = { ``"geek"``, ``"geeky"``, ` `                   ``"geeks"``, ``"gel"` `}; ` ` `  `    ``foreach``(String str ``in` `s)  ` `    ``{ ` `        ``insert(root, str); ` `    ``} ` ` `  `    ``displayJoint(root); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```k
e
```

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.

Improved By : sapnasingh4991, Rajput-Ji