What if you could find the closest match in a huge list without checking every item?
Why Floor and Ceil in BST in DSA Typescript?
Imagine you have a big phone book sorted by names. You want to find the closest name that is just before or just after a name you have in mind, but you don't want to look through every single page.
Looking through the phone book page by page is slow and tiring. You might miss the closest name or take too long to find it. It's easy to get lost or confused when the list is very long.
Using a special tree called a Binary Search Tree (BST), you can quickly jump to the closest smaller or larger name. The BST keeps names sorted, so you can find the floor (closest smaller or equal) and ceil (closest larger or equal) fast without checking every name.
let closestFloor = null; for (let name of phoneBook) { if (name <= targetName && (closestFloor === null || name > closestFloor)) { closestFloor = name; } }
function findFloor(node, target) {
if (!node) return null;
if (node.value === target) return node.value;
if (node.value > target) return findFloor(node.left, target);
let floorRight = findFloor(node.right, target);
return floorRight !== null ? floorRight : node.value;
}This lets you find the closest smaller or larger value quickly, making searching smarter and faster in sorted data.
When booking flights, you might want to find the closest earlier or later flight time to your preferred time. Floor and ceil in BST help find these times instantly.
Manual search is slow and error-prone for finding closest smaller or larger values.
Floor and ceil in BST use the tree's order to find these values quickly.
This makes searching in sorted data fast and efficient.
Practice
floor of a value in a Binary Search Tree (BST) represent?Solution
Step 1: Understand the definition of floor in BST
The floor of a value in BST is the greatest value that is less than or equal to the given value.Step 2: Compare with other options
The smallest value in the BST greater than or equal to the given value describes ceil, not floor. Options C and D are unrelated to floor concept.Final Answer:
The greatest value in the BST less than or equal to the given value -> Option AQuick Check:
Floor = greatest ≤ value [OK]
- Confusing floor with ceil
- Thinking floor is the smallest value
- Assuming floor is always the root
Solution
Step 1: Check parameter order and types
Function should accept root node (possibly null) and a key number to find ceil for.Step 2: Validate return type
Return type should be number or null if no ceil found. function findCeil(root: TreeNode | null, key: number): number | null matches this.Final Answer:
function findCeil(root: TreeNode | null, key: number): number | null -> Option BQuick Check:
Correct params and return type [OK]
- Swapping parameter order
- Using wrong parameter types
- Missing null in root type
10
/ \
5 15
/ \
12 20
Solution
Step 1: Locate key 14 in BST or nearest nodes
14 is not in BST. Check nodes greater than or equal to 14: 15 and 20.Step 2: Find smallest node ≥ 14
Between 15 and 20, 15 is smaller and ≥ 14, so ceil is 15.Final Answer:
15 -> Option CQuick Check:
Ceil = smallest ≥ 14 is 15 [OK]
- Choosing 12 which is less than 14
- Choosing 20 which is larger but not smallest ≥ 14
- Returning null when ceil exists
function findFloor(root: TreeNode | null, key: number): number | null {
if (!root) return null;
if (root.val === key) return root.val;
const floorRight = findFloor(root.right, key);
return floorRight !== null ? floorRight : root.val;
}
What is the bug in this code?Solution
Step 1: Identify missing logic for root.val > key
The code does not recurse into the left subtree when root.val > key. Instead, it always computes floorRight from the right subtree.Step 2: Trace buggy return
When root.val > key and right subtree yields null for floorRight (common case), it returns root.val which exceeds key, violating floor definition.Final Answer:
It returns root.val even if floorRight is null and root.val > key -> Option AQuick Check:
Missing left recursion on root.val > key [OK]
- Ignoring null checks
- Confusing left and right subtree calls
- Assuming root.val always valid floor
Solution
Step 1: Identify floor of 5 in BST
Floor is greatest value ≤ 5. Values ≤ 5 are 2 and 4. Greatest is 4.Step 2: Identify ceil of 5 in BST
Ceil is smallest value ≥ 5. Values ≥ 5 are 6, 8, 10, 12, 14. Smallest is 6.Final Answer:
Floor = 4, Ceil = 6 -> Option DQuick Check:
Floor ≤ 5 = 4, Ceil ≥ 5 = 6 [OK]
- Swapping floor and ceil values
- Assuming floor or ceil equals key if not present
- Choosing values not in BST
Ready to prove it?
Pass the test and this pattern moves unknown
