20210417 [leetcode] 合并K个升序链表

https://leetcode-cn.com/problems/merge-k-sorted-lists/

方法1 分治

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        def merge2lists(l1,l2):
            if not l1 or not l2:
                return l1 if l1 else l2 
            
            ans = ListNode(0)
            head = ans 
            p1, p2 = l1, l2 
            while p1 and p2:
                if p1.val >= p2.val:
                    ans.next = p2 
                    p2 = p2.next 
                else:
                    ans.next = p1 
                    p1 = p1.next 
                ans = ans.next 
            ans.next = p1 if p1 else p2 
            return head.next 

        def merge(lists, l, r):
            if l == r : return lists[l]
            
            mid = l + (r - l) // 2
           
            return merge2lists(merge(lists,l, mid), merge(lists, mid+1, r))
            # return None

        if len(lists) == 0:
            return None
        return merge(lists, 0, len(lists)-1)

方法2 最小堆

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        import heapq
        dummy=ListNode(0)
        p = dummy
        q = []
        for i in range(len(lists)):
            if lists[i]:
                heapq.heappush(q, (lists[i].val, i))
                lists[i] = lists[i].next 
        
        while q:
            min_value, min_index = heapq.heappop(q)
            p.next = ListNode(min_value)
            p = p.next 
            if lists[min_index]:
                heapq.heappush(q,(lists[min_index].val, min_index))
                lists[min_index] = lists[min_index].next 
        return dummy.next