leetcode_23.合并K排序链表

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:
输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6

解析：看到这一题，马上就能想到之前的合并两个链表leetcode_21.合并两个有序链表
这一题相当于上一题的升级版，从合并的实现方法上来说可以参照上一题。

问题在于合并的顺序，最简单的方法是按照顺序一一合并，第一题合并1和2，然后将合并后的新1和3合并，然后是1和4。这样虽然简单，但是相当于第一条链表合并了k次，第二条链表合并了k-1次，太多次重复的合并操作大大增加了运算时间。

我们可以采用分治的思想，每次合并操作可以分解为将前半部分合并与将后半部分合并，而子合并操作同样可以分解，一直到仅剩一条或者两条链表合并。此时每条链表相当于合并了log₂K次，复杂度从O(N²)降到了O(NlogN)。

有什么办法可以快速有效的实现分治算法呢，我们想到了队列。将整个数组按顺序放入队列，每次取出队列前两个链表，并将合并后的新链表插入队列尾。这样不需要额外的判断便自然实现了分治算法。

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size()==0) return nullptr;
        if(lists.size()==1) return lists[0];
        //现将vector转换为deque,双端队列首尾插入迅速,再构建队列
        queue<ListNode*> tmp(deque<ListNode*>(lists.begin(),lists.end()));
        while(tmp.size()>1){
            ListNode* a = tmp.front();
            tmp.pop();
            ListNode* b = tmp.front();
            tmp.pop();
            tmp.push(mergeTwoLists(a,b));
        }
        return tmp.front();
    }
private:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* head = new ListNode(0);
        ListNode* pre = head;
        while(l1!=nullptr&&l2!=nullptr){
            if(l1->val<l2->val){
                pre->next = l1;
                l1 = l1->next;
            }
            else{
                pre->next = l2;
                l2 = l2->next;
            }
            pre = pre->next;
        }
        pre->next = (l1?l1:l2);
        return head->next;
    }
};