合并K个有序的链表

题目：给定一个链表数组，每个链表都已经按升序排列。

请将所有链表合并到一个升序链表中，返回合并后的链表。

**示例 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 = []输出：[]

算法一：两两进行合并(二路归并法合并两个链表)

//顺序进行两两二路合并
//时间复杂度为 O(k^2 n)
//空间复杂度O(1)
class Solution {
public:
     ListNode* mergeTwolists(ListNode* l1,ListNode* l2)
     {
         if(!l1 || !l2) return l1?l1:l2;
         ListNode* dummy=new ListNode(-1);
         ListNode* p=dummy;
         while(l1 && l2)
         {
             if(l1->val<l2->val)
             {
                 p->next=l1;
                 l1=l1->next;
             }
             else
             {
                 p->next=l2;
                 l2=l2->next;
             }
             p=p->next;
         }
         p->next=(l1?l1:l2);
         return dummy->next;
     }
    ListNode* mergeKLists(vector<ListNode*>& lists) {

        ListNode* temp=nullptr;//如果链表组为空，或者每个链表长度为0，返回的temp都为NULL
        for(size_t i=0;i<lists.size();i++)//两两进行合并，第 i 次循环把第 i 个链表和 temp 合并，答案保存到 temp 中
        {
            temp=mergeTwolists(temp,lists[i]);
        }
        return temp;
    }
};

算法二：分治合并

//时间复杂度O(kn logk)
//空间复杂度O(logk)
class Solution {
public:
    ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
        if ((!a) || (!b)) return a ? a : b;
        ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
        while (aPtr && bPtr) {
            if (aPtr->val < bPtr->val) {
                tail->next = aPtr; aPtr = aPtr->next;
            } else {
                tail->next = bPtr; bPtr = bPtr->next;
            }
            tail = tail->next;
        }
        tail->next = (aPtr ? aPtr : bPtr);
        return head.next;
    }

    ListNode* merge(vector <ListNode*> &lists, int l, int r) {
        if (l == r) return lists[l];
        if (l > r) return nullptr;
        int mid = (l + r) >> 1;
        return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return merge(lists, 0, lists.size() - 1);
    }
};