【每日一题】合并K个排序链表

2020.04.26

一道也是可以利用归并思想解决的题目。只是要在子函数想清楚，每次都要对链表操作。

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        if not lists:
            return 
        return self.divide(lists)
                
    def divide(self, lists):
        n = len(lists)
        if n == 1:
            return lists[0]
        mid = (n-1)//2
        left = self.divide(lists[:mid+1])
        right = self.divide(lists[mid+1:])
        lists_sort = self.meger(left,right)
        return lists_sort
    
    def meger(self, left, right): # 两个链表
        headl = left
        headr = right
        head = ans = ListNode(None)
        while headl and headr:
            if headl.val<headr.val:
                head.next = headl
                headl = headl.next
            else:
                head.next = headr
                headr = headr.next
            head = head.next
        if headl:
            head.next = headl
        if headr:
            head.next = headr
        return ans.next

另外一种值得借鉴的思路是利用堆维护一个优先队列。我们需要维护当前每个链表没有被合并的元素的最前面一个，k个链表就最多有 k个满足这样条件的元素，每次在这些元素里面选取 val 属性最小的元素合并到答案中。

def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        import heapq
        dummy = ListNode(0)
        p = dummy
        head = []
        for i in range(len(lists)):
            if lists[i] :
            # 这里，数组的头元素的值作为权值
                heapq.heappush(head, (lists[i].val, i))
                lists[i] = lists[i].next
        while head:
            val, idx = heapq.heappop(head)
            p.next = ListNode(val)
            p = p.next
            if lists[idx]:
                heapq.heappush(head, (lists[idx].val, idx))
                lists[idx] = lists[idx].next
        return dummy.next

时间复杂度同样也是$O(nk\log k)$