Print BST keys in the given range

16 Jun, 2022
Given two values k1 and k2 (where k1 < k2) and a root pointer to a Binary Search Tree. Print all the keys of the tree in range k1 to k2. i.e. print all x such that k1<=x<=k2 and x is a key of given BST. Print all the keys in increasing order. 
Example: 
Graph:

Input: k1 = 10 and k2 = 22
Output: 12, 20 and 22.
Explanation: The keys are 4, 8, 12, 20, and 22.
So keys in range 10 to 22 is 12, 20 and 22.

Input: k1 = 1 and k2 = 10
Output: 4 and 8
Explanation: The keys are 4, 8, 12, 20, and 22.
So keys in range 1 to 10 is 4 and 8.
Approach: Traverse the tree in the inorder traversal. If the Binary search tree is traversed in inorder traversal the keys are traversed in increasing order. So while traversing the keys in the inorder traversal. If the key lies in the range print the key else skip the key.
Algorithm: 
Create a recursive function that takes root as a parameter and the range is (k1, k2)If the value of root’s key is greater than k1, then recursively call in left subtree.If the value of root’s key is in range, then print the root’s key.recursively call the right subtree.
Create a recursive function that takes root as a parameter and the range is (k1, k2)
If the value of root’s key is greater than k1, then recursively call in left subtree.
If the value of root’s key is in range, then print the root’s key.
recursively call the right subtree.
Implementation:  
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
C++
C
Java
Python3
C#
Javascript
// C++ program to print BST in given range#include<bits/stdc++.h>using namespace std; /* A tree node structure */class node{    public:    int data;    node *left;    node *right;}; /* The functions prints all the keyswhich in the given range [k1..k2].    The function assumes than k1 < k2 */void Print(node *root, int k1, int k2){    /* base case */    if ( NULL == root )        return;         /* Since the desired o/p is sorted,        recurse for left subtree first        If root->data is greater than k1,        then only we can get o/p keys        in left subtree */    if ( k1 < root->data )        Print(root->left, k1, k2);         /* if root's data lies in range,    then prints root's data */    if ( k1 <= root->data && k2 >= root->data )        cout<<root->data<<" ";         /* recursively call the right subtree */   Print(root->right, k1, k2);} /* Utility function to create a new Binary Tree node */node* newNode(int data){    node *temp = new node();    temp->data = data;    temp->left = NULL;    temp->right = NULL;         return temp;} /* Driver code */int main(){    node *root = new node();    int k1 = 10, k2 = 25;         /* Constructing tree given    in the above figure */    root = newNode(20);    root->left = newNode(8);    root->right = newNode(22);    root->left->left = newNode(4);    root->left->right = newNode(12);         Print(root, k1, k2);    return 0;} // This code is contributed by rathbhupendra
#include<stdio.h>#include<stdlib.h> /* A tree node structure */struct node{  int data;  struct node *left;  struct node *right;}; /* The functions prints all the keys which inthe given range [k1..k2]. The function assumes than k1 < k2 */void Print(struct node *root, int k1, int k2){   /* base case */   if ( NULL == root )      return;    /* Since the desired o/p is sorted, recurse for left subtree first      If root->data is greater than k1, then only we can get o/p keys      in left subtree */   if ( k1 < root->data )     Print(root->left, k1, k2);    /* if root's data lies in range, then prints root's data */   if ( k1 <= root->data && k2 >= root->data )     printf("%d ", root->data );   /* recursively call the right subtree */   Print(root->right, k1, k2);} /* Utility function to create a new Binary Tree node */struct node* newNode(int data){  struct node *temp = malloc(sizeof(struct node));  temp->data = data;  temp->left = NULL;  temp->right = NULL;   return temp;} /* Driver function to test above functions */int main(){  struct node *root = malloc(sizeof(struct node));  int k1 = 10, k2 = 25;   /* Constructing tree given in the above figure */  root = newNode(20);  root->left = newNode(8);  root->right = newNode(22);  root->left->left = newNode(4);  root->left->right = newNode(12);   Print(root, k1, k2);   getchar();  return 0;}  // This code was modified by italovinicius18
// Java program to print BST in given range // A binary tree nodeclass Node {     int data;    Node left, right;     Node(int d) {        data = d;        left = right = null;    }} class BinaryTree {         static Node root;         /* The functions prints all the keys which in     the given range [k1..k2]. The function assumes than k1 < k2 */    void Print(Node node, int k1, int k2) {                 /* base case */        if (node == null) {            return;        }         /* Since the desired o/p is sorted, recurse for left subtree first         If root->data is greater than k1, then only we can get o/p keys         in left subtree */        if (k1 < node.data) {            Print(node.left, k1, k2);        }         /* if root's data lies in range, then prints root's data */        if (k1 <= node.data && k2 >= node.data) {            System.out.print(node.data + " ");        }         /* recursively call the right subtree  */         Print(node.right, k1, k2);    }         public static void main(String[] args) {        BinaryTree tree = new BinaryTree();        int k1 = 10, k2 = 25;        tree.root = new Node(20);        tree.root.left = new Node(8);        tree.root.right = new Node(22);        tree.root.left.left = new Node(4);        tree.root.left.right = new Node(12);         tree.Print(root, k1, k2);    }} // This code has been contributed by Mayank Jaiswal
# Python program to find BST keys in given range # A binary tree nodeclass Node:     # Constructor to create a new node    def __init__(self, data):        self.data = data        self.left = None        self.right = None # The function prints all the keys in the given range# [k1..k2]. Assumes that k1 < k2def Print(root, k1, k2):         # Base Case    if root is None:        return     # Since the desired o/p is sorted, recurse for left    # subtree first. If root.data is greater than k1, then    # only we can get o/p keys in left subtree    if k1 < root.data :        Print(root.left, k1, k2)     # If root's data lies in range, then prints root's data    if k1 <= root.data and k2 >= root.data:        print (root.data,end=' ')     # recursively call the right subtree    Print(root.right, k1, k2) # Driver function to test above functionk1 = 10 ; k2 = 25 ;root = Node(20)root.left = Node(8)root.right = Node(22)root.left.left = Node(4)root.left.right = Node(12) Print(root, k1, k2) # This code is contributed by Nikhil Kumar Singh(nickzuck_007)
using System; // C# program to print BST in given range // A binary tree nodepublic class Node{     public int data;    public Node left, right;     public Node(int d)    {        data = d;        left = right = null;    }} public class BinaryTree{     public static Node root;     /* The functions prints all the keys which in the     given range [k1..k2]. The function assumes than k1 < k2 */    public virtual void Print(Node node, int k1, int k2)    {         /* base case */        if (node == null)        {            return;        }         /* Since the desired o/p is sorted, recurse for left subtree first         If root->data is greater than k1, then only we can get o/p keys         in left subtree */        if (k1 < node.data)        {            Print(node.left, k1, k2);        }         /* if root's data lies in range, then prints root's data */        if (k1 <= node.data && k2 >= node.data)        {            Console.Write(node.data + " ");        }         /* recursively call the right subtree */            Print(node.right, k1, k2);    }     public static void Main(string[] args)    {        BinaryTree tree = new BinaryTree();        int k1 = 10, k2 = 25;        BinaryTree.root = new Node(20);        BinaryTree.root.left = new Node(8);        BinaryTree.root.right = new Node(22);        BinaryTree.root.left.left = new Node(4);        BinaryTree.root.left.right = new Node(12);         tree.Print(root, k1, k2);    }} // This code is contributed by Shrikant13
<script> // JavaScript program to print BST in given range // A binary tree nodeclass Node {    constructor(val) {        this.data = val;        this.left = null;        this.right = null;    }}    var root = null;     /*     * The functions prints all the keys     which in the given range [k1..k2]. The     * function assumes than k1 < k2     */    function Print(node , k1 , k2) {         /* base case */        if (node == null) {            return;        }         /*         * Since the desired o/p is sorted,         recurse for left subtree first If root->data         * is greater than k1, then only we can         get o/p keys in left subtree         */        if (k1 < node.data) {            Print(node.left, k1, k2);        }         /* if root's data lies in range,        then prints root's data */        if (k1 <= node.data && k2 >= node.data) {            document.write(node.data + " ");        }         /* recursively call the right subtree */         Print(node.right, k1, k2);    }         var k1 = 10, k2 = 25;        root = new Node(20);        root.left = new Node(8);        root.right = new Node(22);        root.left.left = new Node(4);        root.left.right = new Node(12);         Print(root, k1, k2); // This code is contributed by todaysgaurav </script>
Output: 
12 20 22
Complexity Analysis:  
Time Complexity: O(n), where n is the total number of keys in tree. A single traversal of the tree is needed.
Space Complexity: O(height of the tree). // as recursion call
No extra space is required.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
shrikanth13
rathbhupendra
Ankur Goel
andrew1234
guptasameer24
todaysgaurav
mlg434cgodfzak0a1s4w0aap74jkr355eye5e57v
maheshreddy11
sagar0719kumar
amartyaghoshgfg
simmytarika5
hardikkoriintern
Flipkart
Microsoft
Binary Search Tree
Tree
Flipkart
Microsoft
Binary Search Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.