Construct a BST from given postorder traversal using Stack

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

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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<bits/stdc++.h> 
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<Node*> 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<Node> 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<Node> s = new Stack<Node>(); 
        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 */

Output:

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

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

C++

Java

Python3

C#

Recommended Posts: