Heap Insert Operation Bubble Up in DSA C - 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?

The bubble up 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 moves up at most the height of the heap.

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.

intermediate

Explain the difference between bubble up and bubble down in heap operations.

Bubble up is used after insertion to move the new element up to maintain heap order. Bubble down is used after removal of the root to move the last element down to restore heap order.

What happens first when inserting a new element into a heap?

A Swap the element with the root

B Add the element at the end of the heap array

C Remove the smallest element

D Sort the entire heap

The new element is added at the end of the heap array before bubble up starts.

In a min-heap, if the inserted element is larger than its parent, what does bubble up do?

A Removes the parent

B Swaps the element with its parent

C Moves the element to the root

D Stops the bubble up operation

Bubble up stops when the inserted element is not smaller than its parent.

Which of these is the correct parent index for a node at index 5?

A 4

B 3

C 2

D 1

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

What is the worst-case number of swaps in bubble up for a heap with n elements?

A O(log n)

B O(n)

C O(n log n)

D O(1)

Bubble up swaps at most the height of the heap, which is O(log n).

Which operation is used to restore heap order after removing the root?

A Bubble down

B Bubble up

C Heapify

D Insertion

Bubble down moves the last element down to restore heap order after root removal.

Describe the steps of the bubble up operation when inserting into a min-heap.

Think about how the new element moves up the tree.

Explain why bubble up operation has O(log n) time complexity.

Consider the shape and height of a binary heap.

Practice

1. What is the main purpose of the bubble up operation during a heap insert?

easy

A. To restore the heap property by moving the new element up if it is larger than its parent

B. To remove the smallest element from the heap

C. To sort all elements in ascending order

D. To swap the root with the last element

Solution

1. Step 1: Understand heap property

   A max-heap requires each parent to be greater than or equal to its children.

2. Step 2: Purpose of bubble up

   When inserting, bubble up moves the new element up if it is larger than its parent to restore heap property.

3. Final Answer:

   To restore the heap property by moving the new element up if it is larger than its parent -> Option A

4. Quick Check:

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

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

Common Mistakes:

• Thinking bubble up sorts the entire heap
• Confusing bubble up with removing elements
• Assuming bubble up swaps root with last element

2. Which of the following C code snippets correctly performs the bubble up step after inserting a new element at index i in a max-heap array heap?

easy

A. if (heap[i] > heap[i + 1]) swap(heap[i], heap[i + 1]);

B. while (i > 0 && heap[i] < heap[(i - 1) / 2]) { int temp = heap[i]; heap[i] = heap[(i - 1) / 2]; heap[(i - 1) / 2] = temp; i = (i - 1) / 2; }

C. for (int j = i; j > 0; j--) { if (heap[j] > heap[j - 1]) swap(heap[j], heap[j - 1]); }

D. while (i > 0 && heap[i] > heap[(i - 1) / 2]) { int temp = heap[i]; heap[i] = heap[(i - 1) / 2]; heap[(i - 1) / 2] = temp; i = (i - 1) / 2; }

Solution

1. Step 1: Identify correct bubble up condition

   Bubble up swaps while current element is greater than its parent at index (i-1)/2.

2. Step 2: Check code correctness

   while (i > 0 && heap[i] > heap[(i - 1) / 2]) { int temp = heap[i]; heap[i] = heap[(i - 1) / 2]; heap[(i - 1) / 2] = temp; i = (i - 1) / 2; } correctly uses a while loop with condition and swaps elements, updating index i to parent.

3. Final Answer:

   while (i > 0 && heap[i] > heap[(i - 1) / 2]) { int temp = heap[i]; heap[i] = heap[(i - 1) / 2]; heap[(i - 1) / 2] = temp; i = (i - 1) / 2; } -> Option D

4. Quick Check:

   Bubble up uses parent index (i-1)/2 and swaps if child > parent [OK]

Hint: Use parent index (i-1)/2 and swap if child > parent [OK]

Common Mistakes:

• Using < instead of > in condition
• Using for loop instead of while
• Swapping with next element instead of parent

3. Given the max-heap array heap = [50, 30, 40, 10, 20], what will be the heap array after inserting 45 and performing bubble up?

medium

A. [50, 45, 40, 10, 20, 30]

B. [50, 30, 45, 10, 20, 40]

C. [45, 30, 50, 10, 20, 40]

D. [50, 30, 40, 10, 20, 45]

Solution

1. Step 1: Insert 45 at the end

   Insert 45 at index 5: heap = [50, 30, 40, 10, 20, 45]

2. Step 2: Bubble up 45

   Parent of index 5 is (5-1)/2=2 with value 40. Since 45 > 40, swap them. New heap: [50, 30, 45, 10, 20, 40]

3. Final Answer:

   [50, 30, 45, 10, 20, 40] -> Option B

4. Quick Check:

   Inserted 45 bubbled up swapping with 40 [OK]

Hint: Insert at end, swap up if bigger than parent [OK]

Common Mistakes:

• Not swapping after insertion
• Swapping with wrong parent index
• Placing 45 at wrong position

4. Consider the following bubble up code snippet for a max-heap insert:

while (i > 0 && heap[i] < heap[(i - 1) / 2]) {
    int temp = heap[i];
    heap[i] = heap[(i - 1) / 2];
    heap[(i - 1) / 2] = temp;
    i = (i - 1) / 2;
}

What is the error in this code?

medium

A. Parent index calculation is incorrect

B. The loop should start from i = 1 instead of i > 0

C. The comparison operator should be > instead of < to maintain max-heap property

D. Swapping elements is not needed in bubble up

Solution

1. Step 1: Analyze comparison operator

   Bubble up in max-heap swaps when child is greater than parent, so condition should be heap[i] > heap[parent].

2. Step 2: Identify error

   Code uses heap[i] < heap[parent], which is wrong and breaks max-heap property.

3. Final Answer:

   The comparison operator should be > instead of < to maintain max-heap property -> Option C

4. Quick Check:

   Max-heap bubble up swaps if child > parent [OK]

Hint: Use > to compare child and parent in max-heap bubble up [OK]

Common Mistakes:

• Using < instead of > in condition
• Incorrect parent index formula
• Skipping swaps in bubble up

5. You have a max-heap represented as an array: [60, 40, 55, 20, 30, 50]. You insert 65 at the end and perform bubble up. What is the final heap array after bubble up completes?

hard

A. [65, 60, 55, 20, 30, 50, 40]

B. [65, 40, 60, 20, 30, 50, 55]

C. [60, 40, 65, 20, 30, 50, 55]

D. [60, 40, 55, 20, 30, 50, 65]

Solution

1. Step 1: Insert 65 at the end

   Heap becomes [60, 40, 55, 20, 30, 50, 65]. Index of 65 is 6.

2. Step 2: Bubble up 65

   Parent index = (6-1)/2 = 2, value 55. Since 65 > 55, swap: [60, 40, 65, 20, 30, 50, 55].

3. Step 3: Continue bubble up

   New index = 2. Parent index = (2-1)/2 = 0, value 60. Since 65 > 60, swap: [65, 40, 60, 20, 30, 50, 55].

4. Final Answer:

   [65, 60, 55, 20, 30, 50, 40] -> Option A

5. Quick Check:

   Inserted 65 bubbled up swapping with 55 then 60 [OK]

Hint: Bubble up swaps repeatedly until parent is larger [OK]

Common Mistakes:

• Stopping bubble up after one swap
• Swapping with wrong parent index
• Not updating index after swap