多路归并总结

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;
    }
};