Top K Frequent Elements Using Heap in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Top K Frequent Elements Using Min-Heap

What is the output of the following TypeScript code that finds the top 2 frequent elements using a min-heap?

DSA Typescript

function topKFrequent(nums: number[], k: number): number[] {
  const freqMap = new Map<number, number>();
  for (const num of nums) {
    freqMap.set(num, (freqMap.get(num) ?? 0) + 1);
  }

  const heap: [number, number][] = [];

  for (const [num, freq] of freqMap.entries()) {
    if (heap.length < k) {
      heap.push([num, freq]);
      heap.sort((a, b) => a[1] - b[1]);
    } else if (freq > heap[0][1]) {
      heap[0] = [num, freq];
      heap.sort((a, b) => a[1] - b[1]);
    }
  }

  return heap.map(pair => pair[0]);
}

console.log(topKFrequent([1,1,1,2,2,3], 2));

A [3, 2]

B [2, 3]

C [1, 3]

D [1, 2]

💡 Hint

Count frequencies first, then keep only top k elements in a min-heap sorted by frequency.

The frequencies are: 1 -> 3 times, 2 -> 2 times, 3 -> 1 time. The top 2 frequent elements are 1 and 2. The heap keeps the smallest frequency at the root, so after processing all, it contains [1,3] and [2,2]. The output extracts the numbers only.

❓ Predict Output

intermediate

Output of Top K Frequent Elements with Different Input

What is the output of this TypeScript function call for top 3 frequent elements?

DSA Typescript

function topKFrequent(nums: number[], k: number): number[] {
  const freqMap = new Map<number, number>();
  for (const num of nums) {
    freqMap.set(num, (freqMap.get(num) ?? 0) + 1);
  }

  const heap: [number, number][] = [];

  for (const [num, freq] of freqMap.entries()) {
    if (heap.length < k) {
      heap.push([num, freq]);
      heap.sort((a, b) => a[1] - b[1]);
    } else if (freq > heap[0][1]) {
      heap[0] = [num, freq];
      heap.sort((a, b) => a[1] - b[1]);
    }
  }

  return heap.map(pair => pair[0]);
}

console.log(topKFrequent([4,4,4,6,6,7,7,7,7,8], 3));

A [6, 7, 4]

B [7, 4, 6]

C [7, 8, 6]

D [4, 7, 8]

💡 Hint

Check frequencies: 4 appears 3 times, 6 appears 2 times, 7 appears 4 times, 8 appears once.

Frequencies: 7 -> 4, 4 -> 3, 6 -> 2, 8 -> 1. Top 3 are 7, 4, and 6. The heap keeps the smallest frequency at root, so after processing all, it contains these three numbers.

🔧 Debug

advanced

Identify the Error in Heap Implementation for Top K Frequent Elements

What error will occur when running this TypeScript code to find top 2 frequent elements?

DSA Typescript

function topKFrequent(nums: number[], k: number): number[] {
  const freqMap = new Map<number, number>();
  for (const num of nums) {
    freqMap.set(num, freqMap.get(num) + 1);
  }

  const heap: [number, number][] = [];

  for (const [num, freq] of freqMap.entries()) {
    if (heap.length < k) {
      heap.push([num, freq]);
      heap.sort((a, b) => a[1] - b[1]);
    } else if (freq > heap[0][1]) {
      heap[0] = [num, freq];
      heap.sort((a, b) => a[1] - b[1]);
    }
  }

  return heap.map(pair => pair[0]);
}

console.log(topKFrequent([1,1,2,2,2,3], 2));

A TypeError: Cannot read property '1' of undefined

B TypeError: Cannot read property 'get' of undefined

C TypeError: Cannot read property '1' of null

D TypeError: Cannot read property 'get' of null

💡 Hint

Check how freqMap.get(num) is used before adding 1.

The code does freqMap.get(num) + 1 without checking if freqMap.get(num) is undefined initially. This causes undefined + 1 which is NaN, but then freqMap.set(num, NaN) is stored. Later, sorting or comparisons cause TypeError when accessing undefined elements.

❓ Predict Output

advanced

Output of Top K Frequent Elements Using Max-Heap Simulation

What is the output of this TypeScript code that simulates a max-heap by sorting descending?

DSA Typescript

function topKFrequent(nums: number[], k: number): number[] {
  const freqMap = new Map<number, number>();
  for (const num of nums) {
    freqMap.set(num, (freqMap.get(num) ?? 0) + 1);
  }

  const sorted = Array.from(freqMap.entries()).sort((a, b) => b[1] - a[1]);

  return sorted.slice(0, k).map(pair => pair[0]);
}

console.log(topKFrequent([5,5,5,6,6,7,7,7,7,8,8,8], 4));

A [7, 5, 8, 6]

B [5, 7, 8, 6]

C [7, 8, 5, 6]

D [8, 7, 5, 6]

💡 Hint

Count frequencies and sort descending by frequency.

Frequencies: 7 -> 4, 5 -> 3, 8 -> 3, 6 -> 2. Sorted descending: 7(4), 5(3), 8(3), 6(2). Top 4 are [7,5,8,6].

🧠 Conceptual

expert

Why Use a Min-Heap Instead of Max-Heap for Top K Frequent Elements?

Which reason best explains why a min-heap of size k is preferred over a max-heap of all elements when finding top k frequent elements?

A A min-heap sorts all elements in ascending order, which is faster than max-heap sorting.

B A max-heap cannot be implemented efficiently in TypeScript, so min-heap is the only option.

C A min-heap of size k keeps only the k largest frequencies efficiently, reducing memory and time complexity.

D A min-heap automatically removes duplicates, which max-heap does not.

💡 Hint

Think about how to keep track of only the top k elements without sorting all.

Using a min-heap of size k allows us to keep track of the k largest frequencies by always removing the smallest frequency when a larger one appears. This reduces memory usage and improves performance compared to sorting all elements or using a max-heap of all 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