Heap Insert Operation Bubble Up in DSA Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the bubble up operation in a heap insert?

The bubble up operation moves the newly inserted element up the heap to restore the heap property, ensuring the parent node is always smaller (min-heap) or larger (max-heap) than its children.

beginner

In a min-heap, when does the bubble up operation stop?

It stops when the inserted element is no longer smaller than its parent or it reaches the root of the heap.

intermediate

What is the time complexity of the bubble up operation in a heap?

The time complexity is O(log n), where n is the number of elements in the heap, because the element may move up the height of the heap which is logarithmic in size.

beginner

Which index formula is used to find the parent of a node at index i in a heap array?

The parent index is calculated as (i - 1) / 2 using integer division.

beginner

Why is the bubble up operation important after inserting a new element in a heap?

Because inserting at the end may break the heap property, bubble up fixes this by swapping the new element with its parent until the heap property is restored.

What is the first step after inserting a new element at the end of a heap array?

A Remove the root element

B Perform bubble up to restore heap property

C Sort the entire array

D Do nothing

After insertion at the end, bubble up is used to restore the heap property by moving the new element up if needed.

In a max-heap, bubble up swaps the new element with its parent if:

A The new element is larger than the parent

B The new element is at the root

C The new element is equal to the parent

D The new element is smaller than the parent

In a max-heap, the new element bubbles up if it is larger than its parent to maintain the max-heap property.

What is the parent index of the node at index 5 in a heap array?

A 4

B 3

C 2

D 1

Parent index = (5 - 1) / 2 = 4 / 2 = 2.

What happens if the bubble up operation reaches the root of the heap?

A It continues swapping with a non-existent parent

B It restarts from the bottom

C It removes the root

D It stops because the root has no parent

Bubble up stops at the root because there is no parent to compare with.

Which of these best describes the heap property restored by bubble up?

A Every parent is smaller than its children in a min-heap

B Every parent is larger than its children in a min-heap

C Every child is smaller than its parent in a max-heap

D Heap property is not related to parent-child values

In a min-heap, the heap property means every parent is smaller than its children.

Explain the bubble up operation during heap insertion and why it is necessary.

Think about how the heap property might break after insertion.

Describe how to find the parent of a node in a heap stored as an array and how this helps in bubble up.

Focus on array indexing and parent-child relationships.

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