Open in App
Not now

# General Tree (Each node can have arbitrary number of children) Level Order Traversal

• Difficulty Level : Easy
• Last Updated : 14 Mar, 2023

Given a generic tree, perform a Level order traversal and print all of its nodes

Examples:

```Input :            10
/   /    \   \
2  34    56   100
/ \        |   / | \
77  88      1   7  8  9

Output : 10
2 34 56 100
77 88 1 7 8 9

Input :             1
/   /    \   \
2  3      4    5
/ \        |  /  | \
6   7       8 9  10  11
Output : 1
2 3 4 5
6 7 8 9 10 11```

The approach to this problem is similar to Level Order traversal in a binary tree. We Start with pushing root node in a queue and for each node we pop it, print it and push all its child in the queue.

In case of a generic tree we store child nodes in a vector. Thus we put all elements of the vector in the queue.

Implementation:

## C++

 `// CPP program to do level order traversal` `// of a generic tree` `#include ` `using` `namespace` `std;` ` `  `// Represents a node of an n-ary tree` `struct` `Node` `{` `    ``int` `key;` `    ``vectorchild;` `};` ` `  ` ``// Utility function to create a new tree node` `Node *newNode(``int` `key)` `{` `    ``Node *temp = ``new` `Node;` `    ``temp->key = key;` `    ``return` `temp;` `}`   `// Prints the n-ary tree level wise` `void` `LevelOrderTraversal(Node * root)` `{` `    ``if` `(root==NULL)` `        ``return``;` ` `  `    ``// Standard level order traversal code` `    ``// using queue` `    ``queue q;  ``// Create a queue` `    ``q.push(root); ``// Enqueue root ` `    ``while` `(!q.empty())` `    ``{` `        ``int` `n = q.size();`   `        ``// If this node has children` `        ``while` `(n > 0)` `        ``{` `            ``// Dequeue an item from queue and print it` `            ``Node * p = q.front();` `            ``q.pop();` `            ``cout << p->key << ``" "``;` ` `  `            ``// Enqueue all children of the dequeued item` `            ``for` `(``int` `i=0; ichild.size(); i++)` `                ``q.push(p->child[i]);` `            ``n--;` `        ``}` ` `  `        ``cout << endl; ``// Print new line between two levels` `    ``}` `}` ` `  `// Driver program` `int` `main()` `{` `    ``/*   Let us create below tree` `    ``*              10` `    ``*        /   /    \   \` `    ``*        2  34    56   100` `    ``*       / \         |   /  | \` `    ``*      77  88       1   7  8  9` `    ``*/` `    ``Node *root = newNode(10);` `    ``(root->child).push_back(newNode(2));` `    ``(root->child).push_back(newNode(34));` `    ``(root->child).push_back(newNode(56));` `    ``(root->child).push_back(newNode(100));` `    ``(root->child[0]->child).push_back(newNode(77));` `    ``(root->child[0]->child).push_back(newNode(88));` `    ``(root->child[2]->child).push_back(newNode(1));` `    ``(root->child[3]->child).push_back(newNode(7));` `    ``(root->child[3]->child).push_back(newNode(8));` `    ``(root->child[3]->child).push_back(newNode(9));` ` `  `    ``cout << ``"Level order traversal Before Mirroring\n"``;` `    ``LevelOrderTraversal(root);` `  `  `    ``return` `0;` `} `

## Java

 `// Java program to do level order traversal` `// of a generic tree` `import` `java.util.*;`   `class` `GFG ` `{`   `// Represents a node of an n-ary tree` `static` `class` `Node` `{` `    ``int` `key;` `    ``Vectorchild = ``new` `Vector<>();` `};`   `// Utility function to create a new tree node` `static` `Node newNode(``int` `key)` `{` `    ``Node temp = ``new` `Node();` `    ``temp.key = key;` `    ``return` `temp;` `}`   `// Prints the n-ary tree level wise` `static` `void` `LevelOrderTraversal(Node root)` `{` `    ``if` `(root == ``null``)` `        ``return``;`   `    ``// Standard level order traversal code` `    ``// using queue` `    ``Queue q = ``new` `LinkedList<>(); ``// Create a queue` `    ``q.add(root); ``// Enqueue root ` `    ``while` `(!q.isEmpty())` `    ``{` `        ``int` `n = q.size();`   `        ``// If this node has children` `        ``while` `(n > ``0``)` `        ``{` `            ``// Dequeue an item from queue` `            ``// and print it` `            ``Node p = q.peek();` `            ``q.remove();` `            ``System.out.print(p.key + ``" "``);`   `            ``// Enqueue all children of ` `            ``// the dequeued item` `            ``for` `(``int` `i = ``0``; i < p.child.size(); i++)` `                ``q.add(p.child.get(i));` `            ``n--;` `        ``}` `        `  `        ``// Print new line between two levels` `        ``System.out.println(); ` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args) ` `{` `    `  `    ``/* Let us create below tree` `    ``*             10` `    ``*     / / \ \` `    ``*     2 34 56 100` `    ``*     / \         | / | \` `    ``*     77 88     1 7 8 9` `    ``*/` `    ``Node root = newNode(``10``);` `    ``(root.child).add(newNode(``2``));` `    ``(root.child).add(newNode(``34``));` `    ``(root.child).add(newNode(``56``));` `    ``(root.child).add(newNode(``100``));` `    ``(root.child.get(``0``).child).add(newNode(``77``));` `    ``(root.child.get(``0``).child).add(newNode(``88``));` `    ``(root.child.get(``2``).child).add(newNode(``1``));` `    ``(root.child.get(``3``).child).add(newNode(``7``));` `    ``(root.child.get(``3``).child).add(newNode(``8``));` `    ``(root.child.get(``3``).child).add(newNode(``9``));`   `    ``System.out.println(``"Level order traversal "` `+ ` `                            ``"Before Mirroring "``);` `    ``LevelOrderTraversal(root);` `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program to do level order traversal` `# of a generic tree` ` `  `# Represents a node of an n-ary tree` `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` `     `  `# Driver program` `if` `__name__``=``=``'__main__'``:` `    `  `    ``'''   Let us create below tree` `                  ``10` `            ``/   /    \   \` `            ``2  34    56   100` `           ``/ \         |   /  | \` `          ``77  88       1   7  8  9` `    ``'''` `    ``root ``=` `newNode(``10``);` `    ``(root.child).append(newNode(``2``));` `    ``(root.child).append(newNode(``34``));` `    ``(root.child).append(newNode(``56``));` `    ``(root.child).append(newNode(``100``));` `    ``(root.child[``0``].child).append(newNode(``77``));` `    ``(root.child[``0``].child).append(newNode(``88``));` `    ``(root.child[``2``].child).append(newNode(``1``));` `    ``(root.child[``3``].child).append(newNode(``7``));` `    ``(root.child[``3``].child).append(newNode(``8``));` `    ``(root.child[``3``].child).append(newNode(``9``));` `  `  `    ``print``(``"Level order traversal Before Mirroring"``)` `    ``LevelOrderTraversal(root);`   `    ``# This code is contributed by rutvik_56.`

## C#

 `// C# program to do level order traversal` `// of a generic tree` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG ` `{`   `// Represents a node of an n-ary tree` `public` `class` `Node` `{` `    ``public` `int` `key;` `    ``public` `Listchild = ``new` `List();` `};`   `// Utility function to create a new tree node` `static` `Node newNode(``int` `key)` `{` `    ``Node temp = ``new` `Node();` `    ``temp.key = key;` `    ``return` `temp;` `}`   `// Prints the n-ary tree level wise` `static` `void` `LevelOrderTraversal(Node root)` `{` `    ``if` `(root == ``null``)` `        ``return``;`   `    ``// Standard level order traversal code` `    ``// using queue` `    ``Queue q = ``new` `Queue(); ``// Create a queue` `    ``q.Enqueue(root); ``// Enqueue root ` `    ``while` `(q.Count != 0)` `    ``{` `        ``int` `n = q.Count;`   `        ``// If this node has children` `        ``while` `(n > 0)` `        ``{` `            ``// Dequeue an item from queue` `            ``// and print it` `            ``Node p = q.Peek();` `            ``q.Dequeue();` `            ``Console.Write(p.key + ``" "``);`   `            ``// Enqueue all children of ` `            ``// the dequeued item` `            ``for` `(``int` `i = 0; i < p.child.Count; i++)` `                ``q.Enqueue(p.child[i]);` `            ``n--;` `        ``}` `        `  `        ``// Print new line between two levels` `        ``Console.WriteLine(); ` `    ``}` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args) ` `{` `    `  `    ``/* Let us create below tree` `    ``*             10` `    ``*     / / \ \` `    ``*     2 34 56 100` `    ``*     / \         | / | \` `    ``*     77 88     1 7 8 9` `    ``*/` `    ``Node root = newNode(10);` `    ``(root.child).Add(newNode(2));` `    ``(root.child).Add(newNode(34));` `    ``(root.child).Add(newNode(56));` `    ``(root.child).Add(newNode(100));` `    ``(root.child[0].child).Add(newNode(77));` `    ``(root.child[0].child).Add(newNode(88));` `    ``(root.child[2].child).Add(newNode(1));` `    ``(root.child[3].child).Add(newNode(7));` `    ``(root.child[3].child).Add(newNode(8));` `    ``(root.child[3].child).Add(newNode(9));`   `    ``Console.WriteLine(``"Level order traversal "` `+ ` `                           ``"Before Mirroring "``);` `    ``LevelOrderTraversal(root);` `}` `}`   `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

```Level order traversal Before Mirroring
10
2 34 56 100
77 88 1 7 8 9 ```

Time Complexity: O(n) where n is the number of nodes in the n-ary tree.
Auxiliary Space: O(n)

This article is contributed by Raghav Sharma. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up
Related Articles