Top K Frequent Words - Practice Coding Problems

Input & Output

example_1.py — Basic Case

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

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

💡 Note: "i" and "love" are the two most frequent words. Both appear 2 times each. Since they have the same frequency, we need to break ties lexicographically: "i" comes before "love" alphabetically.

example_2.py — Lexicographical Tie-breaking

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

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

💡 Note: "the": 4 times, "is": 3 times, "sunny": 2 times, "day": 1 time. All have different frequencies so lexicographical ordering only matters within same frequency groups.

example_3.py — All Same Frequency

$ Input: words = ["apple", "banana", "cherry"], k = 2

› Output: ["apple", "banana"]

💡 Note: All words appear exactly once, so we sort them lexicographically: "apple" < "banana" < "cherry", and take the first k=2.

Visualization

Tap to expand

Understanding the Visualization

Data Collection

Scan all posts and count hashtag frequencies, like a social media crawler

Smart Filtering

Use a priority system (heap) to keep track of only the top K trends, not all hashtags

Tie Breaking

When hashtags have the same popularity, display them alphabetically for consistency

Trending Page

Present the final top K trending hashtags in the correct order

Key Takeaway

🎯 Key Insight: Use a min-heap of size K to efficiently track top elements without sorting everything - just like how trending algorithms work in real social media platforms!

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) for counting + O(n) for bucketing + O(n) for collection

✓ Linear Growth

Space Complexity

O(n)

O(n) for frequency map + O(n) for buckets

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 500
1 ≤ k ≤ number of unique words
words[i] consists of lowercase English letters only
1 ≤ words[i].length ≤ 10
Follow-up: Could you solve it in O(n log k) time and O(n) extra space?

Asked in

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

The optimal approach uses either a min-heap of size K for O(n log k) time complexity, or bucket sort for O(n) time when frequency range is small. The key insight is that we don't need to sort all elements - we only need the top K, making heap-based solutions very efficient when K << number of unique words.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Count + Sort All)	O(n log n)	O(n)	Count frequencies, create pairs, sort everything, take first K
Hash Map + Priority Queue	O(n log k)	O(n)	Count frequencies first, then use priority queue to find top K
Bucket Sort (Optimal)	O(n)	O(n)	Use bucket sort based on frequencies for O(n) sorting

Brute Force (Count + Sort All) — Algorithm Steps

Count frequency of each word using a hash map
Create list of (word, frequency) pairs
Sort all pairs by frequency (desc) then lexicographically (asc)
Return first k words from sorted list

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Scan array and build frequency map

Create Pairs

Convert map to (word, frequency) pairs

Sort All

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>

typedef struct {
    char word[100];
    int freq;
} WordFreq;

int compare(const void *a, const void *b) {
    WordFreq *wf1 = (WordFreq*)a;
    WordFreq *wf2 = (WordFreq*)b;
    if (wf1->freq != wf2->freq) {
        return wf2->freq - wf1->freq; // freq desc
    }
    return strcmp(wf1->word, wf2->word); // lexicographical asc
}

char** topKFrequent(char** words, int wordsSize, int k, int* returnSize) {
    WordFreq pairs[1000];
    int uniqueCount = 0;
    
    // Count frequencies
    for (int i = 0; i < wordsSize; i++) {
        int found = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (strcmp(pairs[j].word, words[i]) == 0) {
                pairs[j].freq++;
                found = 1;
                break;
            }
        }
        if (!found) {
            strcpy(pairs[uniqueCount].word, words[i]);
            pairs[uniqueCount].freq = 1;
            uniqueCount++;
        }
    }
    
    // Sort
    qsort(pairs, uniqueCount, sizeof(WordFreq), compare);
    
    // Return first k words
    char** result = (char**)malloc(k * sizeof(char*));
    for (int i = 0; i < k; i++) {
        result[i] = (char*)malloc(strlen(pairs[i].word) + 1);
        strcpy(result[i], pairs[i].word);
    }
    *returnSize = k;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) for counting + O(n log n) for sorting all elements

⚡ Linearithmic

Space Complexity

O(n)

O(n) for hash map + O(n) for pairs list

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 500
1 ≤ k ≤ number of unique words
words[i] consists of lowercase English letters only
1 ≤ words[i].length ≤ 10
Follow-up: Could you solve it in O(n log k) time and O(n) extra space?

142.4K Views

High Frequency

~25 min Avg. Time

2.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Count + Sort All) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler