leetCode第23题

之所以记录这道题，是因为提交的时候出现了一个BUG我感觉很有意思，下面是我的第一版解法

    public ListNode mergeKLists(ListNode[] lists) {
        PriorityQueue<ListNode> priorityQueue = new PriorityQueue<>(lists.length,(a,b)->a.val-b.val);
        for (ListNode listNode:lists){
            //遍历lists
            while (listNode!=null){
                priorityQueue.add(listNode);
                listNode = listNode.next;
            }
        }
        ListNode head = new ListNode();
        ListNode tmp = head;
        while (!priorityQueue.isEmpty()){
            ListNode l1 = priorityQueue.poll();
            tmp.next = l1;
            tmp = l1;
        }
        return head.next;
    }

初看没什么问题对不对，我也这么认为的，但是提交的时候报如下错误

Found cycle in the ListNode

意思如其描述，链表出现环了，但是是怎么出现的呢？首先入优先级队列的时候肯定没有，那必然是生成新的返回链表的时候出现的。具体分析了一下，发现在

  ListNode l1 = priorityQueue.poll();
            tmp.next = l1;

这一句出现了问题。

因为priorityQueue poll出来的结点是有next的，就比如原来的某个链表是4->2->1->3,

priorityQueue先poll出1，然后poll出2，我们本意是head->1->2。。。

但是因为原来链表2->1，这样就形成了环，就出现了上面的报错，所以在构造新链表的时候将next设为null即可，我们需要的仅仅是他的值

  ListNode l1 = priorityQueue.poll();
            l1.next = null;
            tmp.next = l1;

下面是完整的代码

    public ListNode mergeKLists(ListNode[] lists) {
        PriorityQueue<ListNode> priorityQueue = new PriorityQueue<>(lists.length,(a,b)->a.val-b.val);
        for (ListNode listNode:lists){
            //遍历lists
            while (listNode!=null){
                priorityQueue.add(listNode);
                listNode = listNode.next;
            }
        }
        //创建新的Listnode，用头插法
        ListNode head = new ListNode();
        ListNode tmp = head;
        while (!priorityQueue.isEmpty()){
            ListNode l1 = priorityQueue.poll();
            l1.next = null;
            tmp.next = l1;
            tmp = l1;
        }
        return head.next;
    }

这样就能通过leetcode的提交了。

然后我看了一下别的和我的思路比较相同的解法，发现还有优化的地方，题目中给的lists所有的子链表都是已经排过序的，这个条件我没有用到，如果利用这个条件的话，代码可以优化为

    public ListNode mergeKLists(ListNode[] lists) {
        if (lists.length == 0) {
            return null;
        }
        //虚拟头节点
        ListNode dummy = new ListNode(-1);
        ListNode p = dummy;
        //优先级队列，最小堆,list.length是初始化capacity，可以省略
        PriorityQueue<ListNode> queue = new PriorityQueue<>(lists.length,(o1, o2) -> o1.val - o2.val);
        // 将k个链表的头节点假如最小堆
        for (ListNode head:lists){
            if (head!=null){
                queue.add(head);
            }
        }
        while (!queue.isEmpty()){
            //获取最小节点，街道结果链表中
            ListNode node = queue.poll();
            p.next = node;
            if (node.next!=null){
                queue.add(node.next);
            }
            p = p.next;
        }

        return dummy.next;
    }

这段代码比我的代码要节省更少的空间，因为priorityQueue有进有出，所以最小堆的深度也没有我的代码的深，插入调整啥的操作也会更快，所以这个解法更好