方法1:小根堆维护 k 个链表
使用小根堆维护 k 个链表的头部,每次 O(logK) 比较 K个链表的头结点 求 min,然后poll出来,若该 min 节点的 next 不为空,则继续加入到堆中,
时间复杂度:O(NlogK)
空间复杂度 O(1)
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
int n = lists.length;
if(n == 0){
return null;
}
PriorityQueue<ListNode> pq = new PriorityQueue<>(
new Comparator<ListNode>(){
@Override
public int compare(ListNode o1, ListNode o2){
return o1.val-o2.val;
}
}
);
for(ListNode list : lists){
if(list != null) pq.add(list);
}
ListNode dummyHead = new ListNode(0);
ListNode curr = dummyHead;
while(!pq.isEmpty()){
ListNode tmp = pq.poll();
curr.next = tmp;
curr = curr.next;
if(tmp.next != null) pq.add(tmp.next);
}
return dummyHead.next;
}
}
方法2:两两合并链表(归并排序)
思路分析:
二路归并,这里二路归并的元素是链表,相当于每个链表是已经排序好的分块。
时间复杂度分析:
K 条链表的总结点数是 N,平均每条链表有 N/K 个节点,因此合并两条链表的时间复杂度是 O(N/K)。从 K 条链表开始两两合并成 1 条链表,因此每条链表都会被合并 logKlogK 次,因此 K 条链表会被合并 K * logK次,因此总共的时间复杂度是K∗logK∗N/K 即 O(NlogK)。
时间复杂度:O(NlogK)
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
if (lists.length == 0) {
return null;
}
int k = lists.length;
while (k > 1) {
int idx = 0;
for (int i = 0; i < k; i += 2) {
if (i == k - 1) {
lists[idx++] = lists[i];
} else {
lists[idx++] = merge2Lists(lists[i], lists[i + 1]);
}
}
k = idx;
}
return lists[0];
}
private ListNode merge2Lists(ListNode l1, ListNode l2) {
ListNode dummyHead = new ListNode(0);
ListNode tail = dummyHead;
while (l1 != null && l2 != null) {
if (l1.val < l2.val) {
tail.next = l1;
l1 = l1.next;
} else {
tail.next = l2;
l2 = l2.next;
}
tail = tail.next;
}
tail.next = l1 == null? l2: l1;
return dummyHead.next;
}
}
方法3:合并成一个链表后用快排(待补充)
时间复杂度O(nlogn)