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].
BinaryTree1

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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// A C++ program to remove BST keys outside the given range
#include<stdio.h>
#include <iostream>
  
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right



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.



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


8


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.