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

Recall & Review

beginner

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

The bubble up operation restores the heap property by moving the newly inserted element up the tree until it is in the correct position.

beginner

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

It stops when the inserted element is greater than or equal to its parent or it reaches the root of the heap.

intermediate

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

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 data structure is commonly used to implement a heap for efficient bubble up operations?

A heap is commonly implemented using an array, where parent and child indices can be calculated easily for bubble up.

beginner

Explain the parent index calculation in a zero-based array heap during bubble up.

For a node at index i, the parent index is calculated as (i - 1) // 2 in a zero-based array.

What does the bubble up operation do after inserting a new element in a min-heap?

A Moves the element up until it is less than or equal to its parent

B Moves the element down until it is larger than its children

C Swaps the element with the root

D Removes the smallest element

Bubble up moves the new element up until the heap property is restored, meaning it is not smaller than its parent.

In a zero-based array heap, what is the parent index of the element at index 5?

A 1

B 2

C 4

D 3

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

What is the worst-case time complexity of bubble up in a heap with n elements?

A O(n)

B O(1)

C O(n log n)

D O(log n)

Bubble up moves up the height of the heap, which is log n, so O(log n).

When inserting into a max-heap, bubble up continues while the inserted element is:

A Equal to its parent

B Less than its parent

C Greater than its parent

D At the root

In a max-heap, bubble up moves the element up while it is greater than its parent.

Which data structure is best suited for implementing a heap to support bubble up?

A Array

B Linked list

C Stack

D Queue

Arrays allow easy calculation of parent and child indices, making bubble up efficient.

Describe the bubble up process during a heap insert operation.

Think about how the new element moves up the tree.

Explain how to calculate the parent index of a node in a zero-based array heap.

Focus on the index math for parent-child relationships.

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