Sum of nodes in a Binary Search Tree with values from a given range

Last Updated : 21 Oct, 2024

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:

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:

Output: 11
Explanation: The nodes in the given Tree that lies in the range [11, 15] is {11}. Therefore, the sum of node is 11.

Approach:

The idea to traverse the tree recursively. For each node, if it lies within the range, then return the sum of left subtree, right subtree and current node. If its value is less than range, then return the value of right subtree. Otherwise return the value of left subtree.

Below is the implementation of the above approach:

C++

// C++ program to calculate sum of  // nodes in a Binary Search Tree  // with values from a given range #include <bits/stdc++.h> using namespace std;  class Node { public:     int data;     Node *left, *right;     Node (int x) {         data = x;         left = nullptr;         right = nullptr;     } };  // function to find sum of nodes that lie  // within a given range int nodeSum(Node *root, int low, int high) {          if (root == nullptr) return 0;          // If root value is less than range.     if (root->data < low) {         return nodeSum(root->right, low, high);     }          // If root value is greater than range.     else if (root->data > high) {         return nodeSum(root->left, low, high);     }          // If root value lies in the range.     int left = nodeSum(root->left, low, high);     int right = nodeSum(root->right, low, high);          return low + high + root->data; }  int main() {          // BST     //       22     //      /  \     //    12    30     //   /  \     //  8    20     Node* root = new Node(22);     root->left = new Node(12);     root->right = new Node(30);     root->left->left = new Node(8);     root->left->right = new Node(20);     int l = 10, h = 22;          cout << nodeSum(root, l, h) << endl;          return 0; }

Java

// Java program to calculate sum of  // nodes in a Binary Search Tree  // with values from a given range  import java.util.ArrayList;  class Node {     int data;     Node left, right;      Node(int x) {         data = x;         left = null;         right = null;     } }  class GfG {      // function to find sum of nodes that lie      // within a given range     static int nodeSum(Node root, int low, int high) {         if (root == null) return 0;          // If root value is less than range.         if (root.data < low) {             return nodeSum(root.right, low, high);         }          // If root value is greater than range.         else if (root.data > high) {             return nodeSum(root.left, low, high);         }          // If root value lies in the range.         int left = nodeSum(root.left, low, high);         int right = nodeSum(root.right, low, high);          return left + right + root.data;     }      public static void main(String[] args) {          // BST         //       22         //      /  \         //    12    30         //   /  \         //  8    20         Node root = new Node(22);         root.left = new Node(12);         root.right = new Node(30);         root.left.left = new Node(8);         root.left.right = new Node(20);         int l = 10, h = 22;          System.out.println(nodeSum(root, l, h));     } }

Python

# Python program to calculate sum of  # nodes in a Binary Search Tree  # with values from a given range  class Node:     def __init__(self, x):         self.data = x         self.left = None         self.right = None  # function to find sum of nodes that lie  # within a given range def nodeSum(root, low, high):     if root is None:         return 0      # If root value is less than range.     if root.data < low:         return nodeSum(root.right, low, high)      # If root value is greater than range.     elif root.data > high:         return nodeSum(root.left, low, high)      # If root value lies in the range.     left = nodeSum(root.left, low, high)     right = nodeSum(root.right, low, high)      return left + right + root.data  if __name__ == "__main__":      # BST     #       22     #      /  \     #    12    30     #   /  \     #  8    20     root = Node(22)     root.left = Node(12)     root.right = Node(30)     root.left.left = Node(8)     root.left.right = Node(20)     l = 10     h = 22      print(nodeSum(root, l, h))

// C# program to calculate sum of  // nodes in a Binary Search Tree  // with values from a given range  using System; using System.Collections.Generic;  class Node {     public int data;     public Node left, right;      public Node(int x) {         data = x;         left = null;         right = null;     } }  class GfG {      // function to find sum of nodes that lie      // within a given range     static int nodeSum(Node root, int low, int high) {         if (root == null) return 0;          // If root value is less than range.         if (root.data < low) {             return nodeSum(root.right, low, high);         }          // If root value is greater than range.         else if (root.data > high) {             return nodeSum(root.left, low, high);         }          // If root value lies in the range.         int left = nodeSum(root.left, low, high);         int right = nodeSum(root.right, low, high);          return left + right + root.data;     }      static void Main(string[] args) {          // BST         //       22         //      /  \         //    12    30         //   /  \         //  8    20         Node root = new Node(22);         root.left = new Node(12);         root.right = new Node(30);         root.left.left = new Node(8);         root.left.right = new Node(20);         int l = 10, h = 22;          Console.WriteLine(nodeSum(root, l, h));     } }

JavaScript

// JavaScript program to calculate sum of  // nodes in a Binary Search Tree  // with values from a given range  class Node {     constructor(x) {         this.data = x;         this.left = null;         this.right = null;     } }  // function to find sum of nodes that lie  // within a given range function nodeSum(root, low, high) {     if (root === null) return 0;      // If root value is less than range.     if (root.data < low) {         return nodeSum(root.right, low, high);     }      // If root value is greater than range.     else if (root.data > high) {         return nodeSum(root.left, low, high);     }      // If root value lies in the range.     let left = nodeSum(root.left, low, high);     let right = nodeSum(root.right, low, high);      return left + right + root.data; }  // BST //       22 //      /  \ //    12    30 //   /  \ //  8    20 let root = new Node(22); root.left = new Node(12); root.right = new Node(30); root.left.left = new Node(8); root.left.right = new Node(20); let l = 10, h = 22;  console.log(nodeSum(root, l, h));

Output

Time Complexity: O(n), where n is the number of nodes in tree.
Auxiliary Space: O(h), where h is the height of tree.

Related articles:

Sum of specially balanced nodes from a given Binary Tree

CoderSaty

Improve

Article Tags :

Practice Tags :

Sum of nodes in a Binary Search Tree with values from a given range

Similar Reads