Floor in Binary Search Tree (BST)

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    

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.


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 ciel of BST you can refer to this article.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP 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 and
initialises 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java code to find floor of a key in BST
class GfG {
  
    /*Structure of each Node in the tree*/
    static class Node {
        int data;
        Node left, right;
    }
  
    /*This function is used to create and 
initialises 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 insert 
new 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 
            
            / \ 
        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));
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 code to find floor of a key in BST
INT_MAX = 2147483647
  
# Binary Tree Node 
""" A utility function to create a
new 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 insert 
new 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 Code 
if __name__ == '__main__':
  
    """ Let us create following BST 
            
            / \ 
        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)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# code to find floor of a key in BST
using 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 and 
initialises 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 insert 
new 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 
            
            / \ 
        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

chevron_right


Output:

8


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.