Why Priority Queue Introduction and Concept in DSA Go?

The Big Idea

What if your program could always pick the most important task instantly, without you lifting a finger?

The Scenario

Imagine you are organizing a line for a popular ride at an amusement park. People arrive, but some have special passes that let them go ahead of others. If you try to manage this line manually, it becomes confusing and slow.

The Problem

Trying to reorder the line every time someone new arrives or leaves is tiring and error-prone. You might lose track of who should go first or accidentally let someone skip unfairly. This manual sorting wastes time and causes frustration.

The Solution

A priority queue automatically keeps the line sorted by importance. When a new person arrives, it places them in the right spot quickly. When it's time to let someone on the ride, it always picks the most important person first without extra effort.

Before vs After

✗ Before

line := []int{5, 3, 4}
// Insert 6, then sort manually
line = append(line, 6)
sort.Ints(line)

✓ After

pq := NewPriorityQueue()
pq.Insert(5)
pq.Insert(3)
pq.Insert(4)
pq.Insert(6)
// pq always keeps highest priority at front

What It Enables

Priority queues let you handle tasks or people by importance automatically, making your programs smarter and faster.

Real Life Example

Hospitals use priority queues to treat patients by urgency, so the most critical cases get help first without delay.

Key Takeaways

Manual sorting of priorities is slow and error-prone.

Priority queues keep data automatically ordered by importance.

This helps in real-time decision making like task scheduling or emergency handling.

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