Open In App
Related Articles

Print BST keys in the given range

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given two values k1 and k2 where k1 < k2 and a root pointer to a Binary Search Tree. The task is to print all the keys of the tree in the range k1 to k2 in increasing order. 

Examples: 

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: 8
Explanation: The key 8 is in the range 1 to 10

Approach: Below is the idea to solve the problem:

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.

Follow the below steps to Implement the idea:

  • Run DFS on BST in in-order traversal starting from root keeping k1 and k2 as parameters.
    • If the value of the root’s key is greater than k1, then recursively call in the left subtree i.e. if k1 < root->data call for root->left.
    • If the value of the root’s key is in range, then print the root’s key i.e. if k1 <= root->data and k2 >= root->data print root->data.
    • Recursively call for the right subtree i.e. root->right.

Below is the Implementation of the above approach:

C++

// 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 keys
which 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
        */
      
    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

                    

C

#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 in
the 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

// Java program to print BST in given range
 
// A binary tree node
class 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

                    

Python3

# Python program to find BST keys in given range
 
# A binary tree node
class 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 < k2
def 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 function
k1 = 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)

                    

C#

using System;
 
// C# program to print BST in given range
 
// A binary tree node
public 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

                    

Javascript

<script>
 
// JavaScript program to print BST in given range
 
// A binary tree node
class 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 

Time Complexity: O(N), where N is the total number of keys in the tree, A single traversal of the tree is needed.
Auxiliary Space: O(H). where H is the height of the tree in recursion call stack

Approach 2: Using Morris Inorder Traversal

In this approach, we use Morris Inorder Traversal to traverse the tree without using a stack or recursion. In Morris Inorder Traversal, we make use of threaded binary trees to find the predecessor of the current node. We start with the root node and traverse to the leftmost node of the subtree rooted at the current node. For each node in the subtree, we check if it lies within the given range and print its key. If the node has a right child, we find its inorder successor using the threaded binary tree and update the pointers to create a threaded binary tree.

  • If the given root node is NULL, return.
  • Initialize a current pointer to point to the root node.
  • While the current pointer is not NULL, do the following:
    •  If the left child of the current node is NULL:
      • If the key of the current node is within the given range, print the key.
      •  Move to the right child of the current node.
    •  If the left child of the current node is not NULL:
      •  Find the rightmost node in the left subtree of the current node.
      •  If the right child of the rightmost node is NULL, set it to point to the current node and move to the left child of the current node.
      •  If the right child of the rightmost node is not NULL, set it to NULL, check if the key of the current node is within the given range, and move to the right child of the current node.

Here’s the C++ code for this approach:

C++

#include<iostream>
using namespace std;
 
struct Node
{
    int key;
    Node *left, *right;
};
 
Node* newNode(int item)
{
    Node* temp = new Node;
    temp->key = item;
    temp->left = temp->right = NULL;
    return temp;
}
 
void printRange(Node* root, int lower, int upper)
{
    if (root == NULL)
        return;
     
    Node* curr = root;
    while (curr != NULL)
    {
        if (curr->left == NULL)
        {
            if (curr->key >= lower && curr->key <= upper)
                cout << curr->key << " ";
            curr = curr->right;
        }
        else
        {
            Node* pre = curr->left;
            while (pre->right != NULL && pre->right != curr)
                pre = pre->right;
 
            if (pre->right == NULL)
            {
                pre->right = curr;
                curr = curr->left;
            }
            else
            {
                pre->right = NULL;
                if (curr->key >= lower && curr->key <= upper)
                    cout << curr->key << " ";
                curr = curr->right;
            }
        }
    }
}
 
int main()
{
    Node* root = newNode(20);
    root->left = newNode(8);
    root->right = newNode(22);
    root->left->left = newNode(4);
    root->right->left = newNode(12);
 
    int lower = 10, upper = 25;
    printRange(root, lower, upper);
    return 0;
}

                    

Java

class Node {
    int key;
    Node left, right;
 
    Node(int item) {
        key = item;
        left = right = null;
    }
}
 
public class Main {
    static void printRange(Node root, int lower, int upper) {
        if (root == null) {
            return;
        }
 
        Node curr = root;
        while (curr != null) {
            if (curr.left == null) {
                if (curr.key >= lower && curr.key <= upper) {
                    System.out.print(curr.key + " ");
                }
                curr = curr.right;
            } else {
                Node pre = curr.left;
                while (pre.right != null && pre.right != curr) {
                    pre = pre.right;
                }
 
                if (pre.right == null) {
                    pre.right = curr;
                    curr = curr.left;
                } else {
                    pre.right = null;
                    if (curr.key >= lower && curr.key <= upper) {
                        System.out.print(curr.key + " ");
                    }
                    curr = curr.right;
                }
            }
        }
    }
 
    public static void main(String[] args) {
        Node root = new Node(20);
        root.left = new Node(8);
        root.right = new Node(22);
        root.left.left = new Node(4);
        root.right.left = new Node(12);
 
        int lower = 10, upper = 25;
        printRange(root, lower, upper);
    }
}

                    

Python3

class Node:
    def __init__(self, item):
        self.key = item
        self.left = None
        self.right = None
 
def newNode(item):
    temp = Node(item)
    return temp
 
def printRange(root, lower, upper):
    if root is None:
        return
 
    curr = root
    while curr is not None:
        if curr.left is None:
            if curr.key >= lower and curr.key <= upper:
                print(curr.key, end=' ')
            curr = curr.right
        else:
            pre = curr.left
            while pre.right is not None and pre.right != curr:
                pre = pre.right
 
            if pre.right is None:
                pre.right = curr
                curr = curr.left
            else:
                pre.right = None
                if curr.key >= lower and curr.key <= upper:
                    print(curr.key, end=' ')
                curr = curr.right
 
root = newNode(20)
root.left = newNode(8)
root.right = newNode(22)
root.left.left = newNode(4)
root.right.left = newNode(12)
 
lower = 10
upper = 25
printRange(root, lower, upper)

                    

C#

using System;
 
public class Node
{
    public int key;
    public Node left, right;
 
    public Node(int item)
    {
        key = item;
        left = right = null;
    }
}
 
public class Program
{
    static void PrintRange(Node root, int lower, int upper)
    {
        if (root == null)
            return;
 
        Node curr = root;
        while (curr != null)
        {
            if (curr.left == null)
            {
                if (curr.key >= lower && curr.key <= upper)
                    Console.Write(curr.key + " ");
                curr = curr.right;
            }
            else
            {
                Node pre = curr.left;
                while (pre.right != null && pre.right != curr)
                    pre = pre.right;
 
                if (pre.right == null)
                {
                    pre.right = curr;
                    curr = curr.left;
                }
                else
                {
                    pre.right = null;
                    if (curr.key >= lower && curr.key <= upper)
                        Console.Write(curr.key + " ");
                    curr = curr.right;
                }
            }
        }
    }
 
    public static void Main(string[] args)
    {
        Node root = new Node(20);
        root.left = new Node(8);
        root.right = new Node(22);
        root.left.left = new Node(4);
        root.right.left = new Node(12);
 
        int lower = 10, upper = 25;
        PrintRange(root, lower, upper);
    }
}

                    

Javascript

class Node {
    constructor(key) {
        this.key = key;
        this.left = null;
        this.right = null;
    }
}
 
function printRange(root, lower, upper) {
    if (root === null) {
        return;
    }
 
    let curr = root;
    while (curr !== null) {
        if (curr.left === null) {
            if (curr.key >= lower && curr.key <= upper) {
                process.stdout.write(curr.key + " ");
            }
            curr = curr.right;
        } else {
            let pre = curr.left;
            while (pre.right !== null && pre.right !== curr) {
                pre = pre.right;
            }
 
            if (pre.right === null) {
                pre.right = curr;
                curr = curr.left;
            } else {
                pre.right = null;
                if (curr.key >= lower && curr.key <= upper) {
                    process.stdout.write(curr.key + " ");
                }
                curr = curr.right;
            }
        }
    }
}
 
function main() {
    let root = new Node(20);
    root.left = new Node(8);
    root.right = new Node(22);
    root.left.left = new Node(4);
    root.right.left = new Node(12);
 
    let lower = 10, upper = 25;
    printRange(root, lower, upper);
}
 
// Function call
main();

                    

Output
20 12 22 

Time Complexity: O(N), where N is the total number of keys in the tree, A single traversal of the tree is needed.
Auxiliary Space: O(1). 

 

 



Last Updated : 23 Aug, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads