347. 前K個高頻元素

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

例如，

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

注意：

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

class Solution(object):
    def topKFrequent(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]

        output = sorted(Dict.items(),key=lambda e:e[1],reverse=True)
        final = [output[i][0] for i in range(k)]
        return final
        """
        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]))#最小堆
            if len(p) > len(count_list) - k:
                _, val = heapq.heappop(p)#返回 root 節點，即 heap 中最小的元素
                result.append(-val)

        return result
 

23. 合併K個排序連結串列

合併 k 個排序連結串列，返回合併後的排序連結串列。請分析和描述演算法的複雜度。

示例:

輸入:
[
  1->4->5,
  1->3->4,
  2->6
]
輸出: 1->1->2->3->4->4->5->6

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode

        res = []
        for i in lists:
            while i:
                res.append(i.val)
                i = i.next
        res.sort()
        return res

        """
        heap = []
        for ln in lists:
            if ln:
                heap.append((ln.val, ln))
        dummy = ListNode(0)
        cur = dummy
        heapq.heapify(heap)
        while heap:
            valu, ln_index = heapq.heappop(heap)
            cur.next = ln_index
            cur = cur.next
            if ln_index.next:
                heapq.heappush(heap, (ln_index.next.val, ln_index.next))
        return dummy.next