使用最小堆合并 K 个已排序链表的 C++ 程序 – 第 2 组
给定k个大小为n的链表，每个链表按非降序排序，将它们合并为一个排序（非降序）链表，并将排序后的链表打印为输出。
例子：
Input: k = 3, n = 4
list1 = 1->3->5->7->NULL
list2 = 2->4->6->8->NULL
list3 = 0->9->10->11->NULL
Output: 0->1->2->3->4->5->6->7->8->9->10->11
Merged lists in a sorted order
where every element is greater
than the previous element.
Input: k = 3, n = 3
list1 = 1->3->7->NULL
list2 = 2->4->8->NULL
list3 = 9->10->11->NULL
Output: 1->2->3->4->7->8->9->10->11
Merged lists in a sorted order
where every element is greater
than the previous element.资料来源：合并 K 排序的链表 |方法二
这篇文章的方法 3中讨论了该问题的有效解决方案。
方法：此解决方案基于用于解决此处讨论的“合并 k 个排序数组”问题的MIN HEAP方法。 MinHeap： Min-Heap 是一棵完全二叉树，其中每个内部节点中的值小于或等于该节点子节点中的值。将堆的元素映射到数组中很简单：如果一个节点存储在索引 k 处，那么它的左子节点存储在索引 2k + 1 处，其右子节点存储在索引 2k + 2 处。
- 创建一个最小堆并插入所有“k”链表的第一个元素。
- 只要 min-heap 不为空，请执行以下步骤：
- 删除最小堆的顶部元素（这是最小堆中所有元素中的当前最小值）并将其添加到结果列表中。
- 如果在上一步弹出的元素旁边存在一个元素（在同一个链表中），则将其插入最小堆。
- 返回合并列表的头节点地址。
下面是上述方法的实现：
C++
// C++ implementation to merge k
// sorted linked lists
// | Using MIN HEAP method
#include
using namespace std;
struct Node {
int data;
struct Node* next;
};
// Utility function to create a new node
struct Node* newNode(int data)
{
// allocate node
struct Node* new_node = new Node();
// put in the data
new_node->data = data;
new_node->next = NULL;
return new_node;
}
// 'compare' function used to build up the
// priority queue
struct compare {
bool operator()(
struct Node* a, struct Node* b)
{
return a->data > b->data;
}
};
// function to merge k sorted linked lists
struct Node* mergeKSortedLists(
struct Node* arr[], int k)
{
// priority_queue 'pq' implemented
// as min heap with the
// help of 'compare' function
priority_queue, compare> pq;
// push the head nodes of all
// the k lists in 'pq'
for (int i = 0; i < k; i++)
if (arr[i] != NULL)
pq.push(arr[i]);
// Handles the case when k = 0
// or lists have no elements in them
if (pq.empty())
return NULL;
struct Node *dummy = newNode(0);
struct Node *last = dummy;
// loop till 'pq' is not empty
while (!pq.empty()) {
// get the top element of 'pq'
struct Node* curr = pq.top();
pq.pop();
// add the top element of 'pq'
// to the resultant merged list
last->next = curr;
last = last->next;
// check if there is a node
// next to the 'top' node
// in the list of which 'top'
// node is a member
if (curr->next != NULL)
// push the next node of top node in 'pq'
pq.push(curr->next);
}
// address of head node of the required merged list
return dummy->next;
}
// function to print the singly linked list
void printList(struct Node* head)
{
while (head != NULL) {
cout << head->data << " ";
head = head->next;
}
}
// Driver program to test above
int main()
{
int k = 3; // Number of linked lists
int n = 4; // Number of elements in each list
// an array of pointers storing the head nodes
// of the linked lists
Node* arr[k];
// creating k = 3 sorted lists
arr[0] = newNode(1);
arr[0]->next = newNode(3);
arr[0]->next->next = newNode(5);
arr[0]->next->next->next = newNode(7);
arr[1] = newNode(2);
arr[1]->next = newNode(4);
arr[1]->next->next = newNode(6);
arr[1]->next->next->next = newNode(8);
arr[2] = newNode(0);
arr[2]->next = newNode(9);
arr[2]->next->next = newNode(10);
arr[2]->next->next->next = newNode(11);
// merge the k sorted lists
struct Node* head = mergeKSortedLists(arr, k);
// print the merged list
printList(head);
return 0;
} 输出
0 1 2 3 4 5 6 7 8 9 10 11 复杂性分析：
- 时间复杂度： O(N * log k) or O(n * k * log k)，其中，'N'是所有链表中元素的总数，'k'是链表的总数，' n' 是每个链表的大小。
所有N个节点的插入和删除操作都会在min-heap中进行。
最小堆中的插入和删除需要 log k 时间。 - 辅助空间： O(k)。
优先级队列在任何时间点最多有“k”个元素，因此我们的算法所需的额外空间是 O(k)。
请参阅有关合并 k 排序链表的完整文章 |设置 2（使用最小堆）了解更多详情！