Top K Frequent Elements

Input & Output

Example 1 — Basic Case

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

› Output: [1,2]

💡 Note: Element 1 appears 3 times, element 2 appears 2 times, element 3 appears 1 time. The 2 most frequent elements are 1 and 2.

Example 2 — Single Element

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

› Output: [1]

💡 Note: Only one element exists, so it's the most frequent by default.

Example 3 — Multiple Same Frequency

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

› Output: [1,2]

💡 Note: Both elements appear once, so both are equally frequent. Return both in any order.

Constraints

1 ≤ nums.length ≤ 10⁵
k is in the range [1, number of unique elements in the array]
-10⁴ ≤ nums[i] ≤ 10⁴
Follow up: Your algorithm's time complexity must be better than O(n log n)

Visualization

Tap to expand

Asked in

G Google 65 a Amazon 58 f Facebook 42 M Microsoft 38 🍎 Apple 25

The key insight is to use frequency counting with bucket sort for optimal O(n) performance. Count element frequencies, then use buckets indexed by frequency to avoid sorting. The bucket sort approach achieves O(n) time and meets the follow-up requirement.

Common Approaches

✓ Brute Force with Sorting

⏱️ Time: O(n log n) Space: O(n)

First count frequency of each element using a hash map. Then create pairs of (element, frequency), sort by frequency in descending order, and take the first k elements.

Bucket Sort (Optimal)

⏱️ Time: O(n) Space: O(n)

Count frequencies first, then create buckets where bucket[i] contains all elements with frequency i. Iterate from highest frequency bucket downward to collect k elements.

Min Heap Approach

⏱️ Time: O(n log k) Space: O(n + k)

Count frequencies first, then use a min heap of size k. For each element, if heap size < k, add it. Otherwise, if current frequency > heap top frequency, replace heap top.

Brute Force with Sorting — Algorithm Steps

Step 1: Count frequency of each element in hash map
Step 2: Create array of (element, frequency) pairs
Step 3: Sort pairs by frequency descending
Step 4: Extract first k elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Build hash map of element frequencies

Sort by Frequency

Sort all elements by their frequency

Take Top K

Extract first k elements from sorted list

Code -

solution.c — C

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

typedef struct {
    int value;
    int freq;
} FreqPair;

int compare(const void* a, const void* b) {
    FreqPair* pairA = (FreqPair*)a;
    FreqPair* pairB = (FreqPair*)b;
    return pairB->freq - pairA->freq; // Descending order
}

int* solution(int* nums, int numsSize, int k, int* returnSize) {
    // Simple frequency counting with arrays (assuming nums range is reasonable)
    int freq[20001] = {0}; // For nums in range [-10000, 10000]
    int offset = 10000;
    
    // Count frequencies
    for (int i = 0; i < numsSize; i++) {
        freq[nums[i] + offset]++;
    }
    
    // Create array of frequency pairs
    FreqPair* freqList = (FreqPair*)malloc(numsSize * sizeof(FreqPair));
    int uniqueCount = 0;
    
    for (int i = 0; i < 20001; i++) {
        if (freq[i] > 0) {
            freqList[uniqueCount].value = i - offset;
            freqList[uniqueCount].freq = freq[i];
            uniqueCount++;
        }
    }
    
    // Sort by frequency
    qsort(freqList, uniqueCount, sizeof(FreqPair), compare);
    
    // Extract first k elements
    int* result = (int*)malloc(k * sizeof(int));
    for (int i = 0; i < k; i++) {
        result[i] = freqList[i].value;
    }
    
    *returnSize = k;
    free(freqList);
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int nums[1000];
    int numsSize = 0;
    
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    if (start && end) {
        start++; // Skip [
        *end = '\0'; // Null terminate
        
        char* token = strtok(start, ",");
        while (token != NULL) {
            // Skip whitespace
            while (isspace(*token)) token++;
            nums[numsSize++] = atoi(token);
            token = strtok(NULL, ",");
        }
    }
    
    int k;
    scanf("%d", &k);
    
    int returnSize;
    int* result = solution(nums, numsSize, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to count frequencies + O(n log n) to sort unique elements

⚡ Linearithmic

Space Complexity

O(n)

Hash map stores up to n unique elements and their frequencies

⚡ Linearithmic Space

286.3K Views

Very High Frequency

~25 min Avg. Time

8.4K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler