Codestin Search App

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.

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

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.

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
✓ Recursion with Bounds (Optimal)	O(n)	O(n)	Use upper and lower bounds to efficiently place each node without scanning
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) — Algorithm Steps

Start with bounds (-∞, +∞) and index 0
If current value is within bounds, create node and advance index
Recursively build left subtree with updated upper bound
Recursively build right subtree with updated lower bound
Use a global index to process preorder sequentially

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with 8

Create root with bounds (-∞, +∞)

Process 5

5 < 8, goes left with bounds (-∞, 8)

Process 1

1 < 5, goes left with bounds (-∞, 5)

Continue

Each node updates bounds for its children

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.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* index, int size, int minVal, int maxVal) {
    if (*index >= size) return NULL;
    
    int val = preorder[*index];
    
    if (val < minVal || val > maxVal) return NULL;
    
    (*index)++;
    struct TreeNode* root = createNode(val);
    
    root->left = build(preorder, index, size, minVal, val);
    root->right = build(preorder, index, size, val, maxVal);
    
    return root;
}

struct TreeNode* bstFromPreorder(int* preorder, int preorderSize) {
    if (preorderSize == 0) return NULL;
    int index = 0;
    return build(preorder, &index, preorderSize, INT_MIN, INT_MAX);
}

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)

Each element in preorder is processed exactly once

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth, O(log n) for balanced tree, O(n) worst case

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Recursion with Bounds (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler