力扣23(java)-合并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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/merge-k-sorted-lists
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路：

参考@【王尼玛】的解题思路

一、小根堆

如图：4个链表中的最小值，一定来自黄色的部分，黄色的部分就是一个小根堆。
这个堆的元素个数是lists中链表的个数，初始时只是将每个链表的头结点放入堆中，建立完初始的堆后，就不断的从堆中获取节点，如果获取到的节点不为空，即还有下一个节点，那么就将下一个节点放到堆中。

代码：

/**
 * 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;
        PriorityQueue<ListNode> queue = new PriorityQueue(new Comparator<ListNode>(){
            public int compare(ListNode l1, ListNode l2){
                //升序
                return l1.val - l2.val;
            }
        });
        ListNode dummy = new ListNode(0);
        ListNode cur = dummy;
        //把每个链表的头结点放进队列中
        for(ListNode node: lists){
            if(node != null){
                queue.add(node);
            }
        }
        while(!queue.isEmpty()){
            cur.next = queue.poll();
            cur = cur.next;
            //将当前结点的下一个结点也放入队列中
            if(cur.next != null){
                queue.add(cur.next);
            }
        }
        return dummy.next;
    }
}

 二、分治和合并

先将整个链表在中间进行拆分成两部分，然后再对这两部分继续拆分，直到拆分成最小单元（只有一个链表）时，再进行两两进行合并，合并后以当前合并后的链表为新的链表再与其他的链表进行合并。看图更容易理解

 代码：

/**
 * 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;
        return mergeTwolists(lists, 0, lists.length - 1);
    }
    //分治
    private ListNode mergeTwolists(ListNode[] lists, int start, int end){
        if(start == end){
            return lists[start];
        }
        int mid = start + (end - start) / 2;
        ListNode l1 = mergeTwolists(lists, start, mid);
        ListNode l2 = mergeTwolists(lists, mid+1, end);
        return merge(l1, l2);
    }
    //合并    
    private ListNode merge(ListNode a, ListNode b){
        if(a == null || b == null){
            return (a == null) ? b : a;
        }
        if(a.val < b.val){
            a.next = merge(a.next, b);
            return a;
        }else{
            b.next = merge(a, b.next);
            return b;
        }

    }
}

小知识：

1.compare(Object o1, Object o2) 方法，比较o1和o2的大小：

如果要按照升序排序，
则 o1小于o2返回 -1，o1与o2相等返回 0，01大于02返回 1

如果要按照降序排序
则 o1小于o2返回 1，o1与o2相等返回 0，01大于02返回 -1

2.优先队列：优先队列PriorityQueue是Queue接口的实现，可以对其中元素进行排序

常用方法：

peek()//返回队首元素

poll()//返回队首元素，队首元素出队列

add()//添加元素

size()//返回队列元素个数

isEmpty()//判断队列是否为空，为空返回true,不空返回false

优先队列中的元素可以默认自然排序或者通过提供的Comparator（比较器）在队列实例化的时排序。（不指定Comparator时默认为最小堆）

PriorityQueue<Integer> heap = new PriorityQueue<Integer>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //升序（小顶堆）
                return o1 - o2; 
                或者这样写：
                //降序（大顶堆）
　　　　　  return o2 - o1;
            }
        });

 总结：

小顶堆， return 前减后(o1-o2)；
大顶堆， return 后减前(o2-o1)；

在堆中，比较器的使用方式为：若返回值>=0，则表示不要交换，否则，需要交换。所以我们只需要认清传入的两个参数，o1和o2哪一个是谁我们就可以控制其是否要交换，只需要记住，o1永远是新的，在插入时是child，删除时是parent。