 Open in App
Not now

# Create a binary tree from post order traversal and leaf node array

• Last Updated : 26 Nov, 2021

Given 2 arrays, the first one containing postorder traversal sequence and the second one containing the information whether the corresponding node in the first array is a leaf node or a non-leaf node, create a binary tree and return its root and print it’s inorder traversal. (There can be more than one tree possible, but you have to form only one tree)
Examples:

```Input:
postorder = {40, 20, 50, 60, 30, 10}
isLeaf = {true, false, true, true, false, false}
Output: 20 40 10 50 30 60
Explanation:
Generated Binary tree
10
/    \
20      30
\     /  \
40   50  60

Input:
postorder = {20, 18, 25, 100, 81, 15, 7}
isLeaf = {true, false, true, true, false, false, false}
Output: 7 18 20 15 25 81 100
Explanation:
Generated Binary tree
7
\
15
/   \
18     81
\    /  \
20  25  100```

Approach:
The idea is to first construct the root node of the binary tree using the last key in the post-order sequence. Then using the given boolean array, we find if the root node is an internal node or a leaf node. If the root node is an internal node, we recursively construct its right and left subtrees.
Below is the implementation of the above approach :

## C++

 `// C++ implementation for``// the above approach``#include ``using` `namespace` `std;` `// struct to store``// tree nodes``struct` `Tree {``    ``int` `val;``    ``Tree* leftchild;``    ``Tree* rightchild;``    ``Tree(``int` `_val, Tree* _leftchild, Tree* _rightchild)``    ``{``        ``val = _val;``        ``leftchild = _leftchild;``        ``rightchild = _rightchild;``    ``}``};`  `// Function to generate binary tree``// from given postorder traversal sequence``// and leaf or non-leaf node information.``struct` `Tree* createBinaryTree(``int` `post[], ``bool` `isLeaf[], ``int``& n)``{``  ``// Base condition``  ``if` `(n < 0){``    ``return` `NULL;``  ``}``  ``struct` `Tree* root = ``new` `Tree(post[n], NULL, NULL);``  ``bool` `isInternalNode = !isLeaf[n];``  ``n--;``  ``// If internal node``  ``// creating left and``  ``// right child``  ``if` `(isInternalNode) {``    ``root->rightchild = createBinaryTree(post, isLeaf, n);``    ``root->leftchild = createBinaryTree(post, isLeaf, n);``  ``}``  ``return` `root;``}` `// Function to print``// in-order traversal``// of a binary tree.``void` `inorder(``struct` `Tree* root)``{``  ``if` `(root == NULL){``    ``return``;``  ``}``  ``inorder(root->leftchild);``  ``cout << root->val << ``" "``;``  ``inorder(root->rightchild);``}` `// Driver code``int` `main()``{``  ``int` `post[] = { 40, 20, 50, 60, 30, 10 };``  ``bool` `isLeaf[] = { ``true``, ``false``, ``true``, ``true``, ``false``, ``false` `};``  ``int` `n = ``sizeof``(post) / ``sizeof``(post) - 1;` `  ``struct` `Tree* root = createBinaryTree(post, isLeaf, n);``  ``inorder(root);` `  ``return` `0;``}`

## Java

 `// Java implementation for``// the above approach``class` `GFG``{` `static` `int` `n;` `// to store tree nodes``static` `class` `Tree``{``    ``int` `val;``    ``Tree leftchild;``    ``Tree rightchild;``    ``Tree(``int` `_val, Tree _leftchild,``                   ``Tree _rightchild)``    ``{``        ``val = _val;``        ``leftchild = _leftchild;``        ``rightchild = _rightchild;``    ``}``};` `// Function to generate binary tree``// from given postorder traversal sequence``// and leaf or non-leaf node information.``static` `Tree createBinaryTree(``int` `post[],``                             ``boolean` `isLeaf[])``{``    ``// Base condition``    ``if` `(n < ``0``)``    ``{``        ``return` `null``;``    ``}``    ``Tree root = ``new` `Tree(post[n], ``null``, ``null``);``    ``boolean` `isInternalNode = !isLeaf[n];``    ``n--;``    ` `    ``// If internal node creating left and``    ``// right child``    ``if` `(isInternalNode)``    ``{``        ``root.rightchild = createBinaryTree(post, isLeaf);``        ``root.leftchild = createBinaryTree(post, isLeaf);``    ``}``    ``return` `root;``}` `// Function to print in-order traversal``// of a binary tree.``static` `void` `inorder(Tree root)``{``    ``if` `(root == ``null``)``    ``{``        ``return``;``    ``}``    ``inorder(root.leftchild);``    ``System.out.print(root.val + ``" "``);``    ``inorder(root.rightchild);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `post[] = { ``40``, ``20``, ``50``, ``60``, ``30``, ``10` `};``    ``boolean` `isLeaf[] = { ``true``, ``false``, ``true``,``                         ``true``, ``false``, ``false` `};``    ``n = post.length - ``1``;``    ` `    ``Tree root = createBinaryTree(post, isLeaf);``    ``inorder(root);``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python implementation of above algorithm` `# Utility class to create a node``class` `Tree:``    ``def` `__init__(``self``, key):``        ``self``.val ``=` `key``        ``self``.leftchild ``=` `self``.rightchild ``=` `None` `n ``=` `0` `# Function to generate binary tree``# from given postorder traversal sequence``# and leaf or non-leaf node information.``def` `createBinaryTree( post, isLeaf):``    ``global` `n` `    ``# Base condition``    ``if` `(n < ``0``):``        ``return` `None` `    ``root ``=` `Tree(post[n])``    ``isInternalNode ``=` `not` `isLeaf[n]``    ``n ``=` `n ``-` `1` `    ``# If internal node``    ``# creating left and``    ``# right child``    ``if` `(isInternalNode):``        ``root.rightchild ``=` `createBinaryTree(post, isLeaf)``        ``root.leftchild ``=` `createBinaryTree(post, isLeaf)``    ` `    ``return` `root` `# Function to print``# in-order traversal``# of a binary tree.``def` `inorder( root):` `    ``if` `(root ``=``=` `None``):``        ``return``    ` `    ``inorder(root.leftchild)``    ``print``( root.val ,end ``=` `" "``)``    ``inorder(root.rightchild)` `# Driver code` `post ``=` `[``40``, ``20``, ``50``, ``60``, ``30``, ``10``]``isLeaf ``=` `[``True``, ``False``, ``True``, ``True``, ``False``, ``False` `]``n ``=` `len``(post)``-``1` `root ``=` `createBinaryTree(post, isLeaf)``inorder(root)` `# This code is contributed by Arnab Kundu`

## C#

 `// C# implementation of the above approach``using` `System;``    ` `class` `GFG``{``static` `int` `n;` `// to store tree nodes``public` `class` `Tree``{``    ``public` `int` `val;``    ``public` `Tree leftchild;``    ``public` `Tree rightchild;``    ``public` `Tree(``int` `_val, Tree _leftchild,``                          ``Tree _rightchild)``    ``{``        ``val = _val;``        ``leftchild = _leftchild;``        ``rightchild = _rightchild;``    ``}``};` `// Function to generate binary tree``// from given postorder traversal sequence``// and leaf or non-leaf node information.``static` `Tree createBinaryTree(``int` `[]post,``                         ``Boolean []isLeaf)``{``    ``// Base condition``    ``if` `(n < 0)``    ``{``        ``return` `null``;``    ``}``    ``Tree root = ``new` `Tree(post[n], ``null``, ``null``);``    ``Boolean isInternalNode = !isLeaf[n];``    ``n--;``    ` `    ``// If internal node creating left and``    ``// right child``    ``if` `(isInternalNode)``    ``{``        ``root.rightchild = createBinaryTree(post,``                                           ``isLeaf);``        ``root.leftchild = createBinaryTree(post,``                                          ``isLeaf);``    ``}``    ``return` `root;``}` `// Function to print in-order traversal``// of a binary tree.``static` `void` `inorder(Tree root)``{``    ``if` `(root == ``null``)``    ``{``        ``return``;``    ``}``    ``inorder(root.leftchild);``    ``Console.Write(root.val + ``" "``);``    ``inorder(root.rightchild);``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]post = { 40, 20, 50, 60, 30, 10 };``    ``Boolean []isLeaf = { ``true``, ``false``, ``true``,``                         ``true``, ``false``, ``false` `};``    ``n = post.Length - 1;``    ` `    ``Tree root = createBinaryTree(post, isLeaf);``    ``inorder(root);``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output:

`20 40 10 50 30 60`

Time Complexity: O(N).
Auxiliary Space: O(N).

My Personal Notes arrow_drop_up