多路归并算法

多路归并算法 是一种将多个有序序列合并为一个有序序列的算法。它是 归并排序 的扩展，适用于需要合并多个有序序列的场景，例如外部排序（External Sorting）或数据库中的多路归并连接（Multiway Merge Join）。以下是多路归并算法的核心概念、适用场景、实现方法及经典例题：

---

一、核心概念

1. 多路归并
   • 将 (k) 个有序序列合并为一个有序序列。
2. 最小堆（优先队列）
   • 用于高效地从 (k) 个序列中选择当前最小的元素。
3. 时间复杂度
   • 假设每个序列的长度为 (n)，则多路归并的时间复杂度为 (O(nk \log k))。

---

二、适用场景

1. 外部排序
   • 当数据量太大，无法全部加载到内存时，使用多路归并对多个有序文件进行合并。
2. 数据库操作
   • 在数据库中，多路归并用于合并多个有序表或索引。
3. 分布式计算
   • 在 MapReduce 等分布式计算框架中，多路归并用于合并多个节点的输出。

---

三、实现方法

1. 使用最小堆（优先队列）

• 初始化一个最小堆，将每个序列的第一个元素插入堆中。
• 每次从堆中取出最小元素，将其加入结果序列，并从该元素所属的序列中取出下一个元素插入堆中。
• 重复上述步骤，直到所有序列的元素都被处理完毕。

2. 代码实现

以下是使用最小堆实现多路归并的 Python 代码：

import heapq

def multiway_merge(arrays):
    # 最小堆，存储 (元素值, 序列索引, 元素索引)
    heap = []
    for i, array in enumerate(arrays):
        if array:  # 如果序列非空
            heapq.heappush(heap, (array[0], i, 0))
    
    result = []
    while heap:
        val, array_idx, element_idx = heapq.heappop(heap)
        result.append(val)
        # 从当前序列中取出下一个元素
        if element_idx + 1 < len(arrays[array_idx]):
            next_element = arrays[array_idx][element_idx + 1]
            heapq.heappush(heap, (next_element, array_idx, element_idx + 1))
    
    return result

# 示例
arrays = [
    [1, 3, 5, 7],
    [2, 4, 6, 8],
    [0, 9, 10, 11]
]
print(multiway_merge(arrays))  # 输出 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

---

四、经典例题

1. 合并 K 个有序链表

问题描述：合并 (k) 个有序链表为一个有序链表。

代码实现：

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

def mergeKLists(lists):
    heap = []
    for i, node in enumerate(lists):
        if node:
            heapq.heappush(heap, (node.val, i, node))
    
    dummy = ListNode()
    curr = dummy
    while heap:
        val, i, node = heapq.heappop(heap)
        curr.next = node
        curr = curr.next
        if node.next:
            heapq.heappush(heap, (node.next.val, i, node.next))
    
    return dummy.next

# 示例
lists = [
    ListNode(1, ListNode(4, ListNode(5))),
    ListNode(1, ListNode(3, ListNode(4))),
    ListNode(2, ListNode(6))
]
result = mergeKLists(lists)
while result:
    print(result.val, end=" ")
    result = result.next
# 输出 1 1 2 3 4 4 5 6

---

五、多路归并的优化

1. 败者树（Loser Tree）

   • 败者树是一种用于多路归并的高效数据结构，可以减少比较次数。
   • 适用于 (k) 较大的场景。

2. 分阶段归并

   • 当 (k) 非常大时，可以分阶段进行归并，例如先将部分序列两两归并，再对结果进行归并。

---

六、总结

• 多路归并算法是归并排序的扩展，适用于合并多个有序序列的场景。
• 使用最小堆可以高效实现多路归并，时间复杂度为 (O(nk \log k))。
• 多路归并在外部排序、数据库操作和分布式计算中有广泛应用。