Skip to content
Related Articles

Related Articles

Improve Article
Sum of nodes in a Binary Search Tree with values from a given range
  • Last Updated : 31 May, 2021

Given a Binary Search Tree consisting of N nodes and two positive integers L and R, the task is to find the sum of values of all the nodes that lie in the range [L, R].

Examples:

Input: L = 7, R = 15
                    10
                   /    \
                5      15
              /  \        \
           3       7   18
Output: 32
Explanation:
The nodes in the given Tree that lies in the range [7, 15] are {7, 10, 15}. Therefore, the sum of nodes is 7 + 10 + 15 = 32.

Input: L = 11, R = 15
                     8
                   /   \
                5      11
              /  \        \
           3       6   20
Output: 11

Approach: The given problem can be solved by performing any Tree Traversal and calculating the sum of nodes which are lying in the range [L, R].



Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Class for node of the Tree
class Node {
public:
    int val;
    Node *left, *right;
};
 
// Function to create a new BST node
Node* newNode(int item)
{
    Node* temp = new Node();
    temp->val = item;
    temp->left = temp->right = NULL;
 
    // Return the newly created node
    return temp;
}
 
// Stores the sum of all nodes
// lying in the range [L, R]
int sum = 0;
 
// Function to perform level order
// traversal on the Tree and
// calculate the required sum
int rangeSumBST(Node* root, int low,
                int high)
{
    // Base Case
    if (root == NULL)
        return 0;
 
    // Stores the nodes while
    // performing level order traversal
    queue<Node*> q;
 
    // Push the root node
    // into the queue
    q.push(root);
 
    // Iterate until queue is empty
    while (q.empty() == false) {
 
        // Stores the front
        // node of the queue
        Node* curr = q.front();
        q.pop();
 
        // If the value of the node
        // lies in the given range
        if (curr->val >= low
            && curr->val <= high) {
 
            // Add it to sum
            sum += curr->val;
        }
 
        // If the left child is
        // not NULL and exceeds low
        if (curr->left != NULL
            && curr->val > low)
 
            // Insert into queue
            q.push(curr->left);
 
        // If the right child is not
        // NULL and exceeds low
        if (curr->right != NULL
            && curr->val < high)
 
            // Insert into queue
            q.push(curr->right);
    }
 
    // Return the resultant sum
    return sum;
}
 
// Function to insert a new node
// into the Binary Search Tree
Node* insert(Node* node, int data)
{
    // Base Case
    if (node == NULL)
        return newNode(data);
 
    // If the data is less than the
    // value of the current node
    if (data <= node->val)
 
        // Recur for left subtree
        node->left = insert(node->left,
                            data);
 
    // Otherwise
    else
 
        // Recur for the right subtree
        node->right = insert(node->right,
                             data);
 
    // Return the node
    return node;
}
 
// Driver Code
int main()
{
    /* Let us create following BST
         10   
        / \
       5   15
      / \     \
     3   7    18  */
    Node* root = NULL;
    root = insert(root, 10);
    insert(root, 5);
    insert(root, 15);
    insert(root, 3);
    insert(root, 7);
    insert(root, 18);
 
    int L = 7, R = 15;
    cout << rangeSumBST(root, L, R);
 
    return 0;
}

Java




// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Class for node of the Tree
static class Node
{
    int val;
    Node left, right;
};
 
// Function to create a new BST node
static Node newNode(int item)
{
    Node temp = new Node();
    temp.val = item;
    temp.left = temp.right = null;
 
    // Return the newly created node
    return temp;
}
 
// Stores the sum of all nodes
// lying in the range [L, R]
static int sum = 0;
 
// Function to perform level order
// traversal on the Tree and
// calculate the required sum
static int rangeSumBST(Node root, int low,
                                  int high)
{
     
    // Base Case
    if (root == null)
    return 0;
 
    // Stores the nodes while
    // performing level order traversal
    Queue<Node> q = new LinkedList<Node>();
 
    // Push the root node
    // into the queue
    q.add(root);
 
    // Iterate until queue is empty
    while (q.isEmpty() == false)
    {
         
        // Stores the front
        // node of the queue
        Node curr = q.peek();
        q.remove();
 
        // If the value of the node
        // lies in the given range
        if (curr.val >= low &&
            curr.val <= high)
        {
             
            // Add it to sum
            sum += curr.val;
        }
 
        // If the left child is
        // not null and exceeds low
        if (curr.left != null &&
            curr.val > low)
 
            // Insert into queue
            q.add(curr.left);
 
        // If the right child is not
        // null and exceeds low
        if (curr.right != null &&
            curr.val < high)
 
            // Insert into queue
            q.add(curr.right);
    }
 
    // Return the resultant sum
    return sum;
}
 
// Function to insert a new node
// into the Binary Search Tree
static Node insert(Node node, int data)
{
     
    // Base Case
    if (node == null)
        return newNode(data);
 
    // If the data is less than the
    // value of the current node
    if (data <= node.val)
 
        // Recur for left subtree
        node.left = insert(node.left,
                           data);
 
    // Otherwise
    else
 
        // Recur for the right subtree
        node.right = insert(node.right,
                            data);
 
    // Return the node
    return node;
}
 
// Driver Code
public static void main(String[] args)
{
     
    /* Let us create following BST
         10   
        / \
       5   15
      / \     \
     3   7    18  */
    Node root = null;
    root = insert(root, 10);
    insert(root, 5);
    insert(root, 15);
    insert(root, 3);
    insert(root, 7);
    insert(root, 18);
 
    int L = 7, R = 15;
    System.out.print(rangeSumBST(root, L, R));
}
}
 
// This code is contributed by 29AjayKumar

Python3




# Python3 program for the above approach
from collections import deque
 
# Class for node of the Tree
class Node:
    def __init__(self,v):
        self.val = v
        self.left = None
        self.right = None
 
# Function to perform level order
# traversal on the Tree and
# calculate the required sum
def rangeSumBST(root, low, high):
    sum = 0
     
    # Base Case
    if (root == None):
        return 0
 
    # Stores the nodes while
    # performing level order traversal
    q = deque()
     
    # Push the root node
    # into the queue
    q.append(root)
 
    # Iterate until queue is empty
    while (len(q) > 0):
 
        # Stores the front
        # node of the queue
        curr = q.popleft()
        # q.pop()
 
        # If the value of the node
        # lies in the given range
        if (curr.val >= low
            and curr.val <= high):
 
            # Add it to sum
            sum += curr.val
 
        # If the left child is
        # not NULL and exceeds low
        if (curr.left != None
            and curr.val > low):
 
            # Insert into queue
            q.append(curr.left)
 
        # If the right child is not
        # NULL and exceeds low
        if (curr.right != None
            and curr.val < high):
 
            # Insert into queue
            q.append(curr.right)
 
    # Return the resultant sum
    return sum
 
# Function to insert a new node
# into the Binary Search Tree
def insert(node, data):
   
    # Base Case
    if (node == None):
        return Node(data)
 
    # If the data is less than the
    # value of the current node
    if (data <= node.val):
 
        # Recur for left subtree
        node.left = insert(node.left, data)
    # Otherwise
    else:
        # Recur for the right subtree
        node.right = insert(node.right, data)
 
    # Return the node
    return node
 
# Driver Code
if __name__ == '__main__':
    # /* Let us create following BST
    #      10
    #     / \
    #    5   15
    #   / \     \
    #  3   7    18  */
    root = None
    root = insert(root, 10)
    root = insert(root, 5)
    root = insert(root, 15)
    root = insert(root, 3)
    root = insert(root, 7)
    root = insert(root, 18)
 
    L, R = 7, 15
    print(rangeSumBST(root, L, R))
 
# This code is contributed by mohit kumar 29.

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Class for node of the Tree
class Node
{
    public int val;
    public Node left, right;
};
 
// Function to create a new BST node
static Node newNode(int item)
{
    Node temp = new Node();
    temp.val = item;
    temp.left = temp.right = null;
 
    // Return the newly created node
    return temp;
}
 
// Stores the sum of all nodes
// lying in the range [L, R]
static int sum = 0;
 
// Function to perform level order
// traversal on the Tree and
// calculate the required sum
static int rangeSumBST(Node root, int low,
                                  int high)
{
     
    // Base Case
    if (root == null)
    return 0;
 
    // Stores the nodes while
    // performing level order traversal
    Queue<Node> q = new Queue<Node>();
 
    // Push the root node
    // into the queue
    q.Enqueue(root);
 
    // Iterate until queue is empty
    while (q.Count!=0)
    {
         
        // Stores the front
        // node of the queue
        Node curr = q.Peek();
        q.Dequeue();
 
        // If the value of the node
        // lies in the given range
        if (curr.val >= low &&
            curr.val <= high)
        {
             
            // Add it to sum
            sum += curr.val;
        }
 
        // If the left child is
        // not null and exceeds low
        if (curr.left != null &&
            curr.val > low)
 
            // Insert into queue
            q.Enqueue(curr.left);
 
        // If the right child is not
        // null and exceeds low
        if (curr.right != null &&
            curr.val < high)
 
            // Insert into queue
            q.Enqueue(curr.right);
    }
 
    // Return the resultant sum
    return sum;
}
 
// Function to insert a new node
// into the Binary Search Tree
static Node insert(Node node, int data)
{
     
    // Base Case
    if (node == null)
        return newNode(data);
 
    // If the data is less than the
    // value of the current node
    if (data <= node.val)
 
        // Recur for left subtree
        node.left = insert(node.left,
                           data);
 
    // Otherwise
    else
 
        // Recur for the right subtree
        node.right = insert(node.right,
                            data);
 
    // Return the node
    return node;
}
 
// Driver Code
public static void Main(String[] args)
{
     
    /* Let us create following BST
         10   
        / \
       5   15
      / \     \
     3   7    18  */
    Node root = null;
    root = insert(root, 10);
    insert(root, 5);
    insert(root, 15);
    insert(root, 3);
    insert(root, 7);
    insert(root, 18);
 
    int L = 7, R = 15;
    Console.Write(rangeSumBST(root, L, R));
}
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
 
// JavaScript program for the above approach
 
// Class for node of the Tree
class Node
{
    // Function to create a new BST node
    constructor(item)
    {
        this.val=item;
        this.left=this.right=null;
    }
}
 
// Stores the sum of all nodes
// lying in the range [L, R]
let sum = 0;
 
// Function to perform level order
// traversal on the Tree and
// calculate the required sum
function rangeSumBST(root,low,high)
{
    // Base Case
    if (root == null)
        return 0;
  
    // Stores the nodes while
    // performing level order traversal
    let q = [];
  
    // Push the root node
    // into the queue
    q.push(root);
  
    // Iterate until queue is empty
    while (q.length!=0)
    {
          
        // Stores the front
        // node of the queue
        let curr = q.shift();
         
  
        // If the value of the node
        // lies in the given range
        if (curr.val >= low &&
            curr.val <= high)
        {
              
            // Add it to sum
            sum += curr.val;
        }
  
        // If the left child is
        // not null and exceeds low
        if (curr.left != null &&
            curr.val > low)
  
            // Insert into queue
            q.push(curr.left);
  
        // If the right child is not
        // null and exceeds low
        if (curr.right != null &&
            curr.val < high)
  
            // Insert into queue
            q.push(curr.right);
    }
  
    // Return the resultant sum
    return sum;
}
 
// Function to insert a new node
// into the Binary Search Tree
function  insert(node,data)
{
    // Base Case
    if (node == null)
        return new Node(data);
  
    // If the data is less than the
    // value of the current node
    if (data <= node.val)
  
        // Recur for left subtree
        node.left = insert(node.left,
                           data);
  
    // Otherwise
    else
  
        // Recur for the right subtree
        node.right = insert(node.right,
                            data);
  
    // Return the node
    return node;
}
 
// Driver Code
/* Let us create following BST
         10  
        / \
       5   15
      / \     \
     3   7    18  */
let root = null;
root = insert(root, 10);
insert(root, 5);
insert(root, 15);
insert(root, 3);
insert(root, 7);
insert(root, 18);
 
let L = 7, R = 15;
document.write(rangeSumBST(root, L, R));
 
     
 
// This code is contributed by patel2127
 
</script>
Output: 
32

 

Time Complexity: O(N)
Auxiliary Space: O(N)

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes




My Personal Notes arrow_drop_up
Recommended Articles
Page :