Count BST subtrees that lie in given range

Given a Binary Search Tree (BST) and a range [low, high], the task is to count the number of nodes where all the nodes under that node (or subtree rooted with that node) lie in the given range.

Examples:

Input : low = 8, high = 10

Output: 1
Explanation: There is only 1 node with the value 10 whose subtree is in the given range.
Input: low = 12, high = 20

Output: 3
Explanation: There are three nodes whose subtree is in the given range. The nodes are 12, 10 and 14

Approach:

The idea is to traverse the given Binary Search Tree (BST) in a bottom-up manner. For every node, make recursive calls for its subtrees, if subtrees are in range and the nodes are also in range, then increment the count and return true.

Below is the implementation of the above approach:

C++

// C++ program to count BST subtrees
// that lie in 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;
    }
};

// Recursive function to count
// subtrees that lie in a range
bool subtreeCntRecur(Node* root, int low, int high, int &ans) {
    if (root == nullptr) return true;
    
    // Check for left and right subtree.
    bool left = subtreeCntRecur(root->left, low, high, ans);
    bool right = subtreeCntRecur(root->right, low, high, ans);
    
    // If current subtree lies within range, then increment
    // ans count and return true.
    if (root->data>=low&&root->data<=high&&left&&right) {
        ans++;
        return true;
    }
    
    // Else return false as this subtree 
    // is out of range.
    return false;
}

// Function to count subtress that 
// lie in a given range
int subtreeCnt(Node* root, int low, int high) {
    int ans = 0;
    subtreeCntRecur(root, low, high, ans);
    
    return ans;
}

int main() {
    
    // Binary tree 
    //         10
    //       /    \
    //     5       50
    //   /       /  \
    //  1       40   100
    Node* root = new Node(10);
    root->left = new Node(5);
    root->right = new Node(50);
    root->left->left = new Node(1);
    root->right->left = new Node(40);
    root->right->right = new Node(100);
    int low = 1, high = 45;
    
    cout << subtreeCnt(root, low, high) << endl;
    
    return 0;
}

Java

// Java program to count BST subtrees
// that lie in given range
class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {

    // Recursive function to count
    // subtrees that lie in a range
    static boolean subtreeCntRecur(Node root, int low,
                                   int high, int[] ans) {
        if (root == null) return true;
        
        // Check for left and right subtree.
        boolean left = subtreeCntRecur(root.left, low, high, ans);
        boolean right = subtreeCntRecur(root.right, low, high, ans);
        
        // If current subtree lies within range, then increment
        // ans count and return true.
        if (root.data >= low && root.data <= high && left && right) {
            ans[0]++;
            return true;
        }
        
        // Else return false as this subtree 
        // is out of range.
        return false;
    }

    // Function to count subtrees that 
    // lie in a given range
    static int subtreeCnt(Node root, int low, int high) {
        int[] ans = {0};
        subtreeCntRecur(root, low, high, ans);
        return ans[0];
    }

    public static void main(String[] args) {
        
        // Binary tree 
        //         10
        //       /    \
        //     5       50
        //   /       /  \
        //  1       40   100
        Node root = new Node(10);
        root.left = new Node(5);
        root.right = new Node(50);
        root.left.left = new Node(1);
        root.right.left = new Node(40);
        root.right.right = new Node(100);
        int low = 1, high = 45;
        
        System.out.println(subtreeCnt(root, low, high));
    }
}

Python

# Python program to count BST subtrees
# that lie in given range

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# Recursive function to count
# subtrees that lie in a range
def subtreeCntRecur(root, low, high, ans):
    if root is None:
        return True
    
    # Check for left and right subtree.
    left = subtreeCntRecur(root.left, low, high, ans)
    right = subtreeCntRecur(root.right, low, high, ans)
    
    # If current subtree lies within range, then increment
    # ans count and return true.
    if root.data >= low and root.data <= high \
    and left and right:
        ans[0] += 1
        return True
    
    # Else return false as this subtree 
    # is out of range.
    return False

# Function to count subtrees that 
# lie in a given range
def subtreeCnt(root, low, high):
    ans = [0]
    subtreeCntRecur(root, low, high, ans)
    return ans[0]

if __name__ == "__main__":
    
    # Binary tree 
    #         10
    #       /    \
    #     5       50
    #   /       /  \
    #  1       40   100
    root = Node(10)
    root.left = Node(5)
    root.right = Node(50)
    root.left.left = Node(1)
    root.right.left = Node(40)
    root.right.right = Node(100)
    low, high = 1, 45
    
    print(subtreeCnt(root, low, high))

// C# program to count BST subtrees
// that lie in given range
using System;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {

    // Recursive function to count
    // subtrees that lie in a range
    static bool subtreeCntRecur(Node root, int low,
                                int high, ref int ans) {
        if (root == null) return true;
        
        // Check for left and right subtree.
        bool left = subtreeCntRecur(root.left, low, high, ref ans);
        bool right = subtreeCntRecur(root.right, low, high, ref ans);
        
        // If current subtree lies within range, then increment
        // ans count and return true.
        if (root.data >= low && root.data <= high && left && right) {
            ans++;
            return true;
        }
        
        // Else return false as this subtree 
        // is out of range.
        return false;
    }

    // Function to count subtrees that 
    // lie in a given range
    static int subtreeCnt(Node root, int low, int high) {
        int ans = 0;
        subtreeCntRecur(root, low, high, ref ans);
        return ans;
    }

    static void Main(string[] args) {
        
        // Binary tree 
        //         10
        //       /    \
        //     5       50
        //   /       /  \
        //  1       40   100
        Node root = new Node(10);
        root.left = new Node(5);
        root.right = new Node(50);
        root.left.left = new Node(1);
        root.right.left = new Node(40);
        root.right.right = new Node(100);
        int low = 1, high = 45;
        
        Console.WriteLine(subtreeCnt(root, low, high));
    }
}

JavaScript

// JavaScript program to count BST subtrees
// that lie in given range

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// Recursive function to count
// subtrees that lie in a range
function subtreeCntRecur(root, low, high, ans) {
    if (root === null) return true;
    
    // Check for left and right subtree.
    let left = subtreeCntRecur(root.left, low, high, ans);
    let right = subtreeCntRecur(root.right, low, high, ans);
    
    // If current subtree lies within range, then increment
    // ans count and return true.
    if (root.data >= low && root.data <= high && left && right) {
        ans[0]++;
        return true;
    }
    
    // Else return false as this subtree 
    // is out of range.
    return false;
}

// Function to count subtrees that 
// lie in a given range
function subtreeCnt(root, low, high) {
    let ans = [0];
    subtreeCntRecur(root, low, high, ans);
    return ans[0];
}

// Binary tree 
//         10
//       /    \
//     5       50
//   /       /  \
//  1       40   100
let root = new Node(10);
root.left = new Node(5);
root.right = new Node(50);
root.left.left = new Node(1);
root.right.left = new Node(40);
root.right.right = new Node(100);
let low = 1, high = 45;

console.log(subtreeCnt(root, low, high));

Output

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

Count BST subtrees that lie in given range

Explore