Floor in Binary Search Tree (BST) - GeeksforGeeks

19 Jul, 2021
Given a Binary Search Tree and a number x, find floor of x in the given BST. 
Input : x = 14 and root of below tree
            10
           /  \
          5    15
              /  \
            12    30
Output : 12

Input : x = 15 and root of below tree
            10
           /  \
          5    15
              /  \
            12    30
Output : 15    
 
A simple solution is to traverse the tree using (Inorder or Preorder or Postorder) and keep track of closest smaller or same element. Time complexity of this solution is O(n) where n is total number of Nodes in BST.We can efficiently find closest smaller or same element in O(h) time where h is height of BST. Algorithm to find the floor of a key in a binary search tree (BST):  
1 Start at the root Node.
2 If root->data == key, 
     floor of the key is equal 
     to the root.
3 Else if root->data > key, then 
     floor of the key must lie in the
     left subtree.
4 Else floor may lie in the right subtree 
  but only if there is a value lesser than 
  or equal to the key.If not, then root is
  the key.
For finding ceil of BST you can refer to this article.  
C++
Java
Python3
C#
Javascript
// C++ code to find floor of a key in BST#include <bits/stdc++.h>using namespace std; /*Structure of each Node in the tree*/struct Node {    int data;    Node *left, *right;}; /*This function is used to create andinitializes new Nodes*/Node* newNode(int key){    Node* temp = new Node;    temp->left = temp->right = NULL;    temp->data = key;    return temp;} /* This function is used to insert new values in BST*/Node* insert(Node* root, int key){    if (!root)        return newNode(key);    if (key < root->data)        root->left = insert(root->left, key);    else        root->right = insert(root->right, key);    return root;} /*This function is used to find floor of a key*/int floor(Node* root, int key){    if (!root)        return INT_MAX;     /* If root->data is equal to key */    if (root->data == key)        return root->data;     /* If root->data is greater than the key */    if (root->data > key)        return floor(root->left, key);     /* Else, the floor may lie in right subtree      or may be equal to the root*/    int floorValue = floor(root->right, key);    return (floorValue <= key) ? floorValue : root->data;} int main(){    /* Let us create following BST              7            /    \           5      10         /  \    /  \        3    6   8   12 */    Node* root = NULL;    root = insert(root, 7);    insert(root, 10);    insert(root, 5);    insert(root, 3);    insert(root, 6);    insert(root, 8);    insert(root, 12);    cout << floor(root, 9) << endl;    return 0;}
// Java code to find floor of a key in BSTclass GfG {     /*Structure of each Node in the tree*/    static class Node {        int data;        Node left, right;    }     /*This function is used to create andinitializes new Nodes*/    static Node newNode(int key)    {        Node temp = new Node();        temp.left = null;        temp.right = null;        temp.data = key;        return temp;    }     /* This function is used to insertnew values in BST*/    static Node insert(Node root, int key)    {        if (root == null)            return newNode(key);        if (key < root.data)            root.left = insert(root.left, key);        else            root.right = insert(root.right, key);        return root;    }     /*This function is used to find floor of a key*/    static int floor(Node root, int key)    {        if (root == null)            return Integer.MAX_VALUE;         /* If root->data is equal to key */        if (root.data == key)            return root.data;         /* If root->data is greater than the key */        if (root.data > key)            return floor(root.left, key);         /* Else, the floor may lie in right subtree    or may be equal to the root*/        int floorValue = floor(root.right, key);        return (floorValue <= key) ? floorValue : root.data;    }     public static void main(String[] args)    {        /* Let us create following BST            7            / \        5     10        / \ / \        3 6 8 12 */        Node root = null;        root = insert(root, 7);        insert(root, 10);        insert(root, 5);        insert(root, 3);        insert(root, 6);        insert(root, 8);        insert(root, 12);        System.out.println(floor(root, 9));    }}
# Python3 code to find floor of a key in BSTINT_MAX = 2147483647 # Binary Tree Node""" A utility function to create anew BST node """class newNode:     # Construct to create a newNode    def __init__(self, data):        self.data = data        self.left = None        self.right = None """ This function is used to insertnew values in BST"""def insert(root, key):     if (not root):        return newNode(key)    if (key < root.data):        root.left = insert(root.left, key)    else:        root.right = insert(root.right, key)    return root """This function is used to find floor of a key"""def floor(root, key) :     if (not root):        return INT_MAX     """ If root.data is equal to key """    if (root.data == key) :        return root.data     """ If root.data is greater than the key """    if (root.data > key) :        return floor(root.left, key)     """ Else, the floor may lie in right subtree    or may be equal to the root"""    floorValue = floor(root.right, key)    return floorValue if (floorValue <= key) else root.data # Driver Codeif __name__ == '__main__':     """ Let us create following BST            7            / \        5     10        / \ / \        3 6 8 12 """    root = None    root = insert(root, 7)    insert(root, 10)    insert(root, 5)    insert(root, 3)    insert(root, 6)    insert(root, 8)    insert(root, 12)    print(floor(root, 9)) # This code is contributed by# Shubham Singh(SHUBHAMSINGH10)
// C# code to find floor of a key in BSTusing System; class GfG {     /*Structure of each Node in the tree*/    public class Node {        public int data;        public Node left, right;    }     /*This function is used to create andinitializes new Nodes*/    static Node newNode(int key)    {        Node temp = new Node();        temp.left = null;        temp.right = null;        temp.data = key;        return temp;    }     /* This function is used to insertnew values in BST*/    static Node insert(Node root, int key)    {        if (root == null)            return newNode(key);        if (key < root.data)            root.left = insert(root.left, key);        else            root.right = insert(root.right, key);        return root;    }     /*This function is used to find floor of a key*/    static int floor(Node root, int key)    {        if (root == null)            return int.MaxValue;         /* If root->data is equal to key */        if (root.data == key)            return root.data;         /* If root->data is greater than the key */        if (root.data > key)            return floor(root.left, key);         /* Else, the floor may lie in right subtree    or may be equal to the root*/        int floorValue = floor(root.right, key);        return (floorValue <= key) ? floorValue : root.data;    }     // Driver code    public static void Main(String[] args)    {        /* Let us create following BST            7            / \        5     10        / \ / \        3 6 8 12 */        Node root = null;        root = insert(root, 7);        insert(root, 10);        insert(root, 5);        insert(root, 3);        insert(root, 6);        insert(root, 8);        insert(root, 12);        Console.WriteLine(floor(root, 9));    }} // This code has been contributed by 29AjayKumar
<script>// Javascript code to find floor of a key in BST class Node{    constructor()    {        this.data=0;        this.left=this.right=null;    }} /*This function is used to create andinitializes new Nodes*/function newNode(key){    let temp = new Node();        temp.left = null;        temp.right = null;        temp.data = key;        return temp;} /* This function is used to insertnew values in BST*/function insert(root,key){    if (root == null)            return newNode(key);        if (key < root.data)            root.left = insert(root.left, key);        else            root.right = insert(root.right, key);        return root;} /*This function is used to find floor of a key*/function floor(root,key){    if (root == null)            return Number.MAX_VALUE;          /* If root->data is equal to key */        if (root.data == key)            return root.data;          /* If root->data is greater than the key */        if (root.data > key)            return floor(root.left, key);          /* Else, the floor may lie in right subtree    or may be equal to the root*/        let floorValue = floor(root.right, key);        return (floorValue <= key) ? floorValue : root.data;} /* Let us create following BST            7            / \        5     10        / \ / \        3 6 8 12 */let root = null;root = insert(root, 7);insert(root, 10);insert(root, 5);insert(root, 3);insert(root, 6);insert(root, 8);insert(root, 12);document.write(floor(root, 9)); // This code is contributed by rag2127</script>
8
 
SHUBHAMSINGH10
prerna saini
29AjayKumar
mukulbindal170299
praveenkumargamisaharghat
rag2127
Binary Search Tree
Searching
Searching
Binary Search Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Red-Black Tree | Set 2 (Insert)
Inorder Successor in Binary Search Tree
Two nodes of a BST are swapped, correct the BST
Optimal Binary Search Tree | DP-24
Find k-th smallest element in BST (Order Statistics in BST)
Binary Search
Linear Search
Maximum and minimum of an array using minimum number of comparisons
Given an array of size n and a number k, find all elements that appear more than n/k times
K'th Smallest/Largest Element in Unsorted Array | Set 1