給定K個有序數組，每個數組有n個元素，想把這些數組合並成一個有序數組

可以利用最小堆完成，時間復雜度是O(nklogk)，具體過程如下：

創建一個大小為n*k的數組保存最後的結果
創建一個大小為k的最小堆，堆中元素為k個數組中的每個數組的第一個元素
重復下列步驟n*k次：
每次從堆中取出最小元素（堆頂元素），並將其存入輸出數組中
用堆頂元素所在數組的下一元素將堆頂元素替換掉，
如果數組中元素被取光了，將堆頂元素替換為無窮大。每次替換堆頂元素後，重新調整堆
初始化最小堆的時間復雜度O（k），總共有kn次循環，每次循環調整最小堆的時間復雜度是O（logk），所以總的時間復雜度是O（knlogk）

代碼如下，已測試通過：

import sys

class HeapNode:
    def __init__(self,x,y=0,z=0):
        self.value=x
        self.i=y
        self.j=z


def Min_Heap(heap):#構造一個堆，將堆中所有數據重新排序
    HeapSize = len(heap)#將堆的長度單獨拿出來方便
    for i in range((HeapSize -2)//2,-1,-1):#從後往前出數
        Min_Heapify(heap,i)


def Min_Heapify(heap,root):
    heapsize
 
=len(heap)
    MIN=root
    left=2*root+1
    right=left+1
    if left<heapsize and heap[MIN].value>heap[left].value:
        MIN=left
    if right <heapsize and heap[MIN].value>heap[right].value:
        MIN=right
    if MIN!=root:
        heap[MIN], heap[root] = heap[root], heap[MIN]
        Min_Heapify(heap, MIN)

 
def MergeKArray(nums,n):
    # 合並k個有序數組，每個數組長度都為k
    knums=[]
    output=[]
    for i in range(len(nums)):
        subnums=nums[i]
        knums.append(HeapNode(subnums[0],i,1))
        Min_Heap(knums)#k個元素初始化最小堆

    for i in range(len(nums)*n):
        # 取堆頂，存結果
        root=knums[0]
        output.append(root.value)
        #替換堆頂
        if root.j<n:
            root.value=nums[root.i][root.j]
            root.j+=1
        else:
            root.value=sys.maxsize
        knums[0]=root
        Min_Heapify(knums,0)
    return output


knums=[[1,2,3],[1,3,6],[4,5,8]]
print(MergeKArray(knums,3))

合並k個有序數組