GeeksforGeeks App
Open App
Browser
Continue

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

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