Top K Frequent Elements Using Heap in DSA Typescript - 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

↓

Heapify

↓

Extract k elements from heap

↓

Return top k frequent elements

Count frequencies, keep a min-heap of size k for top frequencies, then extract results.

Execution Sample

DSA Typescript

const topKFrequent = (nums: number[], k: number): number[] => {
  const freqMap = new Map<number, number>();
  nums.forEach(n => freqMap.set(n, (freqMap.get(n) || 0) + 1));
  const heap: [number, number][] = [];
  // heap operations omitted for brevity
  return heap.map(([freq, num]) => num);
};

Counts frequencies of numbers, uses a min-heap to keep top k frequent elements, returns them.

Execution Table

Step	Operation	Element Processed	Heap Size	Heap Content (freq,num)	Visual State
1	Count frequency of 1	1	0	[]	freqMap={1:1}
2	Count frequency of 1	1	0	[]	freqMap={1:2}
3	Count frequency of 2	2	0	[]	freqMap={1:2,2:1}
4	Count frequency of 3	3	0	[]	freqMap={1:2,2:1,3:1}
5	Add (1,2) to heap	2	1	[(1,2)]	Heap=[(freq=1,num=2)]
6	Add (2,1) to heap	1	2	[(1,2),(2,1)]	Heap=[(freq=1,num=2),(freq=2,num=1)]
7	Add (1,3) to heap	3	3	[(1,2),(2,1),(1,3)]	Heap=[(freq=1,num=2),(freq=2,num=1),(freq=1,num=3)]
8	Heap size > k=2, remove min	-	2	[(1,3),(2,1)]	Removed (1,2), Heap=[(freq=1,num=3),(freq=2,num=1)]
9	Extract elements from heap	-	2	[(1,3),(2,1)]	Top k elements: [3,1]
10	Return result	-	-	[3,1]	Final output: [3,1]

💡 All elements processed and heap contains 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	After Step 8	Final
freqMap	{}	{1:1}	{1:2}	{1:2,2:1}	{1:2,2:1,3:1}	{1:2,2:1,3:1}	{1:2,2:1,3:1}	{1:2,2:1,3:1}	{1:2,2:1,3:1}	{1:2,2:1,3:1}
heap	[]	[]	[]	[]	[(1,2)]	[(1,2),(2,1)]	[(1,2),(2,1),(1,3)]	[(1,3),(2,1)]	[(1,3),(2,1)]	[(1,3),(2,1)]

Key Moments - 3 Insights

Why do we remove the smallest frequency element when heap size exceeds k?

Because we want to keep only the top k frequent elements. The heap is a min-heap by frequency, so the smallest frequency is at the root. Removing it keeps the heap size at k and ensures only the largest frequencies remain (see Step 8 in execution_table).

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

Using a min-heap of size k lets us efficiently discard less frequent elements. If a new element has frequency higher than the min (root), we replace it. This keeps the heap small and focused on top frequencies (see Steps 5-8).

What happens if k is equal to the number of unique elements?

The heap will contain all unique elements without removals, so all frequencies are kept. The heap size never exceeds k, so no removals occur (see Steps 5-7).

Visual Quiz - 3 Questions

Look at the execution_table at Step 8, which element is removed from the heap?

A (1,2)

B (1,3)

C (2,1)

D (3,1)

💡 Hint

Check the 'Heap Content' and 'Visual State' columns at Step 8.

At which step does the heap first reach size k=2?

A Step 5

B Step 6

C Step 7

D Step 8

💡 Hint

Look at the 'Heap Size' column in execution_table.

If the frequency of element 3 was 3 instead of 1, how would the heap content change after Step 7?

A Heap would contain (3,3) and (1,2)

B Heap would contain (1,3) and (2,1)

C Heap would contain (3,3) and (2,1)

D Heap would contain (1,2) and (2,1)

💡 Hint

Higher frequency elements replace smaller ones in the min-heap (see key_moments about heap behavior).

Concept Snapshot

Top K Frequent Elements Using Heap:
- Count frequencies of elements.
- Use a min-heap of size k to track top frequencies.
- Add elements to heap; if size > k, remove smallest frequency.
- Extract elements from heap for result.
- Efficient for large input with many duplicates.

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 keeps only the k elements with the highest frequencies. When adding a new element, if the heap is smaller than k, we add it directly. If the heap is full and the new element's frequency is higher than the smallest frequency in the heap, we remove the smallest and add the new one. Finally, we extract the elements from the heap to get the top k frequent numbers. The execution table tracks each step, showing frequency counts, heap size, and heap content. Key moments explain why we use a min-heap and why we remove the smallest frequency element when the heap is full. The quiz tests understanding of heap operations and frequency counting.

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 remove duplicates from the list

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

Solution

1. Step 1: Understand the problem goal

   The goal is to find the K elements that appear most frequently in a list.

2. Step 2: Role of heap in this context

   A heap helps efficiently keep track of the top K elements by frequency without sorting the entire list.

3. Final Answer:

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

4. Quick Check:

   Heap = Efficient top K tracking [OK]

Hint: Heap keeps top K elements efficiently by frequency [OK]

Common Mistakes:

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

2. Which of the following TypeScript code snippets correctly initializes a min-heap to store pairs of [frequency, element] for the Top K Frequent Elements problem?

easy

A. const minHeap = new MinPriorityQueue<{freq: number, val: number}>({priority: x => x.freq});

B. const minHeap = new Array();

C. const minHeap = new Map();

D. const minHeap = new Set<[number, number]>();

Solution

1. Step 1: Identify correct heap initialization syntax

   TypeScript with modern libraries uses MinPriorityQueue with a priority function for min-heap.

2. Step 2: Check each option

   const minHeap = new MinPriorityQueue<{freq: number, val: number}>({priority: x => x.freq}); correctly creates a min-heap with priority based on frequency. Others are arrays, maps, or sets which do not provide heap behavior.

3. Final Answer:

   const minHeap = new MinPriorityQueue<{freq: number, val: number}>({priority: x => x.freq}); -> Option A

4. Quick Check:

   MinPriorityQueue with priority function = correct heap [OK]

Hint: Use MinPriorityQueue with priority function for min-heap [OK]

Common Mistakes:

• Using Array instead of heap
• Using Map or Set which are not heaps
• Missing priority function in heap initialization

3. What will be the output of the following TypeScript code snippet for nums = [1,1,1,2,2,3] and k = 2?

function topKFrequent(nums: number[], k: number): number[] {
  const freqMap = new Map();
  for (const num of nums) {
    freqMap.set(num, (freqMap.get(num) || 0) + 1);
  }
  const minHeap = new MinPriorityQueue<{val: number, freq: number}>({priority: x => x.freq});
  for (const [num, freq] of freqMap.entries()) {
    minHeap.enqueue({val: num, freq});
    if (minHeap.size() > k) {
      minHeap.dequeue();
    }
  }
  const result = [];
  while (minHeap.size() > 0) {
    result.push(minHeap.dequeue().element.val);
  }
  return result.reverse();
}
console.log(topKFrequent([1,1,1,2,2,3], 2));

medium

A. [3, 2]

B. [1, 2]

C. [2, 1]

D. [1, 3]

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 (1,3), (2,2), (3,1). When size > 2, remove smallest freq. So 3 with freq 1 is removed.

3. Step 3: Extract elements from heap and reverse

   Heap contains (1,3) and (2,2). Extracted order reversed gives [1, 2].

4. Final Answer:

   [1, 2] -> Option B

5. Quick Check:

   Top 2 frequent = [1, 2] [OK]

Hint: Keep heap size ≤ k, remove smallest frequency [OK]

Common Mistakes:

• Not reversing result array
• Removing wrong element from heap
• Confusing frequency counts

4. Identify the bug in the following TypeScript code for finding top K frequent elements:

function topKFrequent(nums: number[], k: number): number[] {
  const freqMap = new Map();
  for (const num of nums) {
    freqMap.set(num, freqMap.get(num) + 1);
  }
  const minHeap = new MinPriorityQueue<{val: number, freq: number}>({priority: x => x.freq});
  for (const [num, freq] of freqMap.entries()) {
    minHeap.enqueue({val: num, freq});
    if (minHeap.size() > k) {
      minHeap.dequeue();
    }
  }
  const result = [];
  while (minHeap.size() > 0) {
    result.push(minHeap.dequeue().element.val);
  }
  return result.reverse();
}

medium

A. Map should be replaced with Set

B. minHeap.dequeue() removes wrong element

C. freqMap.get(num) + 1 causes error when num not in map

D. result.reverse() is unnecessary

Solution

1. Step 1: Check frequency map update line

   freqMap.get(num) returns undefined if num not present, so undefined + 1 causes NaN.

2. Step 2: Correct way to update frequency

   Use freqMap.get(num) || 0 to default to 0 if undefined, then add 1.

3. Final Answer:

   freqMap.get(num) + 1 causes error when num not in map -> Option C

4. Quick Check:

   Undefined + 1 = NaN error [OK]

Hint: Use (freqMap.get(num) || 0) + 1 to avoid undefined [OK]

Common Mistakes:

• Not handling undefined in map get
• Removing wrong element from heap
• Thinking reverse is unnecessary
• Replacing Map with Set incorrectly

5. Given a large array nums 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 heap with priority comparing frequency first, then element value to break ties

B. Sort the entire array before building the heap

C. Use a max-heap instead of a min-heap without tie-break logic

D. Ignore tie cases as they do not affect the result

Solution

1. Step 1: Understand tie frequency problem

   When multiple elements share frequency, we want consistent ordering by element value.

2. Step 2: Modify heap priority to handle ties

   Use a comparator that first compares frequency, then element value to break ties, ensuring smallest elements come first.

3. Step 3: Why other options fail

   Sorting entire array is inefficient; max-heap without tie-break can give inconsistent results; ignoring ties causes unpredictable output.

4. Final Answer:

   Use a heap with priority comparing frequency first, then element value to break ties -> Option A

5. Quick Check:

   Priority with tie-break = correct tie handling [OK]

Hint: Add tie-break by element value in heap priority [OK]

Common Mistakes:

• Sorting entire array wastes time
• Ignoring tie-break leads to wrong output
• Using max-heap without tie-break causes inconsistency