Construct Binary Tree from Inorder and Postorder Traversal

Construct Binary Tree from Inorder and Postorder Traversal - Problem

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

You may assume that duplicates do not exist in the tree.

A binary tree can be uniquely determined by its inorder and postorder traversals because:

The last element in postorder 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

Input & Output

Example 1 — Basic Tree

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

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

💡 Note: The last element 3 in postorder is the root. In inorder, 3 splits the array: [9] (left subtree) and [15,20,7] (right subtree). Recursively apply the same logic.

Example 2 — Single Node

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

› Output: [-1]

💡 Note: Only one node, which is both root and the entire tree.

Example 3 — Linear Tree

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

› Output: [2,1,3]

💡 Note: Root is 2. In inorder: [1] is left subtree, [3] is right subtree. Creates a balanced tree with 2 as root.

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

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 35 f Facebook 28

The key insight is that postorder's last element is always the root, and inorder tells us which elements belong to left vs right subtrees. Best approach uses hash map optimization for O(1) root lookups. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force Recursive

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

For each recursive call, find the root (last element of postorder), locate it in inorder array by linear search, then recursively build left and right subtrees.

Hash Map Optimization

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

Build a hash map of inorder values to indices for O(1) lookups, then recursively construct the tree using the same divide and conquer approach but with faster root finding.

Brute Force Recursive — Algorithm Steps

Step 1: Take last element of postorder as root
Step 2: Find root position in inorder by linear search
Step 3: Split arrays and recursively build left and right subtrees

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Root

Last element of postorder is root

Locate in Inorder

Linear search to find root position

Split & Recurse

Divide arrays and build subtrees

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.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;
}

int findIndex(int* arr, int size, int target) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == target) return i;
    }
    return -1;
}

struct TreeNode* solution(int* inorder, int inorderSize, int* postorder, int postorderSize) {
    if (inorderSize == 0 || postorderSize == 0) {
        return NULL;
    }
    
    // Last element in postorder is the root
    int rootVal = postorder[postorderSize - 1];
    struct TreeNode* root = createNode(rootVal);
    
    // Find root position in inorder
    int rootIdx = findIndex(inorder, inorderSize, rootVal);
    
    // Recursively build subtrees
    root->left = solution(inorder, rootIdx, postorder, rootIdx);
    root->right = solution(inorder + rootIdx + 1, inorderSize - rootIdx - 1, 
                          postorder + rootIdx, postorderSize - rootIdx - 1);
    
    return root;
}

static int resultArray[10000];
static int resultSize;

void treeToArray(struct TreeNode* root) {
    if (!root) {
        resultSize = 0;
        return;
    }
    
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    resultSize = 0;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        if (node) {
            resultArray[resultSize++] = node->val;
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        } else {
            resultArray[resultSize++] = -1001;
        }
    }
    
    while (resultSize > 0 && resultArray[resultSize - 1] == -1001) {
        resultSize--;
    }
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        int num = 0;
        int sign = 1;
        if (*p == '-') {
            sign = -1;
            p++;
        }
        while (*p >= '0' && *p <= '9') {
            num = num * 10 + (*p - '0');
            p++;
        }
        arr[(*size)++] = sign * num;
    }
}

int main() {
    char line[1000];
    static int inorder[1000], postorder[1000];
    int inorderSize = 0, postorderSize = 0;
    
    // Parse inorder
    fgets(line, sizeof(line), stdin);
    parseArray(line, inorder, &inorderSize);
    
    // Parse postorder
    fgets(line, sizeof(line), stdin);
    parseArray(line, postorder, &postorderSize);
    
    struct TreeNode* result = solution(inorder, inorderSize, postorder, postorderSize);
    treeToArray(result);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        printf("%d", resultArray[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we perform O(n) linear search in inorder array

✓ Linear Growth

Space Complexity

O(n)

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

⚡ Linearithmic Space

287.6K Views

High Frequency

~25 min Avg. Time

3.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

Brute Force Recursive — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler