Validate Binary Search Tree - Practice Coding Problems

Validate Binary Search Tree - Problem

You're given the root of a binary tree and need to determine if it represents a valid Binary Search Tree (BST).

A valid BST must satisfy these strict rules:

All nodes in the left subtree have values strictly less than the current node's value
All nodes in the right subtree have values strictly greater than the current node's value
Both left and right subtrees must also be valid BSTs

⚠️ Important: The key word here is "strictly" - no duplicate values are allowed, and the BST property must hold for all descendants, not just immediate children!

For example, a tree where the root is 5, left child is 3, and the left child of 3 is 7 would be invalid because 7 > 5, violating the BST property even though 7 > 3.

Input & Output

example_1.py — Valid BST

$ Input: root = [5,3,8,1,4,null,9]

› Output: true

💡 Note: This forms a valid BST. Inorder traversal gives [1,3,4,5,8,9] which is in strictly ascending order. All left descendants < root < all right descendants for every node.

example_2.py — Invalid BST

$ Input: root = [5,3,8,1,6,null,9]

› Output: false

💡 Note: Node 6 is in the left subtree of root 5, but 6 > 5, violating the BST property. Even though 6 > 3 (its parent), it must also be < 5 (the root ancestor).

example_3.py — Edge Case with Duplicates

$ Input: root = [5,5,7]

› Output: false

💡 Note: BST requires strictly less/greater values. Having a duplicate value 5 in the left subtree violates the 'strictly less' requirement.

Visualization

Tap to expand

Understanding the Visualization

Start at Root

Begin validation journey at the family head

Visit Left Branch

Check all left descendants have smaller salaries

Process Current

Validate current person's salary is in correct order

Visit Right Branch

Check all right descendants have larger salaries

Maintain Order

Ensure the salary sequence keeps increasing

Key Takeaway

🎯 Key Insight: A valid BST's inorder traversal always produces strictly ascending values. Instead of checking ranges for each node, we can simply verify this ordering property during traversal - elegant and efficient!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during inorder traversal

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h (O(log n) for balanced, O(n) for skewed)

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-2³¹ ≤ Node.val ≤ 2³¹ - 1
Tree nodes contain unique values (but this needs to be validated!)

Asked in

a Amazon 67 G Google 54 ⊞ Microsoft 48 f Meta 42 Apple 31

The optimal solution uses inorder traversal with O(n) time complexity. Key insight: a valid BST's inorder traversal produces values in strictly ascending order. We traverse left → root → right, ensuring each value is greater than the previous. This elegantly validates the BST property in a single pass without needing to track ranges or validate entire subtrees repeatedly.

Common Approaches

Approach	Time	Space	Notes
✓ Inorder Traversal (Optimal)	O(n)	O(h)	Use inorder traversal - values should be in strictly ascending order
Brute Force (Validate Every Subtree)	O(n²)	O(n)	For each node, check all left descendants < node < all right descendants

Inorder Traversal (Optimal) — Algorithm Steps

Perform inorder traversal (left → root → right)
Keep track of the previously visited value
Ensure current value > previous value
If any value violates this, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Inorder

Begin inorder traversal: left → root → right

Visit Left First

Recursively visit leftmost nodes first

Check Ordering

Ensure each visited value > previous value

Continue Right

Move to right subtree maintaining order

Code -

solution.c — C

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

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

static long long prev = LLONG_MIN;

bool inorder(struct TreeNode* node) {
    if (!node) return true;
    
    // Check left subtree
    if (!inorder(node->left)) return false;
    
    // Check current node
    if ((long long)node->val <= prev) return false;
    prev = node->val;
    
    // Check right subtree
    return inorder(node->right);
}

bool isValidBST(struct TreeNode* root) {
    prev = LLONG_MIN;  // Reset for each test
    return inorder(root);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during inorder traversal

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h (O(log n) for balanced, O(n) for skewed)

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-2³¹ ≤ Node.val ≤ 2³¹ - 1
Tree nodes contain unique values (but this needs to be validated!)

89.4K Views

Very High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Inorder Traversal (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler