Floor in Binary Search Tree (BST)

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)