Largest BST Subtree - Practice Coding Problems

Largest BST Subtree - Problem

You're given the root of a binary tree, and your mission is to find the largest subtree that is also a valid Binary Search Tree (BST).

But what makes this challenging? The "largest" means the subtree with the maximum number of nodes, and a subtree must include all of its descendants - you can't cherry-pick nodes!

BST Properties Reminder:

All nodes in the left subtree have values < root's value
All nodes in the right subtree have values > root's value
Both left and right subtrees are also BSTs

Goal: Return the size (number of nodes) of the largest valid BST subtree.

Example: In a tree like [10, 5, 15, 1, 8, null, 7], you need to identify which portions form valid BSTs and find the one with the most nodes.

Input & Output

example_1.py — Mixed BST Tree

$ Input: root = [10,5,15,1,8,null,7]

› Output: 3

💡 Note: The largest BST subtree is the one rooted at node 5, which includes nodes {5, 1, 8}. This subtree follows BST properties: 1 < 5 < 8. The right subtree rooted at 15 is invalid because 7 < 15 violates BST property.

example_2.py — Single Node Tree

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

› Output: 2

💡 Note: The largest BST subtree has 2 nodes. Multiple subtrees of size 2 exist: {2,3} and others. The entire tree is not a BST due to duplicate values and structure violations.

example_3.py — Complete BST Tree

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

› Output: 3

💡 Note: The entire tree is a valid BST since 1 < 2 < 3. Therefore, the largest BST subtree is the whole tree with 3 nodes.

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-10⁴ ≤ Node.val ≤ 10⁴
A subtree must include all of its descendants

Visualization

Tap to expand

Understanding the Visualization

Start from the bottom floors

Begin inspection at leaf nodes (individual rooms) - each is automatically valid

Check floor connections

For each floor, verify that left wing rooms < center room < right wing rooms

Gather section information

Collect data: smallest room number, largest room number, total rooms, validity status

Report to upper management

Pass summary information upward so upper floors can make decisions efficiently

Track largest valid section

Keep record of the biggest properly organized section found during inspection

Key Takeaway

🎯 Key Insight: Bottom-up information gathering allows us to make BST validity decisions efficiently by passing (min, max, size, isBST) data from children to parents, avoiding redundant validations.

Asked in

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

The optimal solution uses bottom-up dynamic programming with a single DFS traversal. Each node returns information about its subtree: minimum value, maximum value, size, and BST validity. This eliminates redundant validations and achieves O(n) time complexity, making it significantly more efficient than the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Bottom-Up DP (Optimal)	O(n)	O(h)	Single pass with bottom-up information propagation for optimal efficiency

Bottom-Up DP (Optimal) — Algorithm Steps

Perform post-order DFS traversal (visit children before parent)
For each node, collect info from children: min value, max value, BST size
Check if current node can form valid BST with its children
If valid, calculate new min, max, and total size for parent
If invalid, mark as non-BST but still track max BST size found in subtrees
Return the maximum BST size encountered

Visualization

Tap to expand

Step-by-Step Walkthrough

Visit leaf nodes

Start from leaves, each leaf is a valid BST of size 1

Collect child info

For each internal node, gather min, max, size from children

Validate BST property

Check if left_max < current < right_min

Update parent info

If valid BST, compute new min, max, size for parent

Track global maximum

Keep track of largest BST size seen so far

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct Result {
    int minVal;
    int maxVal;
    int size;
    int isBst;
};

int maxSize;

int max(int a, int b) {
    return (a > b) ? a : b;
}

int max3(int a, int b, int c) {
    return max(max(a, b), c);
}

struct Result dfs(struct TreeNode* node) {
    struct Result result;
    
    if (!node) {
        result.minVal = INT_MAX;
        result.maxVal = INT_MIN;
        result.size = 0;
        result.isBst = 1;
        return result;
    }
    
    struct Result left = dfs(node->left);
    struct Result right = dfs(node->right);
    
    // Check if current node can form BST with children
    if (left.isBst && right.isBst && left.maxVal < node->val && node->val < right.minVal) {
        // Current subtree is BST
        result.minVal = (left.minVal == INT_MAX) ? node->val : left.minVal;
        result.maxVal = (right.maxVal == INT_MIN) ? node->val : right.maxVal;
        result.size = left.size + right.size + 1;
        result.isBst = 1;
        maxSize = max(maxSize, result.size);
    } else {
        // Current subtree is not BST
        maxSize = max3(maxSize, left.size, right.size);
        result.minVal = INT_MIN;
        result.maxVal = INT_MAX;
        result.size = 0;
        result.isBst = 0;
    }
    
    return result;
}

int largestBSTSubtree(struct TreeNode* root) {
    maxSize = 0;
    dfs(root);
    return maxSize;
}

int main() {
    printf("Optimal solution ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal of all n nodes in the tree, with constant work at each node

✓ Linear Growth

Space Complexity

O(h)

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

✓ Linear Space

78.0K Views

Medium-High Frequency

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

Bottom-Up DP (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler