原题如下：

1、选值法

笔者见到这个题第一时间想到的是归并排序，每次挑选出所有链表第一个节点中，全部最小的值（假设有n个），建立新链表。被选中的老链表节点后移一位，新链表生长n位。
例如:
[1->4->5，1->3->4，2->6]
（1）第一次选择后：
老链表：
[4->5，3->4，2->6]
新链表：
[1->1]
（2）第二次选择后：
老链表：
[4->5，3->4，6]
新链表：
[1->1->2]
。。。。。。
遇到空节点就删除，直到所有节点为空。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        ret=[]
        head=ListNode(0)
        h=head
        flag=1#用于标记是否有节点，只要存在一个节点，flag就为1
        while flag:
            mn=float("inf")#记录最小值
            flag=0
            index=0
            now=[]#记录所有本次循环找到最小值的节点下标index
            while index<len(lists):
                node=lists[index]
                if node:
                    flag=1
                    #print(mn,node.val)
                    if node.val<mn:
                        now=[index]
                        mn=node.val
                    elif node.val==mn:
                        now.append(index)
                    index+=1
                else:
                    lists.pop(index)
            if flag:
            	for t in now:
	                lists[t]=lists[t].next
	                #print(t.val,t.next.val)
	                temp=ListNode(mn)
	                head.next=temp
	                head=head.next
        return h.next

时间复杂度最坏为O（kn），k表示老链表的数目。
当老链表数目k接近所有节点数时，时间复杂度最坏为O（n2），原题测试样例中给出了最坏情况的样例（如下图），因此这份代码会超时。

这个神仙样例给了17页这种情形，代码复杂度拉到最大直接超时，笔者原地爆炸。

其实这里是比较好的方法，只是笔者思路偏差，只要做如下优化：
选值时可采用O（k）的空间建立堆，将所有链表第一个节点加入堆。这样时间复杂度为O（nlogk），读者可自行尝试（笔者优化时采用了其他思路，写博客的时候才发现这里直通最优复杂度）。

2、排序

（1）直接排序
针对这种情形，可以考虑讲所有节点记录下来，排序后建立链表。排序的时间复杂度为O(nlogn)。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
import heapq
class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        head=ListNode(0)
        h=head
        sort=[]
        index=0
        while index<len(lists):
            while lists[index]:
                sort.append(lists[index].val)
                lists[index]=lists[index].next
            index+=1
        sort.sort()
        while sort:
            temp=ListNode(sort.pop(0))
            head.next=temp
            head=head.next
        return h.next

这份代码超88%。

（2）堆排序
如果考虑使用堆排序。（这个地方其实没有必要，不如上面快，只是笔者写了，就分享出来）
（1）遍历每个节点，将所有节点加入最小堆，遍历时间复杂度O(n)，加入堆O(logn)，这一步整体为O(logn)。
（2）全部存完后再从小到大取出建立链表(O(logn))。
整个的时间复杂度仍为O(nlogn)。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
import heapq
class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        head=ListNode(0)
        h=head
        sort=[]
        index=0
        while index<len(lists):
            #print(lists[index].val)
            while lists[index]:
                heapq.heappush(sort,lists[index].val)
                lists[index]=lists[index].next
            index+=1
            #print(sort)
        #print(sort)
        while sort:
            temp=ListNode(heapq.heappop(sort))
            head.next=temp
            head=head.next
        return h.next

这份代码速度超75%。

3、两两合并

时间复杂度O（nlogk），k为老链表数目。
总链表数N->N/2->N/4->N/8…
思路就是归并排序，节省了空间。