23. 合并K个升序链表

23. 合并K个升序链表

方法1：小根堆维护 k 个链表

使用小根堆维护 k 个链表的头部，每次 O(logK) 比较 K个链表的头结点 求 min，然后poll出来，若该 min 节点的 next 不为空，则继续加入到堆中，

时间复杂度：O(NlogK)

空间复杂度 O(1)

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        int n = lists.length;
        if(n == 0){
            return null;
        }
        PriorityQueue<ListNode> pq = 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)  pq.add(list);
        }
 
        ListNode dummyHead = new ListNode(0);
        ListNode curr = dummyHead;
        
        while(!pq.isEmpty()){
            ListNode tmp = pq.poll();
            curr.next = tmp;
            curr = curr.next;
            if(tmp.next != null)  pq.add(tmp.next);
        }
        return dummyHead.next;
    }
}

方法2：两两合并链表（归并排序）

思路分析：

二路归并，这里二路归并的元素是链表，相当于每个链表是已经排序好的分块。

时间复杂度分析：

K 条链表的总结点数是 N，平均每条链表有 N/K 个节点，因此合并两条链表的时间复杂度是 O(N/K)。从 K 条链表开始两两合并成 1 条链表，因此每条链表都会被合并 logKlogK 次，因此 K 条链表会被合并 K * logK次，因此总共的时间复杂度是K∗logK∗N/K 即 O（NlogK）。

时间复杂度：O(NlogK)

 
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists.length == 0) {
            return null;
        }
        int k = lists.length;
        while (k > 1) {
            int idx = 0;
            for (int i = 0; i < k; i += 2) {
                if (i == k - 1) {
                    lists[idx++] = lists[i];
                } else {
                    lists[idx++] = merge2Lists(lists[i], lists[i + 1]);
                }
            }
            k = idx;
        }
        return lists[0];
    }
 
    private ListNode merge2Lists(ListNode l1, ListNode l2) {
    ListNode dummyHead = new ListNode(0);
    ListNode tail = dummyHead;
    while (l1 != null && l2 != null) {
        if (l1.val < l2.val) {
            tail.next = l1;
            l1 = l1.next;
        } else {
            tail.next = l2;
            l2 = l2.next;
        }
        tail = tail.next;
    }
 
    tail.next = l1 == null? l2: l1;
 
    return dummyHead.next;
}
}

方法3：合并成一个链表后用快排（待补充）

时间复杂度O(nlogn)