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 > ();
    }
    public void addChild(int key)
    {
        // Create a new node
        TreeNode node = new TreeNode(key);
        // Add node into child
        this.child.add(node);
    }
}
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);
        tree.root.addChild(8);
        tree.root.addChild(5);
        // Add child node [-2,1,6] in node (8)
        tree.root.child.get(0).addChild(-2);
        tree.root.child.get(0).addChild(1);
        tree.root.child.get(0).addChild(6);
        // Add child node [9,11] in node (1)
        tree.root.child.get(0).child.get(1).addChild(9);
        tree.root.child.get(0).child.get(1).addChild(11);
        // Add child node [17  12] in node (11)
        tree.root.child.get(0).child.get(1).child.get(1).addChild(17);
        tree.root.child.get(0).child.get(1).child.get(1).addChild(12);
        // Add child node [7 18 3 4] in node (5)
        tree.root.child.get(1).addChild(7);
        tree.root.child.get(1).addChild(18);
        tree.root.child.get(1).addChild(3);
        tree.root.child.get(1).addChild(4);
        // Add child node [2,1,3] in node (4)
        tree.root.child.get(1).child.get(3).addChild(2);
        tree.root.child.get(1).child.get(3).addChild(1);
        tree.root.child.get(1).child.get(3).addChild(3);
        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
}
func(this *TreeNode) addChild(key int) {
	// Create a new node
	var node * TreeNode = getTreeNode(key)
	// Add node into child
	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)
	tree.root.addChild(8)
	tree.root.addChild(5)
	// Add child node [-2,1,6] in node (8)
	tree.root.child[0].addChild(-2)
	tree.root.child[0].addChild(1)
	tree.root.child[0].addChild(6)
	// Add child node [9,11] in node (1)
	tree.root.child[0].child[1].addChild(9)
	tree.root.child[0].child[1].addChild(11)
	// Add child node [17  12] in node (11)
	tree.root.child[0].child[1].child[1].addChild(17)
	tree.root.child[0].child[1].child[1].addChild(12)
	// Add child node [7 18 3 4] in node (5)
	tree.root.child[1].addChild(7)
	tree.root.child[1].addChild(18)
	tree.root.child[1].addChild(3)
	tree.root.child[1].addChild(4)
	// Add child node [2,1,3] in node (4)
	tree.root.child[1].child[3].addChild(2)
	tree.root.child[1].child[3].addChild(1)
	tree.root.child[1].child[3].addChild(3)
	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;
	}
	void addChild(int key)
	{
		// Create a new node
		TreeNode *node = new TreeNode(key);
		// Add node into child
		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);
	tree->root->addChild(8);
	tree->root->addChild(5);
	// Add child node [-2,1,6] in node (8)
	tree->root->child.at(0)->addChild(-2);
	tree->root->child.at(0)->addChild(1);
	tree->root->child.at(0)->addChild(6);
	// Add child node [9,11] in node (1)
	tree->root->child.at(0)->child.at(1)->addChild(9);
	tree->root->child.at(0)->child.at(1)->addChild(11);
	// Add child node [17  12] in node (11)
	tree->root->child.at(0)->child.at(1)->child.at(1)->addChild(17);
	tree->root->child.at(0)->child.at(1)->child.at(1)->addChild(12);
	// Add child node [7 18 3 4] in node (5)
	tree->root->child.at(1)->addChild(7);
	tree->root->child.at(1)->addChild(18);
	tree->root->child.at(1)->addChild(3);
	tree->root->child.at(1)->addChild(4);
	// Add child node [2,1,3] in node (4)
	tree->root->child.at(1)->child.at(3)->addChild(2);
	tree->root->child.at(1)->child.at(3)->addChild(1);
	tree->root->child.at(1)->child.at(3)->addChild(3);
	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 > ();
	}
	public void addChild(int key)
	{
		// Create a new node
		TreeNode node = new TreeNode(key);
		// Add node into child
		this.child.Add(node);
	}
}
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);
		tree.root.addChild(8);
		tree.root.addChild(5);
		// Add child node [-2,1,6] in node (8)
		tree.root.child[0].addChild(-2);
		tree.root.child[0].addChild(1);
		tree.root.child[0].addChild(6);
		// Add child node [9,11] in node (1)
		tree.root.child[0].child[1].addChild(9);
		tree.root.child[0].child[1].addChild(11);
		// Add child node [17  12] in node (11)
		tree.root.child[0].child[1].child[1].addChild(17);
		tree.root.child[0].child[1].child[1].addChild(12);
		// Add child node [7 18 3 4] in node (5)
		tree.root.child[1].addChild(7);
		tree.root.child[1].addChild(18);
		tree.root.child[1].addChild(3);
		tree.root.child[1].addChild(4);
		// Add child node [2,1,3] in node (4)
		tree.root.child[1].child[3].addChild(2);
		tree.root.child[1].child[3].addChild(1);
		tree.root.child[1].child[3].addChild(3);
		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();
	}
	public	function addChild($key)
	{
		// Create a new node
		$node = new TreeNode($key);
		// Add node into child
		$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);
	$tree->root->addChild(8);
	$tree->root->addChild(5);
	// Add child node [-2,1,6] in node (8)
	$tree->root->child[0]->addChild(-2);
	$tree->root->child[0]->addChild(1);
	$tree->root->child[0]->addChild(6);
	// Add child node [9,11] in node (1)
	$tree->root->child[0]->child[1]->addChild(9);
	$tree->root->child[0]->child[1]->addChild(11);
	// Add child node [17  12] in node (11)
	$tree->root->child[0]->child[1]->child[1]->addChild(17);
	$tree->root->child[0]->child[1]->child[1]->addChild(12);
	// Add child node [7 18 3 4] in node (5)
	$tree->root->child[1]->addChild(7);
	$tree->root->child[1]->addChild(18);
	$tree->root->child[1]->addChild(3);
	$tree->root->child[1]->addChild(4);
	// Add child node [2,1,3] in node (4)
	$tree->root->child[1]->child[3]->addChild(2);
	$tree->root->child[1]->child[3]->addChild(1);
	$tree->root->child[1]->child[3]->addChild(3);
	$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 = [];
	}
	addChild(key)
	{
		// Create a new node
		var node = new TreeNode(key);
		// Add node into child
		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);
	tree.root.addChild(8);
	tree.root.addChild(5);
	// Add child node [-2,1,6] in node (8)
	tree.root.child[0].addChild(-2);
	tree.root.child[0].addChild(1);
	tree.root.child[0].addChild(6);
	// Add child node [9,11] in node (1)
	tree.root.child[0].child[1].addChild(9);
	tree.root.child[0].child[1].addChild(11);
	// Add child node [17  12] in node (11)
	tree.root.child[0].child[1].child[1].addChild(17);
	tree.root.child[0].child[1].child[1].addChild(12);
	// Add child node [7 18 3 4] in node (5)
	tree.root.child[1].addChild(7);
	tree.root.child[1].addChild(18);
	tree.root.child[1].addChild(3);
	tree.root.child[1].addChild(4);
	// Add child node [2,1,3] in node (4)
	tree.root.child[1].child[3].addChild(2);
	tree.root.child[1].child[3].addChild(1);
	tree.root.child[1].child[3].addChild(3);
	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 = []
	
	def addChild(self, key) :
		#  Create a new node
		node = TreeNode(key)
		#  Add node into child
		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)
	tree.root.addChild(8)
	tree.root.addChild(5)
	#  Add child node [-2,1,6] in node (8)
	tree.root.child[0].addChild(-2)
	tree.root.child[0].addChild(1)
	tree.root.child[0].addChild(6)
	#  Add child node [9,11] in node (1)
	tree.root.child[0].child[1].addChild(9)
	tree.root.child[0].child[1].addChild(11)
	#  Add child node [17  12] in node (11)
	tree.root.child[0].child[1].child[1].addChild(17)
	tree.root.child[0].child[1].child[1].addChild(12)
	#  Add child node [7 18 3 4] in node (5)
	tree.root.child[1].addChild(7)
	tree.root.child[1].addChild(18)
	tree.root.child[1].addChild(3)
	tree.root.child[1].addChild(4)
	#  Add child node [2,1,3] in node (4)
	tree.root.child[1].child[3].addChild(2)
	tree.root.child[1].child[3].addChild(1)
	tree.root.child[1].child[3].addChild(3)
	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_reader :key, :child
	attr_accessor :key, :child
	def initialize(key) 
		#  Set node key
		self.key = key
		#  Create memory of TreeNode child
		self.child = []
	end

	def addChild(key) 
		#  Create a new node
		node = TreeNode.new(key)
		#  Add node into child
		self.child.push(node)
	end

end

class NAryTree 
	# Define the accessor and reader of class NAryTree
	attr_reader :root
	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)
	tree.root.addChild(8)
	tree.root.addChild(5)
	#  Add child node [-2,1,6] in node (8)
	tree.root.child[0].addChild(-2)
	tree.root.child[0].addChild(1)
	tree.root.child[0].addChild(6)
	#  Add child node [9,11] in node (1)
	tree.root.child[0].child[1].addChild(9)
	tree.root.child[0].child[1].addChild(11)
	#  Add child node [17  12] in node (11)
	tree.root.child[0].child[1].child[1].addChild(17)
	tree.root.child[0].child[1].child[1].addChild(12)
	#  Add child node [7 18 3 4] in node (5)
	tree.root.child[1].addChild(7)
	tree.root.child[1].addChild(18)
	tree.root.child[1].addChild(3)
	tree.root.child[1].addChild(4)
	#  Add child node [2,1,3] in node (4)
	tree.root.child[1].child[3].addChild(2)
	tree.root.child[1].child[3].addChild(1)
	tree.root.child[1].child[3].addChild(3)
	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);
		// Add node into child
		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);
		tree.root.addChild(8);
		tree.root.addChild(5);
		// Add child node [-2,1,6] in node (8)
		tree.root.child(0).addChild(-2);
		tree.root.child(0).addChild(1);
		tree.root.child(0).addChild(6);
		// Add child node [9,11] in node (1)
		tree.root.child(0).child(1).addChild(9);
		tree.root.child(0).child(1).addChild(11);
		// Add child node [17  12] in node (11)
		tree.root.child(0).child(1).child(1).addChild(17);
		tree.root.child(0).child(1).child(1).addChild(12);
		// Add child node [7 18 3 4] in node (5)
		tree.root.child(1).addChild(7);
		tree.root.child(1).addChild(18);
		tree.root.child(1).addChild(3);
		tree.root.child(1).addChild(4);
		// Add child node [2,1,3] in node (4)
		tree.root.child(1).child(3).addChild(2);
		tree.root.child(1).child(3).addChild(1);
		tree.root.child(1).child(3).addChild(3);
		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? ]();
	}
	func addChild(_ key: Int)
	{
		// Create a new node
		let node: TreeNode = TreeNode(key);
		// Add node into child
		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);
	tree.root!.addChild(8);
	tree.root!.addChild(5);
	// Add child node [-2,1,6] in node (8)
	tree.root!.child[0]!.addChild(-2);
	tree.root!.child[0]!.addChild(1);
	tree.root!.child[0]!.addChild(6);
	// Add child node [9,11] in node (1)
	tree.root!.child[0]!.child[1]!.addChild(9);
	tree.root!.child[0]!.child[1]!.addChild(11);
	// Add child node [17  12] in node (11)
	tree.root!.child[0]!.child[1]!.child[1]!.addChild(17);
	tree.root!.child[0]!.child[1]!.child[1]!.addChild(12);
	// Add child node [7 18 3 4] in node (5)
	tree.root!.child[1]!.addChild(7);
	tree.root!.child[1]!.addChild(18);
	tree.root!.child[1]!.addChild(3);
	tree.root!.child[1]!.addChild(4);
	// Add child node [2,1,3] in node (4)
	tree.root!.child[1]!.child[3]!.addChild(2);
	tree.root!.child[1]!.child[3]!.addChild(1);
	tree.root!.child[1]!.child[3]!.addChild(3);
	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 > ();
	}
	fun addChild(key: Int): Unit
	{
		// Create a new node
		val node: TreeNode = TreeNode(key);
		// Add node into child
		this.child.add(node);
	}
}
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);
	tree.root?.addChild(8);
	tree.root?.addChild(5);
	// Add child node [-2,1,6] in node (8)
	tree.root!!.child[0].addChild(-2);
	tree.root!!.child[0].addChild(1);
	tree.root!!.child[0].addChild(6);
	// Add child node [9,11] in node (1)
	tree.root!!.child[0].child[1].addChild(9);
	tree.root!!.child[0].child[1].addChild(11);
	// Add child node [17  12] in node (11)
	tree.root!!.child[0].child[1].child[1].addChild(17);
	tree.root!!.child[0].child[1].child[1].addChild(12);
	// Add child node [7 18 3 4] in node (5)
	tree.root!!.child[1].addChild(7);
	tree.root!!.child[1].addChild(18);
	tree.root!!.child[1].addChild(3);
	tree.root!!.child[1].addChild(4);
	// Add child node [2,1,3] in node (4)
	tree.root!!.child[1].child[3].addChild(2);
	tree.root!!.child[1].child[3].addChild(1);
	tree.root!!.child[1].child[3].addChild(3);
	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.

New Comment




© 2022, kalkicode.com, All rights reserved