Skip to content
Related Articles

Related Articles

Count of nodes in a binary tree having their nodes in range [L, R]

View Discussion
Improve Article
Save Article
  • Last Updated : 17 Jan, 2022
View Discussion
Improve Article
Save Article

Given a Binary Tree consisting of N nodes and two positive integers L and R, the task is to find the count of nodes having their value in the range [L, R].

Examples:

Input: Tree in the image below, L = 4, R = 15

Output: 2
Explanation: The nodes in the given Tree that lies in the range [4, 15] are {5, 10}.

Input: Tree in the image below, L = 8, R = 20

Output: 4

Approach: The given problem can be solved by performing any Tree Traversal and maintaining the count of nodes having their values in the range [L, R]. This article uses a DFS traversal.

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 Binary node
Node* newNode(int item)
{
    Node* temp = new Node();
    temp->val = item;
    temp->left = temp->right = NULL;
 
    // Return the newly created node
    return temp;
}
 
// Function to find the count of
// nodes in the given tree with
// their value in the range [1, N]
int countRange(Node* root, int low,
               int high, int count)
{
    int val = 0;
 
    // If root exists
    if (root != NULL) {
 
        val += root->val >= low
                       && root->val <= high
                   ? 1
                   : 0;
    }
 
    // Otherwise return
    else {
        return 0;
    }
 
    // Add count of current node,
    // count in left subtree, and
    // count in the right subtree
    count = val
            + countRange(root->left,
                         low, high, count)
            + countRange(root->right,
                         low, high, count);
 
    // Return Answer
    return count;
}
 
// Driver Code
int main()
{
    Node* root = NULL;
    root = newNode(20);
    root->left = newNode(2);
    root->right = newNode(10);
    root->right->left = newNode(2);
    root->right->right = newNode(5);
 
    int L = 4, R = 15;
    cout << countRange(root, L, R, 0);
 
    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 Binary 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;
  }
 
  // Function to find the count of
  // nodes in the given tree with
  // their value in the range [1, N]
  static int countRange(Node root, int low,
                        int high, int count)
  {
    int val = 0;
 
    // If root exists
    if (root != null) {
 
      val += root.val >= low
        && root.val <= high
        ? 1
        : 0;
    }
 
    // Otherwise return
    else {
      return 0;
    }
 
    // Add count of current node,
    // count in left subtree, and
    // count in the right subtree
    count = val
      + countRange(root.left,
                   low, high, count)
      + countRange(root.right,
                   low, high, count);
 
    // Return Answer
    return count;
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    Node root = null;
    root = newNode(20);
    root.left = newNode(2);
    root.right = newNode(10);
    root.right.left = newNode(2);
    root.right.right = newNode(5);
 
    int L = 4, R = 15;
    System.out.print(countRange(root, L, R, 0));
  }
}
 
// This code is contributed by shikhasingrajput


Python3




# Python program for the above approach
 
# Class for Node of the Tree
class Node:
    def __init__(self, val):
        self.val = val;
        self.left = None;
        self.right = None;
 
# Function to create a new Binary Node
def newNode(item):
    temp = Node(item);
     
    # Return the newly created Node
    return temp;
 
# Function to find the count of
# Nodes in the given tree with
# their value in the range [1, N]
def countRange(root, low, high, count):
    val = 0;
 
    # If root exists
    if (root != None):
 
        val += 1 if(root.val >= low and root.val <= high) else 0;
 
 
    # Otherwise return
    else:
        return 0;
 
    # Add count of current Node,
    # count in left subtree, and
    # count in the right subtree
    count = val + countRange(root.left, low, high, count) + countRange(root.right, low, high, count);
 
    # Return Answer
    return count;
 
 
# Driver Code
if __name__ == '__main__':
    root = None;
    root = newNode(20);
    root.left = newNode(2);
    root.right = newNode(10);
    root.right.left = newNode(2);
    root.right.right = newNode(5);
 
    L = 4;
    R = 15;
    print(countRange(root, L, R, 0));
 
# This code is contributed by 29AjayKumar


C#




// C# program for the above approach
using System;
 
public class GFG{
 
  // Class for node of the Tree
  class Node {
 
    public int val;
    public Node left, right;
  };
 
  // Function to create a new Binary 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;
  }
 
  // Function to find the count of
  // nodes in the given tree with
  // their value in the range [1, N]
  static int countRange(Node root, int low,
                        int high, int count)
  {
    int val = 0;
 
    // If root exists
    if (root != null) {
 
      val += root.val >= low
        && root.val <= high
        ? 1
        : 0;
    }
 
    // Otherwise return
    else {
      return 0;
    }
 
    // Add count of current node,
    // count in left subtree, and
    // count in the right subtree
    count = val
      + countRange(root.left,
                   low, high, count)
      + countRange(root.right,
                   low, high, count);
 
    // Return Answer
    return count;
  }
 
  // Driver Code
  public static void Main(String[] args)
  {
    Node root = null;
    root = newNode(20);
    root.left = newNode(2);
    root.right = newNode(10);
    root.right.left = newNode(2);
    root.right.right = newNode(5);
 
    int L = 4, R = 15;
    Console.Write(countRange(root, L, R, 0));
  }
}
 
// This code is contributed by shikhasingrajput


Javascript




<script>
      // JavaScript code for the above approach
 
      // Class for node of the Tree
      class Node {
 
          constructor(val1) {
              this.val = val1;
              this.left = null;
              this.right = null;
          }
      };
 
      // Function to find the count of
      // nodes in the given tree with
      // their value in the range [1, N]
      function countRange(root, low,
          high, count) {
          let val = 0;
 
          // If root exists
          if (root != null) {
 
              val += root.val >= low
                  && root.val <= high
                  ? 1
                  : 0;
          }
 
          // Otherwise return
          else {
              return 0;
          }
 
          // Add count of current node,
          // count in left subtree, and
          // count in the right subtree
          count = val
              + countRange(root.left,
                  low, high, count)
              + countRange(root.right,
                  low, high, count);
 
          // Return Answer
          return count;
      }
 
      // Driver Code
      let root = null;
      root = new Node(20);
      root.left = new Node(2);
      root.right = new Node(10);
      root.right.left = new Node(2);
      root.right.right = new Node(5);
 
      let L = 4, R = 15;
      document.write(countRange(root, L, R, 0));
 
// This code is contributed by Potta Lokesh
  </script>


 
 

Output

2

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!