23.合并K个升序链表

前置知识：合并两个有序链表
思路
在解决[合并K个排序链表]这个问题之前，我们先看一个简单的问题：如何合并两个有序链表？建设链表a和b的长度都是n，如何在O(N)的时间代价以及O(1)的空间代价完成合并？。为了达到空间代价是O(1)，需要原地调整链表元素完成合并。

首先需要设置虚拟头部head保存合并之后链表的头部。
需要指针tail来记录下一个插入位置的位置，以及两个指针aPtr和bPtr来记录a和b未合并部分的第一位。
当aPtr和bPtr都不为空的时候，取val较小的合并；如果aPtr为空，则把整个bPtr以及后面的元素全部合并；bPtr为空时同理；
合并时，应先调整tail的next属性，在后移tail和*Ptr(aPtr和bPtr)。

    public ListNode mergeTwoLists(ListNode a, ListNode b){
        /**
         * 1.需要一个head保存合并之后链表的头部
         * 2.指针tail记录下一个插入位置的前一个位置
         * 3.aPtr和bPtr记录a和b未合并的第一位
         * 复杂度：时间复杂度O(N),空间复杂度O(1).
         */
        if(a==null||b==null){
            return a!=null?a:b;
        }
        ListNode head = new ListNode();
        ListNode tail = head, aPtr = a, bPtr = b;
        while(aPtr!=null&&bPtr!=null){
            if(aPtr.val<bPtr.val){
                tail.next = aPtr;
                aPtr = aPtr.next;
            }else{
                tail.next = bPtr;
                bPtr = bPtr.next;
            }
            tail = tail.next;
        }
        tail.next = (aPtr!=null?aPtr:bPtr);
        return head.next;
    }

复杂度分析

时间复杂度：O(N);
空间复杂度：O(1);

方法一：顺序合并
思路
用一个变量ans来维护以及合并的链表，第i次循环把第i个链表和ans合并，答案保存到ans中。

    public ListNode mergeKLists(ListNode[] lists) {
        /**
         * 23.合并K个升序链表
         * Lists: 链表数组
         */
        ListNode ans = null;
        for(int i =0;i<lists.length;++i){
            ans = mergeTwoLists(ans, lists[i]);
        }
        return ans;
    }

复杂度分析

时间复杂度：假设每个链表的最长长度是n。在第一次合并之后，ans的长度为n;第二次合并之后，ans的长度为2n,第i次合并之后，ans的长度为in。第i次合并的时间代价是O(n+(i-1)n)=O(in)，那么总的时间代价为 $O(\sum_{i=1}^k(i×n))=O(\frac{(1+k)k}{2}×n=O(k^2n))$ ,故渐进时间复杂度为 $O(k^2n)$ 。
空间复杂度：没有用到与k和n规模相关的辅助空间，故渐进空间复杂度为O(1)。

方法二：分治合并
思路
优化方法一，用分治的方法进行合并。

将k个链表配对并将同一对中的链表合并。
第一轮合并后，k个链表合并成了 $\frac{k}{2}$ 个链表，平均长度为 $2n$ ，然后是 $\frac{k}{4}$ 个链表， $\frac{k}{8}$ 个链表等等；
重复这一个过程，直到得到最终的有序链表。

    public ListNode mergeKLists(ListNode[] lists) {
        /**
         * 23.合并K个升序链表
         * Lists: 链表数组
         */
        return merge(lists, 0, lists.length-1);
    }

    public ListNode merge(ListNode[] lists, int l, int r){
        if(l==r){
            return lists[l];
        }
        if(l>r){
            return null;
        }
        int mid = (l+r)>>1;
        return mergeTwoLists(merge(lists, l, mid), merge(lists, mid+1, r));
    }

复杂度分析

时间复杂度：考虑递归[向上回升]的过程——第一轮合并 $\frac{k}{2}$ 组链表，每组时间代价是O(2n);第二轮合并 $\frac{k}{4}$ 组链表，每一组的时间代价是O(4n)……所有总的时间代价是 $O(\sum_{i=1}^∞\frac{k}{2^i}×2^in)=O(kn)$ 。
空间复杂度：递归会使用 $O(logk)$ 空间代价的栈。

方法三：使用优先队列合并
思路
我们需要维护当前每个链表没有被合并的元素的最前面一个，k个链表就最多有k个满足这样条件的元素，每次在这些元素里面选取val最小的合并到答案中。在选取最小元素时，我们可以使用优先队列来优化这个过程。

    class Status implements Comparable<Status> {
        int val;
        ListNode ptr;

        Status(int val, ListNode ptr){
            this.val = val;
            this.ptr = ptr;
        }

        @Override
        public int compareTo(Status status) {
            return this.val-status.val;
        }
    }

    PriorityQueue<Status> queue = new PriorityQueue<>();
    public ListNode mergeKLists(ListNode[] lists) {
        /**
         * 23.合并K个升序链表
         * Lists: 链表数组
         */
        for(ListNode node: lists){
            if(node!=null){
                queue.offer(new Status(node.val, node));
            }
        }
        ListNode head = new ListNode(0);
        ListNode tail = head;
        while(!queue.isEmpty()){
            Status f = queue.poll();
            tail.next = f.ptr;
            tail = tail.next;
            if(f.ptr.next!=null){
                queue.offer(new Status(f.ptr.next.val, f.ptr.next));
            }
        }
        return head.next;
    }