🔴 Hot News: web//https://www.geeksforgeeks.org/remove bst keys outside the given range

Given a Binary Search Tree (BST) and a range [min, max], remove all keys which are outside the given range. The modified tree should also be BST. For example, consider the following BST and range [-10, 13].

The given tree should be changed to following. Note that all keys outside the range [-10, 13] are removed and modified tree is BST.

There are two possible cases for every node.
1) Node’s key is outside the given range. This case has two sub-cases.
…….a) Node’s key is smaller than the min value.
…….b) Node’s key is greater that the max value.
2) Node’s key is in range.

We don’t need to do anything for case 2. In case 1, we need to remove the node and change root of sub-tree rooted with this node.
The idea is to fix the tree in Postorder fashion. When we visit a node, we make sure that its left and right sub-trees are already fixed. In case 1.a), we simply remove root and return right sub-tree as new root. In case 1.b), we remove root and return left sub-tree as new root.

Following is implementation of the above approach.

C++

// A C++ program to remove BST keys outside the given range 
#include<bits/stdc++.h> 
  
using namespace std; 
  
// A BST node has key, and left and right pointers 
struct node 
{ 
    int key; 
    struct node *left; 
    struct node *right; 
}; 
  
// Removes all nodes having value outside the given range and returns the root 
// of modified tree 
node* removeOutsideRange(node *root, int min, int max) 
{ 
   // Base Case 
   if (root == NULL) 
      return NULL; 
  
   // First fix the left and right subtrees of root 
   root->left =  removeOutsideRange(root->left, min, max); 
   root->right =  removeOutsideRange(root->right, min, max); 
  
   // Now fix the root.  There are 2 possible cases for toot 
   // 1.a) Root's key is smaller than min value (root is not in range) 
   if (root->key < min) 
   { 
       node *rChild = root->right; 
       delete root; 
       return rChild; 
   } 
   // 1.b) Root's key is greater than max value (root is not in range) 
   if (root->key > max) 
   { 
       node *lChild = root->left; 
       delete root; 
       return lChild; 
   } 
   // 2. Root is in range 
   return root; 
} 
  
// A utility function to create a new BST node with key as given num 
node* newNode(int num) 
{ 
    node* temp = new node; 
    temp->key = num; 
    temp->left = temp->right = NULL; 
    return temp; 
} 
  
// A utility function to insert a given key to BST 
node* insert(node* root, int key) 
{ 
    if (root == NULL) 
       return newNode(key); 
    if (root->key > key) 
       root->left = insert(root->left, key); 
    else
       root->right = insert(root->right, key); 
    return root; 
} 
  
// Utility function to traverse the binary tree after conversion 
void inorderTraversal(node* root) 
{ 
    if (root) 
    { 
        inorderTraversal( root->left ); 
        cout << root->key << " "; 
        inorderTraversal( root->right ); 
    } 
} 
  
// Driver program to test above functions 
int main() 
{ 
    node* root = NULL; 
    root = insert(root, 6); 
    root = insert(root, -13); 
    root = insert(root, 14); 
    root = insert(root, -8); 
    root = insert(root, 15); 
    root = insert(root, 13); 
    root = insert(root, 7); 
  
    cout << "Inorder traversal of the given tree is: "; 
    inorderTraversal(root); 
  
    root = removeOutsideRange(root, -10, 13); 
  
    cout << "\nInorder traversal of the modified tree is: "; 
    inorderTraversal(root); 
  
    return 0; 
} 

Java

// A Java program to remove BST 
// keys outside the given range 
import java.math.BigDecimal; 
import java.util.ArrayList; 
import java.util.Arrays; 
import java.util.List; 
import java.util.Scanner; 
  
class Node 
{ 
    int key; 
    Node left; 
    Node right; 
} 
  
class GFG 
{ 
    // Removes all nodes having value 
    // outside the given range and  
    // returns the root of modified tree 
    private static Node removeOutsideRange(Node root,  
                                           int min, int max)  
    { 
        // BASE CASE 
        if(root == null) 
        { 
            return null; 
        } 
          
        // FIRST FIX THE LEFT AND 
        // RIGHT SUBTREE OF ROOT 
        root.left = removeOutsideRange(root.left,  
                                       min, max); 
        root.right = removeOutsideRange(root.right,  
                                        min, max); 
          
        // NOW FIX THE ROOT. THERE ARE  
        // TWO POSSIBLE CASES FOR THE ROOT 
        // 1. a) Root's key is smaller than 
        // min value(root is not in range) 
        if(root.key < min)  
        { 
            Node rchild = root.right; 
            root = null; 
            return rchild; 
        } 
          
        // 1. b) Root's key is greater than  
        // max value (Root is not in range) 
        if(root.key > max)  
        { 
            Node lchild = root.left; 
            root = null; 
            return lchild; 
        } 
          
        // 2. Root in range 
        return root; 
    } 
  
    public static Node newNode(int num)  
    { 
        Node temp = new Node(); 
        temp.key = num; 
        temp.left = null; 
        temp.right = null; 
        return temp; 
    } 
  
    public static Node insert(Node root, 
                              int key)  
    { 
        if(root == null)  
        { 
            return newNode(key); 
        } 
        if(root.key > key)  
        { 
            root.left = insert(root.left, key); 
        } 
        else 
        { 
            root.right = insert(root.right, key); 
        } 
        return root; 
    } 
      
    private static void inorderTraversal(Node root) 
    { 
        if(root != null)  
        { 
            inorderTraversal(root.left); 
            System.out.print(root.key + " "); 
            inorderTraversal(root.right); 
        } 
    } 
      
    // Driver code 
    public static void main(String[] args) 
    { 
        Node root = null; 
        root = insert(root, 6); 
        root = insert(root, -13); 
        root = insert(root, 14); 
        root = insert(root, -8); 
        root = insert(root, 15); 
        root = insert(root, 13); 
        root = insert(root, 7); 
          
        System.out.print("Inorder Traversal of " +  
                           "the given tree is: "); 
        inorderTraversal(root); 
          
        root = removeOutsideRange(root, -10, 13); 
          
        System.out.print("\nInorder traversal of " +  
                           "the modified tree: "); 
        inorderTraversal(root); 
    } 
} 
  
// This code is contributed  
// by Divya 

Python3

# Python3 program to remove BST keys  
# outside the given range  
  
# A BST node has key, and left and right   
# pointers. A utility function to create  
# a new BST node with key as given num  
class newNode:  
  
    # Constructor to create a new node  
    def __init__(self, data):  
        self.key = data  
        self.left = None
        self.right = None
          
# Removes all nodes having value outside  
# the given range and returns the root  
# of modified tree  
def removeOutsideRange(root, Min, Max): 
      
    # Base Case  
    if root == None: 
        return None
      
    # First fix the left and right  
    # subtrees of root  
    root.left = removeOutsideRange(root.left, 
                                   Min, Max)  
    root.right = removeOutsideRange(root.right, 
                                    Min, Max)  
      
    # Now fix the root. There are 2 
    # possible cases for toot  
    # 1.a) Root's key is smaller than 
    #      min value (root is not in range)  
    if root.key < Min: 
        rChild = root.right  
        return rChild 
          
    # 1.b) Root's key is greater than max 
    #      value (root is not in range)  
    if root.key > Max: 
        lChild = root.left  
        return lChild 
          
    # 2. Root is in range  
    return root 
  
  
# A utility function to insert a given 
# key to BST  
def insert(root, key): 
    if root == None: 
        return newNode(key)  
    if root.key > key: 
        root.left = insert(root.left, key)  
    else: 
        root.right = insert(root.right, key)  
    return root 
  
# Utility function to traverse the binary 
# tree after conversion  
def inorderTraversal(root): 
    if root: 
        inorderTraversal( root.left)  
        print(root.key, end = " ") 
        inorderTraversal( root.right) 
  
# Driver Code  
if __name__ == '__main__': 
    root = None
    root = insert(root, 6) 
    root = insert(root, -13)  
    root = insert(root, 14)  
    root = insert(root, -8)  
    root = insert(root, 15)  
    root = insert(root, 13)  
    root = insert(root, 7)  
  
    print("Inorder traversal of the given tree is:",  
                                          end = " ")  
    inorderTraversal(root)  
  
    root = removeOutsideRange(root, -10, 13) 
    print() 
    print("Inorder traversal of the modified tree is:", 
                                             end = " ")  
    inorderTraversal(root)  
  
# This code is contributed by PranchalK 

C#

// A C# program to remove BST 
// keys outside the given range 
using System; 
  
public class Node  
{  
    public int key;  
    public Node left;  
    public Node right;  
}  
  
public class GFG  
{  
    // Removes all nodes having value  
    // outside the given range and  
    // returns the root of modified tree  
    private static Node removeOutsideRange(Node root,  
                                        int min, int max)  
    {  
        // BASE CASE  
        if(root == null)  
        {  
            return null;  
        }  
          
        // FIRST FIX THE LEFT AND  
        // RIGHT SUBTREE OF ROOT  
        root.left = removeOutsideRange(root.left,  
                                    min, max);  
        root.right = removeOutsideRange(root.right,  
                                        min, max);  
          
        // NOW FIX THE ROOT. THERE ARE  
        // TWO POSSIBLE CASES FOR THE ROOT  
        // 1. a) Root's key is smaller than  
        // min value(root is not in range)  
        if(root.key < min)  
        {  
            Node rchild = root.right;  
            root = null;  
            return rchild;  
        }  
          
        // 1. b) Root's key is greater than  
        // max value (Root is not in range)  
        if(root.key > max)  
        {  
            Node lchild = root.left;  
            root = null;  
            return lchild;  
        }  
          
        // 2. Root in range  
        return root;  
    }  
  
    public static Node newNode(int num)  
    {  
        Node temp = new Node();  
        temp.key = num;  
        temp.left = null;  
        temp.right = null;  
        return temp;  
    }  
  
    public static Node insert(Node root,  
                            int key)  
    {  
        if(root == null)  
        {  
            return newNode(key);  
        }  
        if(root.key > key)  
        {  
            root.left = insert(root.left, key);  
        }  
        else
        {  
            root.right = insert(root.right, key);  
        }  
        return root;  
    }  
      
    private static void inorderTraversal(Node root)  
    {  
        if(root != null)  
        {  
            inorderTraversal(root.left);  
            Console.Write(root.key + " ");  
            inorderTraversal(root.right);  
        }  
    }  
      
    // Driver code  
    public static void Main(String[] args)  
    {  
        Node root = null;  
        root = insert(root, 6);  
        root = insert(root, -13);  
        root = insert(root, 14);  
        root = insert(root, -8);  
        root = insert(root, 15);  
        root = insert(root, 13);  
        root = insert(root, 7);  
          
        Console.Write("Inorder Traversal of " +  
                        "the given tree is: ");  
        inorderTraversal(root);  
          
        root = removeOutsideRange(root, -10, 13);  
          
        Console.Write("\nInorder traversal of " +  
                        "the modified tree: ");  
        inorderTraversal(root);  
    }  
}  
  
// This code has been contributed  
// by PrinciRaj1992 

Output:

Inorder traversal of the given tree is: -13 -8 6 7 13 14 15
Inorder traversal of the modified tree is: -8 6 7 13

Time Complexity: O(n) where n is the number of nodes in given BST.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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.

My Personal Notes

Nov	DEC	Jan
	04
2019	2020	2021

Remove BST keys outside the given range

C++

Java

Python3

C#

Recommended Posts: