LeetCode023：合并K个生序链表

要求：给你一个链表数组，每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中，返回合并后的链表。

输入：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

思路：分治合并
将 k个链表配对并将同一对中的链表合并；第一轮合并以后， k个链表被合并成了k/2个链表，平均长度为2n/k，然后是k/4个链表，k/8个链表等等；
重复这一过程，直到我们得到了最终的有序链表。简单来说就两两合并进行排序

复杂度分析：

• 时间复杂度：考虑递归「向上回升」的过程——第一轮合并 k/2组链表，每一组的时间代价是 O(2n)；第二轮合并 k/4组链表，每一组的时间代价是O(4n)…
  所以总的时间代价是 O(kn×logk)，故渐进时间复杂度为 O(kn×logk)。

• 空间复杂度：递归会使用到O(logk)空间代价的栈空间。

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

/**
 * 选择合并那两个数组的算法
 * @param lists 链表数组
 * @param l     最左面得数组集合
 * @param r     最右面的数组集合
 * @return 合并两个有序链表
 */
private ListNode merge(ListNode[] lists, int l, int r) {
    if (l == r) {
        return lists[l];
    }
    if (l > r) {
        return null;
    }
    //右移运算符>>,运算结果正好能对应一个整数的二分之一值，这就正好能代替数学上的除2运算，但是比除2运算要快。
    //mid=(r+1)>>1相当于mid=(r+1)/2
    int mid = (r + l) >> 1;
    return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
}

private ListNode mergeTwoLists(ListNode a, ListNode b) {
    if (a == null || b == null){
        return a != null ? a : b;
    }
    ListNode head = new ListNode(0);
    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;
}