剑指 Offer II 078. 合并排序链表

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

示例 1：

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

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

提示：

k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4

---

第一时间想到的是个笨方法，就是先比较每个链表的首节点，将最小的拿出来放入result，被拿出来的链表指针前进一个节点，然后再比较所有链表首节点，以此类推。

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        auto cmp=[](ListNode* node1, ListNode* node2)->bool{return node1->val>node2->val;};
        priority_queue<ListNode*,vector<ListNode*>,decltype(cmp)> q(cmp);
        for(ListNode* node: lists)
        {
            if(node!=nullptr)
                q.push(node);
        }
        ListNode* cur=new ListNode(0);
        ListNode* res=cur;
        while(!q.empty())
        {
            ListNode* node = q.top();
            q.pop();
            if(node->next!=nullptr)
            {
                q.push(node->next);
            }
            cur->next = node;
            cur = cur->next;
        }
        return res->next;
    }
};

昨晚之后看评论区的骚操作，用归并排序，两两合并。（分治法）
代码：

class Solution {
public:
    // 合并两个有序链表
    ListNode* merge(ListNode* p1, ListNode* p2){
        if(!p1) return p2;
        if(!p2) return p1;
        if(p1->val <= p2->val){
            p1->next = merge(p1->next, p2);
            return p1;
        }else{
            p2->next = merge(p1, p2->next);
            return p2;
        }
    }
    //将k个链表依次拆分；
    ListNode* mergelist(vector<ListNode*>& lists, int start, int end){
        //必须确保start<end才进行合并，start=end时返回自身即可;
        if(start==end){
            return lists[start];
        }
        else if(start<end){
            int mid = (start + end) / 2;
            ListNode* l1 = mergelist(lists, start, mid);
            ListNode* l2 = mergelist(lists, mid+1, end);
            return merge(l1, l2);
        }
        else{
            return NULL;
        }
    }

    //依次进行两两合并
    ListNode* mergeKLists(vector<ListNode*>& lists) {
       return mergelist(lists, 0, lists.size()-1);
    }
};