LeetCode_23_合并K个排序链表

题目描述：
合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

输入:
[
  1->4->5,
  1->3->4,
  2->6
]
输出: 1->1->2->3->4->4->5->6

思路:
使用PriorityQueue优先队列
特点：
不能添加null元素
可重复
默认构建的是小顶堆
方法：
boolean add （E e） : 调用的offer，
boolean offer（E e） :添加指定元素到优先级队列中, 如果元素为null抛出异常
boolean remove( ) :删除头结点 （父类方法），队列为空，抛出异常
boolean remove（E e） ： 删除队列指定元素
E peek（）： 获取队列头部元素，但不删除，队列为空，返回null
E element（）：获取头结点，（父类方法），队列为空，抛出异常
E poll( ) :删除并且返回队列的头部，如果队列为空，返回null
代码：

import java.util.Comparator;
import java.util.PriorityQueue;

public class LeetCode_23 {
    public static void main(String[] args){
        ListNode l1=new ListNode(6);
        ListNode l2=new ListNode(5);
        ListNode q1=new ListNode(3);
        ListNode q2=new ListNode(2);
        q1.next=l1;
        q2.next=l2;
        ListNode n1=new ListNode(1);
        ListNode n2=new ListNode(2);
        n1.next=q1;
        n2.next=q2;
        ListNode[] lists=new ListNode[2];
        lists[0]=n1;lists[1]=n2;
        System.out.println(new Solution9().mergeKLists(lists));
    }
}

class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
    }

    public String toString() {
        return "data:" + val + " next->" + next;
    }
}
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        PriorityQueue<ListNode> priorityQueue=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) {
                priorityQueue.offer(list);
            }
        }
        ListNode pre=new ListNode(-1);
            ListNode temp=pre;
            while (!priorityQueue.isEmpty()){
                ListNode curr=priorityQueue.poll();
                temp.next=new ListNode(curr.val);
                if (curr.next!=null){
                    priorityQueue.offer(curr.next);
                }
                temp=temp.next;
            }
            return pre.next;
    }
}

输出

data:1 next->data:2 next->data:2 next->data:3 next->data:5 next->data:6 next->null

断点处