Maximum Sum BST in Binary Tree

Maximum Sum BST in Binary Tree - Problem

Given a binary tree root, return the maximum sum of all keys of any sub-tree which is also a Binary Search Tree (BST).

Assume a BST is defined as follows:

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

Input & Output

Example 1 — Mixed Tree

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

› Output: 20

💡 Note: The maximum sum BST is the subtree rooted at node 3: [3,2,5,null,null,4,6] with sum 3+2+5+4+6 = 20

Example 2 — Invalid Root BST

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

› Output: 2

💡 Note: Root is not a valid BST. The maximum sum BST is the single node with value 2, so sum = 2

Example 3 — Negative Values

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

› Output: 8

💡 Note: The maximum sum BST is [1,-2,5,2] with sum 1+(-2)+5+2 = 6, but actually the BST [1,null,3] gives sum 4, and BST [5] gives 5, so we need to find the actual maximum

Constraints

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

Visualization

Tap to expand

Asked in

a Amazon 15 f Facebook 12 G Google 8

The key insight is to use a single DFS traversal that returns validation status, sum, and bounds together. Each recursive call checks if the current subtree is a valid BST using the returned min/max values from children, avoiding redundant traversals. Best approach is optimized DFS with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Check Every Subtree

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

Visit every node, check if the subtree rooted at that node is a valid BST, and if so, calculate its sum. Keep track of the maximum sum found.

Optimized DFS - Single Pass

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

Use a single DFS traversal where each recursive call returns whether the subtree is a valid BST, its sum, and its min/max values. This avoids redundant tree traversals.

Brute Force - Check Every Subtree — Algorithm Steps

For each node in the tree
Check if subtree rooted at this node is a valid BST
If valid BST, calculate sum of all nodes in subtree
Track maximum sum across all valid BST subtrees

Visualization

Tap to expand

Step-by-Step Walkthrough

Visit Node

Check if subtree rooted here is valid BST

Validate

Traverse subtree to verify BST property

Sum

If valid, traverse again to calculate sum

Code -

solution.c — C

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

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

struct TreeNode* newNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int maxSum = 0;

int isValidBST(struct TreeNode* node, long minVal, long maxVal) {
    if (!node) return 1;
    if (node->val <= minVal || node->val >= maxVal) return 0;
    return isValidBST(node->left, minVal, node->val) && 
           isValidBST(node->right, node->val, maxVal);
}

int calculateSum(struct TreeNode* node) {
    if (!node) return 0;
    return node->val + calculateSum(node->left) + calculateSum(node->right);
}

void dfs(struct TreeNode* node) {
    if (!node) return;
    
    if (isValidBST(node, LONG_MIN, LONG_MAX)) {
        int currentSum = calculateSum(node);
        if (currentSum > maxSum) {
            maxSum = currentSum;
        }
    }
    
    dfs(node->left);
    dfs(node->right);
}

int solution(struct TreeNode* root) {
    if (!root) return 0;
    maxSum = 0;
    dfs(root);
    return maxSum;
}

struct TreeNode* buildTree(char* vals[], int size) {
    if (size == 0 || strcmp(vals[0], "null") == 0) return NULL;
    struct TreeNode* root = newNode(atoi(vals[0]));
    struct TreeNode** queue = (struct TreeNode**)malloc(size * sizeof(struct TreeNode*));
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        if (i < size && strcmp(vals[i], "null") != 0) {
            node->left = newNode(atoi(vals[i]));
            queue[rear++] = node->left;
        }
        i++;
        if (i < size && strcmp(vals[i], "null") != 0) {
            node->right = newNode(atoi(vals[i]));
            queue[rear++] = node->right;
        }
        i++;
    }
    free(queue);
    return root;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    int len = strlen(line);
    if (len > 0 && line[len-1] == '\n') {
        line[len-1] = '\0';
        len--;
    }
    
    // Remove brackets
    if (len >= 2 && line[0] == '[' && line[len-1] == ']') {
        memmove(line, line + 1, len - 2);
        line[len - 2] = '\0';
    }
    
    // Parse tokens
    char* vals[1000];
    int count = 0;
    char* token = strtok(line, ",");
    while (token != NULL && count < 1000) {
        vals[count++] = token;
        token = strtok(NULL, ",");
    }
    
    struct TreeNode* root = buildTree(vals, count);
    printf("%d\n", solution(root));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we validate BST property which takes O(n) time in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion call stack can go up to O(n) depth in skewed tree

⚡ Linearithmic Space

78.2K Views

Medium Frequency

~25 min Avg. Time

1.5K 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 Every Subtree — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler