Construct Binary Tree from Preorder and Inorder Traversal

Construct Binary Tree from Preorder and Inorder Traversal - Problem

Imagine you're given two different blueprints of the same binary tree - one showing the order in which nodes were visited in a preorder traversal (root → left → right), and another showing the order from an inorder traversal (left → root → right).

Your task is to reconstruct the original binary tree using these two traversal sequences. This is like being an architect who needs to rebuild a building from two different perspective drawings!

Key insight: The preorder array tells us which node is the root at each step, while the inorder array tells us which nodes belong to the left vs right subtrees.

Example:
preorder = [3,9,20,15,7]
inorder = [9,3,15,20,7]

From this, we can deduce that 3 is the root (first in preorder), 9 is the left subtree (everything left of 3 in inorder), and [20,15,7] forms the right subtree.

Input & Output

example_1.py — Standard Tree Construction

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

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

💡 Note: The tree is constructed with 3 as root (first in preorder), 9 as left child (left of 3 in inorder), and [20,15,7] forming the right subtree. The resulting tree has the structure: 3 at root, 9 as left child, 20 as right child with 15 and 7 as its children.

example_2.py — Single Node Tree

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

› Output: [1]

💡 Note: With only one element, the tree consists of just the root node with value 1. Both traversals contain the same single element, confirming this is the only node in the tree.

example_3.py — Linear Tree (Skewed)

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

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

💡 Note: This creates a left-skewed tree. Root is 1, then 2 is the left child of 1, and 3 is the left child of 2. The inorder traversal [3,2,1] confirms this left-heavy structure.

Visualization

Tap to expand

Understanding the Visualization

Identify Root

First element in preorder is always the root of current subtree

Find Split Point

Root's position in inorder divides left and right subtrees

Calculate Sizes

Count elements to determine subtree boundaries

Recursive Build

Recursively construct left and right subtrees

Key Takeaway

🎯 Key Insight: Preorder gives us the construction order (root first), while inorder gives us the structural boundaries (left/right split). A hash map transforms O(n²) searches into O(1) lookups for optimal O(n) performance.

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) to build hash map + O(n) for tree construction with O(1) lookups

✓ Linear Growth

Space Complexity

O(n)

O(n) for hash map + O(n) for recursion stack in worst case

⚡ Linearithmic Space

Constraints

1 ≤ preorder.length ≤ 3000
inorder.length == preorder.length
-3000 ≤ preorder[i], inorder[i] ≤ 3000
preorder and inorder consist of unique values
inorder is guaranteed to be the inorder traversal of the same tree that preorder is the preorder traversal of

Asked in

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

The optimal approach uses a hash map to store inorder indices for O(1) lookups, eliminating the O(n²) time complexity of repeated linear searches. The key insight is that preorder tells us the root at each level, while inorder tells us how to split left and right subtrees. Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map Optimization	O(n)	O(n)	Pre-build hash map of inorder positions, then construct tree efficiently
Brute Force (Linear Search)	O(n²)	O(n)	Recursively build tree by linearly searching for root in inorder array

Hash Map Optimization — Algorithm Steps

First pass: Build hash map {value → index} for inorder array
Start recursive construction with full arrays
Use hash map to instantly find root position in inorder
Calculate left subtree size from inorder indices
Recursively build left and right subtrees with proper boundaries

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Map

First pass: {9→0, 3→1, 15→2, 20→3, 7→4}

Instant Lookup

Find root 3 at index 1 in O(1) time

Calculate Boundaries

Left size = 1-0 = 1, Right starts at index 2

Recursive Build

Continue with precise array boundaries

Code -

solution.c — C

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

#define MAX_SIZE 1000

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;
}

// Simple hash map implementation using array (assuming values are in reasonable range)
static int inorderMap[MAX_SIZE];

struct TreeNode* buildHelper(int* preorder, int preStart, int preEnd, int inStart, int inEnd) {
    if (preStart > preEnd) {
        return NULL;
    }
    
    int rootVal = preorder[preStart];
    struct TreeNode* root = createNode(rootVal);
    
    // O(1) lookup using hash map
    int rootIdx = inorderMap[rootVal + 100]; // offset for negative values
    int leftSize = rootIdx - inStart;
    
    root->left = buildHelper(preorder, preStart + 1, preStart + leftSize, inStart, rootIdx - 1);
    root->right = buildHelper(preorder, preStart + leftSize + 1, preEnd, rootIdx + 1, inEnd);
    
    return root;
}

struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int inorderSize) {
    // First pass: build hash map of inorder indices
    for (int i = 0; i < inorderSize; i++) {
        inorderMap[inorder[i] + 100] = i; // offset for negative values
    }
    
    return buildHelper(preorder, 0, preorderSize - 1, 0, inorderSize - 1);
}

int main() {
    int preorder[] = {3, 9, 20, 15, 7};
    int inorder[] = {9, 3, 15, 20, 7};
    int size = 5;
    
    struct TreeNode* result = buildTree(preorder, size, inorder, size);
    printf("Tree constructed successfully\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) to build hash map + O(n) for tree construction with O(1) lookups

✓ Linear Growth

Space Complexity

O(n)

O(n) for hash map + O(n) for recursion stack in worst case

⚡ Linearithmic Space

Constraints

1 ≤ preorder.length ≤ 3000
inorder.length == preorder.length
-3000 ≤ preorder[i], inorder[i] ≤ 3000
preorder and inorder consist of unique values
inorder is guaranteed to be the inorder traversal of the same tree that preorder is the preorder traversal of

72.4K Views

High Frequency

~18 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