面试：合并K个有序链表（二路归并+常规解法）

合并K个升序的有序链表，其实在本质上跟合并两个有序的链表是一样的，区别在于，前者需要合并更多次，而这个多次的合并过程也就是我们需要重点考虑的。

首先，我们来看看合并两个升序的有序链表是如何实现的，代码如下：

private ListNode mergeTwo(ListNode fRoot, ListNode sRoot){
        // 如果存在一个为空，返回不为空的
        if(fRoot==null || sRoot==null){
            return fRoot==null?sRoot:fRoot;
        }
        // 两个都不为空
        ListNode f=fRoot, s=sRoot;
        ListNode dummy= new ListNode();
        ListNode head = new ListNode();
        dummy = head;
        while(f!=null && s!=null){
            if(f.val<s.val){
                head.next = f;
                f = f.next;        
            }else{
                head.next = s;
                s = s.next;
            }
            head = head.next;
        }

        head.next = f==null?s:f;
        head = head.next;
        return dummy.next;
}

基于上面的代码，我们来看看如何去合并K个有序的链表。

思路1：每次合并两个有序链表，合并后的链表再同下一个链表进行合并，直至结束。（常规思路）

// ListNode[] lists为K个链表的数组
public ListNode mergeKLists(ListNode[] lists) {

        if(lists.length==0){
            return null;
        }
        ListNode node = lists[0];
        for(int i=1;i<lists.length;i++){
            node = mergeTwo(node,lists[i]);
        }
        return node;
}

思路2：采用二路归并思路，两两合并链表，再将两两合并后的链表进行两两合并，直至结束。（时间上比思路1快，但要注意栈深的问题）

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

private ListNode mergeParse(ListNode[] lists, int l, int r){
    if(l==r){
        return lists[l];
    }

    if(l>r){
        return null;
    }

    int mid = (l+r)>>1;
    ListNode one = mergeParse(lists, l, mid);
    ListNode two = mergeParse(lists, mid+1, r);
    return merge(one, two);
}