Construct Binary Tree from Preorder and Postorder Traversal

Construct Binary Tree from Preorder and Postorder Traversal - Problem

Reconstruct a Binary Tree from Traversal Blueprints

Imagine you have two different ways of reading a binary tree: preorder (root → left → right) and postorder (left → right → root). Your task is to reconstruct the original binary tree from these two traversal sequences.

Given two integer arrays preorder and postorder where:
• preorder represents the preorder traversal of a binary tree with distinct values
• postorder represents the postorder traversal of the same tree

Goal: Reconstruct and return the original binary tree. If multiple valid trees exist, you may return any of them.

Key Insight: Unlike inorder + preorder/postorder combinations, using only preorder + postorder doesn't uniquely determine the tree structure. However, we can still construct a valid binary tree that matches both traversals.

Input & Output

example_1.py — Basic Tree

$ Input: preorder = [1,2,4,5,3,6,7], postorder = [4,5,2,6,7,3,1]

› Output: [1,2,3,4,5,6,7] (tree structure representation)

💡 Note: The tree has root 1, with left subtree rooted at 2 (containing nodes 4,5) and right subtree rooted at 3 (containing nodes 6,7). The preorder visits root first, then left subtree, then right subtree. The postorder visits left subtree, right subtree, then root.

example_2.py — Simple Case

$ Input: preorder = [1,2], postorder = [2,1]

› Output: [1,2] (tree structure representation)

💡 Note: Simple tree with root 1 and left child 2. Since there's only one child, it could be either left or right child - our algorithm chooses left by convention.

example_3.py — Single Node

$ Input: preorder = [1], postorder = [1]

› Output: [1]

💡 Note: Edge case with only one node - both traversals contain just the root node 1.

Visualization

Tap to expand

Understanding the Visualization

Map the Territory

Create an index map of all elements in postorder for instant boundary detection

Identify the Patriarch

The first element in preorder is always the root of current subtree

Find the Heir

The second element in preorder (if exists) is the root of left subtree

Divide the Kingdom

Use postorder indices to determine where left subtree ends and right begins

Recursive Reconstruction

Apply the same process recursively to build left and right subtrees

Key Takeaway

🎯 Key Insight: By preprocessing postorder indices into a hash map, we transform expensive O(n) boundary searches into O(1) lookups, making the entire reconstruction process run in optimal O(n) time while maintaining the elegant divide-and-conquer structure.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially scan the postorder array to find subtree boundaries

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can be O(n) in worst case (skewed tree)

⚡ Linearithmic Space

Constraints

1 ≤ preorder.length ≤ 30
1 ≤ postorder.length ≤ 30
preorder.length == postorder.length
1 ≤ preorder[i], postorder[i] ≤ 10⁶
preorder and postorder are both permutations of the same set of distinct values
preorder and postorder represent valid traversals of the same binary tree

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal approach uses a HashMap for index mapping combined with divide-and-conquer strategy. Build a hash map of postorder indices in O(n) time, then recursively construct the tree by using preorder for root identification and postorder indices for efficient subtree boundary detection, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Recursive Search	O(n²)	O(n)	For each root, linearly search postorder array to find subtree boundaries
HashMap Index + Divide & Conquer	O(n)	O(n)	Build postorder index map first, then use divide-and-conquer with O(1) lookups

Brute Force Recursive Search — Algorithm Steps

Take the first element from preorder as root
If only one element, create leaf node and return
Find the left child in preorder (second element)
Linearly search postorder to find where left subtree ends
Split the arrays based on left subtree size
Recursively build left and right subtrees

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Root

Take first element from preorder as root

Find Left Child

Second element in preorder is left child

Search Postorder

Linear search in postorder to find left subtree boundary

Recursive Split

Split arrays and recursively build left and right subtrees

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* build(int* pre, int preStart, int preEnd, int* post, int postStart, int postEnd) {
    if (preStart > preEnd) return NULL;
    
    struct TreeNode* root = createNode(pre[preStart]);
    if (preStart == preEnd) return root;
    
    int leftRootVal = pre[preStart + 1];
    
    int leftSize = 0;
    for (int i = postStart; i <= postEnd; i++) {
        leftSize++;
        if (post[i] == leftRootVal) break;
    }
    
    root->left = build(pre, preStart + 1, preStart + leftSize, post, postStart, postStart + leftSize - 1);
    root->right = build(pre, preStart + leftSize + 1, preEnd, post, postStart + leftSize, postEnd - 1);
    
    return root;
}

struct TreeNode* constructFromPrePost(int* preorder, int preorderSize, int* postorder, int postorderSize) {
    return build(preorder, 0, preorderSize - 1, postorder, 0, postorderSize - 1);
}

int main() {
    printf("Tree constructed successfully\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially scan the postorder array to find subtree boundaries

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can be O(n) in worst case (skewed tree)

⚡ Linearithmic Space

Constraints

1 ≤ preorder.length ≤ 30
1 ≤ postorder.length ≤ 30
preorder.length == postorder.length
1 ≤ preorder[i], postorder[i] ≤ 10⁶
preorder and postorder are both permutations of the same set of distinct values
preorder and postorder represent valid traversals of the same binary tree

87.5K Views

Medium-High Frequency

~15 min Avg. Time

2.3K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force Recursive Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler