将k个有序链表合并成一个有序链表

将k个有序链表合并成一个有序链表

这里以从小到大排序为例，
时间复杂度为O（nlgk）。
特点：利用最小堆来完成k路归并
思路：取每个列表中的第一个元素，并将其放在最小堆中。与每个元素一起，必须跟踪从哪个列表中获取它。当合并时，从堆中取最小的元素，然后从它的来源列表中插入另一个元素(除非列表为空，为空时最小堆减少)。继续执行，直到清空堆。

辅助类：1⃣️ KeyValuePair
跟踪是哪个链表

class KeyValuePair {
public:
    int key;
    int value;
public:
    KeyValuePair();
    KeyValuePair(int key,int value);
};
KeyValuePair::KeyValuePair(){}
KeyValuePair::KeyValuePair(int key,int value):key(key),value(value){};

2⃣️MinimumHeapTemplate
模版类最小堆的构建
里面所含的头文件代码：堆排序

#include "heap_sort.h"
#include <iostream>
using namespace std;
template <typename T>
void min_heapify(vector<T>& array,int heap_size,int parent_index)
{
    int smallest = parent_index;
    int l = left(parent_index);
    int r = right(parent_index);
    if(l<heap_size && array[l].key<array[smallest].key)
        smallest = l;
    if(r<heap_size && array[r].key<array[smallest].key)
        smallest = r;
    if(parent_index != smallest)
    {
        T temp = array[smallest];
        array[smallest] = array[parent_index];
        array[parent_index] = temp;
        min_heapify(array,heap_size,smallest);
    }
}

template <typename T>
void build_min_heap(vector<T>& array,int length)
{
    for(int i= length/2;i>=0;i--)
    {
        min_heapify(array,length,i);
    }
}

最终合并实现

#include "MinimumHeapTemplate.h"
#include "KeyValuePair.h"
#include <vector>
#include <stdexcept>

using namespace std;
void merge_ordered_arrays(int **array,int row,int column,int *out_array);

void merge_ordered_arrays(int **array,int row,int column,int *out_array){
    vector<KeyValuePair> heap_sort_array(row);
    int *count_array = new int [row];
    int heap_size = row;
    for (int i = 0; i < row; ++i) {
        count_array[i] = 1;
    }
    for (int i = 0; i < row; ++i) {
        heap_sort_array[i].key = array[i][0];
        heap_sort_array[i].value = i;
    }
    build_min_heap(heap_sort_array,row);
    int index = 0;
    while (heap_size>0)
    {
        KeyValuePair top = heap_sort_array[0];
        out_array[index] = top.key;
        index++;
        if(count_array[top.value]<column)
        {
            heap_sort_array[0].key = array[top.value][count_array[top.value]];
            heap_sort_array[0].value = top.value;
            count_array[top.value]++;
            min_heapify(heap_sort_array,heap_size,0);
        }
        else
        {
            heap_size--;
            heap_sort_array[0] = heap_sort_array[heap_size];
            min_heapify(heap_sort_array,heap_size,0);
        }
    }
    delete [] count_array;
}