题目
来源:LeetCode.
给你一个链表数组,每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中,返回合并后的链表。
示例 1:
输入:lists = [[1,4,5],[1,3,4],[2,6]]
输出:[1,1,2,3,4,4,5,6]
解释:链表数组如下:
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
示例 2:
输入:lists = []
输出:[]
示例 3:
输入:lists = [[]]
输出:[]
提示:
- k = = l i s t s . l e n g t h k == lists.length k==lists.length
- 0 < = k < = 1 0 4 0 <= k <= 10^4 0<=k<=104
- 0 < = l i s t s [ i ] . l e n g t h < = 500 0 <= lists[i].length <= 500 0<=lists[i].length<=500
- − 1 0 4 < = l i s t s [ i ] [ j ] < = 1 0 4 -10^4 <= lists[i][j] <= 10^4 −104<=lists[i][j]<=104
- l i s t s [ i ] lists[i] lists[i] 按 升序 排列
- l i s t s [ i ] . l e n g t h lists[i].length lists[i].length 的总和不超过 1 0 4 10^4 104
接下来看一下解题思路:
思路一:顺序合并:
可以遍历链表;
将链表里的两个值采用 LeetCode-21-合并两个有序链表. 有序合并;
然后将合并的结果与数据里的值依次合并,返回最终结果;
public static ListNode mergeKLists1(ListNode[] lists) {
if (lists == null || lists.length < 1) {
return null;
}
if (lists.length < 2) {
return lists[0];
}
ListNode cur = lists[0];
for (int i = 1; i < lists.length; ++i) {
cur = mergeList(cur, lists[i]);
}
return cur;
}
private static ListNode mergeList(ListNode p1, ListNode p2) {
if (p1 == null) {
return p2;
}
if (p2 == null) {
return p1;
}
ListNode dummy = new ListNode(0, p1);
ListNode pred = dummy;
while (p1 != null && p2 != null) {
if (p1.val > p2.val) {
pred.next = p2;
p2 = p2.next;
} else {
pred.next = p1;
p1 = p1.next;
}
pred = pred.next;
}
pred.next = (p1 == null) ? p2 : p1;
return dummy.next;
}
总结
时间复杂度:假设每个链表的最长长度是 n n n。在第一次合并后, c u r cur cur 的长度为 n n n;第二次合并后, c u r cur cur 的长度为 2 × n 2\times n 2×n,第 i i i 次合并后, c u r cur cur 的长度为 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)。
空间复杂度:空间复杂度为 O ( 1 ) O(1) O(1)。
思路二:分治合并:
考虑优化方法一,用分治的方法进行合并。
将
k
k
k 个链表配对并将同一对中的链表合并;
重复这一过程,直到我们得到了最终的有序链表。
public static ListNode mergeKLists3(ListNode[] lists){
if (lists == null || lists.length < 1) {
return null;
}
if (lists.length < 2) {
return lists[0];
}
return merge(lists, 0, lists.length - 1);
}
private static ListNode merge(ListNode[] lists, int start, int end) {
if (start == end) {
return lists[start];
}
if (start > end) {
return null;
}
int mid = (start + end) >> 1;
return mergeList(merge(lists, start, mid), merge(lists, mid + 1, end));
}
private static ListNode mergeList(ListNode p1, ListNode p2) {
if (p1 == null) {
return p2;
}
if (p2 == null) {
return p1;
}
ListNode dummy = new ListNode(0, p1);
ListNode pred = dummy;
while (p1 != null && p2 != null) {
if (p1.val > p2.val) {
pred.next = p2;
p2 = p2.next;
} else {
pred.next = p1;
p1 = p1.next;
}
pred = pred.next;
}
pred.next = (p1 == null) ? p2 : p1;
return dummy.next;
}
总结
时间复杂度:考虑递归「向上回升」的过程——第一轮合并
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) 空间代价的栈空间。
思路三:使用优先队列合并:
可以维护一个队列;
每次在这些元素里面选取 val 属性最小的元素合并到答案中
在选取最小元素的时候,我们可以用优先队列来优化这个过程。
public static ListNode mergeKLists(ListNode[] lists) {
if (lists == null || lists.length < 1) {
return null;
}
if (lists.length < 2) {
return lists[0];
}
PriorityQueue<ListNode> queue = new PriorityQueue<>((node1, node2) -> {
return node1.val - node2.val;
});
ListNode dummmy = new ListNode(0);
ListNode node = dummmy;
for (ListNode list : lists) {
if (list != null) {
queue.add(list);
}
}
while (!queue.isEmpty()) {
ListNode temp = queue.poll();
if (temp.next != null) {
queue.add(temp.next);
}
node.next = temp;
node = node.next;
node.next = null;
}
return dummmy.next;
}
总结
时间复杂度:考虑优先队列中的元素不超过
k
k
k 个,那么插入和删除的时间代价为
O
(
log
k
)
O(\log k)
O(logk),这里最多有
k
n
kn
kn 个点,对于每个点都被插入删除各一次,故总的时间代价即渐进时间复杂度为
O
(
k
n
×
log
k
)
O(kn \times \log k)
O(kn×logk)。
空间复杂度:这里用了优先队列,优先队列中的元素不超过
k
k
k个,故渐进空间复杂度为
O
(
k
)
O(k)
O(k)。