Count BST nodes that lie in a given range in C++

We are given a binary search tree made up of nodes and also a range and the task is to calculate the count of nodes that lies in the given range and display the result.

A Binary Search Tree (BST) is a tree in which all the nodes follow the below-mentioned properties −

• The left subtree of a node has a key less than or equal to its parent node's key.

• The right subtree of a node has a key greater than to its parent node's key.

Thus, BST divides all its sub-trees into two segments; the left subtree and the right subtree and can be defined as −

left_subtree (keys) ≤ node (key) ≤ right_subtree (keys)

For Example

Input −

Range: [11, 40]

Output − count is: 5

Explanation − The node values between the range [11, 40] is 14, 19, 27, 31 and 35 so there are in total 5 nodes in a given binary search tree.

Approach used in the below program is as follows

• Create a structure of a node containing data, left pointer, right pointer and create a range

• Create a function to insert a newnode that the user will enter.

• Create another function to count the nodes that lie in a given range.

• Check IF the root is NULL then return

• Now, check IF root->data = Start AND root->data = End then return 1.

• Now, check IF root->data <= high && root->data >= low then return 1 + getCount(root->left, End, Start) + recursively_call_count_function(root->right, End, Start)

• Else If, root->data < End then return recursively_call_count_function(root->right, End, Start)

• Else, return recursively_call_count_function(root->left, End, Start)

Example

 Live Demo

#include<iostream>
using namespace std;
// A BST node
struct node{
   int data;
   struct node* left, *right;
};
// Utility function to create new node
node *newNode(int data){
   node *temp = new node;
   temp->data = data;
   temp->left = temp->right = NULL;
   return (temp);
}
int findcount(node *root, int low, int high){
   // Base case
   if (!root){
      return 0;
   }
   if (root->data == high && root->data == low){
      return 1;
   }
   // If current node is in range, then include it in count and
   // recur for left and right children of it
   if (root->data <= high && root->data >= low){
      return 1 + findcount(root->left, low, high) +
      findcount(root->right, low, high);
   }
   else if (root->data < low){
      return findcount(root->right, low, high);
   }
   // Else recur for left child
   else{
      return findcount(root->left, low, high);
   }
}
// main function
int main(){
   // Let us construct the BST shown in the above figure
   node *root = newNode(27);
   root->left = newNode(14);
   root->right = newNode(35);
   root->left->left = newNode(10);
   root->left->right = newNode(19);
   root->right->left = newNode(31);
   root->right->right = newNode(42);
   int low = 10;
   int high = 50;
   cout << "Count of nodes between [" << low << ", " << high
   << "] is " << findcount(root, low, high);
   return 0;
}

Output

If we run the above code we will get the following output −

Count of nodes between [10, 50] is 7