What is the Heap / Priority Queue pattern?

The Heap / Priority Queue pattern is a systematic approach to solving a class of coding interview problems. By recognizing the Heap / Priority Queue structure, you can solve problems in optimal time complexity using proven techniques.

When should I use the Heap / Priority Queue pattern?

Use the Heap / Priority Queue pattern when the problem structure matches its recognition signals — typically when brute force would be O(n²) or worse, and the pattern reduces complexity to O(n log k) for top-K.

What is the time complexity of Heap / Priority Queue?

The Heap / Priority Queue pattern typically runs in O(n log k) for top-K time and uses O(k) space. The exact complexity depends on the specific sub-variant being applied.

Is Heap / Priority Queue important for coding interviews?

Yes — the Heap / Priority Queue pattern is frequently tested at FAANG companies and competitive engineering interviews. Mastering this pattern gives you a reliable framework to solve many problem variations quickly.

How do I practice the Heap / Priority Queue pattern?

Start by studying the pattern's mental model and recognition signals on DSAPatterns, then practice the curated LeetCode problems below in order from Easy to Hard. Aim for pattern recognition before memorizing solutions.

← back to patterns

pattern / MEDIUM

Heap / Priority Queue.

Process elements by priority

complexity

time

O(n log k) for top-K

space

O(k)

practice questions

browse and solve all 0 pattern questions →

02' — visual

interactive

Sliding window — k = 3

Maximum sum subarray

Window

[0, 2]

Sum

Step

0 / 3

03'

mental
model.

Maintain a min-heap or max-heap. Operations: insert O(log n), extract-min/max O(log n), peek O(1).

Heap/Priority Queue is used when you need to repeatedly access the min or max element. Implemented as a binary heap.

when to use ✓

01Top K frequent elements
02Merge K sorted lists
03Find median from data stream
04Kth largest element

when not ✗

01When full sort is acceptable
02Random access needed

04'

recognition signals

Need to find top K elements

Need to find min/max repeatedly

Streaming data median

Dijkstra's algorithm

Top KK-way mergeTwo heaps medianSliding window median

05'

templates

python

1# Beginner: Fixed-size sliding window
2def max_sum_k(nums, k):
3   n = len(nums)
4   if n < k:
5      return 0
6   window_sum = sum(nums[:k])
7   max_sum = window_sum
8   for i in range(k, n):
9      window_sum += nums[i] - nums[i - k]
10      max_sum = max(max_sum, window_sum)
11   return max_sum

common mistakes

01Confusing min-heap and max-heap
02Wrong heap initialization
03Not handling empty heap

interview tips

01Use two heaps for median problems
02Master heapq in Python, PriorityQueue in Java
03Combine with hashmap for frequency-based problems

06'

practice this pattern

0 curated problems from LeetCode

See all

No questions found for this pattern yet.

07'

faq

1# Beginner: Fixed-size sliding window

2def max_sum_k(nums, k):

3 n = len(nums)

4 if n < k:

5 return 0

6 window_sum = sum(nums[:k])

7 max_sum = window_sum

8 for i in range(k, n):

9 window_sum += nums[i] - nums[i - k]

10 max_sum = max(max_sum, window_sum)

11 return max_sum