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

示例:

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

解題思路

對於多路歸併排列，我們可以使用優先佇列解決。我們首先想到的解法是，依次將list中的ListNode彈出，然後一次新增到一個優先佇列中，最後將優先佇列中ListNode依次彈出，並且新增到result中即可。

class Solution(object):
    def mergeKLists
 
(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        import heapq 
        result = ListNode(-1)
        cur = result
        p = list()
        for i in lists:
            while i:
                heapq.heappush(p, (i.val, i))
                i = i.next

        while
 
 p:
            cur.next = heapq.heappop(p)[1]
            cur = cur.next

        return result.next

要注意的是上述寫法只可以在python2下使用，在python3中會出現錯誤

TypeError: unorderable types: ListNode() < ListNode()

為什麼呢？

當對一個tuple排序時，python會從0開始對兩個tuple的成員依次比較，如果兩個成員相同就再比較下一個成員。問題中的tuple很有趣，前兩個連結串列的第一項比較結果都相同（1），於是python開始比較第二個成員，第二個成員是一個ListNode

，沒有比較方法，在處理這個問題上py2和py3有了差異，py2隨機瞎排，py3則是丟擲異常。

一種解決辦法是我們重寫一個ListNode，給他新增__lt__方法。我這裡使用了另外的一種解決思路，就是在tuple中再新增一個元素。(￣▽￣)”

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        import heapq 
        result = ListNode(-1)
        cur = result
        p = list()
        x = 0
        for i in lists:
            while i:
                heapq.heappush(p, (i.val, x, i))
                i = i.next
                x += 1

        while p:
            cur.next = heapq.heappop(p)[1]
            cur = cur.next

        return result.next

另外我們也可以這樣做。

首先將list中的每個連結串列比較首元素，然後依次加入優先佇列（或者一個堆，我這裡使用堆）

q : 1  1  2
    |  |  |
    4  3  6
    |  |
    5  4

然後判斷這個優先佇列是否為空，不為空，我們彈出隊首元素（1），接著判斷這個彈出的元素作為一個連結串列節點，其後是否還有元素，如果有元素，將元素加入佇列。同時將結果加入到result中

q : 1  2  4
    |  |  |
    3  6  5
    |
    4

result: 1

接著我們通過這個思路寫出如下程式碼

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        import heapq
        result = ListNode(-1)
        cur = result
        p = list()
        for i in lists:
            if i:
                heapq.heappush(p, (i.val, i))

        while len(p) > 0:
            cur.next = heapq.heappop(p)[1]
            cur = cur.next
            if cur.next:
                heapq.heappush(p, (cur.next.val, cur.next))

        return result.next

這裡的程式碼同樣會出現第一種情況下的問題，所以也可以按照之前的解決方法解決這個問題。

當然你可以先將所有元素加入到一個普通的佇列中，然後通過sorted(list, key=lambda x : x.val)排序，對這個排好序的list，我們還要將它串成一個連結串列。

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