Heap Insert Operation Bubble Up in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to add a new element at the end of the heap list.

DSA Python

heap = [10, 15, 20]
new_value = 12
heap.[1](new_value)

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

Aappend

Binsert

Cpop

Dremove

Attempts:

3 left

💡 Hint

Common Mistakes

Using insert instead of append

Using pop or remove which remove elements

We use append to add the new element at the end of the list representing the heap.

2fill in blank

medium

Complete the code to find the parent index of the newly added element at index i.

DSA Python

i = len(heap) - 1
parent = ([1] - 1) // 2

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

Ai

Blen(heap)

C0

Di + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using len(heap) instead of i

Adding 1 to i incorrectly

The parent index in a heap is calculated as (i - 1) // 2 where i is the current node index.

3fill in blank

hard

Fix the error in the bubble up loop condition to continue while the current node is greater than its parent.

DSA Python

while i > 0 and heap[i] [1] heap[parent]:
    heap[i], heap[parent] = heap[parent], heap[i]
    i = parent
    parent = (i - 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 >= which are incorrect here

In a max-heap, bubble up continues while the current node is greater than its parent, so the condition uses >.

4fill in blank

hard

Fill both blanks to correctly update the current index and parent index after swapping.

DSA Python

i = [1]
parent = ([2] - 1) // 2

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

Aparent

Bi

C0

Dlen(heap)

Attempts:

3 left

💡 Hint

Common Mistakes

Using i instead of parent for updating

Using 0 or len(heap) incorrectly

After swapping, the current index becomes the parent's index, so both i and parent update accordingly.

5fill in blank

hard

Fill all three blanks to complete the bubble up function for a max-heap insert.

DSA Python

def bubble_up(heap):
    i = len(heap) - 1
    parent = ([1] - 1) // 2
    while i > 0 and heap[i] [2] heap[parent]:
        heap[i], heap[parent] = heap[parent], heap[i]
        i = [3]
        parent = (i - 1) // 2

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

Ai

B>

Cparent

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of >

Mixing up i and parent updates

Wrong parent calculation

The bubble up function starts with the last index i, calculates the parent, and swaps while the child is greater than the parent. After swapping, i updates to parent.

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 smaller than its parent

B. To remove the smallest element from the heap

C. To sort all elements in the heap in ascending order

D. To add a new element at the bottom without any changes

Solution

1. Step 1: Understand heap property

   In a min-heap, every parent node is 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 if it is smaller than its parent to restore the heap property.

3. Final Answer:

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

4. Quick Check:

   Bubble up fixes heap order by moving smaller elements up [OK]

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

Common Mistakes:

• Thinking bubble up sorts the entire heap
• Confusing bubble up with removing elements
• Assuming bubble up adds element without changes

2. Which of the following Python code snippets correctly performs the bubble up step after inserting a new element at the end of a min-heap list heap?

easy

A. while i > 0 and heap[i] < heap[(i - 1) // 2]: heap[i], heap[(i - 1) // 2] = heap[(i - 1) // 2], heap[i]; i = (i - 1) // 2

B. while i > 0 and heap[i] > heap[(i - 1) // 2]: heap[i], heap[(i - 1) // 2] = heap[(i - 1) // 2], heap[i]; i = (i - 1) // 2

C. for i in range(len(heap)): if heap[i] < heap[(i - 1) // 2]: swap(heap[i], heap[(i - 1) // 2])

D. if heap[i] < heap[i + 1]: swap(heap[i], heap[i + 1])

Solution

1. Step 1: Identify bubble up condition

   Bubble up swaps while current element is smaller than its parent.

2. Step 2: Check code correctness

   while i > 0 and heap[i] < heap[(i - 1) // 2]: heap[i], heap[(i - 1) // 2] = heap[(i - 1) // 2], heap[i]; i = (i - 1) // 2 uses a while loop with condition heap[i] < heap[parent], swapping and updating i correctly.

3. Final Answer:

   while i > 0 and heap[i] < heap[(i - 1) // 2]: heap[i], heap[(i - 1) // 2] = heap[(i - 1) // 2], heap[i]; i = (i - 1) // 2 -> Option A

4. Quick Check:

   Bubble up swaps smaller child with parent [OK]

Hint: Bubble up swaps while child < parent using index (i-1)//2 [OK]

Common Mistakes:

• Using > instead of < in condition
• Using for loop instead of while
• Swapping with wrong indices

3. Given the min-heap represented as a list heap = [2, 5, 8, 10, 15], what will be the heap list after inserting 1 and performing bubble up?

medium

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

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

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

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

Solution

1. Step 1: Insert 1 at the end

   Heap becomes [2, 5, 8, 10, 15, 1].

2. Step 2: Bubble up 1

   Compare 1 with parent at index 2 (value 8). Swap: [2, 5, 1, 10, 15, 8]. Then compare 1 with new parent at index 0 (value 2). Swap: [1, 5, 2, 10, 15, 8].

3. Final Answer:

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

4. Quick Check:

   Inserted 1 bubbled up to root [OK]

Hint: Insert at end, swap up while smaller than parent [OK]

Common Mistakes:

• Not swapping enough times
• Swapping with wrong parent index
• Leaving new element at the end

4. The following code attempts to insert a new element into a min-heap and bubble it up, but it has a bug. What is the error?

def insert(heap, val):
    heap.append(val)
    i = len(heap) - 1
    while i > 0 and heap[i] > heap[(i - 1) // 2]:
        heap[i], heap[(i - 1) // 2] = heap[(i - 1) // 2], heap[i]
        i = (i - 1) // 2

medium

A. The append method should be insert at index 0

B. The index update i = (i - 1) // 2 is incorrect

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

D. The while loop condition should check i >= 0 instead of i > 0

Solution

1. Step 1: Analyze bubble up condition

   For min-heap, bubble up swaps when child is smaller than parent, so condition should be heap[i] < heap[parent].

2. Step 2: Identify error in code

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

3. Final Answer:

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

4. Quick Check:

   Bubble up swaps when child < parent [OK]

Hint: Use '<' to bubble up smaller elements in min-heap [OK]

Common Mistakes:

• Using '>' instead of '<' in condition
• Incorrect index updates
• Appending at wrong position

5. You have a max-heap represented as [90, 70, 80, 40, 50, 60]. You insert 85 at the end and perform bubble up. What will be the final heap list?

hard

A. [90, 85, 80, 70, 50, 60, 40]

B. [90, 70, 85, 40, 50, 60, 80]

C. [85, 70, 90, 40, 50, 60, 80]

D. [90, 70, 80, 40, 50, 60, 85]

Solution

1. Step 1: Insert 85 at the end

   Heap becomes [90, 70, 80, 40, 50, 60, 85].

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

   Compare 85 with parent at index 2 (80). Since 85 > 80, swap: [90, 70, 85, 40, 50, 60, 80]. Then compare 85 with new parent at index 0 (90). 85 < 90, stop bubbling up.

3. Final Answer:

   [90, 70, 85, 40, 50, 60, 80] -> Option B

4. Quick Check:

   Bubble up swaps larger child with parent in max-heap [OK]

Hint: In max-heap, bubble up swaps if child > parent [OK]

Common Mistakes:

• Not swapping enough times
• Confusing min-heap and max-heap conditions
• Leaving new element at the end