Top K Frequent Elements Using Heap in DSA C++ - Execution Trace

Concept Flow - Top K Frequent Elements Using Heap

Count frequencies

→Build min-heap of size k

↓

For each element frequency

↓

If heap size < k

→Push element

↓

Else if current freq > min freq in heap

↓

Pop min freq

→Push current element

↓

After all elements processed

↓

Extract elements from heap

↓

Return top k frequent elements

Count how often each element appears, keep top k in a small heap, then extract them.

Execution Sample

DSA C++

vector<int> topKFrequent(vector<int>& nums, int k) {
  unordered_map<int,int> freq;
  for (int n : nums) freq[n]++;
  priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> minHeap;
  for (auto& [num, count] : freq) {
    if (minHeap.size() < k) minHeap.push({count, num});
    else if (count > minHeap.top().first) {
      minHeap.pop();
      minHeap.push({count, num});
    }
  }
  vector<int> result;
  while (!minHeap.empty()) {
    result.push_back(minHeap.top().second);
    minHeap.pop();
  }
  return result;
}

Finds the k most frequent numbers in the input list using a min-heap.

Execution Table

Step	Operation	Frequency Map	Heap Content (count,num)	Heap Size	Visual Heap State
1	Count frequencies from nums=[1,1,1,2,2,3]	{1:3, 2:2, 3:1}	[]	0	Empty heap
2	Process element 1 with freq=3	{1:3, 2:2, 3:1}	[(3,1)]	1	Heap: (3,1)
3	Process element 2 with freq=2	{1:3, 2:2, 3:1}	[(2,2),(3,1)]	2	Heap: (2,2) root, (3,1) child
4	Process element 3 with freq=1	{1:3, 2:2, 3:1}	[(2,2),(3,1)]	2	Freq 1 < min heap root 2, skip
5	Extract elements from heap	{1:3, 2:2, 3:1}	[(2,2),(3,1)]	2	Heap before extraction
6	Pop (2,2) from heap	{1:3, 2:2, 3:1}	[(3,1)]	1	Heap after popping (2,2)
7	Pop (3,1) from heap	{1:3, 2:2, 3:1}	[]	0	Heap empty after popping (3,1)
8	Return result [2,1]	{1:3, 2:2, 3:1}	[]	0	Final top k frequent elements

💡 All elements processed and heap extracted to get top k frequent elements

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	Final
freq	{}	{1:3,2:2,3:1}	{1:3,2:2,3:1}	{1:3,2:2,3:1}	{1:3,2:2,3:1}	{1:3,2:2,3:1}	{1:3,2:2,3:1}	{1:3,2:2,3:1}	{1:3,2:2,3:1}
minHeap	[]	[]	[(3,1)]	[(2,2),(3,1)]	[(2,2),(3,1)]	[(2,2),(3,1)]	[(3,1)]	[]	[]
result	[]	[]	[]	[]	[]	[]	[2]	[2,1]	[2,1]

Key Moments - 3 Insights

Why do we skip adding element 3 with frequency 1 to the heap?

Because the heap already has size k=2 and the smallest frequency in the heap is 2, which is greater than 1. So element 3 is less frequent and not included (see execution_table step 4).

Why do we use a min-heap instead of a max-heap?

A min-heap keeps the smallest frequency at the top, so when we find a more frequent element, we can remove the smallest frequency easily to keep only top k frequent elements (see concept_flow and execution_table steps 3-4).

How do we get the final top k elements from the heap?

We pop all elements from the min-heap after processing all frequencies, collecting their numbers into the result (see execution_table steps 5-8).

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the heap content?

A [(1,3),(2,2)]

B [(3,1)]

C [(2,2),(3,1)]

D []

💡 Hint

Check the 'Heap Content (count,num)' column at step 3 in execution_table

At which step does the heap skip adding an element due to lower frequency?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look for the step where the frequency is less than the min heap root in execution_table

If k was 3 instead of 2, how would the heap size change after processing all elements?

A Heap size would be 2

B Heap size would be 3

C Heap size would be 1

D Heap size would be 0

💡 Hint

Refer to variable_tracker row 'minHeap' and think about heap size relative to k

Concept Snapshot

Top K Frequent Elements Using Heap:
- Count frequencies of all elements
- Use a min-heap to keep top k frequent elements
- If heap size < k, push new element
- Else if new freq > min freq in heap, pop min and push new
- Extract elements from heap for result
- Efficient for large input with limited k

Full Transcript

This visualization shows how to find the top k frequent elements using a min-heap. First, we count how many times each number appears. Then, we build a min-heap that holds at most k elements with the highest frequencies. For each frequency, if the heap is not full, we add it. If it is full and the current frequency is bigger than the smallest in the heap, we remove the smallest and add the current one. After processing all, we pop all elements from the heap to get the top k frequent elements. The heap always keeps the smallest frequency on top to easily remove less frequent elements. This method is efficient and uses a small heap to track the top k frequencies.

Practice

1. What is the main purpose of using a heap in the Top K Frequent Elements problem?

easy

A. To efficiently keep track of the top k elements by frequency

B. To sort all elements in ascending order

C. To store elements without any order

D. To remove duplicates from the list

Solution

1. Step 1: Understand the problem goal

   The problem requires finding the k elements that appear most frequently.

2. Step 2: Role of heap in this context

   A heap helps efficiently keep track of the top k frequent elements by maintaining a structure where the smallest frequency is easily accessible and can be replaced if a more frequent element is found.

3. Final Answer:

   To efficiently keep track of the top k elements by frequency -> Option A

4. Quick Check:

   Heap = Efficient top k tracking [OK]

Hint: Heap keeps smallest frequency on top for quick replacement [OK]

Common Mistakes:

• Thinking heap sorts all elements fully
• Confusing heap with simple array storage
• Assuming heap removes duplicates

2. Which of the following C++ STL containers is best suited to implement a min-heap for the Top K Frequent Elements problem?

easy

A. std::vector with std::make_heap and std::pop_heap

B. std::list

C. std::map

D. std::queue

Solution

1. Step 1: Identify heap implementation in C++ STL

   C++ STL uses a vector with heap algorithms like std::make_heap, std::pop_heap, and std::push_heap to implement heaps.

2. Step 2: Check other container suitability

   std::list and std::queue do not support heap operations directly. std::map is a balanced tree, not a heap.

3. Final Answer:

   std::vector with std::make_heap and std::pop_heap -> Option A

4. Quick Check:

   Vector + heap algorithms = min-heap [OK]

Hint: Use vector + heap functions for heap in C++ [OK]

Common Mistakes:

• Choosing std::map thinking it is a heap
• Using std::queue which is FIFO, not heap
• Using std::list which lacks random access

3. What is the output of the following C++ code snippet for nums = {1,1,1,2,2,3} and k = 2?

std::vector<int> nums = {1,1,1,2,2,3};
int k = 2;
// Frequency map
std::unordered_map freq;
for (int n : nums) freq[n]++;

// Min heap to store pairs (frequency, element)
std::priority_queue, std::vector>, std::greater<>> minHeap;

for (auto& p : freq) {
    minHeap.push({p.second, p.first});
    if (minHeap.size() > k) minHeap.pop();
}

std::vector<int> result;
while (!minHeap.empty()) {
    result.push_back(minHeap.top().second);
    minHeap.pop();
}
std::reverse(result.begin(), result.end());
for (int x : result) std::cout << x << " ";

medium

A. 3 2

B. 2 3

C. 1 3

D. 1 2

Solution

1. Step 1: Calculate frequencies

   Frequencies: 1 -> 3 times, 2 -> 2 times, 3 -> 1 time.

2. Step 2: Use min heap to keep top 2 frequent elements

   Insert (3,1), (2,2), (1,3). When size exceeds 2, pop smallest frequency. After all insertions, heap contains (2,2) and (3,1).

3. Step 3: Extract and reverse result

   Extracting gives elements 2 and 1, reversed to 1 2.

4. Final Answer:

   1 2 -> Option D

5. Quick Check:

   Top 2 frequent = 1 and 2 [OK]

Hint: Heap keeps smallest freq; pop when size > k [OK]

Common Mistakes:

• Not reversing the result vector
• Confusing element and frequency in pairs
• Popping wrong element from heap

4. Identify the bug in this code snippet for finding top k frequent elements:

std::unordered_map freq;
for (int n : nums) freq[n]++;

std::priority_queue> maxHeap;
for (auto& p : freq) {
    maxHeap.push({p.second, p.first});
    if (maxHeap.size() > k) maxHeap.pop();
}

std::vector<int> result;
while (!maxHeap.empty()) {
    result.push_back(maxHeap.top().second);
    maxHeap.pop();
}

medium

A. Frequency map is not created correctly

B. Using maxHeap and popping when size > k removes most frequent elements

C. Result vector is not reversed before output

D. Priority queue should store only elements, not pairs

Solution

1. Step 1: Understand heap type and popping logic

   maxHeap stores pairs with highest frequency on top. Popping when size > k removes the top (most frequent) element, which is wrong.

2. Step 2: Correct approach

   Use a minHeap to keep smallest frequency on top and pop it when size > k, so top k frequent remain.

3. Final Answer:

   Using maxHeap and popping when size > k removes most frequent elements -> Option B

4. Quick Check:

   MaxHeap pop removes top freq, wrong for top k [OK]

Hint: Pop from minHeap, not maxHeap, to keep top k [OK]

Common Mistakes:

• Using maxHeap and popping top element
• Not reversing result vector if needed
• Ignoring frequency-element pair structure

5. Given a large input array with many elements having the same frequency, how can you modify the heap approach to ensure the Top K Frequent Elements always returns the smallest elements when frequencies tie? Choose the best approach.

hard

A. Use a hash map only without any heap

B. Use a max-heap ordered by frequency only

C. Use a min-heap ordered by frequency, then by element value descending

D. Sort the entire array before building the heap

Solution

1. Step 1: Understand tie-breaking requirement

   When frequencies tie, we want the smaller element to come first in the top k.

2. Step 2: Modify heap ordering

   Use a min-heap that orders pairs by frequency first, then by element value ascending to break ties correctly.

3. Step 3: Why other options fail

   Max-heap ignores tie-break order, sorting entire array is inefficient, and hash map alone cannot find top k efficiently.

4. Final Answer:

   Use a min-heap ordered by frequency, then by element value ascending -> Option C

5. Quick Check:

   Min-heap with tie-break by element value [OK]

Hint: Tie-break by element value in heap comparator [OK]

Common Mistakes:

• Ignoring tie-break condition in heap
• Sorting entire array wastes time
• Using hash map alone without heap