Given an N-ary Tree. The task is to write a program to perform the preorder traversal of the given n-ary tree.
Examples:
Input: 3-Array Tree 1 / | \ / | \ 2 3 4 / \ / | \ 5 6 7 8 9 / / | \ 10 11 12 13 Output: 1 2 5 10 6 11 12 13 3 4 7 8 9 Input: 3-Array Tree 1 / | \ / | \ 2 3 4 / \ / | \ 5 6 7 8 9 Output: 1 2 5 6 3 4 7 8 9
The preorder Traversal of an N-ary Tree is similar to the preorder traversal of a Binary Search Tree or Binary Tree with the only difference that is, all the child nodes of a parent are traversed from left to right in a sequence.
Iterative Preorder Traversal of Binary Tree.
Cases to handle during traversal: Two Cases have been taken care of in this Iterative Preorder Traversal Algorithm:
- Pop the top node from the stack – Top from the stack and insert it into the visited list of nodes.
- Push all of the child nodes of Top into the stack from right to left as the traversal from the stack will be carried out in reverse order. As a result, correct preorder traversal is achieved.
Note: In the below python implementation, a “dequeue” is used to implement the stack instead of a list because of its efficient append and pop operations.
Below is the implementation of the above approach:
// C++ program for Iterative Preorder // Traversal of N-ary Tree. // Preorder{ Root, print children // from left to right. #include <bits/stdc++.h> using namespace std;
// Node Structure of K-ary Tree class NewNode {
public :
int key;
// All children are stored in a list
vector<NewNode*> child;
NewNode( int val)
: key(val)
{
}
}; // Utility function to print the // preorder of the given K-Ary Tree void preorderTraversal(NewNode* root)
{ stack<NewNode*> Stack;
// 'Preorder'-> contains all the
// visited nodes
vector< int > Preorder;
Stack.push(root);
while (!Stack.empty()) {
NewNode* temp = Stack.top();
Stack.pop();
// store the key in preorder vector(visited list)
Preorder.push_back(temp->key);
// Push all of the child nodes of temp into
// the stack from right to left.
for ( int i = temp->child.size() - 1; i >= 0; i--) {
Stack.push(temp->child[i]);
}
}
for ( auto i : Preorder) {
cout << i << " " ;
}
cout << endl;
} // Driver Code int main()
{ // input nodes
/*
1
/ | \
/ | \
2 3 4
/ \ / | \
/ \ 7 8 9
5 6
/ / | \
10 11 12 13
*/
NewNode* root = new NewNode(1);
root->child.push_back( new NewNode(2));
root->child.push_back( new NewNode(3));
root->child.push_back( new NewNode(4));
root->child[0]->child.push_back( new NewNode(5));
root->child[0]->child[0]->child.push_back(
new NewNode(10));
root->child[0]->child.push_back( new NewNode(6));
root->child[0]->child[1]->child.push_back(
new NewNode(11));
root->child[0]->child[1]->child.push_back(
new NewNode(12));
root->child[0]->child[1]->child.push_back(
new NewNode(13));
root->child[2]->child.push_back( new NewNode(7));
root->child[2]->child.push_back( new NewNode(8));
root->child[2]->child.push_back( new NewNode(9));
preorderTraversal(root);
} // This code is contributed by sarangiswastika5 |
// Java program for Iterative Preorder // Traversal of N-ary Tree. // Preorder{ Root, print children // from left to right. import java.util.*;
public class gfg2 {
// Node Structure of K-ary Tree
static class Node {
int key;
// All children are stored in a list
ArrayList<Node> child;
Node( int val)
{
key = val;
child = new ArrayList<>();
}
};
// Utility function to print the
// preorder of the given K-Ary Tree
static void preorderTraversal(Node root)
{
Stack<Node> stack = new Stack<>();
// 'Preorder'-> contains all the
// visited nodes
ArrayList<Integer> Preorder = new ArrayList<>();
stack.push(root);
while (!stack.isEmpty()) {
Node temp = stack.peek();
stack.pop();
// store the key in preorder vector(visited
// list)
Preorder.add(temp.key);
// Push all of the child nodes of temp into
// the stack from right to left.
for ( int i = temp.child.size() - 1 ; i >= 0 ;
i--) {
stack.push(temp.child.get(i));
}
}
for (Integer i : Preorder) {
System.out.print(i + " " );
}
System.out.println();
}
// Driver Code
public static void main(String[] args)
{
// input nodes
/*
1
/ | \
/ | \
2 3 4
/ \ / | \
/ \ 7 8 9
5 6
/ / | \
10 11 12 13
*/
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.get( 0 ).child.add( new Node( 5 ));
root.child.get( 0 ).child.get( 0 ).child.add(
new Node( 10 ));
root.child.get( 0 ).child.add( new Node( 6 ));
root.child.get( 0 ).child.get( 1 ).child.add(
new Node( 11 ));
root.child.get( 0 ).child.get( 1 ).child.add(
new Node( 12 ));
root.child.get( 0 ).child.get( 1 ).child.add(
new Node( 13 ));
root.child.get( 2 ).child.add( new Node( 7 ));
root.child.get( 2 ).child.add( new Node( 8 ));
root.child.get( 2 ).child.add( new Node( 9 ));
preorderTraversal(root);
}
} // This code is contributed by karandeep1234 |
# Python3 program for Iterative Preorder # Traversal of N-ary Tree. # Preorder: Root, print children # from left to right. from collections import deque
# Node Structure of K-ary Tree class NewNode():
def __init__( self , val):
self .key = val
# all children are stored in a list
self .child = []
# Utility function to print the # preorder of the given K-Ary Tree def preorderTraversal(root):
Stack = deque([])
# 'Preorder'-> contains all the
# visited nodes.
Preorder = []
Preorder.append(root.key)
Stack.append(root)
while len (Stack) > 0 :
# 'Flag' checks whether all the child
# nodes have been visited.
flag = 0
# CASE 1- If Top of the stack is a leaf
# node then remove it from the stack:
if len ((Stack[ len (Stack) - 1 ]).child) = = 0 :
X = Stack.pop()
# CASE 2- If Top of the stack is
# Parent with children:
else :
Par = Stack[ len (Stack) - 1 ]
# a)As soon as an unvisited child is
# found(left to right sequence),
# Push it to Stack and Store it in
# Auxiliary List(Marked Visited)
# Start Again from Case-1, to explore
# this newly visited child
for i in range ( 0 , len (Par.child)):
if Par.child[i].key not in Preorder:
flag = 1
Stack.append(Par.child[i])
Preorder.append(Par.child[i].key)
break
# b)If all Child nodes from left to right
# of a Parent have been visited
# then remove the parent from the stack.
if flag = = 0 :
Stack.pop()
print (Preorder)
# Execution Start From here if __name__ = = '__main__' :
# input nodes
'''
1
/ | \
/ | \
2 3 4
/ \ / | \ / \ 7 8 9 5 6 / / | \ 10 11 12 13 '''
root = NewNode( 1 )
root.child.append(NewNode( 2 ))
root.child.append(NewNode( 3 ))
root.child.append(NewNode( 4 ))
root.child[ 0 ].child.append(NewNode( 5 ))
root.child[ 0 ].child[ 0 ].child.append(NewNode( 10 ))
root.child[ 0 ].child.append(NewNode( 6 ))
root.child[ 0 ].child[ 1 ].child.append(NewNode( 11 ))
root.child[ 0 ].child[ 1 ].child.append(NewNode( 12 ))
root.child[ 0 ].child[ 1 ].child.append(NewNode( 13 ))
root.child[ 2 ].child.append(NewNode( 7 ))
root.child[ 2 ].child.append(NewNode( 8 ))
root.child[ 2 ].child.append(NewNode( 9 ))
preorderTraversal(root) |
// C# program for Iterative Preorder // Traversal of N-ary Tree. // Preorder{ Root, print children // from left to right. using System;
using System.Collections;
using System.Collections.Generic;
class gfg2 {
// Node Structure of K-ary Tree
public class Node {
public int key;
// All children are stored in a list
public List<Node> child;
public Node( int val)
{
key = val;
child = new List<Node>();
}
};
// Utility function to print the
// preorder of the given K-Ary Tree
static void preorderTraversal(Node root)
{
Stack<Node> stack = new Stack<Node>();
// 'Preorder'-> contains all the
// visited nodes
List< int > Preorder = new List< int >();
stack.Push(root);
while (stack.Count != 0) {
Node temp = stack.Peek();
stack.Pop();
// store the key in preorder vector(visited
// list)
Preorder.Add(temp.key);
// Push all of the child nodes of temp into
// the stack from right to left.
for ( int i = temp.child.Count - 1; i >= 0;
i--) {
stack.Push(temp.child[i]);
}
}
foreach ( int i in Preorder)
{
Console.Write(i + " " );
}
Console.WriteLine();
}
// Driver Code
public static void Main( string [] args)
{
// input nodes
/*
1
/ | \
/ | \
2 3 4
/ \ / | \
/ \ 7 8 9
5 6
/ / | \
10 11 12 13
*/
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[0].child.Add( new Node(5));
root.child[0].child[0].child.Add( new Node(10));
root.child[0].child.Add( new Node(6));
root.child[0].child[1].child.Add( new Node(11));
root.child[0].child[1].child.Add( new Node(12));
root.child[0].child[1].child.Add( new Node(13));
root.child[2].child.Add( new Node(7));
root.child[2].child.Add( new Node(8));
root.child[2].child.Add( new Node(9));
preorderTraversal(root);
}
} // This code is contributed by karandeep1234 |
// Node Structure of K-ary Tree class NewNode { constructor(val) { this .key = val;
// all children are stored in an array this .child = [];
} } // Utility function to print the // preorder of the given K-Ary Tree function preorderTraversal(root) {
let stack = []; // 'Preorder'-> contains all the // visited nodes. let preorder = []; preorder.push(root.key); stack.push(root); while (stack.length > 0) {
// 'flag' checks whether all the child // nodes have been visited. let flag = 0; // CASE 1- If Top of the stack is a leaf // node then remove it from the stack: if (stack[stack.length - 1].child.length === 0) {
let x = stack.pop(); // CASE 2- If Top of the stack is // Parent with children: } else {
let par = stack[stack.length - 1]; // a)As soon as an unvisited child is // found(left to right sequence), // Push it to Stack and Store it in // Auxiliary List(Marked Visited) // Start Again from Case-1, to explore // this newly visited child for (let i = 0; i < par.child.length; i++) {
if (!preorder.includes(par.child[i].key)) {
flag = 1; stack.push(par.child[i]); preorder.push(par.child[i].key); break ;
} // b)If all Child nodes from left to right // of a Parent have been visited // then remove the parent from the stack. } if (flag === 0) {
stack.pop(); } } } document.write(preorder); } // Execution Start From here // input nodes /* 1 / | / | 2 3 4 / \ / | / \ 7 8 9 5 6 / / | \ 10 11 12 13 */ let root = new NewNode(1);
root.child.push( new NewNode(2));
root.child.push( new NewNode(3));
root.child.push( new NewNode(4));
root.child[0].child.push( new NewNode(5));
root.child[0].child[0].child.push( new NewNode(10));
root.child[0].child.push( new NewNode(6));
root.child[0].child[1].child.push( new NewNode(11));
root.child[0].child[1].child.push( new NewNode(12));
root.child[0].child[1].child.push( new NewNode(13));
root.child[2].child.push( new NewNode(7))
root.child[2].child.push( new NewNode(8))
root.child[2].child.push( new NewNode(9))
preorderTraversal(root) |
1 2 5 10 6 11 12 13 3 4 7 8 9
Complexity Analysis:
- Time Complexity: O(N), Where n is the total number of nodes in the given tree.
- Auxiliary Space: O(h), Where h is the height of the given tree
Using Recursion:
Approach:
- Create a vector that is used to store the preorder traversal of the N-ary tree.
- While visiting the node store the value of the node in the vector created and call the recursive function for its children.
Below is the implementation of the above algorithm:
// C++ program for Recursive Preorder Traversal of N-ary // Tree. #include <bits/stdc++.h> using namespace std;
// Node Structure of K-ary Tree 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;
} // Recursive function to print the // preorder of the given K-Ary Tree void fun(Node* root, vector< int >& v)
{ if (root == NULL) {
return ;
}
v.push_back(root->val);
for ( int i = 0; i < root->children.size(); i++) {
fun(root->children[i], v);
}
return ;
} // Function to print preorder list void preorderTraversal(Node* root)
{ vector< int > v;
fun(root, v);
for ( auto it : v)
cout << it << " " ;
} // Driver Code int main()
{ // input nodes
/*
1
/ | \
/ | \
2 3 4
/ \ / | \
5 6 7 8 9
/ / | \
10 11 12 13
*/
Node* root = newNode(1);
root->children.push_back(newNode(2));
root->children.push_back(newNode(3));
root->children.push_back(newNode(4));
root->children[0]->children.push_back(newNode(5));
root->children[0]->children[0]->children.push_back(
newNode(10));
root->children[0]->children.push_back(newNode(6));
root->children[0]->children[1]->children.push_back(
newNode(11));
root->children[0]->children[1]->children.push_back(
newNode(12));
root->children[0]->children[1]->children.push_back(
newNode(13));
root->children[2]->children.push_back(newNode(7));
root->children[2]->children.push_back(newNode(8));
root->children[2]->children.push_back(newNode(9));
preorderTraversal(root);
} // This code is contributed by Aditya Kumar (adityakumar129) |
# Python3 program for Recursive Preorder Traversal of N-ary Tree # Node Structure of K-ary Tree class Node:
def __init__( self , val):
self .val = val
self .children = []
# Utility function to create a new tree node def newNode(key):
temp = Node(key)
return temp
# Recursive function to print the preorder of the given K-Ary Tree def fun(root, v):
if root is None :
return
v.append(root.val)
for i in range ( len (root.children)):
fun(root.children[i], v)
return
# Function to print preorder list def preorderTraversal(root):
v = []
fun(root, v)
for it in v:
print (it, end = " " )
# Input nodes ''' 1
/ | \
/ | \
2 3 4
/ \ / | \
5 6 7 8 9
/ / | \
10 11 12 13
''' root = newNode( 1 )
root.children.append(newNode( 2 ))
root.children.append(newNode( 3 ))
root.children.append(newNode( 4 ))
root.children[ 0 ].children.append(newNode( 5 ))
root.children[ 0 ].children[ 0 ].children.append(newNode( 10 ))
root.children[ 0 ].children.append(newNode( 6 ))
root.children[ 0 ].children[ 1 ].children.append(newNode( 11 ))
root.children[ 0 ].children[ 1 ].children.append(newNode( 12 ))
root.children[ 0 ].children[ 1 ].children.append(newNode( 13 ))
root.children[ 2 ].children.append(newNode( 7 ))
root.children[ 2 ].children.append(newNode( 8 ))
root.children[ 2 ].children.append(newNode( 9 ))
preorderTraversal(root) # This code is contributed by lokeshpotta20. |
using System;
using System.Collections;
using System.Collections.Generic;
public class Gfg
{ // Node Structure of K-ary Tree
public class Node {
public int val;
public List<Node> children;
public Node( int val)
{
this .val=val;
this .children= new List<Node>();
}
};
// Utility function to create a new tree node
/*Node* newNode(int key)
{
Node* temp = new Node;
temp.val = key;
return temp;
}*/
// Recursive function to print the
// preorder of the given K-Ary Tree
static void fun(Node root, List< int > v)
{
if (root == null ) {
return ;
}
v.Add(root.val);
for ( int i = 0; i < root.children.Count; i++) {
fun(root.children[i], v);
}
return ;
}
// Function to print preorder list
static void preorderTraversal(Node root)
{
List< int > v= new List< int >();
fun(root, v);
foreach ( int i in v)
Console.Write(i + " " );
}
// Driver Code
public static void Main( string [] args)
{
// input nodes
/*
1
/ | \
/ | \
2 3 4
/ \ / | \
5 6 7 8 9
/ / | \
10 11 12 13
*/
Node root = new Node(1);
root.children.Add( new Node(2));
root.children.Add( new Node(3));
root.children.Add( new Node(4));
root.children[0].children.Add( new Node(5));
root.children[0].children[0].children.Add(
new Node(10));
root.children[0].children.Add( new Node(6));
root.children[0].children[1].children.Add(
new Node(11));
root.children[0].children[1].children.Add(
new Node(12));
root.children[0].children[1].children.Add(
new Node(13));
root.children[2].children.Add( new Node(7));
root.children[2].children.Add( new Node(8));
root.children[2].children.Add( new Node(9));
preorderTraversal(root);
}
} // This code is contributed by poojaagarwal2. |
// Javascript program for Recursive Preorder Traversal of N-ary // Tree. // Node Structure of K-ary Tree class Node { /*char val;
vector<Node*> children;*/
constructor(val)
{
this .val=val;
this .children= new Array();
}
} // Utility function to create a new tree node /*Node* newNode(int key) { Node* temp = new Node;
temp.val = key;
return temp;
}*/ // Recursive function to print the // preorder of the given K-Ary Tree function fun( root, v)
{ if (root == null ) {
return ;
}
v.push(root.val);
for (let i = 0; i < root.children.length; i++) {
fun(root.children[i], v);
}
return ;
} // Function to print preorder list function preorderTraversal( root)
{ v= new Array();
fun(root, v);
for (let it of v)
console.log(it + " " );
} // Driver Code // input nodes /* 1
/ | \
/ | \
2 3 4
/ \ / | \
5 6 7 8 9
/ / | \
10 11 12 13
*/
let root = new Node(1);
root.children.push( new Node(2));
root.children.push( new Node(3));
root.children.push( new Node(4));
root.children[0].children.push( new Node(5));
root.children[0].children[0].children.push( new Node(10));
root.children[0].children.push( new Node(6));
root.children[0].children[1].children.push( new Node(11));
root.children[0].children[1].children.push( new Node(12));
root.children[0].children[1].children.push( new Node(13));
root.children[2].children.push( new Node(7));
root.children[2].children.push( new Node(8));
root.children[2].children.push( new Node(9));
preorderTraversal(root); // This code is contributed by ratiagrawal. |
// Java program for Recursive Preorder Traversal of N-ary // Tree. import java.io.*;
import java.util.*;
// Node Structure of K-ary Tree class Node {
int val;
List<Node> children;
Node( int val)
{
this .val = val;
this .children = new ArrayList<>();
}
} class GFG {
// Recursive function to print the preorder of the given
// K-Ary Tree
static void fun(Node root, List<Integer> v)
{
if (root == null ) {
return ;
}
v.add(root.val);
for ( int i = 0 ; i < root.children.size(); i++) {
fun(root.children.get(i), v);
}
}
// Function to print preorder list
static void preorderTraversal(Node root)
{
List<Integer> v = new ArrayList<>();
fun(root, v);
for ( int i : v)
System.out.print(i + " " );
}
public static void main(String[] args)
{
// input nodes
/*
1
/ | \
/ | \
2 3 4
/ \ /|\
5 6 7 8 9
/ / | \
10 11 12 13
*/
Node root = new Node( 1 );
root.children.add( new Node( 2 ));
root.children.add( new Node( 3 ));
root.children.add( new Node( 4 ));
root.children.get( 0 ).children.add( new Node( 5 ));
root.children.get( 0 ).children.get( 0 ).children.add(
new Node( 10 ));
root.children.get( 0 ).children.add( new Node( 6 ));
root.children.get( 0 ).children.get( 1 ).children.add(
new Node( 11 ));
root.children.get( 0 ).children.get( 1 ).children.add(
new Node( 12 ));
root.children.get( 0 ).children.get( 1 ).children.add(
new Node( 13 ));
root.children.get( 2 ).children.add( new Node( 7 ));
root.children.get( 2 ).children.add( new Node( 8 ));
root.children.get( 2 ).children.add( new Node( 9 ));
preorderTraversal(root);
}
} // This code is contributed by karthik |
1 2 5 10 6 11 12 13 3 4 7 8 9
Complexity Analysis:
Time Complexity: O(N), Where n is the total number of nodes in the given tree.
Auxiliary Space: O(h), Where h is the height of the given tree if you consider the Auxiliary stack space of the recursion.