Construct Binary Tree from Preorder and Inorder Traversal

Construct Binary Tree from Preorder and Inorder Traversal - Problem

Given two integer arrays preorder and inorder where preorder is the preorder traversal of a binary tree and inorder is the inorder traversal of the same tree, construct and return the binary tree.

Key insights:

The first element in preorder is always the root
Elements to the left of root in inorder form the left subtree
Elements to the right of root in inorder form the right subtree
We can recursively apply this pattern to build the entire tree

Input & Output

Example 1 — Basic Tree

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

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

💡 Note: Root is 3 (first in preorder). In inorder, 9 is left subtree, [15,20,7] is right subtree. Recursively build: left child 9, right child 20 with children 15,7.

Example 2 — Linear Tree

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

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

💡 Note: Root 1, left subtree [3,2], no right. Root 2 has left child 3. Forms a left-leaning tree.

Example 3 — Single Node

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

› Output: [1]

💡 Note: Single node tree - root is 1 with no children.

Constraints

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

Visualization

Tap to expand

Asked in

f Facebook 45 A Amazon 38 G Google 32 M Microsoft 28

The key insight is that preorder's first element is always the root, and inorder splits left/right subtrees. Best approach uses HashMap optimization for O(1) root lookups. Time: O(n), Space: O(n)

Common Approaches

✓ HashMap Optimization

⏱️ Time: O(n) Space: O(n)

Pre-build a HashMap mapping each value to its index in the inorder array. This eliminates the O(n) linear search for each node, reducing overall time complexity.

Recursive with Linear Search

⏱️ Time: O(n²) Space: O(n)

For each node, find its position in inorder array by linear search, then recursively build left and right subtrees using the split indices.

HashMap Optimization — Algorithm Steps

Step 1: Build HashMap of inorder values to indices
Step 2: Use preorder index to track current root
Step 3: Use HashMap for O(1) root position lookup
Step 4: Recursively build subtrees with updated bounds

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Map

Create index map from inorder array

O(1) Lookup

Find root position instantly

Recurse

Build subtrees with bounds

Code -

solution.c — C

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

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

// Simple hash map for this problem (assuming values fit in reasonable range)
#define HASH_SIZE 10007
struct HashNode {
    int key;
    int value;
    struct HashNode* next;
};

struct HashNode* hashTable[HASH_SIZE];
int preorderIdx;

int hash(int key) {
    return abs(key) % HASH_SIZE;
}

void insertHash(int key, int value) {
    int idx = hash(key);
    struct HashNode* newNode = malloc(sizeof(struct HashNode));
    newNode->key = key;
    newNode->value = value;
    newNode->next = hashTable[idx];
    hashTable[idx] = newNode;
}

int getHash(int key) {
    int idx = hash(key);
    struct HashNode* curr = hashTable[idx];
    while (curr) {
        if (curr->key == key) return curr->value;
        curr = curr->next;
    }
    return -1;
}

struct TreeNode* buildTree(int* preorder, int left, int right) {
    if (left > right) return NULL;
    
    int rootVal = preorder[preorderIdx++];
    struct TreeNode* root = malloc(sizeof(struct TreeNode));
    root->val = rootVal;
    root->left = NULL;
    root->right = NULL;
    
    int rootIdx = getHash(rootVal);
    
    root->left = buildTree(preorder, left, rootIdx - 1);
    root->right = buildTree(preorder, rootIdx + 1, right);
    
    return root;
}

struct TreeNode* solution(int* preorder, int preorderSize, int* inorder, int inorderSize) {
    if (preorderSize == 0 || inorderSize == 0) return NULL;
    
    // Initialize hash table
    memset(hashTable, 0, sizeof(hashTable));
    
    // Build index map
    for (int i = 0; i < inorderSize; i++) {
        insertHash(inorder[i], i);
    }
    
    preorderIdx = 0;
    return buildTree(preorder, 0, inorderSize - 1);
}

void printTreeArray(struct TreeNode* root) {
    if (!root) {
        printf("[]");
        return;
    }
    
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int result[1000];
    int isNull[1000];
    int resultSize = 0;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        if (node) {
            result[resultSize] = node->val;
            isNull[resultSize] = 0;
            resultSize++;
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        } else {
            result[resultSize] = 0; // dummy value
            isNull[resultSize] = 1;
            resultSize++;
        }
    }
    
    // Remove trailing nulls
    while (resultSize > 0 && isNull[resultSize - 1]) {
        resultSize--;
    }
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (isNull[i]) {
            printf("null");
        } else {
            printf("%d", result[i]);
        }
        if (i < resultSize - 1) printf(",");
    }
    printf("]");
}

int main() {
    char line[1000];
    int preorder[1000], inorder[1000];
    int preorderSize = 0, inorderSize = 0;
    
    // Read preorder
    fgets(line, sizeof(line), stdin);
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    if (start && end && start < end) {
        start++;
        *end = '\0';
        if (strlen(start) > 0) {
            char* token = strtok(start, ",");
            while (token) {
                preorder[preorderSize++] = atoi(token);
                token = strtok(NULL, ",");
            }
        }
    }
    
    // Read inorder
    fgets(line, sizeof(line), stdin);
    start = strchr(line, '[');
    end = strchr(line, ']');
    if (start && end && start < end) {
        start++;
        *end = '\0';
        if (strlen(start) > 0) {
            char* token = strtok(start, ",");
            while (token) {
                inorder[inorderSize++] = atoi(token);
                token = strtok(NULL, ",");
            }
        }
    }
    
    struct TreeNode* result = solution(preorder, preorderSize, inorder, inorderSize);
    printTreeArray(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is visited once, HashMap lookup is O(1)

✓ Linear Growth

Space Complexity

O(n)

HashMap stores n entries plus recursion stack depth up to n

⚡ Linearithmic Space

239.2K Views

High Frequency

~25 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

HashMap Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler