Related Articles

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to print
// N-ary Tree graphically
 
#include <iostream>
#include <list>
#include <vector>
 
using namespace std;
 
// Structure of the node
struct tnode {
    int n;
    list<tnode*> 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation to print
// N-ary Tree graphically
 
import java.util.*;
 
class GFG{
 
// Structure of the node
static class tnode {
    int n;
    Vector<tnode> 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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<tnode> root = new List<tnode>();
   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

chevron_right


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 :