Top K Frequent Words - Practice Coding Problems

Input & Output

Example 1 — Basic Case

$ Input: words = ["i","love","leetcode","i","love","coding"], k = 2

› Output: ["i","love"]

💡 Note: "i" and "love" both appear 2 times (highest frequency). Since they have same frequency, lexicographical order doesn't matter between them, but both beat "leetcode" and "coding" which appear only once.

Example 2 — Lexicographical Tiebreaker

$ Input: words = ["the","day","is","sunny","the","the","the","sunny","is","is"], k = 4

› Output: ["the","is","sunny","day"]

💡 Note: "the" appears 4 times, "is" appears 3 times, "sunny" appears 2 times, "day" appears 1 time. All have different frequencies so lexicographical order within same frequency doesn't apply here.

Example 3 — Same Frequency Sorting

$ Input: words = ["i","love","coding"], k = 2

› Output: ["coding","i"]

💡 Note: All words appear once, so we sort lexicographically: "coding" < "i" < "love". Taking first 2 gives ["coding","i"].

Constraints

1 ≤ words.length ≤ 500
1 ≤ k ≤ number of unique words
words[i] consists of lowercase English letters only
1 ≤ words[i].length ≤ 10

Visualization

Tap to expand

Understanding the Visualization

Input

Array of words and k value

Count & Sort

Count frequencies, then sort by custom rules

Output

Return top k words in proper order

Key Takeaway

🎯 Key Insight: Custom sorting with (-frequency, word) handles both criteria elegantly

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is using a custom comparator that handles both frequency (descending) and lexicographical order (ascending) for ties. The optimal approach uses frequency counting with hash map followed by custom sorting, achieving O(n + m log m) time where m is unique words. A min-heap approach with O(n log k) is better for small k values.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Count and Sort	O(n log n)	O(n)	Count frequencies, create list of all words, sort everything, take first k
Min Heap (Priority Queue)	O(n log k)	O(k)	Use min-heap to maintain only the top k words, avoiding need to sort all words
Hash Map + Custom Sort	O(n + m log m)	O(m)	Count frequencies with hash map, then sort only unique words efficiently

Brute Force Count and Sort — Algorithm Steps

Step 1: Count frequency of each word using hash map
Step 2: Create list of all (word, frequency) pairs
Step 3: Sort entire list by custom comparator
Step 4: Take first k words from sorted list

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Build hash map of word counts

Sort All Words

Sort by frequency desc, then lexicographically

Take Top K

Return first k words from sorted list

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_LEN 20

typedef struct {
    char word[MAX_LEN];
    int freq;
} WordCount;

int compare(const void* a, const void* b) {
    WordCount* wa = (WordCount*)a;
    WordCount* wb = (WordCount*)b;
    if (wa->freq != wb->freq) {
        return wb->freq - wa->freq; // Higher frequency first
    }
    return strcmp(wa->word, wb->word); // Lexicographical order
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse words array
    char words[MAX_WORDS][MAX_LEN];
    int wordCount = 0;
    
    char* ptr = strchr(line, '[');
    ptr++; // Skip [
    char* end = strchr(ptr, ']');
    *end = '\0';
    
    char* token = strtok(ptr, ",");
    while (token != NULL && wordCount < MAX_WORDS) {
        // Remove quotes and spaces
        while (*token == ' ' || *token == '"') token++;
        int len = strlen(token);
        while (len > 0 && (token[len-1] == ' ' || token[len-1] == '"')) {
            token[len-1] = '\0';
            len--;
        }
        strcpy(words[wordCount], token);
        wordCount++;
        token = strtok(NULL, ",");
    }
    
    int k;
    scanf("%d", &k);
    
    // Count frequencies
    WordCount counts[MAX_WORDS];
    int uniqueCount = 0;
    
    for (int i = 0; i < wordCount; i++) {
        int found = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (strcmp(words[i], counts[j].word) == 0) {
                counts[j].freq++;
                found = 1;
                break;
            }
        }
        if (!found) {
            strcpy(counts[uniqueCount].word, words[i]);
            counts[uniqueCount].freq = 1;
            uniqueCount++;
        }
    }
    
    // Sort by frequency and lexicographically
    qsort(counts, uniqueCount, sizeof(WordCount), compare);
    
    // Print result
    printf("[");
    for (int i = 0; i < k; i++) {
        printf("\"%s\"", counts[i].word);
        if (i < k - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Counting takes O(n), sorting all unique words takes O(m log m) where m ≤ n

⚡ Linearithmic

Space Complexity

O(n)

Hash map stores up to n entries, plus list for sorting

⚡ Linearithmic Space

89.6K Views

High Frequency

~15 min Avg. Time

1.8K 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 Count and Sort — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler