Given the root node of an N-ary tree and an integer K, the task is to convert the given tree into adjacency list representation and print the level order traversal considering vertex K as the root node.
Example:
Input: Tree in the image below, K = 5
Output:
5
1 9 10 11
2 3 4
6 7 8Input: Tree in the image below, K = 5
Output:
5
1
2 3 4
7 8
Approach: The given problem can be solved by using the DFS Traversal on the N-ary tree and storing the relation of all the edges into an adjacency list according to the adjacency list representation. The created adjacency list can be used to print the Level Order Traversal with K as the root node. This can be done using BFS traversal which is discussed in this article.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// A binary tree node struct Node {
int data;
vector<Node*> child;
}; // Function to create a new tree node Node* newNode( int key)
{ Node* temp = new Node;
temp->data = key;
return temp;
} // Adjacency list to store the Tree vector<vector< int > > adj;
// Function to perform the DFS traversal // of the N-ary tree using the given // pointer to the root node of the tree void DFS( struct Node* node)
{ // Traverse all child of node
for ( auto x : node->child) {
if (x != NULL) {
// Insert the pair of vertices
// into the adjacency list
adj[node->data].push_back(x->data);
adj[x->data].push_back(node->data);
// Recursive call for DFS on x
DFS(x);
}
}
} // Function to print the level order // traversal of the given tree with // s as root node void levelOrderTrav( int s, int N)
{ // Create a queue for Level
// Order Traversal
queue< int > q;
// Stores if the current
// node is visited
vector< bool > visited(N);
q.push(s);
// -1 marks the end of level
q.push(-1);
visited[s] = true ;
while (!q.empty()) {
// Dequeue a vertex from queue
int v = q.front();
q.pop();
// If v marks the end of level
if (v == -1) {
if (!q.empty())
q.push(-1);
// Print a newline character
cout << endl;
continue ;
}
// Print current vertex
cout << v << " " ;
// Add the child vertices of
// the current node in queue
for ( int u : adj[v]) {
if (!visited[u]) {
visited[u] = true ;
q.push(u);
}
}
}
} // Driver Code int main()
{ Node* root = newNode(1);
(root->child).push_back(newNode(2));
(root->child).push_back(newNode(3));
(root->child).push_back(newNode(4));
(root->child).push_back(newNode(5));
(root->child[0]->child).push_back(newNode(6));
(root->child[0]->child).push_back(newNode(7));
(root->child[2]->child).push_back(newNode(8));
(root->child[3]->child).push_back(newNode(9));
(root->child[3]->child).push_back(newNode(10));
(root->child[3]->child).push_back(newNode(11));
int N = 11;
int K = 5;
adj.resize(N + 1, vector< int >());
DFS(root);
levelOrderTrav(5, 11);
return 0;
} |
// Java program for the above approach import java.util.*;
class Node {
int data;
ArrayList<Node> child;
Node( int data)
{
this .data = data;
this .child = new ArrayList<>();
}
} class Main {
// Adjacency list to store the Tree
static List<List<Integer> > adj = new ArrayList<>();
// Function to perform the DFS traversal
// of the N-ary tree using the given
// pointer to the root node of the tree
static void DFS(Node node)
{
for (Node x : node.child) {
if (x != null ) {
// Insert the pair of vertices
// into the adjacency list
adj.get(node.data).add(x.data);
adj.get(x.data).add(node.data);
// Recursive call for DFS on x
DFS(x);
}
}
}
// Function to print the level order
// traversal of the given tree with
// s as root node
static void levelOrderTrav( int s, int N)
{
// Create a queue for Level
// Order Traversal
Queue<Integer> q = new LinkedList<>();
// Stores if the current
// node is visited
boolean [] visited = new boolean [N + 1 ];
q.offer(s);
// -1 marks the end of level
q.offer(- 1 );
visited[s] = true ;
while (!q.isEmpty()) {
int v = q.poll();
if (v == - 1 ) {
if (!q.isEmpty())
q.offer(- 1 );
System.out.println();
continue ;
}
// Print current vertex
System.out.print(v + " " );
// Add the child vertices of
// the current node in queue
for ( int u : adj.get(v)) {
if (!visited[u]) {
visited[u] = true ;
q.offer(u);
}
}
}
}
public static void main(String[] args)
{
Node root = new Node( 1 );
root.child.add( new Node( 2 ));
root.child.add( new Node( 3 ));
root.child.add( new Node( 4 ));
root.child.add( new Node( 5 ));
root.child.get( 0 ).child.add( new Node( 6 ));
root.child.get( 0 ).child.add( new Node( 7 ));
root.child.get( 2 ).child.add( new Node( 8 ));
root.child.get( 3 ).child.add( new Node( 9 ));
root.child.get( 3 ).child.add( new Node( 10 ));
root.child.get( 3 ).child.add( new Node( 11 ));
int N = 11 ;
int K = 5 ;
for ( int i = 0 ; i <= N; i++)
adj.add( new ArrayList<>());
DFS(root);
levelOrderTrav(K, N);
}
} |
# Python program for the above approach from collections import defaultdict, deque
# A binary tree node class Node:
def __init__( self , data):
self .data = data
self .child = []
# Function to create a new tree node def newNode(key):
temp = Node(key)
return temp
# Adjacency list to store the Tree adj = defaultdict( list )
# Function to perform the DFS traversal # of the N-ary tree using the given # pointer to the root node of the tree def DFS(node):
# Traverse all child of node
for x in node.child:
if x:
# Insert the pair of vertices
# into the adjacency list
adj[node.data].append(x.data)
adj[x.data].append(node.data)
# Recursive call for DFS on x
DFS(x)
# Function to print the level order # traversal of the given tree with # s as root node def levelOrderTrav(s, N):
# Create a queue for Level
# Order Traversal
q = deque()
# Stores if the current
# node is visited
visited = [ False ] * (N + 1 )
q.append(s)
# -1 marks the end of level
q.append( - 1 )
visited[s] = True
while q:
# Dequeue a vertex from queue
v = q.popleft()
# If v marks the end of level
if v = = - 1 :
if q:
q.append( - 1 )
# Print a newline character
continue
# Print current vertex
print (v)
# Add the child vertices of
# the current node in queue
for u in adj[v]:
if not visited[u]:
visited[u] = True
q.append(u)
# Driver Code if __name__ = = "__main__" :
root = newNode( 1 )
root.child.append(newNode( 2 ))
root.child.append(newNode( 3 ))
root.child.append(newNode( 4 ))
root.child.append(newNode( 5 ))
root.child[ 0 ].child.append(newNode( 6 ))
root.child[ 0 ].child.append(newNode( 7 ))
root.child[ 2 ].child.append(newNode( 8 ))
root.child[ 3 ].child.append(newNode( 9 ))
root.child[ 3 ].child.append(newNode( 10 ))
root.child[ 3 ].child.append(newNode( 11 ))
N = 11
K = 5
DFS(root)
levelOrderTrav( 5 , 11 )
# This code is contributed by aadityamaharshi21.
|
using System;
using System.Collections.Generic;
// Node class definition class Node {
// Data members
public int data;
public List<Node> child;
// Constructor
public Node( int data)
{
this .data = data;
this .child = new List<Node>();
}
} class GFG {
// Adjacency list to store the Tree
static List<List< int > > adj = new List<List< int > >();
// Function to perform the DFS traversal
// of the N-ary tree using the given
// pointer to the root node of the tree
static void DFS(Node node)
{
foreach (Node x in node.child)
{
if (x != null ) {
// Insert the pair of vertices
// into the adjacency list
adj[node.data].Add(x.data);
adj[x.data].Add(node.data);
// Recursive call for DFS on x
DFS(x);
}
}
}
// Function to print the level order
// traversal of the given tree with
// s as root node
static void LevelOrderTrav( int s, int N)
{
// Create a queue for Level
// Order Traversal
Queue< int > q = new Queue< int >();
// Stores if the current
// node is visited
bool [] visited = new bool [N + 1];
q.Enqueue(s);
// -1 marks the end of level
q.Enqueue(-1);
visited[s] = true ;
while (q.Count > 0) {
int v = q.Dequeue();
if (v == -1) {
if (q.Count > 0)
q.Enqueue(-1);
Console.WriteLine();
continue ;
}
// Print current vertex
Console.Write(v + " " );
// Add the child vertices of
// the current node in queue
foreach ( int u in adj[v])
{
if (!visited[u]) {
visited[u] = true ;
q.Enqueue(u);
}
}
}
}
// Driver code
public static void Main( string [] args)
{
// Building the tree
Node root = new Node(1);
root.child.Add( new Node(2));
root.child.Add( new Node(3));
root.child.Add( new Node(4));
root.child.Add( new Node(5));
root.child[0].child.Add( new Node(6));
root.child[0].child.Add( new Node(7));
root.child[2].child.Add( new Node(8));
root.child[3].child.Add( new Node(9));
root.child[3].child.Add( new Node(10));
root.child[3].child.Add( new Node(11));
int N = 11;
int K = 5;
for ( int i = 0; i <= N; i++)
adj.Add( new List< int >());
// Function calls
DFS(root);
LevelOrderTrav(K, N);
}
} |
// JavaScript code for the above approach
// A class to represent a tree node
class Node {
constructor(data) {
this .data = data;
this .children = [];
}
}
// Adjacency list to store the tree
const adj = [];
// Function to perform the DFS traversal
// of the N-ary tree using the given
// pointer to the root node of the tree
function DFS(node) {
// Traverse all children of node
for (const child of node.children) {
if (child != null )
{
// Insert the pair of vertices
// into the adjacency list
adj[node.data].push(child.data);
adj[child.data].push(node.data);
// Recursive call for DFS on child
DFS(child);
}
}
}
// Function to print the level order
// traversal of the given tree with
// s as root node
function levelOrderTrav(s, N)
{
// Create a queue for Level
// Order Traversal
const q = [];
// Stores if the current
// node is visited
const visited = new Array(N).fill( false );
q.push(s);
// -1 marks the end of level
q.push(-1);
visited[s] = true ;
while (q.length > 0) {
// Dequeue a vertex from queue
const v = q.shift();
// If v marks the end of level
if (v === -1) {
if (q.length > 0) {
q.push(-1);
}
// Print a newline character
document.write( "<br>" );
continue ;
}
// Print current vertex
document.write(v + " " );
// Add the child vertices of
// the current node in queue
for (const u of adj[v]) {
if (!visited[u]) {
visited[u] = true ;
q.push(u);
}
}
}
}
// Create the N-ary tree
const root = new Node(1);
root.children.push( new Node(2));
root.children.push( new Node(3));
root.children.push( new Node(4));
root.children.push( new Node(5));
root.children[0].children.push( new Node(6));
root.children[0].children.push( new Node(7));
root.children[2].children.push( new Node(8));
root.children[3].children.push( new Node(9));
root.children[3].children.push( new Node(10));
root.children[3].children.push( new Node(11));
const N = 11;
const K = 5;
// Initialize the adjacency list
for (let i = 0; i <= N; i++) {
adj.push([]);
}
// Perform DFS on the tree
DFS(root);
// Print the tree in level order traversal
levelOrderTrav(5, 11);
// This code is contributed by Potta Lokesh. |
5 1 9 10 11 2 3 4 6 7 8
Time Complexity: O(N)
Auxiliary Space: O(N)