【问题描述】23.合并K个排序链表
合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。
示例:
输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6
【解答思路】
1. 两两合并
public class Solution2 {
public ListNode mergeKLists(ListNode[] lists) {
int size = lists.length;
if (size == 0) {
return null;
}
ListNode res = lists[0];
for (int i = 1; i < size; i++) {
if (lists[i] != null) {
res = mergeTwoSortLinkedList(res, lists[i]);
}
}
return res;
}
private ListNode mergeTwoSortLinkedList(ListNode list1, ListNode list2) {
ListNode dummyNode = new ListNode(-1);
ListNode p1 = list1;
ListNode p2 = list2;
ListNode curNode = dummyNode;
// 两者都不为空的时候，才有必要进行比较
while (p1 != null && p2 != null) {
if (p1.val < p2.val) {
// 指针修改发生在这里
curNode.next = p1;
p1 = p1.next;
} else {
// 指针修改发生在这里
curNode.next = p2;
p2 = p2.next;
}
curNode = curNode.next;
}
// 跳出循环是因为 p1 == null 或者 p2 == null
if (p1 == null) {
curNode.next = p2;
}
if (p2 == null) {
curNode.next = p1;
}
return dummyNode.next;
}
}
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/tan-xin-suan-fa-you-xian-dui-lie-fen-zhi-fa-python/
2. 分治法
想清楚数据结构 ListNode[] 只存了头节点
1、先一分为二，分别“递归地”解决了与原问题同结构，但规模更小的两个子问题；
2、再考虑如何合并，这个合并的过程也是一个递归方法（同 LeetCode 第 21 题：合并两个有序链表）。
时间复杂度：O(NlogN)
import java.util.Comparator;
import java.util.PriorityQueue;
class ListNode {
int val;
ListNode next;
ListNode(int x) {
val = x;
}
//测试使用
ListNode(Integer[] nums) {
ListNode currNode = this;
currNode.val = nums[0];
for (int i = 1; i < nums.length; i++) {
currNode.next = new ListNode(nums[i]);
currNode = currNode.next;
}
}
//测试使用
@Override
public String toString() {
ListNode currNode = this;
StringBuilder s = new StringBuilder();
while (currNode != null) {
s.append(currNode.val);
s.append(" -> ");
currNode = currNode.next;
}
// 最后添加一个 NULL 标志表示添加到末尾了
s.append("NULL");
return s.toString();
}
}
public class Solution {
public ListNode mergeKLists(ListNode[] lists) {
int len = lists.length;
if (len == 0) {
return null;
}
return mergeKLists(lists, 0, len - 1);
}
public ListNode mergeKLists(ListNode[] lists, int l, int r) {
// 思考这里为什么取等于？这是因为根据下文对 mergeKLists 的递归调用情况，区间最窄的时候，只可能是左右端点重合
if (l == r) {
return lists[l];
}
int mid = (r - l) / 2 + l;
ListNode l1 = mergeKLists(lists, l, mid);
ListNode l2 = mergeKLists(lists, mid + 1, r);
return mergeTwoSortedListNode(l1, l2);
}
private ListNode mergeTwoSortedListNode(ListNode l1, ListNode l2) {
if (l1 == null) {
return l2;
}
if (l2 == null) {
return l1;
}
if (l1.val < l2.val) {
l1.next = mergeTwoSortedListNode(l1.next, l2);
return l1;
}
l2.next = mergeTwoSortedListNode(l1, l2.next);
return l2;
}
}
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/tan-xin-suan-fa-you-xian-dui-lie-fen-zhi-fa-python/
3. 贪心算法、优先队列 （最小堆）
image
时间复杂度：O(NlogN) 空间复杂度：O(N)
import java.util.Comparator;
import java.util.PriorityQueue;
class ListNode {
int val;
ListNode next;
ListNode(int x) {
val = x;
}
//n条链表合成一条 测试使用
ListNode(Integer[] nums) {
ListNode currNode = this;
currNode.val = nums[0];
for (int i = 1; i < nums.length; i++) {
currNode.next = new ListNode(nums[i]);
currNode = currNode.next;
}
}
//测试使用
@Override
public String toString() {
ListNode currNode = this;
StringBuilder s = new StringBuilder();
while (currNode != null) {
s.append(currNode.val);
s.append(" -> ");
currNode = currNode.next;
}
// 最后添加一个 NULL 标志表示添加到末尾了
s.append("NULL");
return s.toString();
}
}
public class Solution {
public ListNode mergeKLists(ListNode[] lists) {
int len = lists.length;
if (len == 0) {
return null;
}
PriorityQueue priorityQueue = new PriorityQueue<>(len, Comparator.comparingInt(a -> a.val));
/*
@Override
public int compare(ListNode o1, ListNode o2) {
if (o1.val < o2.val) return -1;
else if (o1.val == o2.val) return 0;
else return 1;
}
*/
ListNode dummyNode = new ListNode(-1);
ListNode curNode = dummyNode;
for (ListNode list : lists) {
if (list != null) {
// 这一步很关键，不能也没有必要将空对象添加到优先队列中
priorityQueue.add(list);
}
}
while (!priorityQueue.isEmpty()) {
// 优先队列非空才能出队
ListNode node = priorityQueue.poll();
// 当前节点的 next 指针指向出队元素
curNode.next = node;
// 当前指针向前移动一个元素，指向了刚刚出队的那个元素
curNode = curNode.next;
if (curNode.next != null) {
// 只有非空节点才能加入到优先队列中
priorityQueue.add(curNode.next);
}
}
return dummyNode.next;
}
public static void main(String[] args) {
Integer[] nums1 = {1, 4, 5};
Integer[] nums2 = {1, 3, 4};
Integer[] nums3 = {2, 6};
ListNode head1 = new ListNode(nums1);
ListNode head2 = new ListNode(nums2);
ListNode head3 = new ListNode(nums3);
ListNode[] lists = new ListNode[3];
lists[0] = head1;
lists[1] = head2;
lists[2] = head3;
Solution solution = new Solution();
ListNode mergeKLists = solution.mergeKLists(lists);
System.out.println(mergeKLists);
}
}
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/tan-xin-suan-fa-you-xian-dui-lie-fen-zhi-fa-python/
###### 4. O(N^2)
【总结】
1.递归思想
1、数组的排序方法要很清楚，这一点是迁移到链表上，发现只有归并排序适用；
2、归并排序其实就是分而治之；
3、还要清楚两个排序链表是怎么合并的（可以递归也可以非递归用双指针去穿针引线）。
如果这些所以就很自然迁移到合并 K 个排序链表。
2.链表
- “递归”、“分治”
- “穿针引线” 优先队列 堆
3.PriorityQueue
1>PriorityQueue是一种无界的，线程不安全的队列（无锁）
2>PriorityQueue是一种通过数组实现的，并拥有优先级的队列
3>PriorityQueue存储的元素要求必须是可比较的对象Comparator（数量+比较对象）， 如果不是就必须明确指定比较器
优先队列java解析与用法：https://www.jb51.net/article/84371.htm
优先队列源码解析：https://www.cnblogs.com/CarpenterLee/p/5488070.html
解题解析：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/tan-xin-suan-fa-you-xian-dui-lie-fen-zhi-fa-python/
异度侵入