Why Heap Exists and What Sorted Array Cannot Do Efficiently in DSA Python - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to insert an element into a min-heap using heapq.

DSA Python

import heapq
heap = [1, 3, 5]
heapq.[1](heap, 2)
print(heap)

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

Aheappush

Bpush

Cinsert

Dadd

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'push' or 'insert' which are not heapq functions.

The heappush function adds an element to the heap while maintaining the heap property.

2fill in blank

medium

Complete the code to remove the smallest element from the heap.

DSA Python

import heapq
heap = [1, 3, 5]
smallest = heapq.[1](heap)
print(smallest)

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

Apop

Bremove

Cheappop

Dextract

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'pop' which removes last element, not smallest in heap.

The heappop function removes and returns the smallest element from the heap.

3fill in blank

hard

Fix the error in the code to maintain the heap property after changing an element.

DSA Python

import heapq
heap = [1, 3, 5]
heap[1] = 0
heapq.[1](heap)
print(heap)

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

Aheapify

Bheappush

Cheappop

Dheapreplace

Attempts:

3 left

💡 Hint

Common Mistakes

Using heappush or heappop which do not fix heap after direct change.

After changing an element directly, heapify rebuilds the heap to maintain order.

4fill in blank

hard

Fill both blanks to create a min-heap from a list and then pop the smallest element.

DSA Python

import heapq
numbers = [5, 3, 8, 1]
heapq.[1](numbers)
smallest = heapq.[2](numbers)
print(smallest)

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

Aheapify

Bheappop

Cheappush

Dpop

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'pop' instead of 'heappop' to remove smallest element.

heapify builds the heap from the list, then heappop removes the smallest element.

5fill in blank

hard

Fill all three blanks to create a max-heap using a min-heap by negating values.

DSA Python

import heapq
nums = [2, 7, 4, 1]
neg_nums = [-n for n in nums]
heapq.[1](neg_nums)
max_val = -heapq.[2](neg_nums)
heapq.[3](neg_nums, -5)
print(max_val, neg_nums)

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

Aheapify

Bheappop

Cheappush

Dpop

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'pop' which is not a heap operation.

Negate numbers to use min-heap as max-heap. heapify builds heap, heappop removes max (negated), heappush adds new negated value.

Practice

1. Why do we use a heap instead of just a sorted array when we want to repeatedly access the smallest element?

easy

A. Because a heap allows faster insertion and deletion of elements compared to a sorted array.

B. Because a sorted array uses less memory than a heap.

C. Because a heap stores elements in sorted order all the time.

D. Because a sorted array can only store unique elements.

Solution

1. Step 1: Compare insertion and deletion in sorted array

   Inserting or deleting an element in a sorted array requires shifting elements, which takes linear time (slow).

2. Step 2: Compare insertion and deletion in heap

   A heap allows insertion and deletion in logarithmic time by maintaining a partial order, making these operations faster.

3. Final Answer:

   Because a heap allows faster insertion and deletion of elements compared to a sorted array. -> Option A

4. Quick Check:

   Heap operations faster than sorted array insert/delete [OK]

Hint: Heap supports fast insert/delete; sorted array does not [OK]

Common Mistakes:

• Thinking heaps keep all elements fully sorted
• Assuming sorted arrays have faster insertions
• Confusing memory usage with operation speed

2. Which of the following is the correct way to insert an element into a min-heap in Python using the heapq module?

easy

A. heapq.insert(heap, element)

B. heapq.push(heap, element)

C. heapq.add(heap, element)

D. heapq.heappush(heap, element)

Solution

1. Step 1: Recall heapq module functions

   The heapq module uses heappush() to insert elements into a heap.

2. Step 2: Verify correct function name

   heappush(heap, element) adds the element while maintaining heap property.

3. Final Answer:

   heapq.heappush(heap, element) -> Option D

4. Quick Check:

   Use heappush() to insert in heapq [OK]

Hint: Use heappush() to add elements to heapq heaps [OK]

Common Mistakes:

• Using non-existent heapq.insert() or heapq.push()
• Confusing heappush with push or add
• Trying to use list methods instead

3. What will be the output of the following Python code?

import heapq
arr = [5, 3, 8, 1]
heapq.heapify(arr)
heapq.heappop(arr)
print(arr)

medium

A. [3, 8, 5]

B. [3, 5, 8]

C. [1, 3, 8]

D. [5, 3, 8]

Solution

1. Step 1: Understand heapify and heappop

   heapify converts list into a min-heap: [1, 3, 8, 5]. heappop removes smallest element (1).

2. Step 2: Check remaining heap structure

   After popping 1, heap rearranges to maintain heap property, resulting in [3, 5, 8].

3. Final Answer:

   [3, 5, 8] -> Option B

4. Quick Check:

   heappop removes min, heap rearranges [OK]

Hint: heappop removes smallest; heap rearranges [OK]

Common Mistakes:

• Assuming list stays sorted after heappop
• Forgetting heap property rearrangement
• Confusing heappop with pop()

4. The following code tries to maintain a min-heap but has a bug. What is the error?

import heapq
heap = []
heapq.heappush(heap, 10)
heapq.heappush(heap, 5)
heapq.heappush(heap, 7)
heapq.pop(heap)
print(heap)

medium

A. heapq.pop() is not a valid function; should use heappop()

B. heappush() requires two arguments but given one

C. heapq.heapify() is missing before pushing elements

D. print statement syntax is incorrect

Solution

1. Step 1: Check heapq function usage

   heapq module does not have pop(); correct function to remove smallest is heappop().

2. Step 2: Identify correct function to remove element

   Replace heapq.pop(heap) with heapq.heappop(heap) to fix error.

3. Final Answer:

   heapq.pop() is not a valid function; should use heappop() -> Option A

4. Quick Check:

   Use heappop() to remove from heap [OK]

Hint: Use heappop(), not pop(), to remove from heapq heaps [OK]

Common Mistakes:

• Using pop() instead of heappop()
• Forgetting to heapify before operations
• Incorrect function arguments

5. You have a large stream of numbers and want to always quickly find the smallest number seen so far, while also adding new numbers frequently. Why is a heap better than keeping the numbers in a sorted array for this task?

hard

A. Because heaps store elements in sorted order, so no extra work is needed.

B. Because sorted arrays allow faster insertion than heaps.

C. Because heaps allow quick insertion and quick access to the smallest element without full sorting after each insertion.

D. Because sorted arrays use less memory than heaps.

Solution

1. Step 1: Understand insertion cost in sorted array

   Inserting into a sorted array requires shifting elements to keep order, which is slow (linear time).

2. Step 2: Understand heap advantages

   Heaps allow insertion in logarithmic time and always keep the smallest element accessible at the top without full sorting.

3. Final Answer:

   Because heaps allow quick insertion and quick access to the smallest element without full sorting after each insertion. -> Option C

4. Quick Check:

   Heap = fast insert + fast min access [OK]

Hint: Heap = fast insert + fast min access; sorted array slow insert [OK]

Common Mistakes:

• Thinking heaps keep full sorted order
• Assuming sorted arrays insert faster
• Confusing memory use with speed