Top K Frequent Elements - Practice Coding Problems

Input & Output

example_1.py — Basic case with clear frequencies

$ Input: nums = [1,1,1,2,2,3], k = 2

› Output: [1,2]

💡 Note: Element 1 appears 3 times (most frequent), element 2 appears 2 times (second most frequent), and element 3 appears 1 time. So the top 2 most frequent elements are 1 and 2.

example_2.py — Single element array

$ Input: nums = [1], k = 1

› Output: [1]

💡 Note: There's only one unique element, so it must be the most frequent (and only) element to return.

example_3.py — All elements have same frequency

$ Input: nums = [1,2,3,4,5], k = 3

› Output: [1,2,3] (or any 3 elements)

💡 Note: All elements appear exactly once, so any 3 elements form a valid answer since they all have the same frequency.

Visualization

Tap to expand

Understanding the Visualization

Count Song Plays

Like a radio station tracking how many times each song was played - use a hash map

Maintain Top K Chart

Instead of sorting all songs, use a min heap to efficiently maintain just the top k songs

Smart Filtering

When a new song is processed, only keep it if it's more popular than the least popular in our top k

Final Chart

Extract the k songs from our chart - these are the most frequent elements

Key Takeaway

🎯 Key Insight: Instead of sorting ALL songs by popularity (expensive), we maintain a small chart of just the top k songs using a min heap, making it perfect for scenarios where k is much smaller than the total number of unique elements!

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

O(n) to build frequency map + O(n log k) for heap operations (at most k elements in heap)

⚡ Linearithmic

Space Complexity

O(n + k)

O(n) for frequency map + O(k) for heap of size k

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
k is in the range [1, number of unique elements in the array]
-10⁴ ≤ nums[i] ≤ 10⁴
It is guaranteed that the answer is unique

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses a hash map to count element frequencies in O(n) time, then employs a min heap of size k to efficiently track the top k frequent elements in O(n log k) time. This avoids sorting all elements and achieves better performance when k is small compared to n.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map + Min Heap (Optimal)	O(n log k)	O(n + k)	Use hash map to count frequencies, then min heap to efficiently maintain top k elements
Brute Force (Count + Sort All)	O(n²)	O(n)	Count frequencies using nested loops, then sort all elements by frequency
Hash Map + Sorting	O(n log n)	O(n)	Build frequency map in first pass, then sort all frequencies to get top k

Hash Map + Min Heap (Optimal) — Algorithm Steps

Build frequency map by iterating through array once
Create a min heap to store the k most frequent elements
For each unique element, add to heap if size < k, or replace minimum if current frequency is higher
Extract all elements from heap as the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Frequency Map

Count frequencies: {1:3, 2:2, 3:1}

Process Element (1,3)

Add to empty heap: [(1,3)]

Process Element (2,2)

Add to heap: [(2,2), (1,3)]

Process Element (3,1)

Heap full, (3,1) < min(2,2), so skip

Extract Result

Heap contains top k=2: [2,1]

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 1000

typedef struct {
    int num;
    int count;
} FreqPair;

typedef struct {
    FreqPair data[MAX_SIZE];
    int size;
} MinHeap;

void heapifyUp(MinHeap* heap, int idx) {
    if (idx == 0) return;
    int parent = (idx - 1) / 2;
    if (heap->data[parent].count > heap->data[idx].count) {
        FreqPair temp = heap->data[parent];
        heap->data[parent] = heap->data[idx];
        heap->data[idx] = temp;
        heapifyUp(heap, parent);
    }
}

void heapifyDown(MinHeap* heap, int idx) {
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;
    int smallest = idx;
    
    if (left < heap->size && heap->data[left].count < heap->data[smallest].count)
        smallest = left;
    if (right < heap->size && heap->data[right].count < heap->data[smallest].count)
        smallest = right;
    
    if (smallest != idx) {
        FreqPair temp = heap->data[smallest];
        heap->data[smallest] = heap->data[idx];
        heap->data[idx] = temp;
        heapifyDown(heap, smallest);
    }
}

void heapPush(MinHeap* heap, FreqPair item) {
    heap->data[heap->size] = item;
    heapifyUp(heap, heap->size);
    heap->size++;
}

FreqPair heapPop(MinHeap* heap) {
    FreqPair result = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    if (heap->size > 0) {
        heapifyDown(heap, 0);
    }
    return result;
}

int* topKFrequent(int* nums, int numsSize, int k, int* returnSize) {
    // Build frequency map
    FreqPair freqPairs[MAX_SIZE];
    int uniqueCount = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int found = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (freqPairs[j].num == nums[i]) {
                freqPairs[j].count++;
                found = 1;
                break;
            }
        }
        if (!found) {
            freqPairs[uniqueCount].num = nums[i];
            freqPairs[uniqueCount].count = 1;
            uniqueCount++;
        }
    }
    
    // Use min heap to keep top k elements
    MinHeap heap = {.size = 0};
    
    for (int i = 0; i < uniqueCount; i++) {
        heapPush(&heap, freqPairs[i]);
        if (heap.size > k) {
            heapPop(&heap);
        }
    }
    
    // Extract elements from heap
    int* result = (int*)malloc(k * sizeof(int));
    for (int i = 0; i < k; i++) {
        result[i] = heapPop(&heap).num;
    }
    
    *returnSize = k;
    return result;
}

int main() {
    int nums[] = {1,1,1,2,2,3};
    int k = 2;
    int returnSize;
    int* result = topKFrequent(nums, 6, k, &returnSize);
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

O(n) to build frequency map + O(n log k) for heap operations (at most k elements in heap)

⚡ Linearithmic

Space Complexity

O(n + k)

O(n) for frequency map + O(k) for heap of size k

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
k is in the range [1, number of unique elements in the array]
-10⁴ ≤ nums[i] ≤ 10⁴
It is guaranteed that the answer is unique

42.8K Views

High Frequency

~15 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Map + Min Heap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler