多路歸併總結

23. Merge k Sorted Lists
Example:
Input:
[
1->4->5,
1->3->4,
2->6
]
Output: 1->1->2->3->4->4->5->6
思路
2.1. 方法一
在 合併兩個有序鏈表 的基礎上，我們很容易想到第一種解法，首先我們將第一個鏈表和第二個鏈表合併成一個新的鏈表，然後再往後依次合併接下來的每個鏈表即可。

假設每個鏈表結點數一樣都爲 n，第一次合併時，要遍歷 2n 個結點，往後則要分別遍歷 3n, 4n, … , kn 個結點。可以看到，每次進行合併時都要將之前所有的鏈表遍歷一次，因此這個方法的時間複雜度較高，爲 O((k(k+1)2−1)∗n)

ListNode* mergeKLists(vector<ListNode*>& lists) {
    
    int k = lists.size(); // 鏈表個數
    
    if (k >= 2)
    {   
        // 先將前兩個鏈表合併爲一個新鏈表，再把新鏈表依次和後面的鏈表合併
        ListNode *head = mergeTwoLists(lists[0], lists[1]);
        for (int i = 2; i < k; i++)
        {
            head = mergeTwoLists(head, lists[i]);
        }
        
        return head;  
    }
    else if (k == 1)
    {
        return lists[0];
    } 
    else
    { 
        return NULL;
    }
    
}

    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    
    ListNode *head = new ListNode(0); // 新建哨兵結點，方便操作
    ListNode *temp = head;
    
    // 依次比較兩個鏈表的結點值，將值較小的結點插入到新建的鏈表後面
    while(l1 && l2)
    {
        if (l2->val <= l1->val)
        {
            temp->next = l2;
            temp = temp->next;
            l2 = l2->next;
        }
        else
        {
            temp->next = l1;
            temp = temp->next;
            l1 = l1->next;
        }
    }
    
    // 其中一個鏈表比較完畢，將另外一個鏈表剩餘結點直接插入到新建的鏈表後面
    if (l1)
    {
        temp->next = l1;
    }
    else
    {
        temp->next = l2;
    }
    
    temp = head;
    head = head->next;// 刪除哨兵結點
    delete(temp);
    
    return head;  
} };

2.2. 方法二
我們還可以每次只合並相鄰的兩個鏈表，這樣經過第一次合併後，鏈表個數減半，我們一直重複這個過程，直到最後剩餘一個鏈表即可。

假設每個鏈表結點數一樣都爲 n，第一次合併時，要進行 k/2 次合併，每次合併要遍歷 2n 個結點；第二次合併時，要進行 k/4 次合併，每次合併要遍歷 4n 個結點；可見，每次合併過程都只需要遍歷 kn 次結點。而總共要進行 log2k 個循環，因此這個方法的時間複雜度爲 O(n∗klog2k)

class Solution {
public:
    ListNode* merge(ListNode* head1,ListNode* head2)
    {
        auto dummy=new ListNode(-1);
        auto cur=dummy;
        ListNode* p1=head1;
        ListNode* p2=head2;
        while(p1&&p2)
        {
            if(p1->val<p2->val)
            {
                cur->next=p1;
                p1=p1->next;
               
            }
            else
            {
                cur->next=p2;
                p2=p2->next;
            }
             cur=cur->next;
        }
        if(!p1) cur->next=p2;
        if(!p2) cur->next=p1;
        return dummy->next;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.empty()) return nullptr;
        int n=lists.size();
        while(n>1)
        {
            int k=n+1>>1;
            for(int i=0;i<(n>>1);i++)
            {
                lists[i]=merge(lists[i],lists[i+k]);
            }
            n=k;
        }
        return lists[0];
        
    }
};

2.3. 方法三
利用 C++ 模板庫中的優先隊列構建小頂堆，每次首結點元素值最小的鏈表出隊，然後將首結點插入到新鏈表後面，再把刪除首結點後的子鏈表放入隊列中繼續比較，直到隊列爲空結束。

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        
        int k = lists.size();
        
        struct cmp
        {
            bool operator()(ListNode* a, ListNode* b)
            {
                return a->val > b->val;
            }
        };

        priority_queue<ListNode *, vector<ListNode*>, cmp> q; // 構建小頂堆

        for (int i = 0; i < k; i++)
        {
            if (lists[i])
                q.push(lists[i]);  // 鏈表非空，加入隊列
        }

        ListNode *head = new ListNode(0); // 新建哨兵結點，方便操作
        ListNode *temp = head;

        while(!q.empty())
        {
            temp->next = q.top(); // 將元素值最小的首結點插入到新鏈表後面
            temp = temp->next; // 指針後移
            q.pop();        // 首結點元素值最小的鏈表出隊
            if (temp->next)  // 把刪除首結點後的鏈表放入隊列中
                q.push(temp->next);
        }

        temp = head;
        head = head->next;
        delete(temp);  // 刪除哨兵結點

        return head;
    }
};
class Solution {//第二種代碼
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        auto cmp = [](ListNode*& a, ListNode*& b) {
            return a->val > b->val;
        };
        priority_queue<ListNode*, vector<ListNode*>, decltype(cmp) > q(cmp);
        for (auto node : lists) {
            if (node) q.push(node);
        }
        ListNode *dummy = new ListNode(-1), *cur = dummy;
        while (!q.empty()) {
            auto t = q.top(); q.pop();
            cur->next = t;
            cur = cur->next;
            if (cur->next) q.push(cur->next);
        }
        return dummy->next;
    }
};
class Solution {//第三種代碼
public:
  
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.empty()) return nullptr;
        int n=lists.size();
        
        struct cmp
        {
            bool operator()(ListNode*a, ListNode*b)
            {
               return  a->val>b->val;
            }
        };
        priority_queue<ListNode*,vector<ListNode*>,cmp> q;
        for(int i=0;i<n;i++) 
        {
            if(lists[i])
            q.push(lists[i]);
        }
        auto dummy=new ListNode(-1);
        auto cur=dummy;
        while(q.size())
        {
            auto tmp=q.top();
            q.pop();
            cur->next=tmp;
            cur=cur->next;
            if(tmp->next)
            {
                q.push(tmp->next);
            }
        }
        return dummy->next;
    }
};