如何合并k个排序列表？

Question

def merge(list1, list2):
    results = []
    while list1 and list2:
        if list1[0] < list2[0]:
            results.append(list1.pop(0))
        else:
            results.append(list2.pop(0))
    results.extend(list1)
    results.extend(list2)
    return results

这是将 2 个排序列表合并为 1 的标准算法。但是，我们如何将多个排序列表合并为 1？

l = [[8, 10, 12], [4, 5, 9], [2, 11]]  
merge(l)  
>>> [2, 4, 5, 8, 9, 10, 11, 12]

Answer 1

您可以将自己的merge与reduce ：

from functools import reduce

l = [[8, 10, 12], [4, 5, 9], [2, 11]]

merged = reduce(merge, l)
print(merged)
# [2, 4, 5, 8, 9, 10, 11, 12]

这有运行时间O(kn) 。 您可以合并（唯一）对，直到剩下 1 个最终列表，这会将其改进为O(n log k) （因为要合并的列表数量每次减少一半）。

Answer 2

您可以使用堆和队列实现直接 k-way 合并：

import heapq
from collections import deque


def k_merge(*lists):
    queues = [queue for queue in map(deque, lists)]

    heap = []
    for i, lst in enumerate(queues):
        heap.append((lst.popleft(), i))

    heapq.heapify(heap)

    result = []
    while heap:
        value, index = heapq.heappop(heap)
        result.append(value)

        if queues[index]:
            heapq.heappush(heap, (queues[index].popleft(), index))

    return result


print(k_merge(*[[8, 10, 12], [4, 5, 9], [2, 11]]))

输出

[2, 4, 5, 8, 9, 10, 11, 12]

如果你有k列表和n元素，这种方法是O(nlogk)

Answer 3

您可以使用sorted()对其进行sorted() ：

from itertools import chain

l = [[8, 10, 12], [4, 5, 9], [2, 11]]

sorted(chain(*l))

给出结果：

[2, 4, 5, 8, 9, 10, 11, 12]

Answer 4

用列表理解展平，然后排序

print(sorted([j for i in l for j in i]))
# [2, 4, 5, 8, 9, 10, 11, 12]

Answer 5

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

使用优先队列优化比较过程

1. 时间复杂度：O(n log(k)) 其中 k 是链表的数量：

   • 每次弹出和插入优先队列的比较成本将减少到 O(log k)。 但是找到具有最小值的节点只需要花费 O(1) 时间。

2. 空间复杂度：

   • O(n) 创建一个新的链表花费 O(n) 空间
   • O(k) 上面的代码应用了成本 O(1) 空间的就地方法。
   • 并且优先队列（通常用堆实现）花费 O(k) 空间（在大多数情况下远小于 N）

Answer 6

一个简单有效的方法是heapq.merge ：

>>> lists = [[8, 10, 12], [4, 5, 9], [2, 11]]
>>> list(heapq.merge(*lists))
[2, 4, 5, 8, 9, 10, 11, 12]

看一眼CPython 的实现，它看起来类似于直接的 k-way 合并答案，所以我猜heapq.merge也是O(n log(k)) ，尽管文档字符串不保证这一点。