Priority Queue Introduction and Concept in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a priority queue using a heap in Go.

DSA Go

pq := &PriorityQueue{}
heap.[1](pq)

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

APop

BPush

CInit

DRemove

Attempts:

3 left

💡 Hint

Common Mistakes

Using heap.Push before initializing the heap

Trying to remove elements before initialization

The heap.Init function initializes the priority queue so it can be used properly.

2fill in blank

medium

Complete the code to add an item to the priority queue.

DSA Go

item := &Item{value: "task1", priority: 3}
heap.[1](pq, item)

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

APop

BPush

CInit

DFix

Attempts:

3 left

💡 Hint

Common Mistakes

Using heap.Init again instead of Push

Trying to Pop when adding an item

The heap.Push function adds a new item to the priority queue while maintaining the heap property.

3fill in blank

hard

Fix the error in the code to remove the highest priority item from the queue.

DSA Go

item := heap.[1](pq).(*Item)
return item.value

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

APop

BPush

CInit

DRemove

Attempts:

3 left

💡 Hint

Common Mistakes

Using Push instead of Pop to remove an item

Calling Init again instead of Pop

The heap.Pop function removes and returns the highest priority item from the priority queue.

4fill in blank

hard

Fill both blanks to create a priority queue and add an item with priority 5.

DSA Go

pq := &PriorityQueue{}
heap.[1](pq)
heap.[2](pq, &Item{value: "task2", priority: 5})

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

AInit

BPush

CPop

DFix

Attempts:

3 left

💡 Hint

Common Mistakes

Calling Push before Init

Using Pop instead of Push to add items

First, heap.Init initializes the priority queue. Then, heap.Push adds the new item with priority 5.

5fill in blank

hard

Fill all three blanks to create a priority queue, add an item, and then remove the highest priority item.

DSA Go

pq := &PriorityQueue{}
heap.[1](pq)
heap.[2](pq, &Item{value: "task3", priority: 1})
item := heap.[3](pq).(*Item)
return item.value

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

AInit

BPush

CPop

DRemove

Attempts:

3 left

💡 Hint

Common Mistakes

Skipping initialization

Using Pop before Push

Using Remove instead of Pop

Initialize with heap.Init, add with heap.Push, and remove the highest priority item with heap.Pop.

Practice

1. What is the main feature of a priority queue compared to a regular queue?

easy

A. It does not allow insertion after creation

B. Elements are always dequeued in the order they were inserted

C. Elements are dequeued based on their priority, not just order of insertion

D. It only stores elements of the same value

Solution

1. Step 1: Understand queue behavior

   A regular queue removes elements in the order they were added (FIFO).

2. Step 2: Understand priority queue behavior

   A priority queue removes elements based on priority, not just insertion order.

3. Final Answer:

   Elements are dequeued based on their priority, not just order of insertion -> Option C

4. Quick Check:

   Priority queue = priority-based removal [OK]

Hint: Priority queue removes highest priority first, not oldest [OK]

Common Mistakes:

• Confusing priority queue with FIFO queue
• Thinking priority queue only stores unique values
• Assuming insertion order always matters

2. Which of the following is the correct way to declare a priority queue in Go using the container/heap package?

easy

A. var pq = &PriorityQueue{} // where PriorityQueue implements heap.Interface

B. var pq heap.Interface

C. pq := make([]int, 0) // simple slice, no heap

D. var pq = new(priorityQueue) // without implementing heap.Interface

Solution

1. Step 1: Recognize Go heap usage

   Go's container/heap requires a type implementing heap.Interface.

2. Step 2: Correct declaration

   Creating a pointer to a struct implementing heap.Interface is correct.

3. Final Answer:

   var pq = &PriorityQueue{} // where PriorityQueue implements heap.Interface -> Option A

4. Quick Check:

   PriorityQueue struct + heap.Interface = correct declaration [OK]

Hint: Use struct pointer implementing heap.Interface for priority queue [OK]

Common Mistakes:

• Declaring slice only without heap.Interface
• Using heap.Interface type directly without struct
• Not using pointer receiver for heap methods

3. What will be the output of the following Go code snippet?

package main

import (
  "container/heap"
  "fmt"
)

type IntHeap []int

func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] > h[j] } // max-heap
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *IntHeap) Push(x interface{}) {
  *h = append(*h, x.(int))
}

func (h *IntHeap) Pop() interface{} {
  old := *h
  n := len(old)
  x := old[n-1]
  *h = old[0 : n-1]
  return x
}

func main() {
  h := &IntHeap{2, 1, 5}
  heap.Init(h)
  heap.Push(h, 3)
  fmt.Println(heap.Pop(h))
}

medium

A. 1

B. 5

C. 2

D. 3

Solution

1. Step 1: Understand heap type and ordering

   The Less function returns h[i] > h[j], so this is a max-heap (largest element on top).

2. Step 2: Trace heap operations

   Initial heap: [2,1,5]. After heap.Init, heap property is established. Push 3 adds 3. The max element is 5, so heap.Pop returns 5.

3. Final Answer:

   5 -> Option B

4. Quick Check:

   Max-heap pop returns largest = 5 [OK]

Hint: Check Less() to know max or min heap, then pop returns max/min [OK]

Common Mistakes:

• Assuming min-heap by default
• Confusing Push and Pop order
• Not tracing heap.Init effect

4. Identify the error in the following Go code snippet that uses a priority queue:

package main

import (
  "container/heap"
  "fmt"
)

type IntHeap []int

func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *IntHeap) Push(x interface{}) {
  *h = append(*h, x.(int))
}

func (h *IntHeap) Pop() interface{} {
  old := *h
  n := len(old)
  x := old[n-1]
  *h = old[0 : n-1]
  return x
}

func main() {
  h := IntHeap{3, 2, 1}
  heap.Init(&h)
  heap.Push(&h, 4)
  fmt.Println(heap.Pop(&h))
}

medium

A. heap.Pop called with value instead of pointer

B. Push method does not append correctly

C. Less method should use > for max-heap

D. Swap method has wrong indices

Solution

1. Step 1: Check heap.Pop usage

   heap.Pop requires a pointer to the heap, but code calls heap.Pop(h) passing value.

2. Step 2: Confirm other methods

   Push, Less, Swap are correctly defined. The error is in calling heap.Pop without &.

3. Final Answer:

   heap.Pop called with value instead of pointer -> Option A

4. Quick Check:

   heap.Pop needs pointer argument [OK]

Hint: heap.Pop needs pointer, not value [OK]

Common Mistakes:

• Calling heap.Pop with value instead of pointer
• Confusing Less method for error
• Ignoring method signatures for Push/Pop

5. You want to implement a task scheduler using a priority queue in Go, where tasks with lower integer priority values run first. Which of the following Less method implementations correctly creates a min-heap for this purpose?

hard

A. func (h TaskHeap) Less(i, j int) bool { return h[i].priority > h[j].priority }

B. func (h TaskHeap) Less(i, j int) bool { return h[i].priority >= h[j].priority }

C. func (h TaskHeap) Less(i, j int) bool { return h[i].priority == h[j].priority }

D. func (h TaskHeap) Less(i, j int) bool { return h[i].priority < h[j].priority }

Solution

1. Step 1: Understand min-heap property

   Min-heap means the smallest priority value is at the top, so Less should return true if i's priority is less than j's.

2. Step 2: Analyze options

   func (h TaskHeap) Less(i, j int) bool { return h[i].priority < h[j].priority } returns true if h[i].priority < h[j].priority, which is correct for min-heap. Others do not correctly implement min-heap ordering.

3. Final Answer:

   func (h TaskHeap) Less(i, j int) bool { return h[i].priority < h[j].priority } -> Option D

4. Quick Check:

   Min-heap Less returns true if i priority less than j [OK]

Hint: Min-heap Less returns true if i < j priority [OK]

Common Mistakes:

• Using > instead of < for min-heap
• Using equality in Less method
• Using >= which breaks heap property