solve problem Top K Frequent Elements

Author: P-ppc

README.md

@@ -315,6 +315,7 @@ All solutions will be accepted!
 |71|[Simplify Path](https://leetcode-cn.com/problems/simplify-path/description/)|[java/py/js](./algorithms/SimplifyPath)|Medium|
 |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|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/TopKFrequentElements/README.md

@@ -0,0 +1,2 @@
+# Top K Frequent Elements
+We can solve this problem by heap and hashmap

algorithms/TopKFrequentElements/Solution.java

@@ -0,0 +1,36 @@
+class Solution {
+    class Frequency {
+        int value;
+        int frequency;
+        
+        Frequency(int value, int frequency) {
+            this.value = value;
+            this.frequency = frequency;
+        }
+    }
+        
+    public List<Integer> topKFrequent(int[] nums, int k) {
+        Map<Integer, Integer> frequencyMap = new HashMap<Integer, Integer>();
+        for (int num : nums) {
+            if (frequencyMap.get(num) == null)
+                frequencyMap.put(num, 1);
+            else
+                frequencyMap.put(num, frequencyMap.get(num) + 1);
+        }
+        
+        Comparator<Frequency> frequencyComparator = new Comparator<Frequency>() {
+            public int compare(Frequency a, Frequency b) {
+                return a.frequency > b.frequency ? -1 : (a.frequency == b.frequency ? 0 : 1);
+            }
+        };
+        Queue<Frequency> queue = new PriorityQueue<Frequency>(frequencyComparator);
+        for (int key : frequencyMap.keySet()) {
+            queue.add(new Frequency(key, frequencyMap.get(key)));
+        }
+        
+        List<Integer> res = new ArrayList<Integer>();
+        for (int i = 0; i < k; i++)
+            res.add(queue.poll().value);
+        return res;
+    }
+}

algorithms/TopKFrequentElements/solution.js

@@ -0,0 +1,78 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function(nums, k) {
+    let frequencyMap = new Map()
+    nums.forEach(num => {
+        if (!frequencyMap.has(num))
+            frequencyMap.set(num, 1)
+        else
+            frequencyMap.set(num, frequencyMap.get(num) + 1)
+    })
+    
+    let maxHeap = new MaxHeap()
+    for (let [key, value] of frequencyMap.entries()) 
+        maxHeap.push(key, value)
+    
+    let res = []
+    for (let i = 0; i < k; i++)
+        res.push(maxHeap.pop())
+    return res
+};
+
+function MaxHeap() {
+    this.heap = []
+};
+
+MaxHeap.prototype.push = function(item, priority) {
+    this.heap.push({item, priority})
+    let pos = this.heap.length - 1,
+        pPos = (pos % 2 == 0 ? pos - 2 : pos - 1) / 2
+    
+    while (pPos >= 0 && priority > this.heap[pPos].priority) {
+        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
+    }
+};
+
+MaxHeap.prototype.size = function() {
+    return this.heap.length
+};
+
+MaxHeap.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().item
+    
+    let item = this.heap[0].item,
+        pos = 0,
+        maxChildPos = pos * 2 + 2
+    this.heap[0] = this.heap.pop()
+    
+    if (maxChildPos < size - 1)
+        maxChildPos = this.heap[maxChildPos].priority > this.heap[maxChildPos - 1].priority ? maxChildPos : maxChildPos - 1
+    else
+        maxChildPos = maxChildPos - 1 < size - 1 ? maxChildPos - 1 : pos
+    
+    while (maxChildPos < size - 1 && this.heap[pos].priority < this.heap[maxChildPos].priority) {
+        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)
+            maxChildPos = this.heap[maxChildPos].priority > this.heap[maxChildPos - 1].priority ? maxChildPos : maxChildPos - 1
+        else
+            maxChildPos = maxChildPos - 1 < size - 1 ? maxChildPos - 1 : pos
+    }
+    
+    return item
+};

algorithms/TopKFrequentElements/solution.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def topKFrequent(self, nums, k):
+        """
+        :type nums: List[int]
+        :type k: int
+        :rtype: List[int]
+        """
+        frequency_map = {}
+        for num in nums:
+            if not frequency_map.get(num):
+                frequency_map[num] = 1
+            else:
+                frequency_map[num] += 1
+        
+        heap = []
+        for key, value in frequency_map.items():
+            heap.append({ 'value': key, 'frequency': value })
+            
+        return [x['value'] for x in heapq.nlargest(k, heap, lambda e : e['frequency'])]
+