Heap Insert Operation Bubble Up in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to get the parent index of a node in a heap.

DSA Java

int parentIndex = (childIndex [1] 1) / 2;

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

A+

B*

C-

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using + instead of -

Using * or / incorrectly

In a heap, the parent index is calculated by subtracting 1 from the child index, then dividing by 2.

2fill in blank

medium

Complete the condition to check if the current node should bubble up in a max heap.

DSA Java

while (currentIndex > 0 && heap[currentIndex] [1] heap[parentIndex]) {

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 does not trigger bubble up

In a max heap, a node bubbles up if its value is greater than its parent's value.

3fill in blank

hard

Fix the error in swapping the current node with its parent during bubble up.

DSA Java

int temp = heap[currentIndex];
heap[currentIndex] = heap[[1]];
heap[parentIndex] = temp;

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

ArootIndex

BcurrentIndex

CchildIndex

DparentIndex

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping with currentIndex itself

Using undefined variables like childIndex or rootIndex

We swap the current node with its parent, so the index to swap with is parentIndex.

4fill in blank

hard

Fill both blanks to update indices correctly during bubble up.

DSA Java

currentIndex = [1];
parentIndex = (currentIndex [2] 1) / 2;

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

AparentIndex

BcurrentIndex

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using + instead of - in parent index calculation

Assigning currentIndex incorrectly

After swapping, currentIndex becomes parentIndex, and parentIndex is recalculated by subtracting 1 from currentIndex and dividing by 2.

5fill in blank

hard

Fill all three blanks to complete the bubble up loop for heap insertion.

DSA Java

while (currentIndex > 0 && heap[currentIndex] [1] heap[parentIndex]) {
    int temp = heap[currentIndex];
    heap[currentIndex] = heap[[2]];
    heap[parentIndex] = temp;
    currentIndex = [3];
    parentIndex = (currentIndex - 1) / 2;
}

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

A<

B>

CparentIndex

DcurrentIndex

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > in condition

Swapping with wrong index

Not updating currentIndex correctly

The loop continues while the current node is greater than its parent (max heap). We swap with parentIndex, then update currentIndex to parentIndex.

Practice

1. What is the main purpose of the bubble up operation when inserting a new element into a min-heap?

easy

A. To sort all elements in ascending order

B. To move the new element down to the bottom of the heap

C. To move the new element up until the heap property is restored

D. To remove the smallest element from the heap

Solution

1. Step 1: Understand the heap property

   In a min-heap, every parent node must be smaller than its children.

2. Step 2: Purpose of bubble up

   When a new element is added at the bottom, bubble up moves it up to restore the heap property.

3. Final Answer:

   To move the new element up until the heap property is restored -> Option C

4. Quick Check:

   Bubble up fixes heap by moving new element up [OK]

Hint: Bubble up moves new element up to fix heap [OK]

Common Mistakes:

• Thinking bubble up moves element down
• Confusing bubble up with removing elements
• Assuming bubble up sorts the entire heap

2. Which of the following Java code snippets correctly swaps two elements in an array during the bubble up operation?

easy

A. int temp = arr[parent]; arr[parent] = arr[i]; arr[i] = temp;

B. arr[i] = arr[parent]; arr[parent] = arr[i];

C. int temp = arr[i]; arr[i] = arr[parent]; arr[parent] = arr[i];

D. arr[parent] = arr[i]; arr[i] = arr[parent];

Solution

1. Step 1: Identify correct swap logic

   Swapping requires a temporary variable to hold one value to avoid overwriting.

2. Step 2: Check each option

   int temp = arr[parent]; arr[parent] = arr[i]; arr[i] = temp; correctly uses temp to swap arr[parent] and arr[i]. int temp = arr[i]; arr[i] = arr[parent]; arr[parent] = arr[i]; incorrectly sets arr[parent] to the already modified arr[i], causing data loss. Options B and D overwrite without temp, causing errors.

3. Final Answer:

   int temp = arr[parent]; arr[parent] = arr[i]; arr[i] = temp; -> Option A

4. Quick Check:

   Swap with temp variable = int temp = arr[parent]; arr[parent] = arr[i]; arr[i] = temp; [OK]

Hint: Use temp variable to swap two array elements safely [OK]

Common Mistakes:

• Swapping without a temp variable
• Swapping wrong indices
• Overwriting values causing data loss

3. Consider the min-heap represented by the array: [2, 5, 8, 10, 15]. After inserting the value 1 and performing bubble up, what will be the resulting array?

medium

A. [1, 5, 2, 10, 15, 8]

B. [1, 2, 5, 10, 15, 8]

C. [1, 2, 8, 10, 15, 5]

D. ]5 ,51 ,01 ,8 ,2 ,1[

Solution

1. Step 1: Insert 1 at the end

   Array becomes [2, 5, 8, 10, 15, 1]. Index of 1 is 5.

2. Step 2: Bubble up 1

   Parent index of 5 is (5-1)/2 = 2. Compare arr[2]=8 with 1. Since 1 < 8, swap. Array: [2, 5, 1, 10, 15, 8]. Now index of 1 is 2.

3. Step 3: Continue bubble up

   Parent index of 2 is (2-1)/2 = 0. Compare arr[0]=2 with 1. Since 1 < 2, swap. Array: [1, 5, 2, 10, 15, 8].

4. Final Answer:

   [1, 2, 5, 10, 15, 8] -> Option B

5. Quick Check:

   Bubble up swaps until heap property restored [OK]

Hint: Insert at end, swap with parent if smaller [OK]

Common Mistakes:

• Not swapping enough times
• Swapping with wrong parent index
• Incorrect parent calculation

4. The following Java method attempts to perform bubble up after inserting a new element into a min-heap. What is the bug?

void bubbleUp(int[] heap, int index) {
  while (index > 0) {
    int parent = (index - 1) / 2;
    if (heap[index] < heap[parent]) {
      int temp = heap[index];
      heap[index] = heap[parent];
      heap[parent] = temp;
      index = parent;
    }
  }
}

medium

A. The index update should be inside the if block

B. The parent calculation is incorrect

C. The loop condition should be index >= 0

D. The swap logic is wrong

Solution

1. Step 1: Analyze loop and index update

   The index is updated to parent every iteration, even if no swap occurs.

2. Step 2: Identify bug effect

   If no swap happens, index still moves up, causing unnecessary checks and possible infinite loop if heap property is already satisfied.

3. Step 3: Correct fix

   Update index = parent only when a swap occurs inside the if block.

4. Final Answer:

   The index update should be inside the if block -> Option A

5. Quick Check:

   Update index only after swap to avoid wrong moves [OK]

Hint: Move index up only when swapping during bubble up [OK]

Common Mistakes:

• Updating index outside swap condition
• Wrong parent index formula
• Incorrect swap logic

5. You have a max-heap represented by the array [20, 15, 18, 10, 12, 17]. You insert the value 19. After performing the bubble up operation, what is the final array?

hard

A. [20, 19, 18, 15, 12, 17, 10]

B. [20, 15, 18, 10, 12, 17, 19]

C. [20, 19, 18, 10, 12, 17, 15]

D. [20, 15, 19, 10, 12, 17, 18]

Solution

1. Step 1: Insert 19 at the end

   Array becomes [20, 15, 18, 10, 12, 17, 19]. Index of 19 is 6.

2. Step 2: Bubble up 19 in max-heap

   Parent index of 6 is (6-1)/2 = 2. Compare arr[2]=18 with 19. Since 19 > 18, swap. Array: [20, 15, 19, 10, 12, 17, 18]. Now index of 19 is 2.

3. Step 3: Continue bubble up

   Parent index of 2 is (2-1)/2 = 0. Compare arr[0]=20 with 19. Since 19 < 20, stop bubbling up.

4. Final Answer:

   [20, 15, 19, 10, 12, 17, 18] -> Option D

5. Quick Check:

   Bubble up swaps while child > parent in max-heap [OK]

Hint: Swap up while child is greater than parent in max-heap [OK]

Common Mistakes:

• Stopping bubble up too early
• Swapping with wrong parent index
• Confusing min-heap and max-heap rules