题目描述
合并 k 个排序链表,返回合并后的排序链表。请分析和描述算法的复杂度。
示例:
输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/merge-k-sorted-lists
思路
- 合并 K 个排序链表** 与 合并两个有序链表 的区别点在于操作有序链表的数量上,因此完全可以按照上面的代码思路来实现合并 K 个排序链表。这里可以参考 **归并排序 **的分治思想,将这 K 个链表先划分为两个 K/2 个链表,处理它们的合并,然后不停的往下划分,直到划分成只有一个或两个链表的任务,开始合并。
-
使用堆的思想: 这里需要将这 k 个排序链表整合成一个排序链表,也就是说有多个输入,一个输出,类似于漏斗一样的概念。
因此,可以利用最小堆的概念。如果你对堆的概念不熟悉,可以戳这先了解一下~
取每个 Linked List 的最小节点放入一个 heap 中,排序成最小堆。然后取出堆顶最小的元素,放入输出的合并 List 中,然后将该节点在其对应的 List 中的下一个节点插入到 heap 中,循环上面步骤,以此类推直到全部节点都经过 heap。
由于 heap 的大小为始终为 k ,而每次插入的复杂度是 logk ,一共插入了 nk 个节点。时间复杂度为 O(nklogk),空间复杂度为O(k)。
动画演示
c++
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
// 逐一两两合并链表
// 时间复杂度为O(N1+N2+...N3)
// 空间复杂度为O(1)
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
if(lists.size() == 0) return nullptr;
ListNode *p = lists[0];
for(int i = 1; i < lists.size(); i ++){
p = mergeTwoLists(p, lists[i]);
}
return p;
}
ListNode *mergeTwoLists(ListNode *l1, ListNode *l2){
ListNode head(-1); //定义一个假的结点
for(ListNode* p = &head; l1 != nullptr || l2 != nullptr; p = p->next){
int val1 = l1 == nullptr ? INT_MAX : l1->val;
int val2 = l2 == nullptr ? INT_MAX : l2->val;
if(val1 <= val2){
p->next = l1;
l1 = l1->next;
}else{
p->next = l2;
l2 = l2->next;
}
}
return head.next;
}
};
// 最小堆的思想
// 时间复杂度为 O(Nklogk) 每次插入的复杂度是 logk ,一共插入了 Nk 个节点 (k个链表 N为总结点个数)
// 空间复杂度为O(k)
class Solution {
public:
struct cmp{
bool operator()(ListNode*a,ListNode*b){
return a->val > b->val;
}
};
ListNode* mergeKLists(vector<ListNode*>& lists) {
priority_queue<ListNode*,vector<ListNode*>,cmp> heap;
ListNode Vhead(0),*p = &Vhead;
for(ListNode *node :lists){
if(node!=NULL)heap.push(node);
}
while(!heap.empty()){
ListNode * tmp = heap.top();
heap.pop();
if(tmp->next!=NULL)heap.push(tmp->next);
p->next = tmp;
p = tmp;
}
return Vhead.next;
}
};
// 分治思想
// 时间复杂度为 O(Nlogk)
// 空间复杂度为O(1)
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
if (l1 == NULL) return l2;
if (l2 == NULL) return l1;
ListNode* pre = new ListNode(0);
ListNode* cur = pre;
while (l1 != NULL && l2 != NULL) {
if (l1->val <= l2->val) {
cur->next = l1;
l1 = l1->next;
} else {
cur->next = l2;
l2 = l2->next;
}
cur = cur->next;
}
cur->next = l1 != NULL ? l1 : l2;
return pre->next;
}
ListNode* mergeKLists(vector<ListNode*>& lists) {
int len = lists.size();
if (len == 0) return NULL;
// 分组间隔每次扩大两倍
int interval = 1;
while (interval < len) {
// 根据当前间隔,两两合并,合并后的结果保存在两个链表的第一个
for (int i = 0; i < len - interval; i += 2 * interval) {
lists[i] = mergeTwoLists(lists[i], lists[i + interval]);
}
interval *= 2;
}
return lists[0];
}
};