Heap Insert Operation Bubble Up in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the heap array after inserting 15?

Given a max-heap represented as an array, what is the array after inserting the value 15 and performing bubble up?

DSA C

int heap[] = {20, 18, 10, 12, 9, 8};
int size = 6;
// Insert 15 and bubble up
heap[size] = 15;
int i = size;
size++;
while (i > 0 && heap[(i - 1) / 2] < heap[i]) {
    int temp = heap[i];
    heap[i] = heap[(i - 1) / 2];
    heap[(i - 1) / 2] = temp;
    i = (i - 1) / 2;
}

A [20, 18, 10, 15, 9, 8, 12]

B [20, 18, 10, 12, 9, 8, 15]

C [20, 18, 15, 12, 9, 10, 8]

D [20, 18, 15, 12, 9, 8, 10]

💡 Hint

Remember to swap the inserted element with its parent while it is greater.

After inserting 15 at the end, it bubbles up swapping with 10 to maintain max-heap property.

❓ Predict Output

intermediate

What is the heap after inserting 5 into the max-heap?

Given the max-heap array, what is the array after inserting 5 and performing bubble up?

DSA C

int heap[] = {30, 20, 15, 10, 8, 12};
int size = 6;
// Insert 5 and bubble up
heap[size] = 5;
int i = size;
size++;
while (i > 0 && heap[(i - 1) / 2] < heap[i]) {
    int temp = heap[i];
    heap[i] = heap[(i - 1) / 2];
    heap[(i - 1) / 2] = temp;
    i = (i - 1) / 2;
}

A [30, 20, 15, 10, 8, 12, 5]

B [30, 20, 15, 10, 5, 8, 12]

C [30, 20, 15, 10, 8, 5, 12]

D [30, 20, 15, 5, 8, 12, 10]

💡 Hint

If the inserted value is smaller than its parent, no swaps happen.

Since 5 is smaller than its parent 12, no bubble up swaps occur.

🔧 Debug

advanced

Identify the error in this bubble up code snippet

What error will this bubble up code cause when inserting a new element?

DSA C

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

A It causes an infinite loop because parent index calculation is incorrect.

B It causes an out-of-bounds error accessing heap[-1].

C It works correctly with no errors.

D It causes a syntax error due to missing semicolon.

💡 Hint

Check how parent index is calculated for zero-based arrays.

Parent index should be (i-1)/2, not i/2. Using i/2 can cause wrong parent index and infinite loop.

❓ Predict Output

advanced

What is the heap array after inserting 25?

Given a max-heap array, what is the array after inserting 25 and performing bubble up?

DSA C

int heap[] = {40, 30, 20, 15, 10, 18};
int size = 6;
heap[size] = 25;
int i = size;
size++;
while (i > 0 && heap[(i - 1) / 2] < heap[i]) {
    int temp = heap[i];
    heap[i] = heap[(i - 1) / 2];
    heap[(i - 1) / 2] = temp;
    i = (i - 1) / 2;
}

A [40, 30, 25, 15, 10, 18, 25]

B [40, 30, 25, 15, 10, 18, 20]

C [40, 30, 20, 15, 10, 18, 25]

D [40, 30, 20, 15, 10, 25, 18]

💡 Hint

Bubble up swaps the inserted element with parents while greater.

25 swaps with 20 at index 2, resulting in [40, 30, 25, 15, 10, 18, 20].

🚀 Application

expert

How many swaps occur when inserting 50 into this heap?

Given the max-heap array below, how many swaps happen during bubble up after inserting 50?

DSA C

int heap[] = {45, 30, 40, 10, 20, 35};
int size = 6;
heap[size] = 50;
int i = size;
size++;
int swap_count = 0;
while (i > 0 && heap[(i - 1) / 2] < heap[i]) {
    int temp = heap[i];
    heap[i] = heap[(i - 1) / 2];
    heap[(i - 1) / 2] = temp;
    i = (i - 1) / 2;
    swap_count++;
}

A 1

B 3

C 2

D 0

💡 Hint

Count each time the inserted element swaps with its parent.

50 swaps with 40, then 45, totaling 2 swaps.

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