Related Articles
Print N-ary tree graphically
• Last Updated : 18 Dec, 2020

Given an N-ary tree, the task is to print the N-ary tree graphically.
Graphical Representation of Tree: A representation of tree in which the root is printed in a line and the children nodes are printed in subsequenct lines with some amount of indentation.
Examples:

```Input:
0
/ | \
/  |  \
1   2   3
/ \    / | \
4   5  6  7  8
|
9
Output:
0
+--- 1
|    +--- 4
|    +--- 5
+--- 2
+--- 3
+--- 6
+--- 7
|    +--- 9
+--- 8```

Approach: The idea is to traverse the N-ary Tree using DFS Traversal to traverse the nodes and explore its children nodes until all the nodes are visited and then similarly, traverse the sibling nodes.
The step-by-step algorithm for the above approach is described below –

• Intialize a variable to store the current depth of the node, for root node the depth is 0.
• Declare a boolean array to store the current exploring depths and initially mark all of them to False.
• If the current node is a root node that is the depth of the node is 0, then simply print the data of the node.
• Otherwise, Iterate over a loop from 1 to the current depth of node and print, ‘|’ and three spaces for each of the exploring depth and for non-exploring depth print three spaces only.
• Print the current value of the node and move the output pointer to the next line.
• If the current node is the last node of that depth then mark that depth as non-exploring.
• Similarly, explore all the child nodes with the recursive call.

Below is the implementation of the above approcah:

C++

 `// C++ implementation to print` `// N-ary Tree graphically`   `#include ` `#include ` `#include `   `using` `namespace` `std;`   `// Structure of the node` `struct` `tnode { ` `    ``int` `n;` `    ``list root;` `    ``tnode(``int` `data)` `        ``: n(data)` `    ``{` `    ``}` `};`   `// Function to print the` `// N-ary tree graphically` `void` `printNTree(tnode* x,` `    ``vector<``bool``> flag, ` `    ``int` `depth = 0, ``bool` `isLast = ``false``)` `{` `    ``// Condition when node is None` `    ``if` `(x == NULL) ` `        ``return``;` `    `  `    ``// Loop to print the depths of the` `    ``// current node` `    ``for` `(``int` `i = 1; i < depth; ++i) {` `        `  `        ``// Condition when the depth ` `        ``// is exploring` `        ``if` `(flag[i] == ``true``) {` `            ``cout << ``"| "` `                ``<< ``" "` `                ``<< ``" "` `                ``<< ``" "``;` `        ``}` `        `  `        ``// Otherwise print ` `        ``// the blank spaces` `        ``else` `{` `            ``cout << ``" "` `                ``<< ``" "` `                ``<< ``" "` `                ``<< ``" "``;` `        ``}` `    ``}` `    `  `    ``// Condition when the current` `    ``// node is the root node` `    ``if` `(depth == 0)` `        ``cout << x->n << ``'\n'``;` `    `  `    ``// Condtion when the node is ` `    ``// the last node of ` `    ``// the exploring depth` `    ``else` `if` `(isLast) {` `        ``cout << ``"+--- "` `<< x->n << ``'\n'``;` `        `  `        ``// No more childrens turn it ` `        ``// to the non-exploring depth` `        ``flag[depth] = ``false``;` `    ``}` `    ``else` `{` `        ``cout << ``"+--- "` `<< x->n << ``'\n'``;` `    ``}`   `    ``int` `it = 0;` `    ``for` `(``auto` `i = x->root.begin(); ` `    ``i != x->root.end(); ++i, ++it)`   `        ``// Recursive call for the` `        ``// children nodes` `        ``printNTree(*i, flag, depth + 1, ` `            ``it == (x->root.size()) - 1);` `    ``flag[depth] = ``true``;` `}`   `// Function to form the Tree and ` `// print it graphically` `void` `formAndPrintTree(){` `    ``int` `nv = 10;` `    ``tnode r(0), n1(1), n2(2), ` `        ``n3(3), n4(4), n5(5),` `    ``n6(6), n7(7), n8(8), n9(9);` `    `  `    ``// Array to keep track ` `    ``// of exploring depths` `    ``vector<``bool``> flag(nv, ``true``);` `    `  `    ``// Tree Formation` `    ``r.root.push_back(&n1);` `    ``n1.root.push_back(&n4);` `    ``n1.root.push_back(&n5);` `    ``r.root.push_back(&n2);` `    ``r.root.push_back(&n3);` `    ``n3.root.push_back(&n6);` `    ``n3.root.push_back(&n7);` `    ``n7.root.push_back(&n9);` `    ``n3.root.push_back(&n8);`   `    ``printNTree(&r, flag);` `}`   `// Driver Code` `int` `main(``int` `argc, ``char` `const``* argv[])` `{` `    `  `    ``// Function Call` `    ``formAndPrintTree();` `    ``return` `0;` `}`

Java

 `// Java implementation to print` `// N-ary Tree graphically`   `import` `java.util.*;`   `class` `GFG{`   `// Structure of the node` `static` `class` `tnode { ` `    ``int` `n;` `    ``Vector root = ``new` `Vector<>();` `    ``tnode(``int` `data) ` `    ``{` `        ``this``.n = data;` `    ``}` `};`   `// Function to print the` `// N-ary tree graphically` `static` `void` `printNTree(tnode x,` `    ``boolean``[] flag, ` `    ``int` `depth, ``boolean` `isLast )` `{` `    ``// Condition when node is None` `    ``if` `(x == ``null``) ` `        ``return``;` `    `  `    ``// Loop to print the depths of the` `    ``// current node` `    ``for` `(``int` `i = ``1``; i < depth; ++i) {` `        `  `        ``// Condition when the depth ` `        ``// is exploring` `        ``if` `(flag[i] == ``true``) {` `            ``System.out.print(``"| "` `               ``+ ``" "` `               ``+ ``" "` `               ``+ ``" "``);` `        ``}` `        `  `        ``// Otherwise print ` `        ``// the blank spaces` `        ``else` `{` `            ``System.out.print(``" "` `               ``+ ``" "` `               ``+ ``" "` `               ``+ ``" "``);` `        ``}` `    ``}` `    `  `    ``// Condition when the current` `    ``// node is the root node` `    ``if` `(depth == ``0``)` `        ``System.out.println(x.n);` `    `  `    ``// Condtion when the node is ` `    ``// the last node of ` `    ``// the exploring depth` `    ``else` `if` `(isLast) {` `        ``System.out.print(``"+--- "` `+  x.n + ``'\n'``);` `        `  `        ``// No more childrens turn it ` `        ``// to the non-exploring depth` `        ``flag[depth] = ``false``;` `    ``}` `    ``else` `{` `        ``System.out.print(``"+--- "` `+  x.n + ``'\n'``);` `    ``}`   `    ``int` `it = ``0``;` `    ``for` `(tnode i : x.root) {` `         ``++it;` `      `  `        ``// Recursive call for the` `        ``// children nodes` `        ``printNTree(i, flag, depth + ``1``, ` `            ``it == (x.root.size()) - ``1``);` `    ``}` `    ``flag[depth] = ``true``;` `}`   `// Function to form the Tree and ` `// print it graphically` `static` `void` `formAndPrintTree(){` `    ``int` `nv = ``10``;` `    ``tnode r = ``new` `tnode(``0``);` `    ``tnode n1 = ``new` `tnode(``1``);` `    ``tnode n2 = ``new` `tnode(``2``);` `    ``tnode n3 = ``new` `tnode(``3``);` `    ``tnode n4 = ``new` `tnode(``4``);` `    ``tnode n5 = ``new` `tnode(``5``);` `    ``tnode n6 = ``new` `tnode(``6``);` `    ``tnode n7 = ``new` `tnode(``7``);` `    ``tnode n8 = ``new` `tnode(``8``);` `    ``tnode n9 = ``new` `tnode(``9``);` `    `  `    ``// Array to keep track ` `    ``// of exploring depths` `   `  `    ``boolean``[] flag = ``new` `boolean``[nv];` `    ``Arrays.fill(flag, ``true``);` `    `  `    ``// Tree Formation` `    ``r.root.add(n1);` `    ``n1.root.add(n4);` `    ``n1.root.add(n5);` `    ``r.root.add(n2);` `    ``r.root.add(n3);` `    ``n3.root.add(n6);` `    ``n3.root.add(n7);` `    ``n7.root.add(n9);` `    ``n3.root.add(n8);`   `    ``printNTree(r, flag, ``0``, ``false``);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``// Function Call` `    ``formAndPrintTree();` `}` `}`   `// This code is contributed by gauravrajput1`

C#

 `// C# implementation to print` `// N-ary Tree graphically` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{`   `// Structure of the node` `public` `class` `tnode ` `{ ` `   ``public`   `  ``int` `n;` `    ``public`   ` ``List root = ``new` `List();` `   ``public`   `  ``tnode(``int` `data) ` `  ``{` `     ``this``.n = data;` `  ``}` `};`   `// Function to print the` `// N-ary tree graphically` `static` `void` `printNTree(tnode x,` `                       ``bool``[] flag, ` `                       ``int` `depth, ``bool` `isLast )` `{` `  `  `    ``// Condition when node is None` `    ``if` `(x == ``null``) ` `        ``return``;` `    `  `    ``// Loop to print the depths of the` `    ``// current node` `    ``for` `(``int` `i = 1; i < depth; ++i)` `    ``{` `        `  `        ``// Condition when the depth ` `        ``// is exploring` `        ``if` `(flag[i] == ``true``)` `        ``{` `            ``Console.Write(``"| "` `               ``+ ``" "` `               ``+ ``" "` `               ``+ ``" "``);` `        ``}` `        `  `        ``// Otherwise print ` `        ``// the blank spaces` `        ``else` `        ``{` `            ``Console.Write(``" "` `               ``+ ``" "` `               ``+ ``" "` `               ``+ ``" "``);` `        ``}` `    ``}` `    `  `    ``// Condition when the current` `    ``// node is the root node` `    ``if` `(depth == 0)` `        ``Console.WriteLine(x.n);` `    `  `    ``// Condtion when the node is ` `    ``// the last node of ` `    ``// the exploring depth` `    ``else` `if` `(isLast)` `    ``{` `        ``Console.Write(``"+--- "` `+  x.n + ``'\n'``);` `        `  `        ``// No more childrens turn it ` `        ``// to the non-exploring depth` `        ``flag[depth] = ``false``;` `    ``}` `    ``else` `    ``{` `        ``Console.Write(``"+--- "` `+  x.n + ``'\n'``);` `    ``}`   `    ``int` `it = 0;` `    ``foreach` `(tnode i ``in` `x.root)` `    ``{` `         ``++it;` `      `  `        ``// Recursive call for the` `        ``// children nodes` `        ``printNTree(i, flag, depth + 1, ` `            ``it == (x.root.Count) - 1);` `    ``}` `    ``flag[depth] = ``true``;` `}`   `// Function to form the Tree and ` `// print it graphically` `static` `void` `formAndPrintTree()` `{` `    ``int` `nv = 10;` `    ``tnode r = ``new` `tnode(0);` `    ``tnode n1 = ``new` `tnode(1);` `    ``tnode n2 = ``new` `tnode(2);` `    ``tnode n3 = ``new` `tnode(3);` `    ``tnode n4 = ``new` `tnode(4);` `    ``tnode n5 = ``new` `tnode(5);` `    ``tnode n6 = ``new` `tnode(6);` `    ``tnode n7 = ``new` `tnode(7);` `    ``tnode n8 = ``new` `tnode(8);` `    ``tnode n9 = ``new` `tnode(9);` `    `  `    ``// Array to keep track ` `    ``// of exploring depths   ` `    ``bool``[] flag = ``new` `bool``[nv];` `    ``for``(``int` `i = 0; i < nv; i++)` `        ``flag[i] = ``true``;` `    `  `    ``// Tree Formation` `    ``r.root.Add(n1);` `    ``n1.root.Add(n4);` `    ``n1.root.Add(n5);` `    ``r.root.Add(n2);` `    ``r.root.Add(n3);` `    ``n3.root.Add(n6);` `    ``n3.root.Add(n7);` `    ``n7.root.Add(n9);` `    ``n3.root.Add(n8);`   `    ``printNTree(r, flag, 0, ``false``);` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    `  `    ``// Function Call` `    ``formAndPrintTree();` `}` `}`   `// This code is contributed by aashish1995 `

Output

```0
+--- 1
|    +--- 4
|    +--- 5
+--- 2
+--- 3
+--- 6
+--- 7
|    +--- 9
+--- 8```

Performance Analysis:

• Time Complexity: In the above-given approach, there is recusive call to explore all the vertices which takes O(V) time. Therefore, the time complexity for this approach will be O(V).
• Auxiliary Space Complexity: In the above-given approach, there is extra space used to store the exploring depths. Therefore, the auxiliary space complexity for the above approach will be O(V)

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
Recommended Articles
Page :