Construct Binary Tree from Inorder and Postorder Traversal

Construct Binary Tree from Inorder and Postorder Traversal - Problem

Given two integer arrays inorder and postorder representing the inorder traversal and postorder traversal of the same binary tree, your task is to reconstruct and return the original binary tree.

In an inorder traversal, we visit nodes in the pattern: Left → Root → Right
In a postorder traversal, we visit nodes in the pattern: Left → Right → Root

This is a classic tree reconstruction problem that tests your understanding of tree traversal properties and recursive thinking. The key insight is that the last element in postorder is always the root, and we can use the inorder array to determine which elements belong to the left and right subtrees.

Example: If inorder = [9,3,15,20,7] and postorder = [9,15,7,20,3], the tree looks like:

Input & Output

example_1.py — Standard Tree

$ Input: inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]

› Output: [3,9,20,null,null,15,7]

💡 Note: The tree structure has 3 as root, 9 as left child, and 20 as right child with its own children 15 and 7. Postorder's last element (3) is the root, and inorder helps us split into left [9] and right [15,20,7] subtrees.

example_2.py — Single Node

$ Input: inorder = [-1], postorder = [-1]

› Output: [-1]

💡 Note: A single node tree where the root is -1. Both traversals contain only one element, making it straightforward to construct.

example_3.py — Left Skewed Tree

$ Input: inorder = [1,2,3], postorder = [1,2,3]

› Output: [3,2,null,1,null]

💡 Note: This creates a left-skewed tree. Root is 3 (last in postorder), left subtree contains [1,2] from inorder, and there's no right subtree.

Visualization

Tap to expand

Understanding the Visualization

Identify Root

Last element in postorder is always the root of current subtree

Find Position

Use hash map to instantly locate root's position in inorder array

Split Subtrees

Everything left of root in inorder goes to left subtree, right side goes to right subtree

Recursive Build

Build right subtree first (postorder property), then left subtree

Key Takeaway

🎯 Key Insight: Postorder's last element is always the root, and inorder's root position perfectly divides left and right subtrees. Hash map makes root lookups O(1) instead of O(n)!

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once, and hash map lookups are O(1)

✓ Linear Growth

Space Complexity

O(n)

Hash map stores n entries, plus O(n) recursion stack depth

⚡ Linearithmic Space

Constraints

1 ≤ inorder.length ≤ 3000
postorder.length == inorder.length
-3000 ≤ inorder[i], postorder[i] ≤ 3000
inorder and postorder consist of unique values
Each value of postorder also appears in inorder
inorder is guaranteed to be the inorder traversal of the tree
postorder is guaranteed to be the postorder traversal of the same tree

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28

The optimal solution uses a hash map preprocessing approach. First, build a hash map from the inorder array for O(1) position lookups. Then recursively construct the tree by taking the last element from postorder as root, using the hash map to find its position in inorder, and building right subtree before left subtree. This achieves O(n) time complexity compared to the O(n²) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map Optimization	O(n)	O(n)	Build index map first, then construct tree with O(1) lookups
Brute Force (Linear Search)	O(n²)	O(n)	For each root from postorder, linearly search its position in inorder

Hash Map Optimization — Algorithm Steps

Build a hash map: inorder_value → index for O(1) lookups
Use a helper function with array indices to avoid copying subarrays
Take the last element from postorder as current root
Use hash map to instantly find root's position in inorder
Calculate left and right subtree boundaries
Recursively build right subtree first, then left subtree

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Map

Create inorder_value → index mapping

Take Root

Pop last element from postorder

Hash Lookup

Find root position instantly using hash map

Recursive Build

Build subtrees with calculated boundaries

Code -

solution.c — C

// Definition for a binary tree node
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;
}

// Hash map implementation for C
#define HASH_SIZE 10007
struct HashEntry {
    int key;
    int value;
    struct HashEntry* next;
};

struct HashEntry* hashTable[HASH_SIZE];

void putHash(int key, int value) {
    int hash = abs(key) % HASH_SIZE;
    struct HashEntry* entry = (struct HashEntry*)malloc(sizeof(struct HashEntry));
    entry->key = key;
    entry->value = value;
    entry->next = hashTable[hash];
    hashTable[hash] = entry;
}

int getHash(int key) {
    int hash = abs(key) % HASH_SIZE;
    struct HashEntry* entry = hashTable[hash];
    while (entry) {
        if (entry->key == key) return entry->value;
        entry = entry->next;
    }
    return -1;
}

struct TreeNode* helper(int* postorder, int* postIdx, int inLeft, int inRight) {
    if (inLeft > inRight) return NULL;
    
    // Take root from postorder (from right to left)
    int rootVal = postorder[(*postIdx)--];
    struct TreeNode* root = createNode(rootVal);
    
    // Find root position using hash map O(1)
    int rootIdx = getHash(rootVal);
    
    // Build right subtree first (postorder: left, right, root)
    root->right = helper(postorder, postIdx, rootIdx + 1, inRight);
    root->left = helper(postorder, postIdx, inLeft, rootIdx - 1);
    
    return root;
}

struct TreeNode* buildTree(int* inorder, int inorderSize, int* postorder, int postorderSize) {
    // Clear hash table
    memset(hashTable, 0, sizeof(hashTable));
    
    // Build hash map for O(1) inorder lookups
    for (int i = 0; i < inorderSize; i++) {
        putHash(inorder[i], i);
    }
    
    int postIdx = postorderSize - 1;
    return helper(postorder, &postIdx, 0, inorderSize - 1);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once, and hash map lookups are O(1)

✓ Linear Growth

Space Complexity

O(n)

Hash map stores n entries, plus O(n) recursion stack depth

⚡ Linearithmic Space

Constraints

1 ≤ inorder.length ≤ 3000
postorder.length == inorder.length
-3000 ≤ inorder[i], postorder[i] ≤ 3000
inorder and postorder consist of unique values
Each value of postorder also appears in inorder
inorder is guaranteed to be the inorder traversal of the tree
postorder is guaranteed to be the postorder traversal of the same tree

78.5K Views

High Frequency

~25 min Avg. Time

1.8K 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

Hash Map Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler