# Find postorder traversal of BST from preorder traversal

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

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

Simple Approach: A simple solution is to first construct BST from given preorder traversal as described in this post. After constructing 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 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 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 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 correct position of that element is not found.

Below is implementation of above approach:

 `// C++ program for finding postorder ` `// traversal of BST from preorder traversal ` `#include ` `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 `

Output:
```35 30 100 80 40
```

Time Complexity: O(N), where N is the number of nodes.
Auxiliary Space: O(N) (Function call stack size)

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.

A Programmer and A Machine learning Enthusiast

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Practice Tags :