Largest BST Subtree

Largest BST Subtree - Problem

Given the root of a binary tree, find the largest subtree that is also a Binary Search Tree (BST).

The largest means the subtree with the maximum number of nodes.

A Binary Search Tree (BST) is a tree where:

The left subtree values are less than the parent node's value
The right subtree values are greater than the parent node's value

Note: A subtree must include all of its descendants.

Input & Output

Example 1 — Mixed Valid/Invalid BST

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

› Output: 3

💡 Note: The left subtree [5,1,8] is a valid BST with 3 nodes. The right subtree [15,7] is invalid because 7 < 15. The whole tree is also invalid BST, so the largest BST subtree has 3 nodes.

Example 2 — Entire Tree is BST

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

› Output: 7

💡 Note: The entire tree is a valid BST: left subtree values (1,2,3) < root (4) < right subtree values (5,6,7). All 7 nodes form the largest BST subtree.

Example 3 — Single Node

$ Input: root = [1]

› Output: 1

💡 Note: A single node is always a valid BST, so the largest BST subtree has 1 node.

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-10⁴ ≤ Node.val ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15 F Facebook 12

The key insight is to use post-order DFS to validate BST properties bottom-up while tracking subtree sizes. The optimal approach collects BST information (validity, size, min/max values) in a single traversal. Time: O(n), Space: O(h)

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Brute Force - Validate Each Subtree

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

For each node, validate if the subtree rooted at that node is a valid BST. If valid, count the number of nodes in that subtree. Keep track of the maximum size found.

Optimized DFS - Single Pass

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

Use post-order DFS to collect information about each subtree: whether it's a valid BST, its size, and min/max values. This avoids redundant traversals by gathering all needed information in a single pass.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int getDistance(char c1, char c2) {
    int diff = abs(c1 - c2);
    return (diff > 13) ? 26 - diff : diff;
}

char* solution(char* s, int k) {
    int n = strlen(s);
    char* result = (char*)malloc((n + 1) * sizeof(char));
    strcpy(result, s);
    int budget = k;
    
    // Greedy approach: try to change each character to 'a' if we can afford it
    for (int i = 0; i < n; i++) {
        int costToA = getDistance(s[i], 'a');
        if (costToA <= budget) {
            result[i] = 'a';
            budget -= costToA;
        }
    }
    
    return result;
}

int main() {
    char s[1001];
    int k;
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    scanf("%d", &k);
    
    char* result = solution(s, k);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

127.6K Views

Medium 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