solve problem Top K Frequent Words

P-ppc · P-ppc · commit 9c94dc5f72c2 · 2018-11-14T22:26:06.000+08:00
diff --git a/README.md b/README.md
@@ -316,6 +316,7 @@ All solutions will be accepted!
 |451|[Sort Characters By Frequency](https://leetcode-cn.com/problems/sort-characters-by-frequency/description/)|[java/py/js](./algorithms/SortCharactersByFrequency)|Medium|
 |215|[Kth Largest Element In An Array](https://leetcode-cn.com/problems/kth-largest-element-in-an-array/description/)|[java/py/js](./algorithms/KthLargestElementInAnArray)|Medium|
 |347|[Top K Frequent Elements](https://leetcode-cn.com/problems/top-k-frequent-elements/description/)|[java/py/js](./algorithms/TopKFrequentElements)|Medium|
+|692|[Top K Frequent Words](https://leetcode-cn.com/problems/top-k-frequent-words/description/)|[java/py/js](./algorithms/TopKFrequentWords)|Medium|
 
 # Database
 |#|Title|Solution|Difficulty|
diff --git a/algorithms/TopKFrequentWords/README.md b/algorithms/TopKFrequentWords/README.md
@@ -0,0 +1,2 @@
+# Top K Frequent Words
+We can solve this problem by max heap and hashmap, like [Top K Frequent Elements](./TopKFrequentElements)
diff --git a/algorithms/TopKFrequentWords/Solution.java b/algorithms/TopKFrequentWords/Solution.java
@@ -0,0 +1,36 @@
+class Solution {
+    class Frequency {
+        String word;
+        int frequency;
+        
+        Frequency(String word, int frequency) {
+            this.word = word;
+            this.frequency = frequency;
+        }
+    }
+    
+    public List<String> topKFrequent(String[] words, int k) {
+        Map<String, Integer> frequencyMap = new HashMap<String, Integer>();
+        for (String word : words) {
+            if (frequencyMap.get(word) == null)
+                frequencyMap.put(word, 1);
+            else
+                frequencyMap.put(word, frequencyMap.get(word) + 1);
+        }
+        
+        Comparator<Frequency> frequencyComparator = new Comparator<Frequency>() {
+            public int compare(Frequency a, Frequency b) {
+                return a.frequency > b.frequency ? -1 : (a.frequency == b.frequency ? a.word.compareTo(b.word) : 1);
+            }
+        };
+        Queue<Frequency> queue = new PriorityQueue<Frequency>(frequencyComparator);
+        for (String word : frequencyMap.keySet()) {
+            queue.add(new Frequency(word, frequencyMap.get(word)));
+        }
+        
+        List<String> res = new ArrayList<String>();
+        for (int i = 0; i < k; i++)
+            res.add(queue.poll().word);
+        return res;
+    }
+}
diff --git a/algorithms/TopKFrequentWords/solution.js b/algorithms/TopKFrequentWords/solution.js
@@ -0,0 +1,88 @@
+/**
+ * @param {string[]} words
+ * @param {number} k
+ * @return {string[]}
+ */
+var topKFrequent = function(words, k) {
+    let frequencyMap = new Map()
+    words.forEach(word => {
+        if (!frequencyMap.has(word))
+            frequencyMap.set(word, 1)
+        else
+            frequencyMap.set(word, frequencyMap.get(word) + 1)
+    })
+    
+    let maxFrequencyHeap = new MaxFrequencyHeap()
+    for (let [word, frequency] of frequencyMap.entries()) 
+        maxFrequencyHeap.push(word, frequency)
+    
+    let res = []
+    for (let i = 0; i < k; i++)
+        res.push(maxFrequencyHeap.pop())
+    return res
+};
+
+function MaxFrequencyHeap() {
+    this.heap = []
+};
+
+MaxFrequencyHeap.prototype.push = function(word, frequency) {
+    this.heap.push({word, frequency})
+    let pos = this.heap.length - 1,
+        pPos = (pos % 2 == 0 ? pos - 2 : pos - 1) / 2
+    
+    while (pPos >= 0 && (frequency > this.heap[pPos].frequency || 
+                        (frequency == this.heap[pPos].frequency &&
+                         word < this.heap[pPos].word))) {
+        let temp = this.heap[pos]
+        this.heap[pos] = this.heap[pPos]
+        this.heap[pPos] = temp
+        pos = pPos
+        pPos = (pos % 2 == 0 ? pos - 2 : pos - 1) / 2
+    }
+};
+
+MaxFrequencyHeap.prototype.size = function() {
+    return this.heap.length
+};
+
+MaxFrequencyHeap.prototype.pop = function() {
+    let size = this.size()
+    if (size == 0)
+        throw new Error('pop form empty list')
+    else if (size == 1)
+        return this.heap.pop().word
+    
+    let word = this.heap[0].word,
+        pos = 0,
+        maxChildPos = pos * 2 + 2
+    this.heap[0] = this.heap.pop()
+    
+    if (maxChildPos < size - 1) {
+        if (this.heap[maxChildPos].frequency < this.heap[maxChildPos - 1].frequency ||
+           (this.heap[maxChildPos].frequency == this.heap[maxChildPos - 1].frequency &&
+            this.heap[maxChildPos].word > this.heap[maxChildPos - 1].word))
+            maxChildPos = maxChildPos - 1
+    } else
+        maxChildPos = maxChildPos - 1 < size - 1 ? maxChildPos - 1 : pos
+    
+    while (maxChildPos < size - 1 && (this.heap[pos].frequency < this.heap[maxChildPos].frequency ||
+                                     (this.heap[pos].frequency == this.heap[maxChildPos].frequency &&
+                                      this.heap[pos].word > this.heap[maxChildPos].word))) {
+        let temp = this.heap[maxChildPos]
+        this.heap[maxChildPos] = this.heap[pos]
+        this.heap[pos] = temp
+        pos = maxChildPos
+        maxChildPos = pos * 2 + 2
+        
+        if (maxChildPos < size - 1) {
+            if (this.heap[maxChildPos].frequency < this.heap[maxChildPos - 1].frequency ||
+               (this.heap[maxChildPos].frequency == this.heap[maxChildPos - 1].frequency &&
+                this.heap[maxChildPos].word > this.heap[maxChildPos - 1].word))
+                maxChildPos = maxChildPos - 1
+        } else
+            maxChildPos = maxChildPos - 1 < size - 1 ? maxChildPos - 1 : pos
+    }
+    
+    return word
+};
diff --git a/algorithms/TopKFrequentWords/solution.py b/algorithms/TopKFrequentWords/solution.py
@@ -0,0 +1,75 @@
+class Solution(object):
+    class MaxFrequencyHeap(object):
+        def __init__(self):
+            self.heap = []
+            
+        def push(self, word, frequency):
+            self.heap.append({ 'word': word, 'frequency':  frequency})
+            pos = self.size() - 1
+            p_pos = (pos - 2 if pos % 2 == 0 else pos - 1) / 2
+            
+            while p_pos >= 0 and (frequency > self.heap[p_pos]['frequency'] or \
+                                  (frequency == self.heap[p_pos]['frequency'] and word < self.heap[p_pos]['word'])):
+                self.heap[pos], self.heap[p_pos] = self.heap[p_pos], self.heap[pos]
+                pos = p_pos
+                p_pos = (pos - 2 if pos % 2 == 0 else pos - 1) / 2
+        
+        def size(self):
+            return len(self.heap)
+        
+        def pop(self):
+            size = self.size()
+            if size == 0:
+                raise IndexError('pop form empty list')
+            elif size == 1:
+                return self.heap.pop()['word']
+            
+            word = self.heap[0]['word']
+            self.heap[0] = self.heap.pop()            
+            pos = 0
+            max_child_pos = pos * 2 + 2
+            if max_child_pos < size - 1:
+                if self.heap[max_child_pos]['frequency'] < self.heap[max_child_pos - 1]['frequency'] \
+                or (self.heap[max_child_pos]['frequency'] == self.heap[max_child_pos - 1]['frequency'] and \
+                   self.heap[max_child_pos]['word'] > self.heap[max_child_pos - 1]['word']):
+                    max_child_pos = max_child_pos - 1
+            else:
+                max_child_pos = max_child_pos - 1 if max_child_pos - 1 < size - 1 else pos
+                
+            while max_child_pos < size - 1 and (self.heap[pos]['frequency'] < self.heap[max_child_pos]['frequency'] or \
+                                                (self.heap[pos]['frequency'] == self.heap[max_child_pos]['frequency'] and \
+                                                self.heap[pos]['word'] > self.heap[max_child_pos]['word'])):
+                self.heap[pos], self.heap[max_child_pos] = self.heap[max_child_pos], self.heap[pos]
+                pos = max_child_pos
+                max_child_pos = pos * 2 + 2
+                if max_child_pos < size - 1:
+                    if self.heap[max_child_pos]['frequency'] < self.heap[max_child_pos - 1]['frequency'] \
+                    or (self.heap[max_child_pos]['frequency'] == self.heap[max_child_pos - 1]['frequency'] and \
+                       self.heap[max_child_pos]['word'] > self.heap[max_child_pos - 1]['word']):
+                        max_child_pos = max_child_pos - 1
+                else:
+                    max_child_pos = max_child_pos - 1 if max_child_pos - 1 < size - 1 else pos
+                
+            return word
+        
+    def topKFrequent(self, words, k):
+        """
+        :type words: List[str]
+        :type k: int
+        :rtype: List[str]
+        """
+        frequency_map = {}
+        for word in words:
+            if not frequency_map.get(word):
+                frequency_map[word] = 1
+            else:
+                frequency_map[word] += 1
+                
+        max_frequency_heap = self.MaxFrequencyHeap()
+        for word, frequency in frequency_map.items():
+            max_frequency_heap.push(word, frequency)
+        
+        res = []
+        for i in xrange(k):
+            res.append(max_frequency_heap.pop())
+        return res

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+# Top K Frequent Words`
	`2`	`+We can solve this problem by max heap and hashmap, like [Top K Frequent Elements](./TopKFrequentElements)`