Range Sum of BST

Range Sum of BST - Problem

Given the root node of a binary search tree and two integers low and high, return the sum of values of all nodes with a value in the inclusive range [low, high].

A Binary Search Tree (BST) is a tree where for every node, all values in the left subtree are smaller than the node's value, and all values in the right subtree are greater than the node's value.

Input & Output

Example 1 — Basic BST

$ Input: root = [10,5,15,3,7,null,18], low = 7, high = 15

› Output: 32

💡 Note: Nodes 7, 10, and 15 are in range [7,15]. Sum = 7 + 10 + 15 = 32

Example 2 — Smaller Range

$ Input: root = [10,5,15,3,7,13,18,1,null,6], low = 6, high = 10

› Output: 23

💡 Note: Nodes 6, 7, and 10 are in range [6,10]. Sum = 6 + 7 + 10 = 23

Example 3 — Single Node

$ Input: root = [5], low = 3, high = 8

› Output: 5

💡 Note: Only node 5 exists and it's in range [3,8]. Sum = 5

Constraints

The number of nodes in the tree is in the range [1, 2 × 10⁴]
1 ≤ Node.val ≤ 10⁵
1 ≤ low ≤ high ≤ 10⁵

Visualization

Tap to expand

Asked in

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

The key insight is to leverage the BST property to skip entire subtrees when their values cannot be in our target range. The optimal approach uses DFS with pruning: if current node > high, skip right subtree; if current node < low, skip left subtree. Time: O(n), Space: O(h).

Common Approaches

✓ Brute Force DFS

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

Traverse every node in the tree using DFS and add values that fall within the given range. This approach doesn't utilize the BST property for optimization.

Optimized DFS with BST Pruning

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

Leverage the BST property to prune subtrees when we know they cannot contain values in our range. If current value is greater than high, skip right subtree. If current value is less than low, skip left subtree.

Brute Force DFS — Algorithm Steps

Traverse all nodes using DFS
Check if each node's value is in [low, high]
Sum all values that satisfy the condition

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin traversal from root

Check Range

For each node, check if value is in [low, high]

Sum Valid

Add values that fall in range

Code -

solution.c — C

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

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

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

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

int solution(struct TreeNode* root, int low, int high) {
    if (!root) return 0;
    
    int total = 0;
    if (root->val >= low && root->val <= high) {
        total += root->val;
    }
    
    total += solution(root->left, low, high);
    total += solution(root->right, low, high);
    
    return total;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nodes[1000];
    int size = 0;
    
    // Remove brackets and parse
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    if (start && end) {
        start++; // Skip '['
        *end = '\0'; // Null terminate before ']'
        
        char* token = start;
        while (token && *token) {
            // Skip whitespace
            while (*token == ' ' || *token == '\t') token++;
            if (!*token) break;
            
            if (strncmp(token, "null", 4) == 0) {
                nodes[size++] = -1;
                token += 4;
            } else {
                char* endptr;
                int val = strtol(token, &endptr, 10);
                nodes[size++] = val;
                token = endptr;
            }
            
            // Skip to next comma or end
            while (*token && *token != ',') token++;
            if (*token == ',') token++;
        }
    }
    
    int low, high;
    scanf("%d", &low);
    scanf("%d", &high);
    
    struct TreeNode* root = buildTree(nodes, size);
    int result = solution(root, low, high);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must visit every node in the tree

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

125.0K Views

Medium Frequency

~15 min Avg. Time

3.4K 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 DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler