Related Articles

# Construct a BST from given postorder traversal using Stack

• Difficulty Level : Medium
• Last Updated : 01 Jul, 2021

Given postorder traversal of a binary search tree, construct the BST.
For example,
1. If the given traversal is {1, 7, 5, 50, 40, 10}, then following tree should be constructed and root of the tree should be returned.

```     10
/   \
5     40
/  \      \
1    7      50```

Input : 1 7 5 50 40 10
Output :
Inorder traversal of the constructed tree:
1 5 7 10 40 50
If the given traversal is {2, 6, 4, 9, 13, 11, 7}, then following tree should be constructed and root of the tree should be returned.

```       7
/   \
4     11
/ \    /  \
2   6  9    13```

Input : 2 6 4 9 13 11 7
Output :
Inorder traversal of the constructed tree:
2 4 6 7 9 11 13

Let us first see working Postorder traversal

```Left
Right
Root
Hence last node of post order will be root of tree, create it and push to stack.
If next element(i-1) is greater then it should be in right subtree.
If next element(i-1) is less then it should be in left subtree.```

Algorithm:

• Push root of the BST to the stack i.e, last element of the array.
• Start traversing the array in reverse, if next element is > the element at the top of the stack then,
set this element as the right child of the element at the top of the stack and also push it to the stack.
• Else if, next element is < the element at the top of the stack then,
start popping all the elements from the stack until either the stack is empty or the current element becomes > the element at the top of the stack.
• Make this element left child of the last popped node and repeat the above steps until the array is traversed completely.

Below is the implementation of the above algorithm.

## C++

 `// C++ implementation of the algorithm``/* A binary tree node has data,``pointer to left child and a pointer``to right child */``#include``using` `namespace` `std;` `// Class Node has data and references``// to the left and the right child.``class` `Node``{``    ``public``:``    ``int` `data;``    ``Node* left, *right;` `    ``Node(``int` `data)``    ``{``        ``this``->data = data;``        ``left = right = NULL;``    ``}``};` `// Function that creates the tree``Node* constructTreeUtil(``int` `post[], ``int` `n)``{``    ``// Last node is root``    ``Node* root = ``new` `Node(post[n - 1]);``    ``stack s;``    ``s.push(root);` `    ``// Traverse from second last node``    ``for` `(``int` `i = n - 2; i >= 0; --i)``    ``{``        ``Node* x = ``new` `Node(post[i]);` `        ``// Keep popping nodes while top()``        ``// of stack is greater.``        ``Node* temp = NULL;``        ``while` `(s.size() &&``               ``post[i] < s.top()->data)``            ``temp = s.top(), s.pop();    ` `        ``// Make x as left child of temp``        ``if` `(temp != NULL)``            ``temp->left = x;    ` `        ``// Else make x as right of top    ``        ``else``            ``s.top()->right = x;``        ``s.push(x);``    ``}``    ``return` `root;``}` `// Function that calls the method``// which contructs the tree``Node* constructTree(``int` `post[], ``int` `size)``{``    ``return` `constructTreeUtil(post, size);``}` `// A utility function to print``// inorder traversal of a Binary Tree``void` `printInorder(Node* node)``{``    ``if` `(node == NULL)``        ``return``;``    ``printInorder(node->left);``    ``cout << node->data << ``" "``;``    ``printInorder(node->right);``}` `// Driver Code``int` `main()``{``    ``int` `post[] = { 1, 7, 5, 50, 40, 10 };``    ``int` `size = ``sizeof``(post)/``sizeof``(``int``);` `    ``Node* root = constructTree(post, size);` `    ``cout << ``"Inorder traversal of "``         ``<< ``"the constructed tree:\n"``;``    ``printInorder(root);``}` `// This code is contributed by Arnab Kundu`

## Java

 `// Java implementation of the algorithm``/* A binary tree node has data, pointer to left child``and a pointer to right child */``import` `java.util.*;` `// Class Node has data and references to the left``// and the right child.``class` `Node {``    ``int` `data;``    ``Node left, right;` `    ``Node(``int` `data)``    ``{``        ``this``.data = data;``        ``left = right = ``null``;``    ``}``}` `class` `BinaryTree {` `    ``// Function that creates the tree``    ``Node constructTreeUtil(``int` `post[], ``int` `n)``    ``{``        ``// Last node is root``        ``Node root = ``new` `Node(post[n - ``1``]);``        ``Stack s = ``new` `Stack<>();``        ``s.push(root);` `        ``// Traverse from second last node``        ``for` `(``int` `i = n - ``2``; i >= ``0``; --i) {``            ` `            ``Node x = ``new` `Node(post[i]);` `            ``// Keep popping nodes while top() of stack``            ``// is greater.``            ``Node temp = ``null``;``            ``while` `(!s.isEmpty() && post[i] < s.peek().data)``                ``temp = s.pop();     ` `            ``// Make x as left child of temp  ``            ``if` `(temp != ``null``)``                ``temp.left = x;     ` `            ``// Else make x as right of top     ``            ``else``                ``s.peek().right = x;``            ``s.push(x);``        ``}``        ``return` `root;``    ``}` `    ``// Function that calls the method which contructs the tree``    ``Node constructTree(``int` `post[], ``int` `size)``    ``{``        ``return` `constructTreeUtil(post, size);``    ``}` `    ``// A utility function to print inorder traversal``    ``// of a Binary Tree``    ``void` `printInorder(Node node)``    ``{``        ``if` `(node == ``null``)``            ``return``;``        ``printInorder(node.left);``        ``System.out.print(node.data + ``" "``);``        ``printInorder(node.right);``    ``}` `    ``// Driver program to test above functions``    ``public` `static` `void` `main(String[] args)``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();``        ``int` `post[] = ``new` `int``[] { ``1``, ``7``, ``5``, ``50``, ``40``, ``10` `};``        ``int` `size = post.length;` `        ``Node root = tree.constructTree(post, size);` `        ``System.out.println(``"Inorder traversal of the constructed tree:"``);``        ``tree.printInorder(root);``    ``}``}`

## Python3

 `# Python3 implementation of the algorithm``# A binary tree node has data,``# pointer to left child and a pointer``# to right child` `# Class Node has data and references``# to the left and the right child.``class` `Node:``    ``def` `__init__(``self``, data ``=` `0``):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None``    ` `# Function that creates the tree``def` `constructTreeUtil(post , n):` `    ``# Last node is root``    ``root ``=` `Node(post[n ``-` `1``])``    ``s ``=` `[]``    ``s.append(root)``    ``i ``=` `n ``-` `2` `    ``# Traverse from second last node``    ``while` `( i >``=` `0``):``        ``x ``=` `Node(post[i])` `        ``# Keep popping nodes while top()``        ``# of stack is greater.``        ``temp ``=` `None``        ``while` `(``len``(s) > ``0` `and` `post[i] < s[``-``1``].data) :``            ``temp ``=` `s[``-``1``]``            ``s.pop()    ` `        ``# Make x as left child of temp``        ``if` `(temp !``=` `None``):``            ``temp.left ``=` `x    ` `        ``# Else make x as right of top    ``        ``else``:``            ``s[``-``1``].right ``=` `x``        ``s.append(x)``        ``i ``=` `i ``-` `1``    ` `    ``return` `root` `# Function that calls the method``# which contructs the tree``def` `constructTree( post, size):``    ``return` `constructTreeUtil(post, size)` `# A utility function to print``# inorder traversal of a Binary Tree``def` `printInorder( node):``    ``if` `(node ``=``=` `None``):``        ``return``    ``printInorder(node.left)``    ``print``( node.data, end ``=` `" "``)``    ``printInorder(node.right)` `# Driver Code``post ``=` `[``1``, ``7``, ``5``, ``50``, ``40``, ``10``]``size ``=` `len``(post)` `root ``=` `constructTree(post, size)` `print``( ``"Inorder traversal of the constructed tree:"``)``printInorder(root)` `# This code is contributed by Arnab Kundu`

## C#

 `// C# implementation of the algorithm` `/* A binary tree node has data,``pointer to left child``and a pointer to right child */``using` `System;``using` `System.Collections.Generic;` `// Class Node has data and references ``// to the left and the right child.``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;` `    ``public` `Node(``int` `data)``    ``{``        ``this``.data = data;``        ``left = right = ``null``;``    ``}``}` `public` `class` `BinaryTree``{` `    ``// Function that creates the tree``    ``Node constructTreeUtil(``int` `[]post, ``int` `n)``    ``{``        ``// Last node is root``        ``Node root = ``new` `Node(post[n - 1]);``        ``Stack s = ``new` `Stack();``        ``s.Push(root);` `        ``// Traverse from second last node``        ``for` `(``int` `i = n - 2; i >= 0; --i)``        ``{``            ` `            ``Node x = ``new` `Node(post[i]);` `            ``// Keep popping nodes while top() of stack``            ``// is greater.``            ``Node temp = ``null``;``            ``while` `(s.Count!=0 && post[i] < s.Peek().data)``                ``temp = s.Pop();    ` `            ``// Make x as left child of temp``            ``if` `(temp != ``null``)``                ``temp.left = x;    ` `            ``// Else make x as right of top    ``            ``else``                ``s.Peek().right = x;``            ``s.Push(x);``        ``}``        ``return` `root;``    ``}` `    ``// Function that calls the``    ``// method which contructs the tree``    ``Node constructTree(``int` `[]post, ``int` `size)``    ``{``        ``return` `constructTreeUtil(post, size);``    ``}` `    ``// A utility function to print ``    ``// inorder traversal of a Binary Tree``    ``void` `printInorder(Node node)``    ``{``        ``if` `(node == ``null``)``            ``return``;``        ``printInorder(node.left);``        ``Console.Write(node.data + ``" "``);``        ``printInorder(node.right);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();``        ``int` `[]post = ``new` `int``[] { 1, 7, 5, 50, 40, 10 };``        ``int` `size = post.Length;` `        ``Node root = tree.constructTree(post, size);` `        ``Console.WriteLine(``"Inorder traversal of the constructed tree:"``);``        ``tree.printInorder(root);``    ``}``}` `/* This code contributed by PrinciRaj1992 */`

## Javascript

 ``
Output:
```Inorder traversal of the constructed tree:
1 5 7 10 40 50```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up