Skip to content
Related Articles
Open in App
Not now

Related Articles

Level Order Traversal of N-ary Tree

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 07 Feb, 2023
Improve Article
Save Article

Given an N-ary Tree. The task is to print the level order traversal of the tree where each level will be in a new line.

Examples:

Input:

Image

Output: 
1
3 2 4
5 6
Explanation: At level 1: only 1 is present.
At level 2: 3, 2, 4 is present
At level 3: 5, 6 is present

Input:

Image

Output:  
1
2 3 4 5
6 7 8 9 10
11 12 13
14
Explanation: For the above example there are 5 level present in the n-ary tree.
At level 1: only 1 is present.
At level 2: 2, 3, 4, 5 is present.
At level 3: 6, 7, 8, 9, 10 is present
At level 4:11, 12, 13 is present
At level 5 :- 14 is present

 

Approach 1: Using BFS 

The approach of the problem is to use Level Order Traversal and store all the levels in a 2D array where each of the levels is stored in a different row.

Follow the below steps to implement the approach:

  • Create a vector ans and temp to store the level order traversal of the N-ary tree.
  • Push the root node in the queue.
  • Run a while loop until the queue is not empty:
    • Determine the size of the current level which is the size of the queue (say N):
      • Run a loop for i = 1 to N
      • In each step delete the front node (say cur) and push its data to the temp as a part of the current level.
      • Push all the children of cur into the queue.
    • Push the temp into the final ans vector which stores the different levels in different rows.
  • Return the ans vector.

Below is the implementation of the above approach:

C++




// C++ code for above implementation
#include <bits/stdc++.h>
using namespace std;
 
struct Node {
    char val;
    vector<Node*> children;
};
 
// Utility function to create a new tree node
Node* newNode(int key)
{
    Node* temp = new Node;
    temp->val = key;
    return temp;
}
 
// Function for level order traversal for n-array tree
vector<vector<int> > levelOrder(Node* root)
{
    vector<vector<int> > ans;
    if (!root)
        cout << "N-Ary tree does not any nodes";
 
    // Create a queue namely main_queue
    queue<Node*> main_queue;
 
    // Push the root value in the main_queue
    main_queue.push(root);
 
    // Create a temp vector to store the all the node values
    // present at a particular level
    vector<int> temp;
 
    // Run a while loop until the main_queue is empty
    while (!main_queue.empty()) {
 
        // Get the front of the main_queue
        int n = main_queue.size();
 
        // Iterate through the current level
        for (int i = 0; i < n; i++) {
            Node* cur = main_queue.front();
            main_queue.pop();
            temp.push_back(cur->val);
            for (auto u : cur->children)
                main_queue.push(u);
        }
        ans.push_back(temp);
        temp.clear();
    }
    return ans;
}
 
// Driver code
int main()
{
    Node* root = newNode(1);
    root->children.push_back(newNode(3));
    root->children.push_back(newNode(2));
    root->children.push_back(newNode(4));
    root->children[0]->children.push_back(newNode(5));
    root->children[0]->children.push_back(newNode(6));
 
    // LevelOrderTraversal obj;
    vector<vector<int> > ans = levelOrder(root);
    for (auto v : ans) {
        for (int x : v)
            cout << x << " ";
        cout << endl;
    }
    return 0;
}
 
// This code is contributed by Aditya Kumar (adityakumar129)


Java




import java.util.*;
public class Main {
  static class Node {
 
    public int val;
    public Vector<Node> children;
    public Node(int key)
    {
      val = key;
      children = new Vector<Node>();
    }
  }
 
  // Utility function to create a new tree node
  static Node newNode(int key)
  {
    Node temp = new Node(key);
    return temp;
  }
 
  // Function for level order traversal for n-array tree
  static List<List<Integer> > levelOrder(Node root)
  {
    List<List<Integer> > ans = new ArrayList<>();
    if (root == null)
      System.out.println(
      "N-Ary tree does not any nodes");
 
    // Create one queue main_queue
    Queue<Node> main_queue = new LinkedList<>();
 
    // Push the root value in the main_queue
    main_queue.offer(root);
 
    // Traverse the N-ary Tree by level
    while (!main_queue.isEmpty()) {
      // Create a temp vector to store the all the
      // node values present at a particular level
      List<Integer> temp = new ArrayList<>();
      int size = main_queue.size();
      // Iterate through the current level
      for (int i = 0; i < size; i++) {
        Node node = main_queue.poll();
        temp.add(node.val);
 
        for (Node child : node.children) {
          main_queue.offer(child);
        }
      }
 
      ans.add(temp);
    }
 
    return ans;
  }
 
  // Utility function to print the level order traversal
  public static void printList(List<List<Integer> > temp)
  {
    for (List<Integer> it : temp) {
      for (Integer et : it)
        System.out.print(et + " ");
      System.out.println();
    }
  }
  public static void main(String[] args)
  {
    Node root = newNode(1);
    (root.children).add(newNode(3));
    (root.children).add(newNode(2));
    (root.children).add(newNode(4));
    (root.children.get(0).children).add(newNode(5));
    (root.children.get(0).children).add(newNode(6));
    List<List<Integer> > ans = levelOrder(root);
    printList(ans);
  }
}
 
// This code is contributed by Sania Kumari Gupta


Python3




# Python code for above implementation
class Node:
      
    def __init__(self, key):
          
        self.key = key
        self.child = []
    
 # Utility function to create a new tree node
def newNode(key):  
    temp = Node(key)
    return temp
      
# Prints the n-ary tree level wise
def LevelOrderTraversal(root):
  
    if (root == None):
        return;
    
    # Standard level order traversal code
    # using queue
    q = []  # Create a queue
    q.append(root); # Enqueue root
    while (len(q) != 0):
      
        n = len(q);
   
        # If this node has children
        while (n > 0):
          
            # Dequeue an item from queue and print it
            p = q[0]
            q.pop(0);
            print(p.key, end=' ')
    
            # Enqueue all children of the dequeued item
            for i in range(len(p.child)):
              
                q.append(p.child[i]);
            n -= 1
    
        print() # Print new line between two levels
 
if __name__ == '__main__':
    root = newNode(1);
    root.child.append(newNode(3));
    root.child.append(newNode(2));
    root.child.append(newNode(4));
    root.child[0].child.append(newNode(5));
    root.child[0].child.append(newNode(6));
  
    # LevelOrderTraversal obj;
    LevelOrderTraversal(root);
    
  # This code is contributed by poojaagarwal2.


Output

1 
3 2 4 
5 6 

Time Complexity: O(V) where V is the number of nodes
Auxiliary Space: O(V)

Approach 2: Using DFS 

The approach of the problem is to use Level Order Traversal using DFS and store all the levels in a 2D array where each of the levels is stored in a different row.

  • LevelOrder function will update ans with the current value, pushing it in with a new sub-vector if one matching the level is not present already into ans.
  • Function will increase level by 1;
  • It will call itself recursively on all the children;
  • It will backtrack level.

Below is the implementation of the above approach:

C++




// C++ code for above implementation
#include <bits/stdc++.h>
using namespace std;
 
vector<vector<int> > ans;
int level = 0;
 
struct Node {
    char val;
    vector<Node*> children;
};
 
Node* newNode(int key)
{
    Node* temp = new Node;
    temp->val = key;
    return temp;
}
 
void levelOrder(Node *root) {
        if (ans.size() == level) ans.push_back({root->val});
        else ans[level].push_back(root->val);
        level++;
        for (Node *n: root->children) levelOrder(n);
        level--;
    }
 
int main()
{
    Node* root = newNode(1);
    root->children.push_back(newNode(3));
    root->children.push_back(newNode(2));
    root->children.push_back(newNode(4));
    root->children[0]->children.push_back(newNode(5));
    root->children[0]->children.push_back(newNode(6));
  
    // LevelOrderTraversal obj;
    levelOrder(root);
    for (auto v : ans) {
        for (int x : v)
            cout << x << " ";
        cout << endl;
    }
    return 0;
}


Java




/*package whatever //do not write package name here */
 
import java.io.*;
import java.util.*;
public class GFG {
    static List<List<Integer> > result = new ArrayList<>();
    static int level = 0;
    static class Node {
 
        public int val;
        public Vector<Node> children;
        public Node(int key)
        {
            val = key;
            children = new Vector<Node>();
        }
    }
 
    // Utility function to create a new tree node
    static Node newNode(int key)
    {
        Node temp = new Node(key);
        return temp;
    }
 
    // method to find level order traversal of n-ary tree
    static void levelOrder(Node node)
    {
        if (node == null) {
            return;
        }
        List<Integer> list = result.size() > level
                                 ? result.get(level)
                                 : new ArrayList<>();
        // adding node value to the list
        list.add(node.val);
        if (result.size() <= level) {
            result.add(list);
        }
        // promoting/incrementing the level to next
        level++;
        for (Node n : node.children) {
            levelOrder(n);
        }
        level--;
    }
 
    // utility function to print level order traversal
    public static void printList(List<List<Integer> > temp)
    {
        for (List<Integer> it : temp) {
            for (Integer et : it)
                System.out.print(et + " ");
            System.out.println();
        }
    }
 
    public static void main(String[] args)
    {
        Node root = newNode(1);
        (root.children).add(newNode(3));
        (root.children).add(newNode(2));
        (root.children).add(newNode(4));
        (root.children.get(0).children).add(newNode(5));
        (root.children.get(0).children).add(newNode(6));
        levelOrder(root);
        printList(result);
    }
}


Python3




# Python code fore above implementation
ans = []
level = 0
 
class Node:
    def __init__(self, val):
        self.val = val
        self.children = []
 
def levelOrder(root):
    global level
    if len(ans) == level:
        ans.append([root.val])
    else:
        ans[level].append(root.val)
    level += 1
    for n in root.children:
        levelOrder(n)
    level -= 1
 
root = Node(1)
root.children.append(Node(3))
root.children.append(Node(2))
root.children.append(Node(4))
root.children[0].children.append(Node(5))
root.children[0].children.append(Node(6))
 
levelOrder(root)
for v in ans:
    for x in v:
        print(x, end=" ")
    print()
 
# This code is contributed by Tapesh(tapeshdua420)


Javascript




       // JavaScript code for the above approach
       const ans = [];
       let level = 0;
 
       class Node {
           constructor(val) {
               this.val = val;
               this.children = [];
           }
       }
 
       function levelOrder(root) {
           if (ans.length === level) ans.push([root.val]);
           else ans[level].push(root.val);
           level++;
           for (const n of root.children) levelOrder(n);
           level--;
       }
 
       // create tree
       const root = new Node(1);
       root.children.push(new Node(3));
       root.children.push(new Node(2));
       root.children.push(new Node(4));
       root.children[0].children.push(new Node(5));
       root.children[0].children.push(new Node(6));
 
       levelOrder(root);
       for (const v of ans) {
           for (const x of v) {
               console.log(x + " ");
           }
           console.log('<br>');
       }
 
// This code is contributed by Potta Lokesh


Output

1 
3 2 4 
5 6 

Time Complexity: O(V)
Auxiliary Space: O(V)


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!