# Ceil in BST ## Exploring the Ceil in BST (Binary Search Tree)

When it comes to Binary Search Trees (BSTs), the concept of “ceil” holds a vital role in data manipulation and retrieval. Introducing “ceil” — the concept that enables you to find the smallest element greater than or equal to a specified value within a BST.

Let’s understand the importance of the ceil operation, its applications in real-world scenarios, and its impact on algorithms.

## What is Ceil in BST?

Ceil refers to a crucial concept used to find the smallest element in the tree that is greater than or equal to a specified target value. It essentially identifies the nearest higher value to the given target within the BST.

## Example : The above example demonstrate the value of Ceil value to be “17”(closest value to the target value) as the target value is “16”.

## Algorithm for finding Ceil in BST:

The process for finding the ceil is analogous to that of finding the floor:

1. Begin at the root node of the BST.
2. Compare the target value with the key of the current node.
3. Depending on the comparison:
• If the target value is equal to the current node’s key, the ceil is the current node’s key.
• If the target value is smaller than the current node’s key, move to the left subtree, as the ceil must be on the left side.
• If the target value is greater than the current node’s key, update the ceil candidate to the current node’s key and proceed to the right subtree, as the ceil could still be on the right side, closer to the target value.
4. Continue this process recursively or iteratively until an exact match is found or a leaf node is reached. The ceil candidate will hold the smallest key greater than or equal to the target value.
##### Code for Ceil in BST (Binary Search Tree)
```class TreeNode:
def __init__(self, key):
self.key = key
self.left = None
self.right = None

def find_ceil(root, target):
ceil_value = None
current = root

while current:
if target == current.key:
return current.key
elif target < current.key:
ceil_value = current.key
current = current.left
else:
current = current.right

return ceil_value

# Example usage:
if __name__ == "__main__":
root = TreeNode(50)
root.left = TreeNode(30)
root.right = TreeNode(70)
root.left.left = TreeNode(20)
root.left.right = TreeNode(40)
root.right.left = TreeNode(60)
root.right.right = TreeNode(80)

target_value = 45
result = find_ceil(root, target_value)

if result is not None:
print("Ceil of", target_value, "is", result, ".")
else:
print("No ceil found for", target_value, ".")

```

### Output :

```Ceil of 45 is 50 .
```
##### Explanation
• This Python code efficiently determines the ceil of a target value (45) in a BST.
• The “find_ceil” function iteratively traverses the tree, updating the ceil candidate as it progresses.
• If an exact match is found, it returns the current node’s key as the ceil.
• If the target value is smaller, it explores the left subtree, and if it’s larger, it moves to the right subtree.
• The final ceil candidate represents the smallest key greater than or equal to the target value.

### Code:

```class TreeNode:
def __init__(self, key):
self.key = key
self.left = None
self.right = None

def find_ceil(root, target):
ceil_value = None
current = root

while current:
if target == current.key:
return current.key
elif target < current.key:
ceil_value = current.key
current = current.left
else:
current = current.right

return ceil_value

# Example usage:
if __name__ == "__main__":
root = TreeNode(70)
root.left = TreeNode(40)
root.right = TreeNode(90)
root.left.left = TreeNode(20)
root.left.right = TreeNode(60)
root.right.left = TreeNode(80)
root.right.right = TreeNode(100)

target_value = 55
result = find_ceil(root, target_value)

if result is not None:
print("Ceil of", target_value, "is", result, ".")
else:
print("No ceil found for", target_value, ".")

```

### Output :

```Ceil of 55 is 60 .
```
##### Explanation
• This Python code effectively calculates the ceil of the target value 55 in a BST.
• The “find_ceil” function iterates through the tree, updating the ceil candidate as it proceeds.
• When an exact match isn’t found, it explores the left or right subtree, depending on the comparison with the current node’s key.
• The final ceil candidate represents the smallest key greater than or equal to the target value.
##### Significance of Finding the Ceil in BST

Discovering the ceil in a BST is essential for various reasons:

1. Data Retrieval: It allows you to efficiently retrieve the smallest key that is greater than or equal to a given value in a sorted dataset.

2. Range Queries: Ceil is commonly used in range queries to identify the ending point of a range efficiently.

3. Interpolation: In data analysis and interpolation algorithms, ceil values assist in estimating values between known data points.

##### Practical Use cases of Ceil

The ceil operation finds applications in diverse fields:

1. Finance: Calculating the ceil of stock prices or interest rates aids in financial modeling and analysis.

2. Databases: Databases use ceil for range queries, indexing, and efficient data retrieval.

3. Game Development: In game development, ceil values are crucial for collision detection, physics simulations, and character movement.

4. Statistics: Ceil is employed in statistical analysis, especially when estimating values within a specific range.

5. Geospatial Data: In geospatial data analysis, finding the ceil helps identify the closest geographic features or points of interest.

##### Complexity Analysis Floor in BST

The time and space complexity of finding the ceil in a Binary Search Tree (BST) can be analyzed as follows:

Time Complexity:

• The time complexity of finding the ceil in a BST is O(h), where ‘h’ represents the height of the tree.
• In the worst-case scenario, when the BST is completely unbalanced and resembles a linked list, the height can be ‘n’ (the number of nodes in the tree).
• However, in a well-balanced BST, such as AVL or Red-Black trees, the height is logarithmic, O(log n), with respect to the number of nodes.
• Therefore, the efficiency of finding the ceil depends on the balance of the BST.

Space Complexity:

• The space complexity for the iterative approach is O(1) because it does not require additional memory proportional to the input size.
• For the recursive approach, the space complexity depends on the depth of the recursion stack, which is equal to the height of the tree. In the worst-case scenario, it can be O(n) for an unbalanced tree but is O(log n) for a balanced tree.
##### To wrap it up:

Understanding the ceil concept in Binary Search Trees is paramount for efficiently locating the smallest key greater than or equal to a target value. Its significance spans across data retrieval, range queries, and estimation tasks in a wide array of applications. As you delve into the world of BSTs and their ceils, you unlock the power to optimize algorithms and make informed decisions based on sorted data.

### Related Banners

Get PrepInsta Prime & get Access to all 200+ courses offered by PrepInsta in One Subscription Question 1.

What does “ceil” mean in a Binary Search Tree (BST)?

In a BST, “ceil” refers to the smallest element in the tree that is greater than or equal to a specified value. Question 2.

How is the ceil operation implemented in code for a BST?

The ceil can be found using an iterative or recursive approach by traversing the BST and updating the ceil candidate as needed. Question 3.

What is the significance of finding the ceil in a BST?

Ceil values are vital for data retrieval tasks, range queries, and interpolation algorithms where precise values need to be located within a sorted dataset. Question 4.

How is the ceil operation used in practical scenarios involving sorted data?

Ceil is commonly used in situations where you need to round up values or find the next highest value in a sorted dataset, such as financial calculations and data analysis.

## Get over 200+ course One Subscription

Courses like AI/ML, Cloud Computing, Ethical Hacking, C, C++, Java, Python, DSA (All Languages), Competitive Coding (All Languages), TCS, Infosys, Wipro, Amazon, DBMS, SQL and others