Heap Extract Min or Max Bubble Down in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to get the index of the left child in a heap array.

DSA Rust

fn left_child(index: usize) -> usize {
    index [1]
}

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

A* 2 + 1

B* 2 +

C* 2

D+ 2

Attempts:

3 left

💡 Hint

Common Mistakes

Using 2 * index instead of 2 * index + 1.

Using + 2 instead of + 1.

In a heap stored as an array, the left child of a node at index i is at 2*i + 1.

2fill in blank

medium

Complete the code to swap two elements in a vector.

DSA Rust

fn swap(heap: &mut Vec<i32>, i: usize, j: usize) {
    let temp = heap[i];
    heap[i] = heap[[1]];
    heap[j] = temp;
}

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

Ai

Bj

C0

Dheap.len() - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same index for both assignments.

Using an invalid index like 0 or heap.len() - 1.

To swap elements at i and j, assign heap[i] = heap[j] and heap[j] = temp.

3fill in blank

hard

Fix the error in the bubble down loop condition to avoid out-of-bounds access.

DSA Rust

while child_index [1] heap.len() {
    // bubble down logic
}

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

A<=

B>=

C<

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<=' causes index out of bounds error.

Using '>' or '>=' reverses the logic.

The child index must be strictly less than heap length to be valid.

4fill in blank

hard

Fill both blanks to correctly update the parent and child indices during bubble down.

DSA Rust

parent_index = [1];
child_index = [2];

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

Achild_index

Bparent_index

Cleft_child(parent_index)

Dright_child(parent_index)

Attempts:

3 left

💡 Hint

Common Mistakes

Not updating indices correctly causes infinite loops.

Using wrong functions for child index.

After swapping, parent moves to child's position, and child is updated to left child of new parent.

5fill in blank

hard

Fill all three blanks to complete the bubble down step choosing the correct child to swap with.

DSA Rust

if right_child_index [1] heap.len() && heap[right_child_index] < heap[left_child_index] {
    child_index = [2];
} else {
    child_index = [3];
}

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

A>

Bright_child_index

Cleft_child_index

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' instead of '<' reverses min-heap logic.

Assigning wrong child index causes incorrect swaps.

We pick the smaller child for min-heap bubble down. If right child is smaller, choose it; else left child.

Practice

1. What is the main purpose of the bubble down operation in a min-heap after extracting the minimum element?

easy

A. To insert a new element at the bottom of the heap

B. To remove all elements smaller than the root

C. To swap the last element with the root without any further changes

D. To restore the heap property by moving the root element down to its correct position

Solution

1. Step 1: Understand extract-min operation

   Extracting the minimum removes the root, so the last element moves to the root.

2. Step 2: Purpose of bubble down

   Bubble down moves this new root down to restore the min-heap property by swapping with smaller children.

3. Final Answer:

   To restore the heap property by moving the root element down to its correct position -> Option D

4. Quick Check:

   Bubble down fixes heap after extract-min [OK]

Hint: Bubble down fixes heap from root after extract-min [OK]

Common Mistakes:

• Thinking bubble down inserts new elements
• Assuming bubble down removes elements
• Confusing bubble down with bubble up

2. Which of the following Rust function signatures correctly represents a bubble down operation for a min-heap stored in a vector?

easy

A. fn bubble_down(&heap: Vec<i32>, index: usize)

B. fn bubble_down(heap: &mut Vec<i32>, index: usize)

C. fn bubble_down(heap: Vec<i32>, index: usize) -> Vec<i32>

D. fn bubble_down(heap: &Vec<i32>, index: usize)

Solution

1. Step 1: Identify mutability needs

   Bubble down modifies the heap, so it needs a mutable reference to the vector.

2. Step 2: Check parameter types

   fn bubble_down(heap: &mut Vec<i32>, index: usize) uses &mut Vec<i32>, allowing in-place changes without ownership transfer.

3. Final Answer:

   fn bubble_down(heap: &mut Vec<i32>, index: usize) -> Option B

4. Quick Check:

   Mutable reference needed for in-place heap changes [OK]

Hint: Use &mut Vec for in-place heap modification [OK]

Common Mistakes:

• Passing Vec by value causing ownership move
• Using immutable references when mutation is needed
• Incorrect parameter syntax

3. Consider the following Rust code snippet for a min-heap stored in a vector:

let mut heap = vec![1, 3, 6, 5, 9, 8];
heap[0] = heap.pop().unwrap();
bubble_down(&mut heap, 0);
println!("{:?}", heap);

If bubble_down correctly restores the min-heap property, what will be the printed vector?

medium

A. [3, 5, 8, 6, 9]

B. [6, 3, 8, 5, 9]

C. [3, 5, 6, 8, 9]

D. [5, 3, 6, 8, 9]

Solution

1. Step 1: Understand initial heap and pop

   Initial heap: [1,3,6,5,9,8]. After pop(), last element 8 is removed and placed at root: heap[0] = 8, heap = [8,3,6,5,9]

2. Step 2: Bubble down from root

   Compare 8 with children 3 and 6; smallest is 3, swap 8 and 3: [3,8,6,5,9]. Next, bubble down 8 at index 1 with children 5 and 9; smallest is 5, swap: [3,5,6,8,9]. No further swaps needed.

3. Final Answer:

   [3, 5, 6, 8, 9] -> Option C

4. Quick Check:

   Bubble down swaps to restore min-heap [OK]

Hint: Replace root with last, then bubble down to fix heap [OK]

Common Mistakes:

• Not swapping with smallest child
• Stopping bubble down too early
• Incorrect pop and root replacement

4. Given this Rust bubble down function snippet for a max-heap, identify the bug:

fn bubble_down(heap: &mut Vec<i32>, mut index: usize) {
    let len = heap.len();
    loop {
        let left = 2 * index + 1;
        let right = 2 * index + 2;
        let mut largest = index;
        if left < len && heap[left] > heap[largest] {
            largest = left;
        }
        if right < len && heap[right] > heap[largest] {
            largest = right;
        }
        if largest == index {
            break;
        }
        heap.swap(index, largest);
        // Missing update of index here
    }
}

medium

A. The index variable is not updated after swapping, causing an infinite loop

B. The function uses a min-heap condition instead of max-heap

C. The left and right child indices are calculated incorrectly

D. The swap function is used incorrectly

Solution

1. Step 1: Analyze loop behavior

   After swapping, the index must move to the child's position to continue bubbling down.

2. Step 2: Identify missing update

   The code does not update index = largest after swap, so loop repeats with same index causing infinite loop.

3. Final Answer:

   The index variable is not updated after swapping, causing an infinite loop -> Option A

4. Quick Check:

   Update index after swap to continue bubble down [OK]

Hint: Always update index after swap in bubble down loop [OK]

Common Mistakes:

• Forgetting to update index after swap
• Mixing min-heap and max-heap conditions
• Incorrect child index calculations

5. You have a max-heap represented as [50, 30, 40, 10, 20, 35]. After extracting the maximum element (50), you replace the root with the last element and perform bubble down. What is the final heap array after bubble down completes?

hard

A. [40, 30, 35, 10, 20]

B. [40, 30, 10, 20, 35]

C. [35, 30, 40, 10, 20]

D. [35, 30, 20, 10, 40]

Solution

1. Step 1: Replace root with last element

   Remove 50, move last element 35 to root: [35, 30, 40, 10, 20]

2. Step 2: Bubble down from root

   Compare 35 with children 30 and 40; largest is 40, swap: [40, 30, 35, 10, 20]. Next, bubble down 35 at index 2 with children none (leaf), stop.

3. Final Answer:

   [40, 30, 35, 10, 20] -> Option A

4. Quick Check:

   Bubble down swaps root with largest child until heap restored [OK]

Hint: Replace root with last, bubble down swapping with largest child [OK]

Common Mistakes:

• Not swapping with largest child
• Stopping bubble down too early
• Incorrect root replacement