LeetCode Merge k Sorted Lists

问题网址：https://leetcode.com/problems/merge-k-sorted-lists/description/

问题描述：

合并k个已排序的链接列表并将其作为一个排序列表返回。 分析并描述其复杂性。

蛮力方法

遍历所有链表，并将节点的值收集到一个数组中。

对这个数组进行排序和迭代以获得适当的节点值。

创建一个新的排序链接列表，并用新节点扩展它。

class Solution(object):
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
self.nodes = []
head = point = ListNode(0)
for l in lists:
while l:
self.nodes.append(l.val)
l = l.next
for x in sorted(self.nodes):
point.next = ListNode(x)
point = point.next
return head.next

复杂性分析

时间复杂度：O（NlogN）其中N是节点的总数。

收集所有值O（N）时间。

稳定的排序算法花费O（NlogN）时间。

迭代创建链表需要花费O（N）时间。

空间复杂度：O（N）。

排序成本O（N）空间（取决于您选择的算法）。

创建一个新的链表要花费O（N）空间。

逐一比较方法

比较每个 k个节点（每个链表的头部），得到最小值的节点。

用选定的节点扩展最终的排序链表。

复杂性分析

时间复杂度：O（kN）其中k是链接列表的数量。

几乎每个节点在最终的链接成本中选择O（k）（k-1次比较）。

最终链表中有N节点。

空间复杂性：

O（n）创建新的链接列表花费O（n）空间。

O（1）应用就地方法并不难 - 连接选定的节点，而不是创建新的节点来填充新的链接列表。

通过优先级队列优化方法2

几乎与上面的一样，但通过优先级队列来优化比较过程。

from Queue import PriorityQueue

class Solution(object):
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
head = point = ListNode(0)
q = PriorityQueue()
for l in lists:
if l:
q.put((l.val, l))
while not q.empty():
val, node = q.get()
point.next = ListNode(val)
point = point.next
node = node.next
if node:
q.put((node.val, node))
return head.next

复杂性分析

时间复杂度：O（Nlogk）其中k是链接列表的数量。

对于每个弹出和插入优先级队列，比较成本将减少到O（logk）。 但是找到最小值的节点只需花费O（1）次。

最终链表中有N节点。

空间复杂性：

O（n）创建新的链接列表花费O（n）空间。

O（k）上面的代码适用于成本为O（1）空间的原地方法。 而优先队列（通常用堆实现）耗费O（k）空间（在大多数情况下，它远小于N）。

逐个合并列表方法

将合并\ text {k} k列表问题转换成合并2个列表（k-1）次。 这是合并2列表问题页面。

复杂性分析

时间复杂度：O（kN）其中 k是链接列表的数量。

我们可以在O（n）时间中合并两个排序后的链表，其中nn是两个列表中的节点总数。

总结合并过程，我们可以得到：O（\ sum_ {i = 1} ^ {k-1}（i （\ frac {N} {k}+\frac {N} {k}））=O（ΣI = 1k-1的（i （ķñ）+ķñ））=O（kN）。
9708

空间复杂度：O（1）

我们可以在O（1）空间中合并两个排序后的链表。

合并分而治之方法

这种方法与上述方法并行，但是改进很多。 我们不需要多次遍历大多数节点

配对 k列表并合并每一对。

在第一次配对之后， k列表被合并成平均2N / k长度的k / 2列表，然后是k / 4，k / 8等等。

重复这个过程，直到我们得到最终的排序链表。

因此，我们将在每次配对和合并时遍历几乎NN节点，并重复有关log2k倍。

class Solution(object):
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
amount = len(lists)
interval = 1
while interval < amount:
for i in range(0, amount - interval, interval * 2):
lists[i] = self.merge2Lists(lists[i], lists[i + interval])
interval *= 2
return lists[0] if amount > 0 else lists

def merge2Lists(self, l1, l2):
head = point = ListNode(0)
while l1 and l2:
if l1.val <= l2.val:
point.next = l1
l1 = l1.next
else:
point.next = l2
l2 = l1
l1 = point.next.next
point = point.next
if not l1:
point.next=l2
else:
point.next=l1
return head.next

复杂性分析

时间复杂度：O（Nlogk）其中\ text {k} k是链接列表的数量。

我们可以在O（n）O（n）时间中合并两个排序后的链表，其中nn是两个列表中的节点总数。

总结合并过程，我们可以得到：O \ big（\ sum_ {i = 1} ^ {log_ {2} {k}} N \ big）= O（N \ log k）O（ΣI = 1 2kN）= O（Nlogk）

空间复杂度：O（1）

我们可以在O（1）空间中合并两个排序后的链表。