Skip to content
Related Articles
Get the best out of our app
GeeksforGeeks App
Open App
geeksforgeeks
Browser
Continue

Related Articles

Floor in Binary Search Tree (BST)

Improve Article
Save Article
Like Article
Improve Article
Save Article
Like Article

Given a Binary Search Tree and a number x, find the floor of x in the given BST:

Examples:

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    

Naive Approach: To solve the problem follow the below idea:

A simple solution is to traverse the tree using (Inorder or Preorder or Postorder) and keep track of the closest smaller or same element

Efficient Approach: To solve the problem follow the below idea:

We can efficiently find the closest smaller or same element in O(H) time where H is the height of BST.

Follow the given steps to solve the problem:

  • Start at the root Node
  • If root->data == key, the floor of the key is equal to the root.
  • Else if root->data > key, then the floor of the key must lie in the left subtree.
  • 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 the root is the key.

Below is the implementation of the above approach:

C++

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

// Driver code
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);
  
      // Function call
    cout << floor(root, 9) << endl;
    return 0;
}

Java

// Java code to find floor of a key in BST

import java.io.*;

class GfG {

    /*Structure of each Node in the tree*/
    static class Node {
        int data;
        Node left, right;
    }

    /*This function is used to create and
initializes 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;
    }

      // 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);
      
          // Function call
        System.out.println(floor(root, 9));
    }
}

Python3

# 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 
            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)
    
    # Function call
    print(floor(root, 9))

# This code is contributed by
# Shubham Singh(SHUBHAMSINGH10)

C#

// 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
initializes 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
            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);
      
          // Function call
        Console.WriteLine(floor(root, 9));
    }
}

// This code has been contributed by 29AjayKumar

Javascript

<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 and
initializes 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 insert
new 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>
Output

8

Time Complexity: O(H), where H is the height of the tree
Auxiliary Space: O(1)


My Personal Notes arrow_drop_up
Last Updated : 22 Sep, 2022
Like Article
Save Article
Similar Reads
Related Tutorials