Top K Frequent Elements Using Heap in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a min heap array for storing elements.

DSA C

int minHeap[[1]];

Drag options to blanks, or click blank then click option'

Ak

Bn

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using n instead of k for heap size.

The min heap size should be equal to k, the number of top frequent elements to find.

2fill in blank

medium

Complete the code to push an element into the min heap.

DSA C

void push(int val) {
    minHeap[size] = val;
    int i = size;
    size++;
    while (i > 0 && freq[minHeap[i]] < freq[minHeap[1]]) {
        int parent = (i - 1) / 2;
        int temp = minHeap[i];
        minHeap[i] = minHeap[parent];
        minHeap[parent] = temp;
        i = parent;
    }
}

Drag options to blanks, or click blank then click option'

A0

Bi

Csize

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing with wrong index like i or size.

We compare the current element with its parent to maintain heap property.

3fill in blank

hard

Fix the error in the code to pop the smallest element from the min heap.

DSA C

int pop() {
    int root = minHeap[0];
    minHeap[0] = minHeap[size - 1];
    size--;
    int i = 0;
    while (2 * i + 1 < size) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int smallest = left;
        if (right < size && freq[minHeap[right]] < freq[minHeap[1]]) {
            smallest = right;
        }
        if (freq[minHeap[i]] <= freq[minHeap[smallest]])
            break;
        int temp = minHeap[i];
        minHeap[i] = minHeap[smallest];
        minHeap[smallest] = temp;
        i = smallest;
    }
    return root;
}

Drag options to blanks, or click blank then click option'

Aleft

Bright

Ci

Dsize

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing right child with wrong index like right or i.

We compare right child with left child to find the smaller one.

4fill in blank

hard

Fill both blanks to build a frequency map and insert elements into the min heap.

DSA C

for (int i = 0; i < n; i++) {
    freq[nums[i]] = freq[nums[i]] + 1;
}
for (int key = 0; key < maxKey; key++) {
    if (freq[key] > 0) {
        if (size < [1]) {
            push(key);
        } else if (freq[key] > freq[minHeap[0]]) {
            pop();
            push(key);
        }
    }
}
return minHeap[[2]];

Drag options to blanks, or click blank then click option'

Ak

Bsize - 1

C0

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong heap size or wrong index for min element.

We insert until heap size reaches k, then compare with minHeap root at index 0.

5fill in blank

hard

Fill all three blanks to extract top k frequent elements from the min heap into result array.

DSA C

int result[[1]];
for (int i = [2]; i >= 0; i--) {
    result[i] = pop();
}
return result;

Drag options to blanks, or click blank then click option'

Ak

Bk - 1

C0

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Looping forward instead of backward.

Wrong array size.

Result array size is k. Loop from k-1 down to 0 to fill result in reverse order.

Practice

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

easy

A. To efficiently find and maintain the top K frequent elements

B. To sort all elements in ascending order

C. To store elements without any order

D. To remove duplicates from the list

Solution

1. Step 1: Understand the role of heap in frequency problems

   A heap helps keep track of the most frequent elements efficiently by allowing quick access to the smallest or largest frequency element.

2. Step 2: Identify why heap is used for top K elements

   Using a min-heap of size K allows us to maintain only the top K frequent elements, removing less frequent ones as we go.

3. Final Answer:

   To efficiently find and maintain the top K frequent elements -> Option A

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
• Using heap to remove duplicates
• Ignoring frequency counts in heap

2. Which of the following is the correct way to declare a min-heap in C++ using the standard library for storing pairs of (frequency, element)?

easy

A. priority_queue minHeap;

B. priority_queue> minHeap;

C. priority_queue, vector>, greater>> minHeap;

D. priority_queue, vector>, less>> minHeap;

Solution

1. Step 1: Understand C++ priority_queue syntax for min-heap

   By default, priority_queue is a max-heap. To make it min-heap, we use greater comparator.

2. Step 2: Check the correct template parameters

   We need a priority_queue of pairs, with vector as container, and greater> as comparator for min-heap.

3. Final Answer:

   priority_queue, vector>, greater>> minHeap; -> Option C

4. Quick Check:

   Min-heap = priority_queue with greater comparator [OK]

Hint: Use greater comparator for min-heap in priority_queue [OK]

Common Mistakes:

• Using default priority_queue which is max-heap
• Wrong comparator like less instead of greater
• Incorrect container type in priority_queue

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

#include 
#include 
#include 

int main() {
    int nums[] = {1,1,1,2,2,3};
    int freq[4] = {0};
    for(int i=0; i<6; i++) freq[nums[i]]++;
    int k = 2;
    int result[2];
    int idx = 0;
    for(int i=1; i<=3; i++) {
        if(idx < k) {
            result[idx++] = i;
        } else {
            int min_idx = 0;
            for(int j=1; j freq[result[min_idx]]) result[min_idx] = i;
        }
    }
    for(int i=0; i

medium

A. 3 2

B. 1 3

C. 2 3

D. 1 2

Solution

1. Step 1: Count frequencies of elements

   nums = {1,1,1,2,2,3} so freq[1]=3, freq[2]=2, freq[3]=1.

2. Step 2: Select top 2 frequent elements using simple logic

   Initially result = {1,2}. For i=3, freq[3]=1 is less than min freq in result (which is freq[2]=2), so no replacement.

3. Final Answer:

   1 2 -> Option D

4. Quick Check:

   Top 2 frequent = 1 and 2 [OK]

Hint: Count frequencies, keep top K by comparing min freq [OK]

Common Mistakes:

• Confusing element values with frequencies
• Replacing elements incorrectly in result array
• Ignoring initial filling of result array

4. Identify the bug in the following code snippet that tries to find top 3 frequent elements using a min-heap approach:

#include 
#include 
#include <queue>
#include <vector>
#include <unordered_map>
using namespace std;

int main() {
    vector<int> nums = {4,4,4,6,6,7,7,7,7};
    unordered_map freq;
    for(auto n : nums) freq[n]++;
    priority_queue, vector>, greater>> minHeap;
    int k = 3;
    for(auto it : freq) {
        minHeap.push({it.second, it.first});
        if(minHeap.size() > k) minHeap.pop();
    }
    while(!minHeap.empty()) {
        printf("%d ", minHeap.top().second);
        minHeap.pop();
    }
    return 0;
}

medium

A. The condition to pop from heap should be if size >= k, not > k

B. The output order is reversed; elements print from least to most frequent

C. The min-heap should store (element, frequency) pairs, not (frequency, element)

D. The frequency map is not initialized correctly

Solution

1. Step 1: Understand min-heap stores (frequency, element)

   Min-heap keeps smallest frequency on top, so popping prints from least to most frequent.

2. Step 2: Identify output order issue

   Printing while popping will print elements from lowest to highest frequency, not top frequent first.

3. Final Answer:

   The output order is reversed; elements print from least to most frequent -> Option B

4. Quick Check:

   Min-heap pop order = ascending frequency [OK]

Hint: Min-heap pops smallest first, so output order is reversed [OK]

Common Mistakes:

• Confusing pair order in heap
• Wrong pop condition for heap size
• Ignoring output order from heap pops

5. Given an array nums = {5,3,1,1,1,3,73,1} and k = 2, which approach correctly finds the top K frequent elements using a heap and handles ties properly?

hard

A. Use a min-heap of size k with (frequency, element) pairs, replacing when frequency is higher

B. Use a hash map only without any heap

C. Sort the array and pick the last k elements

D. Use a min-heap of (frequency, element) pairs and pop k times

Solution

1. Step 1: Count frequencies of elements

   Frequencies: 1->4, 3->2, 5->1, 73->1.

2. Step 2: Use min-heap of size k to keep top frequent elements

   Insert pairs (freq, element). If heap size exceeds k, pop smallest frequency. This keeps top k frequent elements efficiently.

3. Step 3: Handle ties by frequency naturally in heap

   Elements with same frequency are handled by heap order; ties do not break correctness.

4. Final Answer:

   Use a min-heap of size k with (frequency, element) pairs, replacing when frequency is higher -> Option A

5. Quick Check:

   Min-heap size k keeps top frequent elements [OK]

Hint: Min-heap size k keeps top frequent elements, replacing lower freq [OK]

Common Mistakes:

• Using max-heap and popping k times without size limit
• Sorting array instead of frequencies
• Ignoring heap for frequency tracking