leetcode合并K个排序链表

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。
示例：
输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6
直接上代码：

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        list1=[]
        l1=l2=ListNode(0)
        for i in lists:
            while i:
                list1.append(i.val)
                i=i.next
        for j in sorted(list1):
            l1.next=ListNode(j)
            l1=l1.next
        return l2.next

这个思路是把所有的节点值存到一个列表里面，然后对列表排序，再把列表的值加入到新的链表中。

还有一种思路，用优先队列解决

class Solution:
    def mergeKLists(self, lists: [ListNode]) -> ListNode:
        k=len(lists)
        heap=[]
        pre=ListNode(0)#用于构成返回链表的头节点
        cur=pre
        node=ListNode(0)#用于访问lists的头节点
        for i in range(k):
            node.next=lists[i]
            while node.next:
                node = node.next
                heapq.heappush(heap,node.val)#存入堆的元素只能是数值,不能是链表的节点,所以是node.val
        while heap:
            b=heapq.heappop(heap) #拿出元素
            cur.next=ListNode(b)#将返回的int型变量转换为链表的结点型,然后不断先后
            cur=cur.next
        return pre.next

还有一种思路，两两合并：

class Solution:
    def judge(self, l1, l2):
        head = point = ListNode(0)
        while l1 and l2:
            if l1.val <= l2.val:
                point.next = l1
                l1 = l1.next
                point=point.next
            else:
                point.next = l2
                l2 = l2.next
                point=point.next
        point.next = l1 if l1 else l2
        return head.next
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        l = len(lists)
        if l==0:
            return 
        temp=lists[0]
        for i in range(1, l):
            temp= self.judge(temp, lists[i])
        return temp

不过这种算法效率太低，可以改进一下，将步长改为2，不断将合并后的两两链表继续合并。