Floor and Ceiling in Binary Search Tree

In a binary search tree, the concept of floor and ceiling play a vital role in looking for the elements that may not exist in the tree. The floor of the given value in the binary search tree points out the biggest value that is smaller than or equal to the surfacing value. On the other hand, the ceiling represents the smallest element that is considered bigger than or equal to the allotted value.

In technical terms, if all the values are organized in a sorted manner, then the value of the floor will be the value that is immediately preceding it. On the other hand, the ceiling is the value that is immediately followed.

Some advantages of using floor and ceiling are: -

The floor and ceiling help us in finding out the closest value when it comes to finding out a target in the binary search tree.
Another advantage of the floor and ceiling is that it helps us determine the closest value in a range of datasets.
They prove to be most significant when it comes to neighbor searching; by finding out the closest value to the target, we can narrow down to the search space and find the value.

Implementation

// C++ implementation 
#include <bits/stdc++.h>
using namespace std;

// In this example, we are creating a binary tree, which consists of a binary tree node that contains data as well as a pointer to the left and right children.
class __nod {
public:
	int ky;
	__nod* Lft;
	__nod* Rt;
};

/* The purpose of this function is to assist in allotting a node with a key and NULL as left and right pointers.*/
__nod* new__nod(int ky)
{
	__nod* __nod = nw __nod();
	__nod->ky = ky;
	__nod->Lft = NULL;
	__nod->Rt = NULL;
	return (__nod);
}

// We need a function that will assist us in discovering the ceiling of a binary tree based on the data present. 
//If the data exceeds the minimum, we must return -1.
int Ceil(__nod* root, int input)
{
	if (root == NULL)
		return -1;
	if (root->ky == input)
		return root->ky;

	//If the root key is smaller, the ceil will be in the right subtree.
	if (root->ky < input)
		return Ceil(root->Rt, input);

	// If neither of the left subtrees or root contains the ceiling value, the value will be stored in the left subtree.
	int ceil = Ceil(root->Lft, input);
	return (ceil >= input) ? Ceil: root->ky;
}

// Main program 
int main()
{
	__nod* root = new__nod(8);

	root->Lft = new__nod(4);
	root->Rt = new__nod(12);

	root->Lft->Lft = new__nod(2);
	root->Lft->Rt = new__nod(6);

	root->Rt->Lft = new__nod(10);
	root->Rt->Rt = new__nod(14);

	for (int i = 0; i < 16; i++)
		cout << i << " " << Ceil(root, i) << endl;

	return 0;
}

Output

A step-by-step explanation of the code

The code begins by importing the necessary header files of the C++ libraries.
The code then emphasizes defining a class named 'Node', which contains the data value and the pointers to the left and right child.
It defines a new helper function to help us allocate a new node with the given value and memory.
The 'Ceil' function is defined to find the ceiling of the given binary tree. It has two parameters: root and input. It returns the -1 value or the ceiling value if the BST appears to be empty.
Now, we have to check the base case. If the tree is empty, return -1.
Now, verify whether the crucial value is equal to the input value. The input value is present if both these values are equal, and the root key is returned as the ceiling value.
If the root key is smaller than the input value, then the ceiling value is present in the right subtree, and if it is larger, it is in the left subtree.
In the program's main function, the binary tree is created with a root node having the value 8.
A loop is executed from 0 to 15 to determine each number's ceiling value in the range.
Finally, the program returns 0, indicating successful execution of the program.

Example 2)

// C program implementation
#include <stdio.h>
#include <stdlib.h>
// In this example, we are creating a binary tree, which consists of a binary tree node that contains data as well as a pointer to the left and right children.
struct __nod {
	int ky;
	struct __nod* Lft;
	struct __nod* Rt;
};
/* The purpose of this function is to assist in allotting a node with a key and NULL as left and right pointers.*/
struct __nod* new__nod(int ky)
{
	struct __nod* __nod
		= (struct __nod*)malloc(sizeof(struct __nod));
	__nod->ky = ky;
	__nod->Lft = NULL;
	__nod->Rt = NULL;
	return (__nod);
}

// We need a function that will assist us in discovering the ceiling of a binary tree based on the data present. 
//If the data is more than the minimum, then we have to return -1.
int Ceil(struct __nod* root, int input)
{
	if (root == NULL)
		return -1;
	if (root->ky == input)
		return root->ky;

	//If the root key is smaller, the ceil will be in the right subtree.
	if (root->ky < input)
		return Ceil(root->Rt, input);

	// If neither of the left subtrees or root contains the ceiling value, the value will be stored in the left subtree.
	int ceil = Ceil(root->Lft, input);
	return (ceil >= input) ? ceil : root->ky;
}

// Main program
int main()
{
	struct __nod* root = new__nod(8);

	root->Lft = new__nod(4);
	root->Rt = new__nod(12);

	root->Lft->Lft = new__nod(2);
	root->Lft->Rt = new__nod(6);

	root->Rt->Lft = new__nod(10);
	root->Rt->Rt = new__nod(14);

	for (int i = 0; i < 16; i++)
		printf("%d %d\n", i, Ceil(root, i));

	return 0;
}

Output

A step-by-step explanation of the code

The code begins by importing the necessary header files, such as "stdio. h" and "stdlib.h".
The code then emphasizes defining a structure for a binary tree node named 'struct', which contains the data value and the pointers to the left and right child.
It defines a new helper function to help us allocate a new node with the given value and memory.
The 'Ceil' function is defined to find the ceiling of the given binary tree. It has two parameters: root and input. It returns the -1 value or the ceiling value if the BST appears to be empty.
Now, we have to check the base case. If the tree is empty, return -1.
Now, verify whether the crucial value is equal to the input value. The input value is present if both these values are equal, and the root key is returned as the ceiling value.
If the root key is smaller than the input value, then the ceiling value is present in the right subtree, and if it is larger, it is in the left subtree.
The binary tree is created in the program's primary function with a root node having the value 8.
A loop is executed from 0 to 15 to determine each number's ceiling value in the range.
Finally, the program returns 0, indicating successful execution of the program.

Example 3)

// Java program implementation
class __nod {

	int data;
	__nod Lft, Rt;

	__nod(int d)
	{
		data = d;
		Lft = Rt = NULL;
	}
}

class BinaryTree {

	__nod root;
// We need a function that will assist us in discovering the ceiling of a binary tree based on the data present.  
//If the data is more than the minimum, then we have to return -1.
	int Ceil(__nod __nod, int input)
	{
		if (__nod == NULL) {
			return -1;
		}
		if (__nod.data == input) {
			return __nod.data;
		}

	//If the root key is minor, the ceil will be in the right subtree.
		if (__nod.data < input) {
			return Ceil(__nod.Rt, input);
		}
	// If neither of the left subtrees or root contains the ceiling value, the value will be stored in the left subtree.
		int ceil = Ceil(__nod.Lft, input);

		Return (ceil >= input) ? ceil : __nod.data;
	}

// Main program
	public static void main(String[] args)
	{
		BinaryTree tree = new BinaryTree();
		tree.root = nw __nod(8);
		tree.root.Lft = nw __nod(4);
		tree.root.Rt = nw __nod(12);
		tree.root.Lft.Lft = nw __nod(2);
		tree.root.Lft.Rt = nw __nod(6);
		tree.root.Rt.Lft = nw __nod(10);
		tree.root.Rt.Rt = nw __nod(14);
		for (int i = 0; i < 16; i++) {

			System.out.println(i + " "
							+ tree.Ceil(tree.root, i));
		}
	}
}

Output

A step-by-step explanation of the code

The code begins by defining the 'node' and 'Binary tree' classes. The binary tree contains BST itself and a reference root node.
The code then emphasizes defining a class named 'Node', which contains the data value and the pointers to the left and right child.
It defines a new helper function to help us allocate a new node with the given value and memory.
The 'Ceil' function is defined to find the ceiling of the given binary tree. It has two parameters: root and input. It returns the -1 value or the ceiling value if the BST appears to be empty.
Now, we have to check the base case; if the tree is empty, return -1.
Now, verify whether the critical value is equal to the input value. The input value is present if both these values are equal, and the root key is returned as the ceiling value.
If the root key is smaller than the input value, then the ceiling value is present in the right subtree, and if it is larger, it is in the left subtree.
In the program's primary function, the binary tree is created with a root node having the value 8.
A loop is executed from 0 to 15 to determine each number's ceiling value in the range.
Finally, the program returns 0, indicating successful execution of the program.