Top K Frequent Elements Using Heap in DSA Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind using a heap to find the top K frequent elements?

Use a heap to keep track of the K elements with the highest frequency by pushing elements and popping the least frequent when size exceeds K.

beginner

What type of heap is commonly used to solve the Top K Frequent Elements problem efficiently?

A min-heap is used to keep the smallest frequency element at the top, so when the heap size exceeds K, the least frequent element can be removed.

beginner

Why do we use a frequency map before using the heap in this problem?

The frequency map counts how many times each element appears, which helps us know the frequency to compare when adding elements to the heap.

intermediate

In TypeScript, which data structure can be used to implement a min-heap for this problem?

A priority queue or a custom binary heap class can be implemented to act as a min-heap since TypeScript does not have a built-in heap.

intermediate

What is the time complexity of finding the top K frequent elements using a heap?

O(N log K), where N is the number of elements, because each element is pushed and popped from the heap of size K.

What does the heap store in the Top K Frequent Elements problem?

A Elements with their frequencies

B Only elements without frequency

C Only frequencies without elements

D Sorted list of all elements

The heap stores pairs of elements and their frequencies to compare and keep track of the top K frequent elements.

Why do we remove elements from the heap when its size exceeds K?

A To keep only the K most frequent elements

B To sort the elements

C To count frequencies

D To convert heap to array

Removing elements when heap size exceeds K ensures only the K elements with highest frequency remain.

Which data structure is used to count the frequency of elements before using the heap?

A Array

B Hash map or dictionary

C Stack

D Queue

A hash map or dictionary is used to count how many times each element appears.

What is the role of a min-heap in this problem?

A To sort elements alphabetically

B To keep the most frequent element on top

C To keep the least frequent element on top for easy removal

D To store all elements

The min-heap keeps the smallest frequency element on top so it can be removed when heap size exceeds K.

What is the overall time complexity of this approach?

A O(N)

B O(N^2)

C O(K log N)

D O(N log K)

Building the frequency map is O(N), and pushing/popping from a heap of size K for N elements is O(N log K).

Explain step-by-step how to find the top K frequent elements using a heap.

Think about counting first, then keeping only K elements with highest counts.

Describe why a min-heap is preferred over a max-heap for this problem.

Focus on how to efficiently keep only K elements.

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