Open In App

Preorder from Inorder and Postorder traversals

Last Updated : 11 Jul, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

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 6
Explanation: Traversals in the above example represents following tree:

print-postorder-traversal-from-given-inorder-and-preorder-traversals

The idea is to first construct the binary tree from a given postorder and inorder, then use a simple recursive method to print the preorder traversal of the constructed tree.

Note: We can optimize the above method. We do not need to create the tree.

Table of Content

[Naive approach] Search current element every time - O(n^2) Time and O(n) Space

 The idea is that root is always the first item in preorder traversal and it must be the last item in postorder traversal. We first push right subtree to a stack, then left subtree, and finally, we push root. Finally, we print contents of stack. To find boundaries of left and right subtrees in post[] and in[], we search root in in[], all elements before root in in[] are elements of left subtree, and all elements after root are elements of right subtree. In post[], all elements after index of root in in[] are elements of right subtree. And elements before index (including the element at index and excluding the first element) are elements of left subtree. 

Below is the implementation of the above approach: 

C++ 
// C++ program to print Postorder traversal from given
// Inorder and Preorder traversals.

#include<bits/stdc++.h>
using namespace std; 

// A utility function to search data in in[]
int search(vector<int>& in, int data, int n) {
    int i = 0;
    for (i = 0; i < n; i++)
        if (in[i] == data)
            return i;
    return i;
}

// Fills preorder traversal of tree with given
// inorder and postorder traversals in a stack
void fillPre(vector<int>& in, vector<int>& post, int inStrt,
            int inEnd, stack<int> &s, int n, int &postIndex) {
    if (inStrt > inEnd)
        return;

    // Find index of next item in postorder traversal in
    // inorder.
    int val = post[postIndex];
    int inIndex = search(in, val, n);
    postIndex--;

    // traverse right tree
    fillPre(in, post, inIndex + 1, inEnd, s, n, postIndex);

    // traverse left tree
    fillPre(in, post, inStrt, inIndex - 1, s, n, postIndex);

    s.push(val);
}

// This function basically initializes postIndex
// as last element index, then fills stack with
// reverse preorder traversal using printPre
vector<int> getPreorderTraversal(vector<int>& in, vector<int>& post, int n) {
    int len = n;
    int postIndex = len - 1;
    stack<int> s;
    fillPre(in, post, 0, len - 1, s, n, postIndex);	
  	vector<int> result;
    while (s.size() > 0) {
      	result.push_back(s.top());
        s.pop();
    }
  	return result;
}

int main() {
    vector<int> in = { 4, 2, 5, 1, 3, 6 };
    vector<int> post = { 4, 5, 2, 6, 3, 1 };
    int n = in.size();
    vector<int> result = getPreorderTraversal(in, post, n);
  	for(int i : result) {
    	cout << i << " ";
    }
}
Java 
// Java program to print Preorder traversal from given
// Inorder and Postorder traversals.

import java.util.*;

class Node {
    int data;
    Node left, right;
    
    Node(int data) {
        this.data = data;
        this.left = this.right = null;
    }
}

class GfG {

    // A utility function to search data in in[]
    static int search(List<Integer> in, int data, int n) {
        for (int i = 0; i < n; i++)
            if (in.get(i) == data)
                return i;
        return -1;
    }

    // Fills preorder traversal of tree with given
    // inorder and postorder traversals in a stack
    static void fillPre(List<Integer> in, List<Integer> post, int inStrt,
                         int inEnd, Stack<Integer> s, int n, int[] postIndex) {
        if (inStrt > inEnd)
            return;

        // Find index of next item in postorder 
      	// traversal in inorder.
        int val = post.get(postIndex[0]);
        int inIndex = search(in, val, n);
        postIndex[0]--;

        // traverse right tree
        fillPre(in, post, inIndex + 1, inEnd, s, n, postIndex);

        // traverse left tree
        fillPre(in, post, inStrt, inIndex - 1, s, n, postIndex);

        s.push(val);
    }

    // This function basically initializes postIndex as last element index,
    // then fills stack with reverse preorder traversal using fillPre
    static List<Integer> getPreorderTraversal
      		(List<Integer> in, List<Integer> post, int n) {
        int postIndex = n - 1;
        Stack<Integer> s = new Stack<>();
        fillPre(in, post, 0, n - 1, s, n, new int[]{postIndex});

        List<Integer> result = new ArrayList<>();
        while (!s.isEmpty()) {
            result.add(s.pop());
        }
        return result;
    }

    public static void main(String[] args) {
        List<Integer> in = Arrays.asList(4, 2, 5, 1, 3, 6);
        List<Integer> post = Arrays.asList(4, 5, 2, 6, 3, 1);
        int n = in.size();

        List<Integer> result = getPreorderTraversal(in, post, n);

        for (int i : result) {
            System.out.print(i + " ");
        }
    }
}
Python 
# Python program to print Preorder traversal from given
# Inorder and Postorder traversals.

# A utility function to search data in in[]
def search(inorder, data, n):
    for i in range(n):
        if inorder[i] == data:
            return i
    return -1

# Fills preorder traversal of tree with given
# inorder and postorder traversals in a stack
def fill_pre(inorder, postorder, in_start, in_end, \
             stack, n, post_index):
    if in_start > in_end:
        return
    
    # Find index of next item in postorder traversal in inorder.
    val = postorder[post_index[0]]
    in_index = search(inorder, val, n)
    post_index[0] -= 1
    
    # Traverse right tree
    fill_pre(inorder, postorder, in_index + 1, in_end,\
             stack, n, post_index)
    
    # Traverse left tree
    fill_pre(inorder, postorder, in_start, in_index - 1,\
             stack, n, post_index)
    
    stack.append(val)

# This function initializes postIndex as 
# last element index and fills stack
# with reverse preorder traversal using fillPre
def get_preorder_traversal(inorder, postorder, n):
    post_index = [n - 1]
    stack = []
    fill_pre(inorder, postorder, 0, n - 1, stack, n, \
             post_index)
    
    return list(reversed(stack))

if __name__ == "__main__":
  
    inorder = [4, 2, 5, 1, 3, 6]
    postorder = [4, 5, 2, 6, 3, 1]
    n = len(inorder)
    result = get_preorder_traversal(inorder, postorder, n)
    
    for val in result:
        print(val, end=" ")
C# 
// C# program to print Preorder traversal from given
// Inorder and Postorder traversals.

using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int data) {
        this.data = data;
        this.left = this.right = null;
    }
}

class GfG {

    // A utility function to search data in in[]
    static int Search(List<int> inorder, int data, int n) {
        for (int i = 0; i < n; i++) {
            if (inorder[i] == data)
                return i;
        }
        return -1;
    }

    // Fills preorder traversal of tree with given 
  	// inorder and postorder traversals in a stack
    static void FillPre(List<int> inorder, List<int> postorder, int inStart,
                         int inEnd, Stack<int> s, int n, ref int postIndex) {
        if (inStart > inEnd)
            return;

        // Find index of next item in postorder 
      	// traversal in inorder.
        int val = postorder[postIndex];
        int inIndex = Search(inorder, val, n);
        postIndex--;

        // Traverse right tree
        FillPre(inorder, postorder, inIndex + 1, inEnd,
                			s, n, ref postIndex);

        // Traverse left tree
        FillPre(inorder, postorder, inStart, inIndex - 1, s,
                			n, ref postIndex);

        s.Push(val);
    }

    // This function initializes postIndex as last 
  	// element index and fills stack
    // with reverse preorder traversal using FillPre
    static List<int> GetPreorderTraversal(List<int> inorder,
                                          List<int> postorder, int n) {
        int postIndex = n - 1;
        Stack<int> s = new Stack<int>();
        FillPre(inorder, postorder, 0, n - 1, s, n, ref postIndex);

        List<int> result = new List<int>();
        while (s.Count > 0) {
            result.Add(s.Pop());
        }
        return result;
    }

    static void Main(string[] args) {
        List<int> inorder = new List<int> { 4, 2, 5, 1, 3, 6 };
        List<int> postorder = new List<int> { 4, 5, 2, 6, 3, 1 };
        int n = inorder.Count;

        List<int> result = GetPreorderTraversal
          					(inorder, postorder, n);

        foreach (int val in result) {
            Console.Write(val + " ");
        }
    }
}
JavaScript 
// JavaScript program to print Preorder traversal from given
// Inorder and Postorder traversals.

// A utility function to search data in inorder[]
function search(inorder, data, n) {
    for (let i = 0; i < n; i++) {
        if (inorder[i] === data)
            return i;
    }
    return -1;
}

// Fills preorder traversal of tree with given 
// inorder and postorder traversals in a stack
function fillPre(inorder, postorder, inStart, inEnd,
					stack, n, postIndex) {
    if (inStart > inEnd)
        return;

    // Find index of next item in postorder 
    // traversal in inorder.
    const val = postorder[postIndex[0]];
    const inIndex = search(inorder, val, n);
    postIndex[0]--;

    // Traverse right tree
    fillPre(inorder, postorder, inIndex + 1, inEnd,
    							stack, n, postIndex);

    // Traverse left tree
    fillPre(inorder, postorder, inStart, inIndex - 1,
    							stack, n, postIndex);

    stack.push(val);
}

// This function initializes postIndex as last
// element index and fills stack
// with reverse preorder traversal using fillPre
function getPreorderTraversal(inorder, postorder, n) {
    let postIndex = [n - 1];
    const stack = [];
    fillPre(inorder, postorder, 0, n - 1, stack, n, postIndex);
    return stack.reverse();
}

const inorder = [4, 2, 5, 1, 3, 6];
const postorder = [4, 5, 2, 6, 3, 1];
const n = inorder.length;

const result = getPreorderTraversal
			  (inorder, postorder, n);
console.log(result.join(" "));

Output
1 2 4 5 3 6

[Expected approach] Using hashing - O(n) Time and O(n) Space

The idea is to use hashing for finding the element so we do not need to call search function every time. By doing this we can reduce time complexity to O(n). The approach of this method is same as above but here we use hashing.

Below is the implementation of the above approach: 

C++ 
// C++ program to print Preorder traversal from
// given Inorder and Postorder traversals.

#include <bits/stdc++.h>
using namespace std;

// Fills preorder traversal of tree with given
// inorder and postorder traversals in a vector
void fillPre(vector<int> &in, vector<int> &post, 
             int inStrt, int inEnd, vector<int> &result,
             unordered_map<int, int> &mp, int &postIndex) {
    if (inStrt > inEnd)
        return;

    // Find index of next item in postorder
  	// traversal in inorder
    int val = post[postIndex];
    int inIndex = mp[val];
    postIndex--;

    // Traverse right subtree
    fillPre(in, post, inIndex + 1, inEnd, 
            result, mp, postIndex);

    // Traverse left subtree
    fillPre(in, post, inStrt, inIndex - 1,
            result, mp, postIndex);

    // Store the current value in result
  	// (preorder traversal)
    result.push_back(val);
}

// This function initializes postIndex as the last element index,
// fills the result vector with preorder traversal, and returns it.
vector<int> getPreorderTraversal(vector<int> &in, 
                                 vector<int> &post, int n) {
    int postIndex = n - 1;
    vector<int> result;

    // Store inorder element positions
  	// in an unordered map
    unordered_map<int, int> mp;
    for (int i = 0; i < n; i++)
        mp[in[i]] = i;

    // Fill the preorder traversal in
  	// the result vector
    fillPre(in, post, 0, n - 1, result, mp, postIndex);
    reverse(result.begin(), result.end());
    return result;
}

int main() {
  
    vector<int> in = {4, 2, 5, 1, 3, 6};
    vector<int> post = {4, 5, 2, 6, 3, 1};
    int n = in.size();

    vector<int> preorder = getPreorderTraversal(in, post, n);

    for (int val : preorder) {
        cout << val << " ";
    }

    return 0;
}
Java 
// Java program to print Preorder traversal from
// given Inorder and Postorder traversals.

import java.util.*;

class Node {
    int val;
    Node left, right;

    Node(int val) {
        this.val = val;
        left = right = null;
    }
}

class GfG {

    // Fills preorder traversal of tree with given
    // inorder and postorder traversals in a list
    static void fillPre(List<Integer> in,
                        List<Integer> post, int inStrt,
                        int inEnd, List<Integer> result,
                        Map<Integer, Integer> mp,
                        int[] postIndex) {
        if (inStrt > inEnd)
            return;

        // Find index of next item in postorder
       	//traversal in inorder
        int val = post.get(postIndex[0]);
        int inIndex = mp.get(val);
        postIndex[0]--;

        // Traverse right subtree
        fillPre(in, post, inIndex + 1, inEnd, result, mp,
                postIndex);

        // Traverse left subtree
        fillPre(in, post, inStrt, inIndex - 1, result, mp,
                postIndex);

        // Store the current value in result (preorder
        // traversal)
        result.add(val);
    }

    // This function initializes postIndex as the last
    // element index, fills the result list with preorder
    // traversal, and returns it.
    static List<Integer>
    getPreorderTraversal(List<Integer> in,
                         List<Integer> post, int N) {
        int[] postIndex = { N - 1 };
        List<Integer> result = new ArrayList<>();

        // Store inorder element positions 
      	// in an unordered map
        Map<Integer, Integer> mp = new HashMap<>();
        for (int i = 0; i < N; i++)
            mp.put(in.get(i), i);

        // Fill the preorder traversal in 
      	// the result list
        fillPre(in, post, 0, N - 1, result, mp, postIndex);
        Collections.reverse(result);
        return result;
    }

    public static void main(String[] args) {
        List<Integer> in = Arrays.asList(4, 2, 5, 1, 3, 6);
        List<Integer> post
            = Arrays.asList(4, 5, 2, 6, 3, 1);
        int N = in.size();
      
        List<Integer> preorder
            = getPreorderTraversal(in, post, N);
        for (int val : preorder) {
            System.out.print(val + " ");
        }
    }
}
Python 
# Python program to print Preorder traversal from
# given Inorder and Postorder traversals.

def fill_pre(in_order, post_order, in_start, in_end, \
             result, mp, post_index):
    if in_start > in_end:
        return

    # Find index of next item in postorder
    # traversal in inorder
    val = post_order[post_index[0]]
    in_index = mp[val]
    post_index[0] -= 1

    # Traverse right subtree
    fill_pre(in_order, post_order, in_index +
             1, in_end, result, mp, post_index)

    # Traverse left subtree
    fill_pre(in_order, post_order, in_start,
             in_index - 1, result, mp, post_index)

    # Store the current value in result (preorder traversal)
    result.append(val)

# This function initializes post_index as the last element index,
# fills the result list with preorder traversal, and returns it.
def get_preorder_traversal(in_order, post_order, N):
    post_index = [N - 1]
    result = []

    # Store inorder element positions
    # in a hashmap
    mp = {val: idx for idx, val in enumerate(in_order)}

    # Fill the preorder traversal in
    # the result list
    fill_pre(in_order, post_order, 0, N - 1,\
             result, mp, post_index)
    result.reverse()
    return result

if __name__ == '__main__':
    in_order = [4, 2, 5, 1, 3, 6]
    post_order = [4, 5, 2, 6, 3, 1]
    N = len(in_order)
    
    preorder = get_preorder_traversal \
    			(in_order, post_order, N)
    print(' '.join(map(str, preorder)))
C# 
// C# program to print Preorder traversal from
// given Inorder and Postorder traversals.

using System;
using System.Collections.Generic;

class Node {
    public int val;
    public Node left, right;

    public Node(int val)
    {
        this.val = val;
        left = right = null;
    }
}

class GfG {

    // Fills preorder traversal of tree with given
    // inorder and postorder traversals in a list
    static void fillPre(List<int> inOrder,
                        List<int> postOrder, int inStrt,
                        int inEnd, List<int> result,
                        Dictionary<int, int> mp,
                        ref int postIndex) {
        if (inStrt > inEnd)
            return;

        // Find index of next item in postorder traversal in
        // inorder
        int val = postOrder[postIndex];
        int inIndex = mp[val];
        postIndex--;

        // Traverse right subtree
        fillPre(inOrder, postOrder, inIndex + 1, inEnd,
                result, mp, ref postIndex);

        // Traverse left subtree
        fillPre(inOrder, postOrder, inStrt, inIndex - 1,
                result, mp, ref postIndex);

        // Store the current value in result (preorder
        // traversal)
        result.Add(val);
    }

    // This function initializes postIndex as the last
    // element index, fills the result list with preorder
    // traversal, and returns it.
    static List<int>
    GetPreorderTraversal(List<int> inOrder,
                         List<int> postOrder, int N) {
        int postIndex = N - 1;
        List<int> result = new List<int>();

        // Store inorder element positions
      	// in a dictionary
        Dictionary<int, int> mp
            = new Dictionary<int, int>();
        for (int i = 0; i < N; i++)
            mp[inOrder[i]] = i;

        // Fill the preorder traversal in 
      	// the result list
        fillPre(inOrder, postOrder, 0, N - 1, result, mp,
                ref postIndex);
        result.Reverse();
        return result;
    }

    static void Main() {
      
        List<int> inOrder
            = new List<int>{ 4, 2, 5, 1, 3, 6 };
        List<int> postOrder
            = new List<int>{ 4, 5, 2, 6, 3, 1 };
        int N = inOrder.Count;

        List<int> preorder
            = GetPreorderTraversal(inOrder, postOrder, N);

        foreach(int val in preorder) {
            Console.Write(val + " ");
        }
    }
}
JavaScript 
// JavaScript program to print Preorder traversal from
// given Inorder and Postorder traversals.

function fillPre(inOrder, postOrder, inStrt, inEnd, result,
                 mp, postIndex) {
    if (inStrt > inEnd)
        return;

    // Find index of next item in postorder traversal in
    // inorder
    let val = postOrder[postIndex[0]];
    let inIndex = mp[val];
    postIndex[0]--;

    // Traverse right subtree
    fillPre(inOrder, postOrder, inIndex + 1, inEnd, result,
            mp, postIndex);

    // Traverse left subtree
    fillPre(inOrder, postOrder, inStrt, inIndex - 1, result,
            mp, postIndex);

    // Store the current value in result (preorder
    // traversal)
    result.push(val);
}

// This function initializes postIndex as the last element
// index, fills the result array with preorder traversal,
// and returns it.
function getPreorderTraversal(inOrder, postOrder, N) {
    let postIndex = [ N - 1 ];
    let result = [];

    // Store inorder element
    // positions in a hashmap
    let mp = {};
    for (let i = 0; i < N; i++) {
        mp[inOrder[i]] = i;
    }

    // Fill the preorder traversal in the result array
    fillPre(inOrder, postOrder, 0, N - 1, result, mp,
            postIndex);
    result.reverse();
    return result;
}

let inOrder = [ 4, 2, 5, 1, 3, 6 ];
let postOrder = [ 4, 5, 2, 6, 3, 1 ];
let N = inOrder.length;
let preorder = getPreorderTraversal(inOrder, postOrder, N);
console.log(preorder.join(" "));

Output
1 2 4 5 3 6

Next Article
Analysis of Algorithms

K
kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox