LeetCode每日一练：23. 合并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 = [[]]
输出：[]

示例解释：

输入：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 = [[]]
输出：[]

第一想法：

读题可知，该题是将几个有序链表分别取出最小的值来进行比较，然后将最小值插入到结果集的末尾，暴力轻松拿下！（暴力的代码不好玩就不写了）

可以想一下还有什么其他方法可以优化一下的

既然每次手动遍历k个链表时间复杂度太高，那可不可以让优化过的集合来帮忙实现呢？

Java中自带PriorityQueue底层为小根堆（可以通过重写比较方法变为大根堆）（想看大小根堆实现的可以在评论区留言，我再出一期小根堆的实现）

思路：

        先将每个ListNode加在PriorityQueue中，自动实现排序功能，每次只需要弹出最小的链表，再让链表指向下一位重新插入到PriorityQueue中

话不多说，直接上代码：

public static ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }
        PriorityQueue<ListNode> queue = new PriorityQueue<>(((o1, o2) -> o1.val-o2.val));
        ListNode cur = new ListNode(-1);
        ListNode res = cur ;
        for (int i = 0; i < lists.length; i++) {
            if (lists[i] != null) {
                queue.add(lists[i]);
            }
        }
        while (!queue.isEmpty()) {
            ListNode poll = queue.poll();
            cur.next = poll;
            if (poll.next != null) {
                queue.add(poll.next);
            }
            cur = cur.next;
        }

        return res.next;
    }

其实还可以想一下，两个有序链表融合大家都会吧，那么n个链表...是不是就不用我说你也想到了

没错，就是将链表两两融合，然后再将上次融合的结果进行融合直至剩下一个链表，和归并排序很像有没有！

直接上代码：

    public static ListNode mergeKLists1(ListNode[] lists) {
        return merge(lists, 0, lists.length - 1);
    }

    public static ListNode merge(ListNode[] lists, int l, int r) {
        if (l == r) {
            return lists[l];
        }
        if (l > r) {
            return null;
        }
        int mid = l + ((r - l) >> 1);
//        return doubleMerge(merge(lists, l, mid),merge(lists,mid,r));
        ListNode left = merge(lists, l, mid);
        ListNode right = merge(lists, mid+1, r);
        return doubleMerge(left, right);
    }

    public static ListNode doubleMerge(ListNode list1, ListNode list2) {
        if (list1 == null || list2 == null) {
            return list1 == null ? list2 : list1;
        }
        ListNode cur = new ListNode(-1);
        ListNode res = cur ;
        while (list1 != null && list2 != null) {
            if (list1.val < list2.val){
                cur.next = list1;
                list1 = list1.next;
            }else {
                cur.next = list2 ;
                list2 = list2.next;
            }
            cur = cur.next;
        }
        cur.next = list1 == null ? list2 : list1;
        return res.next;
    }