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

↓

Add element

↓

Else if frequency > min in heap

↓

Pop min, push new

↓

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#

int[] nums = {1,1,1,2,2,3};
int k = 2;
// Count frequencies
// Use min-heap to keep top k
// Extract results

Find top 2 frequent elements from the array using a min-heap.

Execution Table

Step	Operation	Element Frequency	Heap Before	Heap After	Visual Heap State
1	Count frequencies	{1:3, 2:2, 3:1}	[]	[]	[]
2	Add (1,3) to heap	1:3	[]	[(1,3)]	[(1,3)]
3	Add (2,2) to heap	2:2	[(1,3)]	[(1,3),(2,2)]	[(1,3),(2,2)]
4	Check (3,1), freq=1 < min freq=2	3:1	[(1,3),(2,2)]	[(1,3),(2,2)]	[(1,3),(2,2)] (no change)
5	Extract elements	-	[(1,3),(2,2)]	[]	Extracted: [1,2]
6	Return result	-	-	-	[1,2] (top k frequent elements)

💡 All elements processed and top k extracted from heap.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
freqMap	{}	{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	[]	[]	[(1,3)]	[(1,3),(2,2)]	[(1,3),(2,2)]	[]
result	[]	[]	[]	[]	[]	[1,2]

Key Moments - 3 Insights

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

Using a min-heap of size k keeps the smallest frequency at the top, so when a new element with higher frequency comes, we can remove the smallest and keep only top k frequent elements. See execution_table rows 3-4.

What happens if the frequency of a new element is less than the min frequency in the heap?

We do not add it to the heap because it is not among the top k frequent. This is shown in execution_table row 4 where (3,1) is ignored.

How do we get the final top k elements after processing all frequencies?

We extract all elements from the heap, which contains the top k frequent elements. See execution_table rows 5-6.

Visual Quiz - 3 Questions

Look at the execution_table at Step 3, what is the heap state after adding element (2,2)?

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

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

C [(1,3)]

D []

💡 Hint

Check the 'Heap After' column at Step 3 in execution_table.

At which step does the element (3,1) get ignored because its frequency is less than the min in the heap?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Look at the 'Operation' and 'Heap After' columns at Step 4.

If k was 1 instead of 2, what would be the final result array?

A [3]

B [2]

C [1]

D [1,2]

💡 Hint

Refer to variable_tracker 'result' final value and imagine heap size 1 keeping only highest frequency.

Concept Snapshot

Top K Frequent Elements Using Heap:
- Count frequencies of elements
- Use a min-heap of size k to track top k frequencies
- For each element frequency:
  - If heap size < k, add element
  - Else if frequency > min in heap, replace min
- Extract elements from heap for result

Full Transcript

This concept finds the top k frequent elements in an array using a min-heap. First, count how many times each element appears. Then, build a min-heap that holds at most k elements, where the smallest frequency is at the top. For each element frequency, if the heap has less than k elements, add it. Otherwise, if the new frequency is bigger than the smallest in the heap, remove the smallest and add the new one. After processing all elements, extract the heap elements to get the top k frequent elements. This approach efficiently keeps track of the most frequent elements without sorting all frequencies.

Practice

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

easy

A. To store elements without any order

B. To sort all elements in ascending order

C. To efficiently keep track of the top K elements by frequency

D. To remove duplicates from the list

Solution

1. Step 1: Understand the role of a heap

   A heap is a special tree-based data structure that helps efficiently find and maintain the largest or smallest elements.

2. Step 2: Apply heap to the problem context

   In the Top K Frequent Elements problem, a heap helps keep track of the K elements with the highest frequency without sorting the entire list.

3. Final Answer:

   To efficiently keep track of the top K elements by frequency -> Option C

4. Quick Check:

   Heap = Efficient top K tracking [OK]

Hint: Heap keeps top K elements efficiently without full sorting [OK]

Common Mistakes:

• Thinking heap sorts all elements fully
• Confusing heap with simple list or array
• Ignoring frequency importance

2. Which of the following C# code snippets correctly declares a min-heap using SortedSet for integers?

easy

A. var minHeap = new Stack<int>();

B. var minHeap = new List<int>();

C. var minHeap = new Dictionary();

D. var minHeap = new SortedSet<int>();

Solution

1. Step 1: Identify data structure for min-heap

   A min-heap can be implemented using a SortedSet in C# because it keeps elements sorted automatically.

2. Step 2: Check code correctness

   var minHeap = new SortedSet<int>(); declares a SortedSet<int>, which acts like a min-heap by keeping smallest element accessible.

3. Final Answer:

   var minHeap = new SortedSet<int>(); -> Option D

4. Quick Check:

   SortedSet = min-heap structure [OK]

Hint: Use SortedSet for min-heap in C# [OK]

Common Mistakes:

• Using List instead of a heap structure
• Confusing Dictionary with heap
• Using Stack which is LIFO, not heap

3. What will be the output of the following C# code snippet that finds top 2 frequent elements?

int[] nums = {1,1,1,2,2,3};
int k = 2;
var freq = new Dictionary();
foreach(var num in nums) freq[num] = freq.GetValueOrDefault(num, 0) + 1;
var heap = new SortedSet<(int freq, int num)>();
foreach(var pair in freq) {
    heap.Add((pair.Value, pair.Key));
    if(heap.Count > k) heap.Remove(heap.Min);
}
var result = heap.Select(x => x.num).ToList();
Console.WriteLine(string.Join(", ", result));

medium

A. 2, 1

B. 1, 2

C. 1, 3

D. 3, 2

Solution

1. Step 1: Count frequencies

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

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

   Heap keeps pairs (freq, num). It adds all pairs: (3,1), (2,2), (1,3). When size > 2, removes smallest freq (1,3). Leaving (2,2) and (3,1). SortedSet iterates in ascending order: (2,2), then (3,1).

3. Step 3: Output order

   Result list is created by selecting num from heap in ascending order of freq, so output is "2, 1".

4. Final Answer:

   2, 1 -> Option A

5. Quick Check:

   Top 2 frequent = 2, 1 [OK]

Hint: Keep heap size k, remove smallest freq when exceeded [OK]

Common Mistakes:

• Not removing smallest freq when heap size exceeds k
• Mixing element and frequency order
• Printing frequencies instead of elements

4. Identify the bug in this C# code snippet for top 1 frequent element:

int[] nums = {4,4,4,6,6,7};
int k = 1;
var freq = new Dictionary();
foreach(var num in nums) freq[num] = freq.GetValueOrDefault(num, 0) + 1;
var heap = new SortedSet<(int freq, int num)>();
foreach(var pair in freq) {
    heap.Add((pair.Value, pair.Key));
    if(heap.Count > k) heap.Remove(heap.Max);
}
var result = heap.Select(x => x.num).ToList();
Console.WriteLine(string.Join(", ", result));

medium

A. Removing heap.Max instead of heap.Min causes wrong elements removal

B. Dictionary initialization is incorrect

C. Using GetValueOrDefault causes runtime error

D. Heap should store only numbers, not frequency

Solution

1. Step 1: Understand heap removal logic

   Heap is a min-heap by frequency, so smallest freq is at Min, largest at Max.

2. Step 2: Identify incorrect removal

   Code removes heap.Max when size exceeds k, which removes the largest frequency element instead of smallest, causing wrong result.

3. Final Answer:

   Removing heap.Max instead of heap.Min causes wrong elements removal -> Option A

4. Quick Check:

   Remove heap.Min to keep top frequent [OK]

Hint: Remove heap.Min to keep top frequent elements [OK]

Common Mistakes:

• Removing heap.Max instead of heap.Min
• Confusing frequency and element order
• Not updating frequency dictionary correctly

5. Given the array nums = {5,3,1,1,1,3,73,1} and k = 2, which approach correctly returns the top 2 frequent elements using a heap in C#? A) Use a max-heap to store all elements and pop k times. B) Use a min-heap of size k to keep top frequent elements by frequency. C) Sort the array and pick last k elements. D) Use a queue to store elements and count frequencies later.

hard

A. Use a max-heap to store all elements and pop k times.

B. Use a min-heap of size k to keep top frequent elements by frequency.

C. Sort the array and pick last k elements.

D. Use a queue to store elements and count frequencies later.

Solution

1. Step 1: Understand frequency counting

   Count frequencies: 1 -> 4 times, 3 -> 2 times, 5 -> 1 time, 73 -> 1 time.

2. Step 2: Use min-heap of size k

   Use a min-heap to keep only top k frequent elements by frequency. When heap size exceeds k, remove smallest frequency element.

3. Step 3: Why other options fail

   A) Max-heap of all elements is inefficient. C) Sorting array doesn't group frequencies. D) Queue doesn't help frequency counting efficiently.

4. Final Answer:

   Use a min-heap of size k to keep top frequent elements by frequency. -> Option B

5. Quick Check:

   Min-heap size k = correct approach [OK]

Hint: Keep min-heap size k to track top frequent elements [OK]

Common Mistakes:

• Using max-heap for all elements wastes memory
• Sorting array ignores frequency counts
• Using queue without frequency map