K-geordnete verknüpfte Listen zusammenführen

Frage: Bei einem Array verknüpfter Listen wurde jede verknüpfte Liste in aufsteigender Reihenfolge sortiert.

Bitte führen Sie alle verknüpften Listen zu einer aufsteigend verknüpften Liste zusammen und geben Sie die zusammengeführte verknüpfte Liste zurück.

**Beispiel 1:**

Eingabe: Listen = [[1,4,5],[1,3,4],[2,6]]

Ausgabe: [1,1,2,3,4,4,5,6]

Erläuterung: Das Array der verknüpften Liste lautet wie folgt: [1->4->5, 1->3->4, 2->6] durch Zusammenführen zu einer geordneten verknüpften Liste. 1->1->2->3->4->4->5->6

**Beispiel 2:**

Eingabe: Listen = [] Ausgabe: []

Algorithmus 1: Zwei mal zwei zusammenführen (Zwei-Wege-Zusammenführungsmethode führt zwei verknüpfte Listen zusammen)

//顺序进行两两二路合并
//时间复杂度为 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;
    }
};

Algorithmus 2: Divide and Conquer Merge

//时间复杂度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);
    }
};