Preorder Traversal of an N-ary Tree

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: 

1. Pop the top node from the stack – Top from the stack and insert it into the visited list of nodes.
2. 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<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

# 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<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

// 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<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

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.