Find postorder traversal of BST from preorder traversal
Last Updated :
22 Aug, 2022
Given an array representing preorder traversal of BST, print its postorder traversal.
Examples:
Input : 40 30 35 80 100
Output : 35 30 100 80 40
Input : 40 30 32 35 80 90 100 120
Output : 35 32 30 120 100 90 80 40
Prerequisite: Construct BST from given preorder traversal
Simple Approach: A simple solution is to first construct BST from a given preorder traversal as described in this post. After constructing the tree, perform postorder traversal on it.
Efficient Approach:
An efficient approach is to find postorder traversal without constructing the tree. The idea is to traverse the given preorder array and maintain a range in which current element should lie. This is to ensure that the BST property is always satisfied. Initially the range is set to {minval = INT_MIN, maxval = INT_MAX}. In preorder traversal, the first element is always the root, and it will certainly lie in the initial range.
So store the first element of the preorder array. In postorder traversal, first left and right subtrees are printed and then root data is printed. So first recursive call for left and right subtrees are performed and then the value of root is printed. For left subtree range is updated to {minval, root->data} and for right subtree range is updated to {root->data, maxval}. If the current preorder array element does not lie in the range specified for it, then it does not belong to a current subtree, return from recursive calls until the correct position of that element is not found.
Below is the implementation of the above approach:
C++
// C++ program for finding postorder
// traversal of BST from preorder traversal
#include <bits/stdc++.h>
using namespace std;
// Function to find postorder traversal from
// preorder traversal.
void findPostOrderUtil(int pre[], int n, int minval,
int maxval, int& preIndex)
{
// If entire preorder array is traversed then
// return as no more element is left to be
// added to post order array.
if (preIndex == n)
return;
// If array element does not lie in range specified,
// then it is not part of current subtree.
if (pre[preIndex] < minval || pre[preIndex] > maxval) {
return;
}
// Store current value, to be printed later, after
// printing left and right subtrees. Increment
// preIndex to find left and right subtrees,
// and pass this updated value to recursive calls.
int val = pre[preIndex];
preIndex++;
// All elements with value between minval and val
// lie in left subtree.
findPostOrderUtil(pre, n, minval, val, preIndex);
// All elements with value between val and maxval
// lie in right subtree.
findPostOrderUtil(pre, n, val, maxval, preIndex);
cout << val << " ";
}
// Function to find postorder traversal.
void findPostOrder(int pre[], int n)
{
// To store index of element to be
// traversed next in preorder array.
// This is passed by reference to
// utility function.
int preIndex = 0;
findPostOrderUtil(pre, n, INT_MIN, INT_MAX, preIndex);
}
// Driver code
int main()
{
int pre[] = { 40, 30, 35, 80, 100 };
int n = sizeof(pre) / sizeof(pre[0]);
// Calling function
findPostOrder(pre, n);
return 0;
}
// Java program for finding postorder
// traversal of BST from preorder traversal
import java.util.*;
class Solution {
static class INT {
int data;
INT(int d) { data = d; }
}
// Function to find postorder traversal from
// preorder traversal.
static void findPostOrderUtil(int pre[], int n,
int minval, int maxval,
INT preIndex)
{
// If entire preorder array is traversed then
// return as no more element is left to be
// added to post order array.
if (preIndex.data == n)
return;
// If array element does not lie in range specified,
// then it is not part of current subtree.
if (pre[preIndex.data] < minval
|| pre[preIndex.data] > maxval) {
return;
}
// Store current value, to be printed later, after
// printing left and right subtrees. Increment
// preIndex to find left and right subtrees,
// and pass this updated value to recursive calls.
int val = pre[preIndex.data];
preIndex.data++;
// All elements with value between minval and val
// lie in left subtree.
findPostOrderUtil(pre, n, minval, val, preIndex);
// All elements with value between val and maxval
// lie in right subtree.
findPostOrderUtil(pre, n, val, maxval, preIndex);
System.out.print(val + " ");
}
// Function to find postorder traversal.
static void findPostOrder(int pre[], int n)
{
// To store index of element to be
// traversed next in preorder array.
// This is passed by reference to
// utility function.
INT preIndex = new INT(0);
findPostOrderUtil(pre, n, Integer.MIN_VALUE,
Integer.MAX_VALUE, preIndex);
}
// Driver code
public static void main(String args[])
{
int pre[] = { 40, 30, 35, 80, 100 };
int n = pre.length;
// Calling function
findPostOrder(pre, n);
}
}
// This code is contributed
// by Arnab Kundu
"""Python3 program for finding postorder
traversal of BST from preorder traversal"""
INT_MIN = -2**31
INT_MAX = 2**31
# Function to find postorder traversal
# from preorder traversal.
def findPostOrderUtil(pre, n, minval,
maxval, preIndex):
# If entire preorder array is traversed
# then return as no more element is left
# to be added to post order array.
if (preIndex[0] == n):
return
# If array element does not lie in
# range specified, then it is not
# part of current subtree.
if (pre[preIndex[0]] < minval or
pre[preIndex[0]] > maxval):
return
# Store current value, to be printed later,
# after printing left and right subtrees.
# Increment preIndex to find left and right
# subtrees, and pass this updated value to
# recursive calls.
val = pre[preIndex[0]]
preIndex[0] += 1
# All elements with value between minval
# and val lie in left subtree.
findPostOrderUtil(pre, n, minval,
val, preIndex)
# All elements with value between val
# and maxval lie in right subtree.
findPostOrderUtil(pre, n, val,
maxval, preIndex)
print(val, end=" ")
# Function to find postorder traversal.
def findPostOrder(pre, n):
# To store index of element to be
# traversed next in preorder array.
# This is passed by reference to
# utility function.
preIndex = [0]
findPostOrderUtil(pre, n, INT_MIN,
INT_MAX, preIndex)
# Driver Code
if __name__ == '__main__':
pre = [40, 30, 35, 80, 100]
n = len(pre)
# Calling function
findPostOrder(pre, n)
# This code is contributed by
# SHUBHAMSINGH10
// C# program for finding postorder
// traversal of BST from preorder traversal
using System;
class GFG {
public class INT {
public int data;
public INT(int d) { data = d; }
}
// Function to find postorder traversal from
// preorder traversal.
public static void findPostOrderUtil(int[] pre, int n,
int minval,
int maxval,
INT preIndex)
{
// If entire preorder array is traversed
// then return as no more element is left
// to be added to post order array.
if (preIndex.data == n) {
return;
}
// If array element does not lie in
// range specified, then it is not
// part of current subtree.
if (pre[preIndex.data] < minval
|| pre[preIndex.data] > maxval) {
return;
}
// Store current value, to be printed
// later, after printing left and right
// subtrees. Increment preIndex to find
// left and right subtrees, and pass this
// updated value to recursive calls.
int val = pre[preIndex.data];
preIndex.data++;
// All elements with value between
// minval and val lie in left subtree.
findPostOrderUtil(pre, n, minval, val, preIndex);
// All elements with value between
// val and maxval lie in right subtree.
findPostOrderUtil(pre, n, val, maxval, preIndex);
Console.Write(val + " ");
}
// Function to find postorder traversal.
public static void findPostOrder(int[] pre, int n)
{
// To store index of element to be
// traversed next in preorder array.
// This is passed by reference to
// utility function.
INT preIndex = new INT(0);
findPostOrderUtil(pre, n, int.MinValue,
int.MaxValue, preIndex);
}
// Driver code
public static void Main(string[] args)
{
int[] pre = new int[] { 40, 30, 35, 80, 100 };
int n = pre.Length;
// Calling function
findPostOrder(pre, n);
}
}
// This code is contributed by Shrikant13
<script>
// Javascript program for finding postorder
// traversal of BST from preorder traversal
class INT
{
constructor(d)
{
this.data=d;
}
}
// Function to find postorder traversal from
// preorder traversal.
function findPostOrderUtil(pre,n,minval,maxval,preIndex)
{
// If entire preorder array is traversed then
// return as no more element is left to be
// added to post order array.
if (preIndex.data == n)
return;
// If array element does not lie in range specified,
// then it is not part of current subtree.
if (pre[preIndex.data] < minval
|| pre[preIndex.data] > maxval) {
return;
}
// Store current value, to be printed later, after
// printing left and right subtrees. Increment
// preIndex to find left and right subtrees,
// and pass this updated value to recursive calls.
let val = pre[preIndex.data];
preIndex.data++;
// All elements with value between minval and val
// lie in left subtree.
findPostOrderUtil(pre, n, minval, val, preIndex);
// All elements with value between val and maxval
// lie in right subtree.
findPostOrderUtil(pre, n, val, maxval, preIndex);
document.write(val + " ");
}
// Function to find postorder traversal.
function findPostOrder(pre,n)
{
// To store index of element to be
// traversed next in preorder array.
// This is passed by reference to
// utility function.
let preIndex = new INT(0);
findPostOrderUtil(pre, n, Number.MIN_VALUE,
Number.MAX_VALUE, preIndex);
}
// Driver code
let pre=[40, 30, 35, 80, 100];
let n = pre.length;
// Calling function
findPostOrder(pre, n);
// This code is contributed by unknown2108
</script>
Complexity Analysis:
- Time Complexity: O(N), where N is the number of nodes.
- Auxiliary Space: O(N) (Function call stack size).
Similar Reads
Print Postorder traversal from given Inorder and Preorder traversals Given two arrays represent Inorder and Preorder traversals of a binary tree, the task is to find the Postorder traversal.Example:Input: in[] = [4, 2, 5, 1, 3, 6] pre[] = [1, 2, 4, 5, 3, 6]Output: 4 5 2 6 3 1Explanation: Traversals in the above example represents following tree: A naive method is to
11 min read
Preorder from Inorder and Postorder traversals Given the Inorder and Postorder traversals of a binary tree, the task is to find the Preorder traversal. Examples:Input: post[] = [4, 5, 2, 6, 3, 1] in[] = [4, 2, 5, 1, 3, 6]Output: 1 2 4 5 3 6Explanation: Traversals in the above example represents following tree:The idea is to first construct the b
14 min read
Construct Full Binary Tree from given preorder and postorder traversals Given two arrays that represent preorder and postorder traversals of a full binary tree, construct the binary tree. Full Binary Tree is a binary tree where every node has either 0 or 2 children.Examples of Full Trees. Input: pre[] = [1, 2, 4, 8, 9, 5, 3, 6, 7] , post[] = [8, 9, 4, 5, 2, 6, 7, 3, 1]O
9 min read
Preorder Traversal of Binary Tree Preorder traversal is a tree traversal method that follows the Root-Left-Right order:The root node of the subtree is visited first.Next, the left subtree is recursively traversed.Finally, the right subtree is recursively traversed.How does Preorder Traversal work?Key Properties: Used in expression t
5 min read
Find Leftmost and Rightmost node of BST from its given preorder traversal Given a preorder sequence of the binary search tree of N nodes. The task is to find its leftmost and rightmost nodes. Examples: Input : N = 5, preorder[]={ 3, 2, 1, 5, 4 } Output : Leftmost = 1, Rightmost = 5 The BST constructed from this preorder sequence would be: 3 / \ 2 5 / / 1 4 Leftmost Node o
5 min read
Preorder vs Inorder vs Postorder In Preorder Traversal, the root node is visited first, followed by the left and right subtrees. Inorder Traversal starts with the left subtree, visits the root, and then the right subtree, often used in binary search trees. Postorder Traversal begins with the left subtree, moves to the right subtree
7 min read