Get the best out of our app
GeeksforGeeks App
Open App
Browser
Continue

# 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 ``using` `namespace` `std;` `// Node Structure of K-ary Tree``class` `NewNode {``public``:``    ``int` `key;` `    ``// All children are stored in a list``    ``vector child;``    ``NewNode(``int` `val)``        ``: key(val)``    ``{``    ``}``};` `// Utility function to print the``// preorder of the given K-Ary Tree``void` `preorderTraversal(NewNode* root)``{``    ``stack 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 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 stack = ``new` `Stack<>();` `        ``// 'Preorder'-> contains all the``        ``// visited nodes``        ``ArrayList 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 child;` `        ``public` `Node(``int` `val)``        ``{``            ``key = val;``            ``child = ``new` `List();``        ``}``    ``};` `    ``// Utility function to print the``    ``// preorder of the given K-Ary Tree``    ``static` `void` `preorderTraversal(Node root)``    ``{``        ``Stack stack = ``new` `Stack();` `        ``// '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 ``using` `namespace` `std;` `// Node Structure of K-ary Tree``struct` `Node {``    ``char` `val;``    ``vector 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 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<``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 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 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 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.

My Personal Notes arrow_drop_up