Merge k Sorted Lists

1，题目要求

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

Example:
Input:

[
  1->4->5,
  1->3->4,
  2->6
]

Output: 1->1->2->3->4->4->5->6

合并k个已排序的链表并将其作为一个排序列表返回。 分析并描述其复杂性。

2，题目思路

对于这道题，要求将k个有序单链表合并为一个有序的单链表。

之前，我们做过一道合并两个有序单链表的题目：
Merge Two Sorted Lists

而这道题，是将两个的合并改为k个合并。
一个直接的想法，是利用两两单链表合并的方法，对这k个单链表进行合并即可。

而如果我们想要一揽子的按照两个单链表合并的方法，我们需要定义一个头指针，然后每次都要找到这k个单链表第一个节点中值最大的节点方可。
而每次都要找到这k个最大值，一个比较好的策略是使用priority_queue，即优先队列。
不过还需要注意，首先，我们这里用的是ListNode*的数据类型，因此，priority_queue并不知道如何进行比较排序，也不清楚该数据类型，因此，我们需要给其指定数据类型和数据存储容器container，以及比较方法。
其次，因为priority_queue是默认按照大顶堆的方法实现的，即从大到小的顺序。在这里我们需要从小到大进行排序，因此，我们需要按照从大到小的方法定义cmp，这样才能实现从小到大的排序。

3，代码实现

1，常规合并方法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

static const auto s = []() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return nullptr;
}();


class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.empty())
            return nullptr;
        
        queue<ListNode*> ll;
        for(auto &l : lists)
            ll.push(l);
        while(ll.size() > 1){
            // lists.push_back(mergeTwoLists(lists[0], lists[1]));
            // lists.erase(lists.begin());
            // lists.erase(lists.begin());
            ListNode* temp1 = ll.front();ll.pop();
            ListNode* temp2 = ll.front();ll.pop();
            ll.push(mergeTwoLists(temp1, temp2));
        }
        return ll.front();
    }
private:
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2){
        if(l1 == nullptr)
            return l2;
        if(l2 == nullptr)
            return l1;
        
        if(l1->val <= l2->val){
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;
        }
        else
        {
            l2->next = mergeTwoLists(l1, l2->next);
            return l2;
        }
    }
};

2，利用priority_queue实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
static const auto s = []() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return nullptr;
}();

//因为priority_queue默认从大到小，因此使用以下方法
//实现对结构体的从小到大的排序方法
struct cmp{
    bool operator()(ListNode* a, ListNode* b){
        return a->val > b->val;
    }
};

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<ListNode*, vector<ListNode*>, cmp> pq;
        for(auto &list : lists)
            if(list)
                pq.push(list);
        
        ListNode* p = new ListNode(-1);
        ListNode* head =p;
        while(!pq.empty()){
            ListNode* top = pq.top();
            pq.pop();
            
            p->next = top;
            p = p->next;
            if(top->next)
                pq.push(top->next);
        }
        return head->next;
    }
};