# 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 ` `#include ` ` `  `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.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

17

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