Verify Preorder Sequence in Binary Search Tree

Verify Preorder Sequence in Binary Search Tree - Problem

You're given an array of unique integers that represents a potential preorder traversal sequence of a Binary Search Tree (BST). Your task is to determine if this sequence could actually be generated by traversing a valid BST in preorder.

In a preorder traversal, we visit nodes in this order: root → left subtree → right subtree. For a valid BST, all values in the left subtree must be smaller than the root, and all values in the right subtree must be larger than the root.

Goal: Return true if the given array represents a valid BST preorder traversal, false otherwise.

Example: For [5,2,1,3,6], this could represent a BST where 5 is root, left subtree contains [2,1,3], and right subtree contains [6]. This follows BST properties, so return true.

Input & Output

example_1.py — Valid BST Preorder

$ Input: [5, 2, 1, 3, 6]

› Output: true

💡 Note: This sequence represents a valid BST: root=5, left subtree=[2,1,3] where 2 is root with left=1 and right=3, right subtree=[6]. All BST properties are maintained.

example_2.py — Invalid BST Preorder

$ Input: [5, 2, 6, 1, 3]

› Output: false

💡 Note: After visiting 5→2→6, we're in the right subtree of 2. But then we see 1, which is less than 2, violating BST property that right subtree values must be greater than ancestor nodes.

example_3.py — Single Element

$ Input: [1]

› Output: true

💡 Note: A single element always forms a valid BST (just the root node).

Constraints

1 ≤ preorder.length ≤ 10⁴
1 ≤ preorder[i] ≤ 10⁴
All integers in preorder are unique

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at first location (root), can go anywhere initially

Track Path

Use stack to remember the path of locations visited

Validate Moves

Each new location must respect the 'no going back' rule

Update Bounds

When moving right, update minimum allowed for future locations

Key Takeaway

🎯 Key Insight: Use monotonic stack to track the path from root to current position, maintaining bounds to ensure BST property is never violated during preorder traversal.

Asked in

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

The optimal solution uses a monotonic stack to simulate the BST traversal path. As we process each element, we maintain a lower bound that represents the minimum valid value at the current position. When we encounter a value larger than elements in our stack, we know we've moved to a right subtree and update the bound accordingly. This achieves O(n) time complexity with a single pass through the array.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack (Optimal)	O(n)	O(n)	Use stack to track path and maintain bounds for valid BST preorder sequence

Monotonic Stack (Optimal) — Algorithm Steps

Initialize stack and lower bound (-infinity)
For each element in preorder sequence:
If element is less than lower bound, return false
While stack is not empty and element > stack top:
Pop from stack and update lower bound to popped value
Push current element to stack
Return true if we process entire array successfully

Visualization

Tap to expand

Step-by-Step Walkthrough

Process 5

Push 5, stack: [5], bound: -∞

Process 2

2 > bound, push 2, stack: [5,2]

Process 1

1 > bound, push 1, stack: [5,2,1]

Process 3

3 > 1, pop 1, bound=1, push 3, stack: [5,2,3]

Process 6

6 > bound, pop 3,2, bound=2, push 6, stack: [5,6]

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>
#include <limits.h>

bool verifyPreorder(int* preorder, int size) {
    int stack[1000];
    int top = -1;
    int lowerBound = INT_MIN;
    
    for (int i = 0; i < size; i++) {
        int num = preorder[i];
        
        if (num < lowerBound) {
            return false;
        }
        
        while (top >= 0 && stack[top] < num) {
            lowerBound = stack[top];
            top--;
        }
        
        stack[++top] = num;
    }
    
    return true;
}

int main() {
    int preorder[] = {5, 2, 1, 3, 6};
    int size = sizeof(preorder) / sizeof(preorder[0]);
    printf("%s\n", verifyPreorder(preorder, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once

✓ Linear Growth

Space Complexity

O(n)

Stack can contain up to n elements in worst case (all decreasing sequence)

⚡ Linearithmic Space

28.4K Views

Medium-High Frequency

~18 min Avg. Time

876 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

Monotonic Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler