LeetCode23 - 合并K个有序链表
题目描述:
给你一个链表数组,每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中,返回合并后的链表。
示例 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 == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4
合并K个有序链表,时间复杂度和空间复杂度有限制
解法一:优先队列求解,放一个排序一次logK,一共放N次,复杂度是NlogK
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
if(lists == null || lists.length == 0) return null;
// 新建优先队列
Queue<Integer> queue = new PriorityQueue<Integer>();
// 将所有元素往队列放
for(int i = 0; i< lists.length; i++) {
while(lists[i] != null) {
queue.offer(lists[i].val);
lists[i] = lists[i].next;
}
}
ListNode list = new ListNode(0);
ListNode tmp = list;
// 将队列元素取出构建链表
while(!queue.isEmpty()) {
int s = queue.poll();
tmp.next = new ListNode(s);
tmp = tmp.next;
}
return list.next;
}
}
解法二(重点掌握):优先队列求解,复杂度是NlogK,K 指针指向 K 条链表,每次使用小根堆来 logK 求出最小值,一共N个元素
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
if(lists == null || lists.length == 0) return null;
// 新建优先队列
Queue<ListNode> queue = new PriorityQueue<>((list1, list2) -> list1.val-list2.val);
// 将所有元素往队列放
for(int i = 0; i < lists.length; i++) {
if(lists[i] != null)
queue.offer(lists[i]);
}
ListNode list = new ListNode(0);
ListNode tmp = list;
// 将队列元素取出构建链表
while(!queue.isEmpty()) {
ListNode s = queue.poll();
tmp.next = s;
tmp = tmp.next;
if(s.next != null) {
queue.offer(s.next);
}
}
return list.next;
}
}
解法三:两两合并,时间复杂度,NK
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
if(lists == null || lists.length == 0) return null;
ListNode ret = null;
if(lists.length ==1) {
return lists[0];
}else if(lists.length == 2) {
return merge2Lists(lists[0], lists[1]);
}else {
ret = merge2Lists(lists[0], lists[1]);
for(int i=2; i<lists.length; i++) {
ret = merge2Lists(ret, lists[i]);
}
}
return ret;
}
private ListNode merge2Lists(ListNode list1, ListNode list2){
ListNode res = new ListNode(0);
ListNode temp = res;
while(list1 != null && list2 != null) {
if(list1.val < list2.val) {
temp.next = new ListNode(list1.val);
list1 = list1.next;
}else {
temp.next = new ListNode(list2.val);
list2 = list2.next;
}
temp = temp.next;
}
if(list1 != null){
temp.next = list1;
}
if(list2 != null) {
temp.next = list2;
}
return res.next;
}
}
解法四(重点掌握):两两合并优化
时间复杂度分析:K 条链表的总结点数是 N,平均每条链表有 N/K 个节点,因此合并两条链表的时间复杂度是 O(N/K)。从 K 条链表开始两两合并成 1 条链表,因此每条链表都会被合并 logK 次,因此 K 条链表会被合并 K∗logK 次,因此总共的时间复杂度是 K∗logK∗N/K 即 O(NlogK)
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
if(lists == null || lists.length == 0) return null;
ListNode ret = new ListNode(0);
ListNode temp = ret;
int n = lists.length;
// 当lists就剩1个链表停止
while(n>1) {
// 从lists的第0个链表开始合并
int idx = 0;
for(int i=0; i<n; i+=2) {
if(i == n-1) {
lists[idx++] = lists[i];
}else {
lists[idx++] = merge2Lists(lists[i], lists[i+1]);
}
}
n = idx;
}
return lists[0];
}
private ListNode merge2Lists(ListNode list1, ListNode list2){
ListNode res = new ListNode(0);
ListNode temp = res;
while(list1 != null && list2 != null) {
if(list1.val < list2.val) {
temp.next = new ListNode(list1.val);
list1 = list1.next;
}else {
temp.next = new ListNode(list2.val);
list2 = list2.next;
}
temp = temp.next;
}
if(list1 != null){
temp.next = list1;
}
if(list2 != null) {
temp.next = list2;
}
return res.next;
}
}