leetcode 23. 合并K个排序链表

1. 题目链接 https://leetcode-cn.com/problems/merge-k-sorted-lists/

2. 题目描述

   1. 合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

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

3. 解题思路

   1. 分治法： 将lists分为左右两部分，分别对左右两部分进行合并，再对返回结果进行合并
   2. 堆：维护一个长度为k的堆，堆的元素为链表的头结点，每次从堆中取出值最小的节点，加入到一个新链表中，然后将最小节点的下一个节点放入堆中

4. 代码

   1. 分治

      class Solution:
          def mergeKLists(self, lists):
              n = len(lists)
              if n == 1:
                  return lists[0]
              if n == 0:
                  return None
              mid = n // 2
              left = self.mergeKLists(lists[:mid])
              right = self.mergeKLists(lists[mid:])
              res = ListNode(0)
              head = res
              while left and right:
                  if left.val < right.val:
                      left, res.next = left.next, left
                  else:
                      right, res.next = right.next, right
                  res = res.next
      
              res.next = left or right or None
      
              return head.next

       

   2. 堆

         class Solution:
          def mergeKLists(self, lists):
      
              n = len(lists)
              if n == 1:
                  return lists[0]     if not lists:
                  return None
              import heapq
              heap = [(l.val, l) for l in lists]
              heapq.heapify(heap)
      
              res = ListNode(0)
              cur = res
              while heap:
                  _min = heapq.heappop()[1]
                  cur.next, _min = _min, _min.next
                  if _min:
                      heapq.heappush(heap, (_min.val, _min))
                  cur = cur.next
              return res.next