Preorder Traversal of an Nary Tree (original) (raw)
Last Updated : 11 Jul, 2025
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++ `
// 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
// 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
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#
// 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
JavaScript
// 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)
`
Output
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++ `
// 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& 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 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
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.
C#
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 children; public Node(int val) { this.val=val; this.children=new List(); } };
// 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 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 v=new List(); 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
// 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
// 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 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
`
Output
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.