合并 k 个排序链表,返回合并后的排序链表。请分析和描述算法的复杂度。
示例:
输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6
方法一:顺序合并
首先我们考虑合并两个有序链表应该如何实现,直接比较两个链表当前节点的数值大小即可。
代码如下:
ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
if ((!a) || (!b)) return a ? a : b;
ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
while (aPtr && bPtr) {
if (aPtr->val < bPtr->val) {
tail->next = aPtr; aPtr = aPtr->next;
} else {
tail->next = bPtr; bPtr = bPtr->next;
}
tail = tail->next;
}
tail->next = (aPtr ? aPtr : bPtr);
return head.next;
}
所以,对于K个链表可以将其一个一个按顺序合并,代码如下:
ListNode* mergeKLists(vector<ListNode*>& lists) {
ListNode *ans = nullptr;
for (size_t i = 0; i < lists.size(); ++i) {
ans = mergeTwoLists(ans, lists[i]);
}
return ans;
}
复杂度:
时间复杂度: 假设每个链表的最长长度是
n
n
n。在第一次合并后,
a
n
s
ans
ans 的长度为
n
n
n;第二次合并后,
a
n
s
ans
ans 的长度为 ,第
i
i
i 次合并后,
a
n
s
ans
ans 的长度为
i
×
n
i\times n
i×n。第
i
i
i 次合并的时间代价是
O
(
n
+
(
i
−
1
)
×
n
)
=
O
(
i
×
n
)
O(n + (i - 1) \times n) = O(i \times n)
O(n+(i−1)×n)=O(i×n),那么总的时间代价为
O
(
∑
i
=
1
k
(
i
×
n
)
)
=
O
(
(
1
+
k
)
⋅
k
2
×
n
)
=
O
(
k
2
n
)
O(\sum_{i = 1}^{k} (i \times n)) = O(\frac{(1 + k)\cdot k}{2} \times n) = O(k^2 n)
O(∑i=1k(i×n))=O(2(1+k)⋅k×n)=O(k2n)故渐进时间复杂度为
O
(
k
2
n
)
O(k^2 n)
O(k2n)。
空间复杂度: 没有用到与
k
k
k和
n
n
n 规模相关的辅助空间,故渐进空间复杂度为
O
(
1
)
O(1)
O(1)。
方法二:归并排序
而对于K个有序链表来说,我们可以采用分而治之的思想,将K个有序链表划分成两个链表合并的子集。如下图所示:
代码:
class Solution {
public:
ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
if ((!a) || (!b)) return a ? a : b;
ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
while (aPtr && bPtr) {
if (aPtr->val < bPtr->val) {
tail->next = aPtr; aPtr = aPtr->next;
} else {
tail->next = bPtr; bPtr = bPtr->next;
}
tail = tail->next;
}
tail->next = (aPtr ? aPtr : bPtr);
return head.next;
}
ListNode* merge(vector <ListNode*> &lists, int l, int r) {
if (l == r) return lists[l];
if (l > r) return nullptr;
int mid = (l + r) >> 1; //向下取整
return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
}
ListNode* mergeKLists(vector<ListNode*>& lists) {
return merge(lists, 0, lists.size() - 1);
}
};
复杂度
时间复杂度: 考虑递归「向上回升」的过程——第一轮合并
k
2
\frac{k}{2}
2k 每组链表,每一组的时间代价是
O
(
2
n
)
O(2n)
O(2n);第二轮合并
k
4
\frac{k}{4}
4k 组链表,每一组的时间代价是
O
(
4
n
)
O(4n)
O(4n)…所以总的时间代价是
O
(
∑
i
=
1
∞
k
2
i
×
2
i
n
)
=
O
(
k
n
×
log
k
)
O(\sum_{i = 1}^{\infty} \frac{k}{2^i} \times 2^i n) = O(kn \times \log k)
O(∑i=1∞2ik×2in)=O(kn×logk),故渐进时间复杂度为
O
(
k
n
×
log
k
)
O(kn \times \log k)
O(kn×logk)。
空间复杂度: 递归会使用到
O
(
log
k
)
O(\log k)
O(logk) 空间代价的栈空间。
方法三:使用优先队列
在合并两个链表的时候,我们比较两个链表的当前元素,那么在合并K个链表时,我们可以比较K个链表的当前元素选出最小元素,方法类似。但是我们希望能用最短的时间获取K个元素中的最小元素。如果采用遍历则复杂度为 O ( k ) O(k) O(k),我们还可以采用优先队列,维护一个小顶堆的复杂度为 O ( l o g k ) O(logk) O(logk)。一共有 n × k n\times k n×k个元素,所以总的时间复杂度为 O ( k n × log k ) O(kn \times \log k) O(kn×logk)空间复杂度为 O ( K ) O(K) O(K)。
class Solution {
public:
struct Status {
int val;
ListNode *ptr;
bool operator < (const Status &rhs) const {
return val > rhs.val;
}
};
priority_queue <Status> q;
ListNode* mergeKLists(vector<ListNode*>& lists) {
for (auto node: lists) {
if (node) q.push({node->val, node});
}
ListNode head, *tail = &head;
while (!q.empty()) {
auto f = q.top(); q.pop();
tail->next = f.ptr;
tail = tail->next;
if (f.ptr->next) q.push({f.ptr->next->val, f.ptr->next});
}
return head.next;
}
};