給定一個非空的整數陣列，返回其中出現頻率前 k 高的元素。

例如，

給定陣列 [1,1,1,2,2,3] , 和 k = 2，返回 [1,2]。

注意：

• 你可以假設給定的 k 總是合理的，1 ≤ k ≤ 陣列中不相同的元素的個數。
• 你的演算法的時間複雜度必須優於 O(n log n) , n 是陣列的大小。

解題思路

這個問題的思路很簡單，首先建立一個木桶陣列，遍歷目標陣列，將資料放到木桶陣列中

1 : 1 1 1
2 : 2 2
3 : 3

我這裡的木桶陣列是通過dict實現的

class Solution:
    def topKFrequent(self, nums, k)
 
:
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
        count_list = dict()
        result = list()
        for i in nums:
            count_list[i] = count_list.get(i, 0) + 1
        t = sorted(count_list.items(), key=lambda l : l[1] ,reverse=True
 
)
        for i in range(k):
            result.append(t[i][0])

        return result

但是這種做法的時間複雜度是O(nlog(n))，並沒有達到題目的要求。那麼我們還有什麼辦法，我們可以使用一個priority_queue來儲存這k個元素，通過遍歷陣列，比較陣列中元素出現的頻率，然後實現入隊，出隊操作。

class Solution:
    def topKFrequent(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
 
   
        from queue import PriorityQueue
        count_list = dict()
        for i in nums:
            count_list[i] = count_list.get(i, 0) + 1

        p = PriorityQueue()
        for i in count_list.items():
            if p.qsize() == k:# 判斷優先佇列長度是否滿足k
                if i[1] > p[0]:# bug
                    p.get()
                    p.put((i[1], i[0]))# 通過 (頻率,元素) 形式儲存
            else:
                p.put((i[1], i[0]))

        result = list()
        while not p.empty():
            _, v = p.get()
            result.append(v)

        return result

如你所見，上述程式碼是有問題的，我們無法通過index訪問PriorityQueue的元素。所以我們只能換個方法，可以使用heapq代替。

class Solution:
    def topKFrequent(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """   
        import heapq
        count_list = dict()
        for i in nums:
            count_list[i] = count_list.get(i, 0) + 1

        p = list()
        for i in count_list.items():
            if len(p) == k:
                if i[1] > p[0][0]:
                    heapq.heappop(p)
                    heapq.heappush(p, (i[1], i[0]))
            else:
                heapq.heappush(p, (i[1], i[0]))

        return [i[1] for i in p]

我們現在這個演算法的時間複雜度變成了O(nlog(k))。但是既然我們使用了heapq，那麼我們還有一種更加簡潔的寫法。

class Solution:
    def topKFrequent(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """   
        import heapq
        count_list = dict()
        for i in nums:
            count_list[i] = count_list.get(i, 0) + 1

        p = list()
        for i in count_list.items():
            heapq.heappush(p, (i[1], i[0]))

        return [i[1] for i in heapq.nlargest(k, p)]

但是這種寫法的時間複雜度比上面那種要高，因為我們在維護堆的時候，不再是維護k大小的堆，而是維護n大小的堆。

這個演算法還有缺陷，當我們的n == k的時候，演算法的時間複雜度就和第一種做法是一樣的了，還有沒有更好地解法？

我們可以把這個問題分開考慮，對與n > k，我們依舊使用上述的演算法，而對於n < k，我們就要想有什麼好的解法了。其實也很簡單，我們要清楚我們的PriorityQueue中裝的是什麼，我們通過維護一個n - k大小的PriorityQueue就可以實現。

我們想到的做法就是，維護一個n - k大小的最大堆，當進來一個元素，我們就將最大的那個元素彈出到result中即可。但是在python裡面我們的heapq沒法像c++中那樣可以修改比較函式，我們可以怎麼做呢？

class Solution:
    def topKFrequent(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """   
        import heapq
        count_list = dict()
        for i in nums:
            count_list[i] = count_list.get(i, 0) + 1

        p = list()
        result = list()
        for i in count_list.items():
            heapq.heappush(p, (-i[1], -i[0]))# tricks
            if len(p) > len(count_list) - k:
                _, val = heapq.heappop(p)
                result.append(-val)

        return result

一個更pythonic的解法

class Solution:
    def topKFrequent(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
        from collections import Counter
        return [item[0] for item in Counter(nums).most_common(k)]     

如有問題，希望大家指出！！！