# Post order traversal of n-ary tree

Here given code implementation process.

``````import java.util.Vector;
import java.util.ArrayList;
// Java program for
// Postorder traversal of an N-ary Tree
class TreeNode
{
public int key;
public Vector < TreeNode > child;
public TreeNode(int key)
{
// Set node key
this.key = key;
// Create memory of TreeNode child
this.child = new Vector < TreeNode > ();
}
{
// Create a new node
TreeNode node = new TreeNode(key);
}
}
public class NAryTree
{
public TreeNode root;

public NAryTree()
{
// Set initial tree root to null
this.root = null;
}

public void printPostOrder(TreeNode node)
{
if(node == null)
{
return;
}

for (int  i = 0; i < node.child.size() ; ++i)
{
// Visit child node
printPostOrder(node.child.get(i));
}
// Display node value
System.out.print("  "+node.key);
}
public static void main(String[] args)
{
NAryTree tree = new NAryTree();
/*
10
/   \
/     \
/       \
8         5
/|\      /|\ \
/ | \    / | \ \
-2 1  6  7 18 3  4
/ \           /| \
9  11         2 1  3
/  \
17   12
-----------------------
Constructing N-Arr tree
*/
// First element of tree
tree.root = new TreeNode(10);
// Add child node [-2,1,6] in node (8)
// Add child node [9,11] in node (1)
// Add child node [17  12] in node (11)
// Add child node [7 18 3 4] in node (5)
// Add child node [2,1,3] in node (4)
tree.printPostOrder(tree.root);
}
}``````

#### Output

``  -2  9  17  12  11  1  6  8  7  18  3  2  1  3  4  5  10``
``````package main
import "fmt"
// Go program for
// Postorder traversal of an N-ary Tree
type TreeNode struct {
key int
child [] *TreeNode
}
func getTreeNode(key int) * TreeNode {
var me *TreeNode = &TreeNode {}
// Set node key
me.key = key
// Create memory of TreeNode child
me.child =   make([] *TreeNode,0)
return me
}
// Create a new node
var node * TreeNode = getTreeNode(key)
this.child = append(this.child, node)
}
type NAryTree struct {
root * TreeNode
}
func getNAryTree() * NAryTree {
var me *NAryTree = &NAryTree {}
// Set initial tree root to null
me.root = nil
return me
}
func(this NAryTree) printPostOrder(node * TreeNode) {
if node == nil {
return
}
for i := 0 ; i < len(node.child) ; i++ {
// Visit child node
this.printPostOrder(node.child[i])
}
// Display node value
fmt.Print("  ", node.key)
}
func main() {
var tree * NAryTree = getNAryTree()
/*
10
/   \
/     \
/       \
8         5
/|\      /|\ \
/ | \    / | \ \
-2 1  6  7 18 3  4
/ \           /| \
9  11         2 1  3
/  \
17   12
-----------------------
Constructing N-Ary tree

*/
// First element of tree
tree.root = getTreeNode(10)
// Add child node [-2,1,6] in node (8)
// Add child node [9,11] in node (1)
// Add child node [17  12] in node (11)
// Add child node [7 18 3 4] in node (5)
// Add child node [2,1,3] in node (4)
tree.printPostOrder(tree.root)
}``````

#### Output

``  -2  9  17  12  11  1  6  8  7  18  3  2  1  3  4  5  10``
``````// Include header file
#include <iostream>
#include <vector>

using namespace std;
// C++ program for
// Postorder traversal of an N-ary Tree
class TreeNode
{
public: int key;
vector < TreeNode *> child;
TreeNode(int key)
{
// Set node key
this->key = key;
}
{
// Create a new node
TreeNode *node = new TreeNode(key);
this->child.push_back(node);
}
};
class NAryTree
{
public: TreeNode *root;
NAryTree()
{
this->root = NULL;
}
void printPostOrder(TreeNode *node)
{
if (node == NULL)
{
return;
}
for (int i = 0; i < node->child.size(); ++i)
{
// Visit child node
this->printPostOrder(node->child.at(i));
}
// Display node value
cout << "  " << node->key;
}
};
int main()
{
NAryTree *tree = new NAryTree();
/*
10
/   \
/     \
/       \
8         5
/|\      /|\ \
/ | \    / | \ \
-2 1  6  7 18 3  4
/ \           /| \
9  11         2 1  3
/  \
17   12
-----------------------
Constructing N-Arr tree

*/
// First element of tree
tree->root = new TreeNode(10);
// Add child node [-2,1,6] in node (8)
// Add child node [9,11] in node (1)
// Add child node [17  12] in node (11)
// Add child node [7 18 3 4] in node (5)
// Add child node [2,1,3] in node (4)
tree->printPostOrder(tree->root);
return 0;
}``````

#### Output

``  -2  9  17  12  11  1  6  8  7  18  3  2  1  3  4  5  10``
``````// Include namespace system
using System;
using System.Collections.Generic;
// Csharp program for
// Postorder traversal of an N-ary Tree
public class TreeNode
{
public int key;
public List < TreeNode > child;
public TreeNode(int key)
{
// Set node key
this.key = key;
// Create memory of TreeNode child
this.child = new List < TreeNode > ();
}
{
// Create a new node
TreeNode node = new TreeNode(key);
}
}
public class NAryTree
{
public TreeNode root;
public NAryTree()
{
// Set initial tree root to null
this.root = null;
}
public void printPostOrder(TreeNode node)
{
if (node == null)
{
return;
}
for (int i = 0; i < node.child.Count; ++i)
{
// Visit child node
this.printPostOrder(node.child[i]);
}
// Display node value
Console.Write("  " + node.key);
}
public static void Main(String[] args)
{
NAryTree tree = new NAryTree();
/*
10
/   \
/     \
/       \
8         5
/|\      /|\ \
/ | \    / | \ \
-2 1  6  7 18 3  4
/ \           /| \
9  11         2 1  3
/  \
17   12
-----------------------
Constructing N-Arr tree

*/
// First element of tree
tree.root = new TreeNode(10);
// Add child node [-2,1,6] in node (8)
// Add child node [9,11] in node (1)
// Add child node [17  12] in node (11)
// Add child node [7 18 3 4] in node (5)
// Add child node [2,1,3] in node (4)
tree.printPostOrder(tree.root);
}
}``````

#### Output

``  -2  9  17  12  11  1  6  8  7  18  3  2  1  3  4  5  10``
``````<?php
// Php program for
// Postorder traversal of an N-ary Tree
class TreeNode
{
public \$key;
public \$child;
public	function __construct(\$key)
{
// Set node key
\$this->key = \$key;
// Create memory of TreeNode child
\$this->child = array();
}
{
// Create a new node
\$node = new TreeNode(\$key);
\$this->child[] = \$node;
}
}
class NAryTree
{
public \$root;
public	function __construct()
{
\$this->root = NULL;
}
public	function printPostOrder(\$node)
{
if (\$node == NULL)
{
return;
}
for (\$i = 0; \$i < count(\$node->child); ++\$i)
{
// Visit child node
\$this->printPostOrder(\$node->child[\$i]);
}
// Display node value
echo("  ".\$node->key);
}
}

function main()
{
\$tree = new NAryTree();
/*
10
/   \
/     \
/       \
8         5
/|\      /|\ \
/ | \    / | \ \
-2 1  6  7 18 3  4
/ \           /| \
9  11         2 1  3
/  \
17   12
-----------------------
Constructing N-Arr tree

*/
// First element of tree
\$tree->root = new TreeNode(10);
// Add child node [-2,1,6] in node (8)
// Add child node [9,11] in node (1)
// Add child node [17  12] in node (11)
// Add child node [7 18 3 4] in node (5)
// Add child node [2,1,3] in node (4)
\$tree->printPostOrder(\$tree->root);
}
main();``````

#### Output

``  -2  9  17  12  11  1  6  8  7  18  3  2  1  3  4  5  10``
``````// Node JS program for
// Postorder traversal of an N-ary Tree
class TreeNode
{
constructor(key)
{
// Set node key
this.key = key;
// Create memory of TreeNode child
this.child = [];
}
{
// Create a new node
var node = new TreeNode(key);
this.child.push(node);
}
}
class NAryTree
{
constructor()
{
this.root = null;
}
printPostOrder(node)
{
if (node == null)
{
return;
}
for (var i = 0; i < node.child.length; ++i)
{
// Visit child node
this.printPostOrder(node.child[i]);
}
// Display node value
process.stdout.write("  " + node.key);
}
}

function main()
{
var tree = new NAryTree();
/*
10
/   \
/     \
/       \
8         5
/|\      /|\ \
/ | \    / | \ \
-2 1  6  7 18 3  4
/ \           /| \
9  11         2 1  3
/  \
17   12
-----------------------
Constructing N-Arr tree

*/
// First element of tree
tree.root = new TreeNode(10);
// Add child node [-2,1,6] in node (8)
// Add child node [9,11] in node (1)
// Add child node [17  12] in node (11)
// Add child node [7 18 3 4] in node (5)
// Add child node [2,1,3] in node (4)
tree.printPostOrder(tree.root);
}
main();``````

#### Output

``  -2  9  17  12  11  1  6  8  7  18  3  2  1  3  4  5  10``
``````#  Python 3 program for
#  Postorder traversal of an N-ary Tree
class TreeNode :
def __init__(self, key) :
#  Set node key
self.key = key
#  Create memory of TreeNode child
self.child = []

#  Create a new node
node = TreeNode(key)
self.child.append(node)

class NAryTree :
def __init__(self) :
self.root = None

def printPostOrder(self, node) :
if (node == None) :
return

i = 0
while (i < len(node.child)) :
#  Visit child node
self.printPostOrder(node.child[i])
i += 1

#  Display node value
print(" ", node.key, end = "")

def main() :
tree = NAryTree()
#           10
#          /   \
#         /     \
#        /       \
#       8         5
#      /|\      /|\ \
#     / | \    / | \ \
#    -2 1  6  7 18 3  4
#      / \           /| \
#     9  11         2 1  3
#       /  \
#      17   12
#    -----------------------
#    Constructing N-Arr tree
#  First element of tree
tree.root = TreeNode(10)
#  Add child node [-2,1,6] in node (8)
#  Add child node [9,11] in node (1)
#  Add child node [17  12] in node (11)
#  Add child node [7 18 3 4] in node (5)
#  Add child node [2,1,3] in node (4)
tree.printPostOrder(tree.root)

if __name__ == "__main__": main()``````

#### Output

``  -2  9  17  12  11  1  6  8  7  18  3  2  1  3  4  5  10``
``````#  Ruby program for
#  Postorder traversal of an N-ary Tree
class TreeNode
# Define the accessor and reader of class TreeNode
attr_accessor :key, :child
def initialize(key)
#  Set node key
self.key = key
#  Create memory of TreeNode child
self.child = []
end

#  Create a new node
node = TreeNode.new(key)
self.child.push(node)
end

end

class NAryTree
# Define the accessor and reader of class NAryTree
attr_accessor :root
def initialize()
self.root = nil
end

def printPostOrder(node)
if (node == nil)
return
end

i = 0
while (i < node.child.length)
#  Visit child node
self.printPostOrder(node.child[i])
i += 1
end

#  Display node value
print("  ", node.key)
end

end

def main()
tree = NAryTree.new()
#           10
#          /   \
#         /     \
#        /       \
#       8         5
#      /|\      /|\ \
#     / | \    / | \ \
#    -2 1  6  7 18 3  4
#      / \           /| \
#     9  11         2 1  3
#       /  \
#      17   12
#    -----------------------
#    Constructing N-Arr tree
#  First element of tree
tree.root = TreeNode.new(10)
#  Add child node [-2,1,6] in node (8)
#  Add child node [9,11] in node (1)
#  Add child node [17  12] in node (11)
#  Add child node [7 18 3 4] in node (5)
#  Add child node [2,1,3] in node (4)
tree.printPostOrder(tree.root)
end

main()``````

#### Output

``  -2  9  17  12  11  1  6  8  7  18  3  2  1  3  4  5  10``
``````import scala.collection.mutable._;
// Scala program for
// Postorder traversal of an N-ary Tree
class TreeNode(var key: Int,
var child: ArrayBuffer[TreeNode])
{
def this(key: Int)
{
// Set node key
// Create memory of TreeNode child
this(key, new ArrayBuffer[TreeNode]());
}
def addChild(key: Int): Unit = {
// Create a new node
var node: TreeNode = new TreeNode(key);
this.child += node;
}
}
class NAryTree(var root: TreeNode)
{
def this()
{
this(null);
}
def printPostOrder(node: TreeNode): Unit = {
if (node == null)
{
return;
}
var i: Int = 0;
while (i < node.child.size)
{
// Visit child node
printPostOrder(node.child(i));
i += 1;
}
// Display node value
print("  " + node.key);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var tree: NAryTree = new NAryTree();
/*
10
/   \
/     \
/       \
8         5
/|\      /|\ \
/ | \    / | \ \
-2 1  6  7 18 3  4
/ \           /| \
9  11         2 1  3
/  \
17   12
-----------------------
Constructing N-Arr tree

*/
// First element of tree
tree.root = new TreeNode(10);
// Add child node [-2,1,6] in node (8)
// Add child node [9,11] in node (1)
// Add child node [17  12] in node (11)
// Add child node [7 18 3 4] in node (5)
// Add child node [2,1,3] in node (4)
tree.printPostOrder(tree.root);
}
}``````

#### Output

``  -2  9  17  12  11  1  6  8  7  18  3  2  1  3  4  5  10``
``````import Foundation;
// Swift 4 program for
// Postorder traversal of an N-ary Tree
class TreeNode
{
var key: Int;
var child: [TreeNode? ];
init(_ key: Int)
{
// Set node key
self.key = key;
// Create memory of TreeNode child
self.child = [TreeNode? ]();
}
{
// Create a new node
let node: TreeNode = TreeNode(key);
self.child.append(node);
}
}
class NAryTree
{
var root: TreeNode? ;
init()
{
self.root = nil;
}
func printPostOrder(_ node: TreeNode? )
{
if (node == nil)
{
return;
}
var i: Int = 0;
while (i < node!.child.count)
{
// Visit child node
self.printPostOrder(node!.child[i]);
i += 1;
}
// Display node value
print(" ", node!.key, terminator: "");
}
}
func main()
{
let tree: NAryTree = NAryTree();
/*
10
/   \
/     \
/       \
8         5
/|\      /|\ \
/ | \    / | \ \
-2 1  6  7 18 3  4
/ \           /| \
9  11         2 1  3
/  \
17   12
-----------------------
Constructing N-Arr tree

*/
// First element of tree
tree.root = TreeNode(10);
// Add child node [-2,1,6] in node (8)
// Add child node [9,11] in node (1)
// Add child node [17  12] in node (11)
// Add child node [7 18 3 4] in node (5)
// Add child node [2,1,3] in node (4)
tree.printPostOrder(tree.root);
}
main();``````

#### Output

``  -2  9  17  12  11  1  6  8  7  18  3  2  1  3  4  5  10``
``````// Kotlin program for
// Postorder traversal of an N-ary Tree
class TreeNode
{
var key: Int;
var child: MutableList < TreeNode > ;
constructor(key: Int)
{
// Set node key
this.key = key;
// Create memory of TreeNode child
this.child = mutableListOf < TreeNode > ();
}
{
// Create a new node
val node: TreeNode = TreeNode(key);
}
}
class NAryTree
{
var root: TreeNode ? ;
constructor()
{
this.root = null;
}
fun printPostOrder(node: TreeNode ? ): Unit
{
if (node == null)
{
return;
}
var i: Int = 0;
while (i < node.child.size)
{
// Visit child node
this.printPostOrder(node.child[i]);
i += 1;
}
// Display node value
print("  " + node.key);
}
}
fun main(args: Array < String > ): Unit
{
val tree: NAryTree = NAryTree();
/*
10
/   \
/     \
/       \
8         5
/|\      /|\ \
/ | \    / | \ \
-2 1  6  7 18 3  4
/ \           /| \
9  11         2 1  3
/  \
17   12
-----------------------
Constructing N-Arr tree

*/
// First element of tree
tree.root = TreeNode(10);
// Add child node [-2,1,6] in node (8)
// Add child node [9,11] in node (1)
// Add child node [17  12] in node (11)
// Add child node [7 18 3 4] in node (5)
// Add child node [2,1,3] in node (4)
tree.printPostOrder(tree.root);
}``````

#### Output

``  -2  9  17  12  11  1  6  8  7  18  3  2  1  3  4  5  10``

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.