Depth of BST Given Insertion Order - Practice Coding Problems

Depth of BST Given Insertion Order - Problem

You're given a sequence of integers representing the insertion order into a Binary Search Tree (BST). Your task is to determine the maximum depth of the BST that would be constructed following these insertions.

🌳 BST Properties:

Left subtree contains only nodes with values less than the parent
Right subtree contains only nodes with values greater than the parent
Both subtrees are also valid BSTs

Construction Process: The first element becomes the root, and each subsequent element is inserted following BST rules - compare with existing nodes and go left if smaller, right if larger, until finding an empty spot.

Goal: Return the depth (number of nodes along the longest path from root to leaf) of the resulting BST.

Example: For insertion order [2,1,3], we get a balanced tree with depth 2. For [1,2,3], we get a right-skewed tree with depth 3.

Input & Output

example_1.py — Balanced Tree

$ Input: order = [2, 1, 3]

› Output: 2

💡 Note: The BST formed is balanced: root=2, left child=1, right child=3. The maximum depth is 2 (root to any leaf).

example_2.py — Right Skewed Tree

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

› Output: 4

💡 Note: Each element is greater than the previous, creating a right-skewed tree: 1→2→3→4. Maximum depth is 4.

example_3.py — Complex Tree

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

› Output: 3

💡 Note: Tree structure: root=2, left=1, right=4, and 3 becomes left child of 4. Longest path is 2→4→3 with depth 3.

Constraints

1 ≤ order.length ≤ 10⁵
1 ≤ order[i] ≤ 10⁵
order is a permutation of integers from 1 to n
All values in order are unique

Visualization

Tap to expand

Understanding the Visualization

CEO Takes Position

First person becomes CEO (root) at level 1

Employees Find Positions

Each new employee compares their ID with existing employees to find their reporting position

Track Organization Depth

Keep track of the deepest management level as the hierarchy grows

Key Takeaway

🎯 Key Insight: BST depth calculation is like measuring organizational hierarchy depth - we can track the maximum management level without building the complete org chart!

Asked in

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

The optimal solution uses a monotonic stack to simulate BST insertion without building the actual tree. As we process each element, we maintain a stack of potential ancestors and track the maximum depth reached. This achieves O(n) time complexity with O(n) space, avoiding the overhead of creating tree nodes while accurately calculating the BST depth.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-based Simulation (Optimal)	O(n)	O(n)	Track depth during insertion using stack to simulate BST path
Brute Force (Build Full BST)	O(n²)	O(n)	Build the complete BST structure and then find its depth

Stack-based Simulation (Optimal) — Algorithm Steps

Initialize stack with root element and depth 1
For each new element, pop stack until finding correct parent
Push element to stack with incremented depth
Track maximum depth encountered during the process

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Stack

Start with empty stack, process each element

Find Insertion Point

Pop elements smaller than current value

Update Depth

Calculate depth and update maximum

Code -

solution.c — C

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

typedef struct {
    int val;
    int depth;
} StackItem;

int depthOfBST(int* order, int size) {
    if (size == 0) return 0;
    
    StackItem stack[1000];
    int stackTop = -1;
    int maxDepth = 0;
    
    for (int i = 0; i < size; i++) {
        int val = order[i];
        int depth = 0;
        
        // Find position where this value should be inserted
        while (stackTop >= 0 && stack[stackTop].val < val) {
            if (stack[stackTop].depth > depth) {
                depth = stack[stackTop].depth;
            }
            stackTop--;
        }
        
        depth += 1;
        stackTop++;
        stack[stackTop].val = val;
        stack[stackTop].depth = depth;
        
        if (depth > maxDepth) {
            maxDepth = depth;
        }
    }
    
    return maxDepth;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int order[1000];
    int size = 0;
    char* token = strtok(line, " \n");
    while (token) {
        order[size++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    printf("%d\n", depthOfBST(order, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped at most once from the stack

✓ Linear Growth

Space Complexity

O(n)

Stack can contain at most n elements in worst case (skewed tree)

⚡ Linearithmic Space

42.4K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Stack-based Simulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler