23多个链表合并

合并K个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

输入：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

输入：lists = []
输出：[]

输入：lists = [[]]
输出：[]

public class KMerge {
    //创建一个ListNode比较器，共PriorityQueue使用，可以比较两个节点的大小。
    public static class ValComparator implements Comparator<ListNode>{
        @Override
        public int compare(ListNode o1, ListNode o2) {
            return o1.val-o2.val;
        }
    }
    public ListNode mergeKLists(ListNode[] lists) {
        //PriorityQueue的实质是小根堆，每加入一个元素，意味着重新排序，将最小元素放在堆顶，通过poll方法可以获得最小元素。
        PriorityQueue<ListNode> priorityQueue=new PriorityQueue<>(new ValComparator());
        //如果lists为null，返回null。
        if(lists.length==0){
            return null;
        }
        //将lists中不为null的头结点都加入到小根堆中。
        for(int i=0;i<lists.length;i++){
            if(lists[i]!=null){
                priorityQueue.add(lists[i]);
            }
        }
        //如果小根堆为null，返回null
        if(priorityQueue.isEmpty()){
            return null;
        }
        //先将最小数返回，作为头结点。
        ListNode head=priorityQueue.poll();
        ListNode pre=head;
        //头结点的下一个节点不为null，加入小根堆。
        if(pre.next!=null){
            priorityQueue.add(pre.next);
        }
        //如果小根堆不为空，则弹出最小的数，加入到返回的最终链表中，然后将最小数的下一个节点加入。
        while (!priorityQueue.isEmpty()){
            ListNode cur=priorityQueue.poll();
            pre.next=cur;
            pre=cur;
            if(cur.next!=null){
                priorityQueue.add(cur.next);
            }
        }
        return head;

    }
}