一、描述

给你一个链表数组，每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]

输出：[1,1,2,3,4,4,5,6]

解释：链表数组如下：

[

1->4->5,

1->3->4,

2->6

]

将它们合并到一个有序链表中得到。

1->1->2->3->4->4->5->6

示例 2：

输入：lists = []

输出：[]

示例 3：

输入：lists = [[]]

输出：[]

提示：

k == lists.length

0 <= k <= 10^4

0 <= lists[i].length <= 500

-10^4 <= lists[i][j] <= 10^4

lists[i] 按 升序 排列

lists[i].length 的总和不超过 10^4

二、理解

首先，意识到数组中每个元素是一个链表，要注意和列表的区别；其次，每个链表都是升序的，因此两个链表合二为一可以在线性时间内完成。

思路

将前两个链表合二为一，将新链表与第三个链表合二为一，......，将新链表与第n个链表合二为一。

一些特殊情况为

空数组，直接返回，没有返回值，有返回值便通不过，不知是LeetCode的问题还是我理解的有问题；只有一个链表，直接返回链表头。

小技巧

提示中说明了链表元素的最小值是-10000，可提前生成一个值为-10001的链表头，否则你要在两个链表的首元素中选择一个作为链表头。

这也是为何第三部分代码最后一行是 return head.next 而不是 return head 的原因。

三、代码(初级版)

class ListNode(object):

def __init__(self, val=0, next=None):

self.val = val

self.next = next

class Solution(object):

def mergeKLists(self, lists):

"""

:type lists: List[ListNode]

:rtype: ListNode

"""

k = len(lists)

head = ListNode(val=-10001)

tail = head

if k == 0: return

if k == 1: return lists[0]

lp = lists[0]

rp = None

i = 1

# 将已完成合并的链表与当前链表数组中的第i个链表进行合并

while i < k:

rp = lists[i]

while lp and rp:

if lp.val <= rp.val:

tail.next = lp

tail = lp

lp = lp.next

else:

tail.next = rp

tail = rp

rp = rp.next

if rp: tail.next = rp

if lp: tail.next = lp

i += 1

# 如果数组没有遍历完，则重置头指针和尾指针

if i < k:

lp = head.next

head.next = None

tail = head

return head.next

上述代码虽然通过了测试，但下述结果并不是特别理想。

执行用时：3916 ms, 在所有 Python 提交中击败了15.47%的用户

内存消耗：19.1 MB, 在所有 Python 提交中击败了41.84%的用户

算法复杂度为

，n 为所有的链表节点数。

四、优化版

在优化版本中，注意是意识到了可以效仿归并排序的做法，下面是代码。

# Definition for singly-linked list.

class ListNode(object):

def __init__(self, val=0, nxt=None):

self.val = val

self.next = nxt

class Solution(object):

def mergeKLists(self, lists):

"""

:type lists: List[ListNode]

:rtype: ListNode

"""

k = len(lists)

if k == 0: return

if k == 1: return lists[0]

mid = k / 2

lp = self.mergeKLists(lists[0:mid])

rp = self.mergeKLists(lists[mid:])

head = ListNode(val=-10001)

tail = head

while lp and rp:

if lp.val <= rp.val:

tail.next = lp

tail = lp

lp = lp.next

else:

tail.next = rp

tail = rp

rp = rp.next

if lp: tail.next = lp

if rp: tail.next = rp

return head.next

这次的执行结果

执行用时：92 ms, 在所有 Python 提交中击败了73.96% 的用户

内存消耗：18.9 MB, 在所有 Python 提交中击败了43.94% 的用户

算法复杂度为

，n 为所有的链表节点数。