GeeksforGeeks App
Open App
Browser
Continue

# 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)

My Personal Notes arrow_drop_up