Validate Binary Search Tree

Validate Binary Search Tree - Problem

Given the root of a binary tree, determine if it is a valid binary search tree (BST).

A valid BST is defined as follows:

The left subtree of a node contains only nodes with keys strictly less than the node's key.
The right subtree of a node contains only nodes with keys strictly greater than the node's key.
Both the left and right subtrees must also be binary search trees.

Input & Output

Example 1 — Valid BST

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

› Output: true

💡 Note: The tree is a valid BST: left child 1 < root 2 < right child 3, and all subtrees are valid BSTs

Example 2 — Invalid BST

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

› Output: false

💡 Note: The right subtree contains 3 which is less than root 5, violating BST property

Example 3 — Single Node

$ Input: root = [1]

› Output: true

💡 Note: A single node is always a valid BST

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-2³¹ ≤ Node.val ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The optimal approach uses DFS with min/max bounds to validate each node in a single pass. Each node must satisfy range constraints inherited from its ancestors. Time: O(n), Space: O(h)

Common Approaches

✓ Brute Force - Check All Nodes

⏱️ Time: O(n²) Space: O(h)

Visit every node and for each node, traverse its entire left subtree to ensure all values are smaller, and traverse its entire right subtree to ensure all values are larger.

DFS with Min/Max Bounds

⏱️ Time: O(n) Space: O(h)

Traverse the tree while maintaining valid range bounds for each node. Each node must be within its allowed range based on ancestors.

Inorder Traversal

⏱️ Time: O(n) Space: O(h)

Use inorder traversal (left-root-right) which visits BST nodes in sorted order. If the result is strictly increasing, the tree is a valid BST.

Brute Force - Check All Nodes — Algorithm Steps

For each node in the tree
Check all nodes in left subtree are smaller
Check all nodes in right subtree are larger
Return false if any violation found

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Node

For each node, examine all descendants

Validate Left

All left subtree values must be smaller

Validate Right

All right subtree values must be larger

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.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;
}

void getAllValues(struct TreeNode* node, int* values, int* count) {
    if (!node) {
        return;
    }
    getAllValues(node->left, values, count);
    values[(*count)++] = node->val;
    getAllValues(node->right, values, count);
}

bool isValidNode(struct TreeNode* node) {
    if (!node) {
        return true;
    }
    
    int leftValues[1000], rightValues[1000];
    int leftCount = 0, rightCount = 0;
    
    getAllValues(node->left, leftValues, &leftCount);
    getAllValues(node->right, rightValues, &rightCount);
    
    for (int i = 0; i < leftCount; i++) {
        if (leftValues[i] >= node->val) {
            return false;
        }
    }
    
    for (int i = 0; i < rightCount; i++) {
        if (rightValues[i] <= node->val) {
            return false;
        }
    }
    
    return isValidNode(node->left) && isValidNode(node->right);
}

bool solution(struct TreeNode* root) {
    if (!root) {
        return true;
    }
    return isValidNode(root);
}

void parseArray(const char* str, int* arr, bool* isNull, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (strncmp(p, "null", 4) == 0) {
            isNull[*size] = true;
            arr[*size] = 0;
            p += 4;
        } else {
            isNull[*size] = false;
            arr[*size] = (int)strtol(p, (char**)&p, 10);
        }
        (*size)++;
    }
}

struct TreeNode* buildTree(int* arr, bool* isNull, int size) {
    if (size == 0 || isNull[0]) {
        return NULL;
    }
    
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size && !isNull[i]) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && !isNull[i]) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[1000];
    bool isNull[1000];
    int size;
    parseArray(line, arr, isNull, &size);
    
    struct TreeNode* root = buildTree(arr, isNull, size);
    bool result = solution(root);
    printf("%s\n", result ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially visit all other nodes to validate

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

67.8K Views

High Frequency

~25 min Avg. Time

2.2K 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

Brute Force - Check All Nodes — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler