Floor and Ceil in BST in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start searching for floor value in BST.

DSA Java

public int floor(Node root, int key) {
    if (root == null) return -1;
    if (root.data == [1]) return root.data;
    // rest of code omitted
}

Drag options to blanks, or click blank then click option'

Akey

Broot.data

Cnull

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing root.data with null

Returning 0 instead of key

Using wrong variable in comparison

We check if the current node's data equals the key to return it as floor.

2fill in blank

medium

Complete the code to move left in BST when root data is greater than key.

DSA Java

if (root.data > key) {
    return [1];
}

Drag options to blanks, or click blank then click option'

Afloor(root.right, key)

Bfloor(root.left, key)

Croot.data

Dkey

Attempts:

3 left

💡 Hint

Common Mistakes

Searching right subtree instead of left

Returning root.data directly

Returning key without recursion

If root data is greater than key, floor must be in left subtree.

3fill in blank

hard

Fix the error in code to find floor when root data is less than key.

DSA Java

if (root.data < key) {
    int floorValue = floor(root.right, key);
    return floorValue [1] root.data ? floorValue : root.data;
}

Drag options to blanks, or click blank then click option'

A>

B<

C==

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>'

Using '==' which is equality check

Using '>=' which may cause wrong logic

We return the greater value between floorValue and root.data as floor.

4fill in blank

hard

Fill both blanks to start ceil function and check if root data equals key.

DSA Java

public int ceil(Node root, int key) {
    if (root == [1]) return -1;
    if (root.data == [2]) return root.data;
    // rest of code omitted
}

Drag options to blanks, or click blank then click option'

Anull

Broot

Ckey

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Checking root == 0 instead of null

Comparing root.data with root instead of key

Returning wrong default value

We check if root is null and if root data equals key for ceil.

5fill in blank

hard

Fill all three blanks to complete ceil logic when root data is less than key.

DSA Java

if (root.data < [1]) {
    return [2];
} else {
    int ceilValue = ceil(root.left, [3]);
    // rest omitted
}

Drag options to blanks, or click blank then click option'

Akey

Bceil(root.right, key)

Droot.data

Attempts:

3 left

💡 Hint

Common Mistakes

Using root.data instead of key in comparison

Returning root.data when root.data < key

Passing wrong argument in recursive call

If root data < key, ceil is in right subtree; else search left subtree.

Practice

1. What does the floor of a value in a Binary Search Tree (BST) represent?

easy

A. The greatest value in the BST less than or equal to the given value

B. The smallest value in the BST greater than or equal to the given value

C. The root value of the BST

D. The smallest value in the BST less than the given value

Solution

1. Step 1: Understand the definition of floor in BST

   The floor of a value is the greatest value in the BST that is less than or equal to the given value.

2. Step 2: Compare with options

   The greatest value in the BST less than or equal to the given value matches this definition exactly, while others describe different concepts.

3. Final Answer:

   The greatest value in the BST less than or equal to the given value -> Option A

4. Quick Check:

   Floor = greatest ≤ value [OK]

Hint: Floor is largest value ≤ target in BST [OK]

Common Mistakes:

• Confusing floor with ceil
• Thinking floor is smallest value
• Assuming floor is always the root

2. Which of the following is the correct Java method signature to find the ceil of a value in a BST node class?

easy

A. public int findCeil(Node root, int key)

B. int findCeil(Node root, int key) void

C. public void findCeil(Node root, int key) int

D. findCeil(Node root, int key) public int

Solution

1. Step 1: Recall Java method signature syntax

   In Java, a method signature includes access modifier, return type, method name, and parameters in parentheses.

2. Step 2: Check each option

   public int findCeil(Node root, int key) follows correct syntax: public int findCeil(Node root, int key). Others have incorrect order or missing return types.

3. Final Answer:

   public int findCeil(Node root, int key) -> Option A

4. Quick Check:

   Java method = access + return + name(params) [OK]

Hint: Java method: access + return type + name(params) [OK]

Common Mistakes:

• Placing return type after method name
• Omitting access modifier
• Using void when return type is int

3. Given the BST below and key = 14, what is the floor and ceil?

       15
      /  \
    10    20
   /  \     \
  8   12    25

medium

A. Floor = 15, Ceil = 20

B. Floor = 12, Ceil = 15

C. Floor = 10, Ceil = 15

D. Floor = 12, Ceil = 20

Solution

1. Step 1: Find floor of 14 in BST

   Floor is greatest value ≤ 14. Values ≤14 are 8,10,12. Greatest is 12.

2. Step 2: Find ceil of 14 in BST

   Ceil is smallest value ≥ 14. Values ≥14 are 15,20,25. Smallest is 15.

3. Final Answer:

   Floor = 12, Ceil = 15 -> Option B

4. Quick Check:

   Floor ≤14 = 12, Ceil ≥14 = 15 [OK]

Hint: Floor ≤ key, Ceil ≥ key in BST [OK]

Common Mistakes:

• Choosing floor or ceil outside BST values
• Mixing floor and ceil values
• Ignoring BST property when searching

4. Consider this Java method to find floor in BST:

int floor(Node root, int key) {
  if (root == null) return -1;
  if (root.data == key) return root.data;
  if (root.data > key) return floor(root.left, key);
  int floorValue = floor(root.right, key);
  return (floorValue <= key && floorValue != -1) ? floorValue : root.data;
}

What is the bug in this code?

medium

A. It always searches left subtree

B. It does not check for null root

C. It returns -1 when key is found

D. It returns root.data even if floorValue is -1 and root.data > key

Solution

1. Step 1: Analyze the return condition when root.data > key

   If root.data > key, method searches left subtree correctly.

2. Step 2: Analyze return when root.data < key

   It gets floorValue from right subtree. If floorValue is -1 (no floor found), it returns root.data even if root.data > key, which is wrong.

3. Step 3: Identify bug

   Returning root.data without checking if root.data ≤ key causes incorrect floor when floorValue is -1.

4. Final Answer:

   It returns root.data even if floorValue is -1 and root.data > key -> Option D

5. Quick Check:

   Check root.data ≤ key before returning [OK]

Hint: Check root.data ≤ key before returning floor [OK]

Common Mistakes:

• Ignoring invalid floorValue -1
• Returning root.data without condition
• Not handling null root properly

5. You want to find both floor and ceil of a key in a BST efficiently. Which approach is best?

hard

A. Convert BST to sorted array, then binary search twice

B. Traverse BST twice: once for floor, once for ceil

C. Traverse BST once, updating floor and ceil during search

D. Use BFS traversal to find floor and ceil

Solution

1. Step 1: Understand BST properties for floor and ceil

   BST allows searching floor and ceil by comparing key with node values and moving left or right.

2. Step 2: Evaluate approaches

   Traversing once and updating floor and ceil during search is efficient (O(h)), better than traversing twice or converting to array.

3. Step 3: Choose best approach

   Traverse BST once, updating floor and ceil during search is best as it uses BST property and single traversal.

4. Final Answer:

   Traverse BST once, updating floor and ceil during search -> Option C

5. Quick Check:

   Single BST traversal updates floor & ceil [OK]

Hint: Update floor and ceil in one BST traversal [OK]

Common Mistakes:

• Doing two separate traversals
• Converting BST to array unnecessarily
• Using BFS which ignores BST order