Top K Frequent Words
Problem Description
Given an array of strings words and an integer k, return the k most frequent strings.
Return the answer sorted by the frequency from highest to lowest. Sort the words with the same frequency by their lexicographical order.
Example 1:
Input: words = ["i","love","leetcode","i","love","coding"], k = 2
Output: ["i","love"]
Explanation: "i" and "love" are the two most frequent words.
Note that "i" comes before "love" due to a lower alphabetical order.
Example 2:
Input: words = ["the","day","is","sunny","the","the","the","sunny","is","is"], k = 4
Output: ["the","is","sunny","day"]
Explanation: "the", "is", "sunny" and "day" are the four most frequent words, with the number of occurrence being 4, 3, 2 and 1 respectively.
Constraints:
1 <= words.length <= 5001 <= words[i].length <= 10words[i]consists of lowercase English letters.kis in the range[1, The number ofuniquewords[i]]
Follow-up: Could you solve it in O(n log(k)) time and O(n) extra space?
Solve it on LeetCode
Approaches
1. Frequency Map with Sorting
Intuition:
The main idea is to count the frequency of each word and then sort them by frequency. Since we need the top k frequent words, we can sort the entries and select the first k elements. As words with identical frequencies should be in alphabetical order, we ensure that in our sort function.
Steps:
- Use a hashmap to count the frequency of each word.
- Convert the hashmap into a list of entries (word and frequency pairs).
- Sort the list with a custom comparator:
- First, by decreasing frequency.
- Second, lexicographically in case of a tie in frequency.
- Extract the first k elements from the sorted list.
Code:
- Time Complexity: O(N log N), where N is the number of unique words. Sorting the list of words dictates the complexity.
- Space Complexity: O(N), where N is the number of unique words (storing in hashmap and list).
2. Min-Heap
Intuition:
A min-heap can efficiently help maintain the k most frequent elements, especially when we need to sort by frequency primarily. The idea is to always maintain k elements in the heap and eject elements when the heap grows beyond k, ensuring that the heap contains the most frequent words.
Steps:
- Count the frequency of each word using a hashmap.
- Use a PriorityQueue (min-heap) to maintain the k highest frequency words.
- When adding new elements to the heap of size more than k, remove the smallest frequency word.
- Use a custom comparator to sort by frequency and lexicographical order for words with the same frequency.
- Extract elements from the heap to form the result list.
Code:
- Time Complexity: O(N log k), as we perform heap operations (insertions/deletions) proportional to the number of unique words, where each operation takes O(log k).
- Space Complexity: O(N), for storing the hashmap and the heap potentially containing all unique words.