Why Top K Frequent Elements Using Heap in DSA Typescript?

The Big Idea

What if you could find the most popular things in a huge list without sorting everything?

The Scenario

Imagine you have a huge list of words from a book, and you want to find the top 3 most common words. Doing this by counting each word manually and sorting the entire list is like counting every grain of sand on a beach by hand.

The Problem

Manually counting frequencies and sorting all words takes a lot of time and effort, especially if the list is very large. It's easy to make mistakes, and sorting everything wastes time when you only want the top few.

The Solution

Using a heap helps you keep track of the top frequent words efficiently. Instead of sorting everything, the heap keeps only the most frequent words at the top, so you quickly find the top K without extra work.

Before vs After

✗ Before

const counts = new Map();
for (const word of words) {
  counts.set(word, (counts.get(word) || 0) + 1);
}
const sorted = [...counts.entries()].sort((a, b) => b[1] - a[1]);
const topK = sorted.slice(0, k).map(entry => entry[0]);

✓ After

const counts = new Map();
for (const word of words) {
  counts.set(word, (counts.get(word) || 0) + 1);
}
const minHeap = new MinHeap((a, b) => a.freq - b.freq);
for (const [word, freq] of counts.entries()) {
  minHeap.insert({word, freq});
  if (minHeap.size() > k) minHeap.extractMin();
}
const topK = minHeap.toArray().map(item => item.word);

What It Enables

This method lets you quickly find the most frequent items in huge data sets without wasting time sorting everything.

Real Life Example

Social media platforms use this to show trending hashtags by quickly finding the top used tags from millions of posts.

Key Takeaways

Manual counting and sorting is slow and error-prone for large data.

Heap keeps track of top K frequent elements efficiently.

Using a heap saves time and memory when only top results matter.

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