Construct Binary Search Tree from Preorder Traversal

Construct Binary Search Tree from Preorder Traversal - Problem

Given an array of integers representing the preorder traversal of a Binary Search Tree (BST), your task is to reconstruct and return the original BST.

In a BST, for every node:

All values in the left subtree are strictly less than the node's value
All values in the right subtree are strictly greater than the node's value

A preorder traversal visits nodes in this order: root → left subtree → right subtree

Example: If preorder = [8, 5, 1, 7, 10, 12], this represents:

You need to reconstruct this tree structure and return the root node. It's guaranteed that a valid BST can always be constructed from the given preorder sequence.

Input & Output

example_1.py — Standard BST

$ Input: preorder = [8,5,1,7,10,12]

› Output: [8,5,10,1,7,null,12]

💡 Note: The preorder traversal represents a BST where 8 is root, 5 and 10 are children of 8, and so on. The output shows the tree in level-order format.

example_2.py — Single Node

$ Input: preorder = [1]

› Output: [1]

💡 Note: A tree with only one node - the root node with value 1.

example_3.py — Right Skewed Tree

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

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

💡 Note: Since each value is greater than the previous, each node only has a right child, creating a right-skewed tree.

Visualization

Tap to expand

Understanding the Visualization

Initialize Bounds

Start with root and infinite bounds (-∞, +∞)

Place Node

If current value fits bounds, create node and advance index

Update Bounds

Left child gets (min, current), right child gets (current, max)

Recurse

Continue with updated bounds for each subtree

Key Takeaway

🎯 Key Insight: Using bounds eliminates the need to scan for subtree boundaries. Each recursive call constrains valid values, allowing sequential processing of the preorder array in optimal O(n) time.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we scan through remaining elements 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 ≤ 100
1 ≤ preorder[i] ≤ 1000
All values in preorder are unique
The input represents a valid preorder traversal of a BST

Asked in

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

The optimal approach uses recursion with bounds to construct the BST in O(n) time. Instead of scanning to find subtree boundaries, we maintain valid range bounds for each subtree and process the preorder array sequentially. Each node constrains the valid values for its children: left subtree gets (min, current_val) and right subtree gets (current_val, max).

Common Approaches

Approach	Time	Space	Notes
✓ Recursive with Range Validation	O(n²)	O(n)	For each node, find its left and right subtree boundaries by scanning the array
Recursion with Bounds (Optimal)	O(n)	O(n)	Use upper and lower bounds to efficiently place each node without scanning

Recursive with Range Validation — Algorithm Steps

Take the first element as root
Scan array to find first element greater than root (right subtree start)
Recursively build left subtree from elements before this position
Recursively build right subtree from remaining elements
Return the constructed root node

Visualization

Tap to expand

Step-by-Step Walkthrough

Take Root

First element [8] becomes root

Find Split

Scan to find first element > 8, which is 10 at index 4

Split Array

Left: [5,1,7], Right: [10,12]

Recurse

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* preorder, int start, int end) {
    if (start > end) return NULL;
    
    struct TreeNode* root = createNode(preorder[start]);
    
    // Find first element greater than root
    int i = start + 1;
    while (i <= end && preorder[i] < preorder[start]) {
        i++;
    }
    
    root->left = build(preorder, start + 1, i - 1);
    root->right = build(preorder, i, end);
    
    return root;
}

struct TreeNode* bstFromPreorder(int* preorder, int preorderSize) {
    if (preorderSize == 0) return NULL;
    return build(preorder, 0, preorderSize - 1);
}

int main() {
    int preorder[] = {8, 5, 1, 7, 10, 12};
    int size = 6;
    struct TreeNode* result = bstFromPreorder(preorder, size);
    printf("%d\n", result ? result->val : -1);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we scan through remaining elements 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 ≤ 100
1 ≤ preorder[i] ≤ 1000
All values in preorder are unique
The input represents a valid preorder traversal of a BST

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

Recursive with Range Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler