合并 k 个排序数组

这是一个经典的问题，即将 k 个排序数组合并为一个排序数组。在本文中，我们将讨论算法及其实现，并介绍在不同场景下选择最佳算法。

算法概述

常见的算法有以下几种：

1. 暴力合并

将所有 k 个数组合并成一个大数组，然后再进行排序。时间复杂度为 $O(nklog(nk))$，其中 $n$ 是每个数组的长度。

def mergeKLists(lists: List[List[int]]) -> List[int]:
    res = []
    for lst in lists:
        res += lst
    res.sort()
    return res

2. 分治合并

将 k 个数组两两合并，最终得到一个有序数组。然后再将这个有序数组与下一个有序数组合并。重复此过程直到只剩下一个有序数组。时间复杂度为 $O(nklogk)$。

def mergeKLists(lists: List[List[int]]) -> List[int]:
    def merge(left, right):
        i, j = 0, 0
        res = []
        while i < len(left) and j < len(right):
            if left[i] < right[j]:
                res.append(left[i])
                i += 1
            else:
                res.append(right[j])
                j += 1
        res += left[i:]
        res += right[j:]
        return res
    
    if not lists:
        return []
    n = len(lists)
    while n > 1:
        new_lists = []
        for i in range(0, n, 2):
            if i + 1 < n:
                new_lists.append(merge(lists[i], lists[i + 1]))
            else:
                new_lists.append(lists[i])
        lists = new_lists
        n = len(lists)
    return lists[0]

3. 堆合并

将 k 个数组的第一个元素放入一个小根堆中，然后弹出堆顶元素，并将该元素所在数组的下一个元素插入堆中。重复此过程直到堆为空。时间复杂度为 $O(nklogk)$。

class Node:
    def __init__(self, val, i, j):
        self.val = val
        self.i = i
        self.j = j
    
    def __lt__(self, other):
        return self.val < other.val

def mergeKLists(lists: List[List[int]]) -> List[int]:
    heap = []
    n = len(lists)
    for i in range(n):
        if lists[i]:
            heap.append(Node(lists[i][0], i, 0))
    heapq.heapify(heap)
    res = []
    while heap:
        node = heapq.heappop(heap)
        i, j = node.i, node.j
        res.append(node.val)
        if j + 1 < len(lists[i]):
            heapq.heappush(heap, Node(lists[i][j + 1], i, j + 1))
    return res

算法选择

选择合适的算法取决于数据规模和具体的应用场景。

• 对于数据规模较小的情况，暴力合并是可以接受的。
• 对于数据规模较大且 k 很小的情况，分治合并可以用于优化排序速度。
• 对于数据规模较大且 k 较大的情况，堆合并是最优的选择。

总结

本文介绍了常见的合并 k 个排序数组的算法及其实现，包括暴力合并、分治合并和堆合并。在实际应用中，我们需要根据具体情况选择合适的算法来优化程序性能。