Skip to content
Related Articles

Related Articles

Improve Article
Median of all nodes from a given range in a Binary Search Tree ( BST )
  • Difficulty Level : Medium
  • Last Updated : 18 Jun, 2021

Given a Binary Search Tree (BST)consisting of N nodes and two nodes A and B, the task is to find the median of all the nodes in the given BST whose values lie over the range [A, B].

Examples:

Input: A = 3, B = 11

Output: 6
Explanation:
The nodes that lie over the range [3, 11] are {3, 4, 6, 8, 11}. The median of the given nodes is 6.



Input: A = 6, B = 15

Output: 9.5

Approach: The given problem can be solved by performing any tree traversal on the given tree and store all the nodes lies over the range [A, B], and find the median of all the stored element. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Tree Node structure
struct Node {
    struct Node *left, *right;
    int key;
};
 
// Function to create a new BST node
Node* newNode(int key)
{
    Node* temp = new Node;
    temp->key = key;
    temp->left = temp->right = NULL;
    return temp;
}
 
// Function to insert a new node with
// given key in BST
Node* insertNode(Node* node, int key)
{
    // If the tree is empty,
    // return a new node
    if (node == NULL)
        return newNode(key);
 
    // Otherwise, recur down the tree
    if (key < node->key)
        node->left = insertNode(
            node->left, key);
 
    else if (key > node->key)
        node->right = insertNode(
            node->right, key);
 
    // Return the node pointer
    return node;
}
 
// Function to find all the nodes that
// lies over the range [node1, node2]
void getIntermediateNodes(
    Node* root, vector<int>& interNodes,
    int node1, int node2)
{
    // If the tree is empty, return
    if (root == NULL)
        return;
 
    // Traverse for the left subtree
    getIntermediateNodes(root->left,
                         interNodes,
                         node1, node2);
 
    // If a second node is found,
    // then update the flag as false
    if (root->key <= node2
        and root->key >= node1) {
        interNodes.push_back(root->key);
    }
 
    // Traverse the right subtree
    getIntermediateNodes(root->right,
                         interNodes,
                         node1, node2);
}
 
// Function to find the median of all
// the values in the given BST that
// lies over the range [node1, node2]
float findMedian(Node* root, int node1,
                 int node2)
{
    // Stores all the nodes in
    // the range [node1, node2]
    vector<int> interNodes;
 
    getIntermediateNodes(root, interNodes,
                         node1, node2);
 
    // Store the size of the array
    int nSize = interNodes.size();
 
    // Print the median of array
    // based on the size of array
    return (nSize % 2 == 1)
               ? (float)interNodes[nSize / 2]
               : (float)(interNodes[(nSize - 1) / 2]
                         + interNodes[nSize / 2])
                     / 2;
}
 
// Driver Code
int main()
{
    // Given BST
    struct Node* root = NULL;
    root = insertNode(root, 8);
    insertNode(root, 3);
    insertNode(root, 1);
    insertNode(root, 6);
    insertNode(root, 4);
    insertNode(root, 11);
    insertNode(root, 15);
 
    cout << findMedian(root, 3, 11);
 
    return 0;
}

Java




// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Tree Node structure
static class Node
{
    Node left, right;
    int key;
};
 
static Vector<Integer> interNodes = new Vector<Integer>();
 
// Function to create a new BST node
static Node newNode(int key)
{
    Node temp = new Node();
    temp.key = key;
    temp.left = temp.right = null;
    return temp;
}
 
// Function to insert a new node with
// given key in BST
static Node insertNode(Node node, int key)
{
     
    // If the tree is empty,
    // return a new node
    if (node == null)
        return newNode(key);
 
    // Otherwise, recur down the tree
    if (key < node.key)
        node.left = insertNode(
            node.left, key);
 
    else if (key > node.key)
        node.right = insertNode(
            node.right, key);
 
    // Return the node pointer
    return node;
}
 
// Function to find all the nodes that
// lies over the range [node1, node2]
static void getIntermediateNodes(Node root,
                                 int node1,
                                 int node2)
{
     
    // If the tree is empty, return
    if (root == null)
        return;
 
    // Traverse for the left subtree
    getIntermediateNodes(root.left,
                         node1, node2);
 
    // If a second node is found,
    // then update the flag as false
    if (root.key <= node2 &&
        root.key >= node1)
    {
        interNodes.add(root.key);
    }
 
    // Traverse the right subtree
    getIntermediateNodes(root.right,
                         node1, node2);
}
 
// Function to find the median of all
// the values in the given BST that
// lies over the range [node1, node2]
static float findMedian(Node root, int node1,
                                   int node2)
{
     
    // Stores all the nodes in
    // the range [node1, node2]
    getIntermediateNodes(root,
                         node1, node2);
 
    // Store the size of the array
    int nSize = interNodes.size();
 
    // Print the median of array
    // based on the size of array
    return (nSize % 2 == 1) ?
           (float)interNodes.get(nSize / 2) :
           (float)(interNodes.get((nSize - 1) / 2) +
                    interNodes.get(nSize / 2)) / 2;
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given BST
    Node root = null;
    root = insertNode(root, 8);
    insertNode(root, 3);
    insertNode(root, 1);
    insertNode(root, 6);
    insertNode(root, 4);
    insertNode(root, 11);
    insertNode(root, 15);
 
    System.out.print(findMedian(root, 3, 11));
}
}
 
// This code is contributed by shikhasingrajput

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
public class GFG{
 
// Tree Node structure
class Node
{
    public Node left, right;
    public int key;
};
 
static List<int> interNodes = new List<int>();
 
// Function to create a new BST node
static Node newNode(int key)
{
    Node temp = new Node();
    temp.key = key;
    temp.left = temp.right = null;
    return temp;
}
 
// Function to insert a new node with
// given key in BST
static Node insertNode(Node node, int key)
{
     
    // If the tree is empty,
    // return a new node
    if (node == null)
        return newNode(key);
 
    // Otherwise, recur down the tree
    if (key < node.key)
        node.left = insertNode(
            node.left, key);
 
    else if (key > node.key)
        node.right = insertNode(
            node.right, key);
 
    // Return the node pointer
    return node;
}
 
// Function to find all the nodes that
// lies over the range [node1, node2]
static void getIntermediateNodes(Node root,
                                 int node1,
                                 int node2)
{
     
    // If the tree is empty, return
    if (root == null)
        return;
 
    // Traverse for the left subtree
    getIntermediateNodes(root.left,
                         node1, node2);
 
    // If a second node is found,
    // then update the flag as false
    if (root.key <= node2 &&
        root.key >= node1)
    {
        interNodes.Add(root.key);
    }
 
    // Traverse the right subtree
    getIntermediateNodes(root.right,
                         node1, node2);
}
 
// Function to find the median of all
// the values in the given BST that
// lies over the range [node1, node2]
static float findMedian(Node root, int node1,
                                   int node2)
{
     
    // Stores all the nodes in
    // the range [node1, node2]
    getIntermediateNodes(root,
                         node1, node2);
 
    // Store the size of the array
    int nSize = interNodes.Count;
 
    // Print the median of array
    // based on the size of array
    return (nSize % 2 == 1) ?
           (float)interNodes[nSize / 2] :
           (float)(interNodes[(nSize - 1) / 2] +
                    interNodes[nSize / 2]) / 2;
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given BST
    Node root = null;
    root = insertNode(root, 8);
    insertNode(root, 3);
    insertNode(root, 1);
    insertNode(root, 6);
    insertNode(root, 4);
    insertNode(root, 11);
    insertNode(root, 15);
 
    Console.Write(findMedian(root, 3, 11));
}
}
 
// This code is contributed by shikhasingrajput

Javascript




<script>
    // Javascript program for the above approach
     
    // Tree Node structure
    class Node
    {
        constructor(key) {
           this.left = null;
           this.right = null;
           this.key = key;
        }
    }
     
    let interNodes = [];
  
    // Function to create a new BST node
    function newNode(key)
    {
        let temp = new Node(key);
        return temp;
    }
 
    // Function to insert a new node with
    // given key in BST
    function insertNode(node, key)
    {
 
        // If the tree is empty,
        // return a new node
        if (node == null)
            return newNode(key);
 
        // Otherwise, recur down the tree
        if (key < node.key)
            node.left = insertNode(
                node.left, key);
 
        else if (key > node.key)
            node.right = insertNode(
                node.right, key);
 
        // Return the node pointer
        return node;
    }
 
    // Function to find all the nodes that
    // lies over the range [node1, node2]
    function getIntermediateNodes(root, node1, node2)
    {
 
        // If the tree is empty, return
        if (root == null)
            return;
 
        // Traverse for the left subtree
        getIntermediateNodes(root.left,
                             node1, node2);
 
        // If a second node is found,
        // then update the flag as false
        if (root.key <= node2 &&
            root.key >= node1)
        {
            interNodes.push(root.key);
        }
 
        // Traverse the right subtree
        getIntermediateNodes(root.right,
                             node1, node2);
    }
 
    // Function to find the median of all
    // the values in the given BST that
    // lies over the range [node1, node2]
    function findMedian(root, node1, node2)
    {
 
        // Stores all the nodes in
        // the range [node1, node2]
        getIntermediateNodes(root, node1, node2);
 
        // Store the size of the array
        let nSize = interNodes.length;
 
        // Print the median of array
        // based on the size of array
        return (nSize % 2 == 1) ?
               interNodes[parseInt(nSize / 2, 10)] :
               (interNodes[parseInt((nSize - 1) / 2, 10)] +
                        interNodes[nSize / 2]) / 2;
    }
     
    // Given BST
    let root = null;
    root = insertNode(root, 8);
    insertNode(root, 3);
    insertNode(root, 1);
    insertNode(root, 6);
    insertNode(root, 4);
    insertNode(root, 11);
    insertNode(root, 15);
  
    document.write(findMedian(root, 3, 11));
 
// This code is contributed by suresh07.
</script>
Output: 
6

 

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 :