记录合并K个升序链表的方法（包含优先队列的自定义排序方法）

一.题目

23. 合并K个升序链表
    给你一个链表数组，每个链表都已经按升序排列。
    请你将所有链表合并到一个升序链表中，返回合并后的链表。
    

二.合并两个有序链表

回想之前做的合并两个有序列表。
法一：递归

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
    //递归
    //递归结束条件
    if(list1 == nullptr) {
        return list2;
    }
    if(list2 == nullptr) {
        return list1;
    }
    if(list1->val < list2->val) {
        list1->next = mergeTwoLists(list1->next, list2);
        return list1;
    }else {
        list2->next = mergeTwoLists(list1, list2->next);
        return list2;
    }
    }
};

法二：迭代

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
    //迭代，dummy虚拟头节点
    ListNode* dummy = new ListNode(-1);
    ListNode* head = dummy;
    while(list1 !=nullptr && list2 != nullptr) {
        if(list1->val < list2->val) {
            head->next = list1;
            list1 = list1->next;
        }else {
            head->next = list2;
            list2 = list2->next;
        }
        head = head->next;
    }
    head->next = list1 == nullptr ? list2 : list1;
    return dummy->next;
    }
};

三.优先队列

对合并k个升序链表这个题目可以使用优先队列的方法，分析如下：
我们维护当前每个链表没有被合并的元素的最前面一个，k 个链表就最多有 k 个满足这样条件的元素，每次在这些元素里面选取 val 属性最小的元素合并到答案中。在选取最小元素的时候，可以用优先队列来优化这个过程。
（注意优先队列的自定义排序写法）
代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
struct cmp {
    bool operator()(ListNode* a, ListNode* b) {
        return a->val > b->val;
    }
};
    priority_queue<ListNode*, vector<ListNode*>,cmp> q;
    ListNode* mergeKLists(vector<ListNode*>& lists) {
    //利用优先级队列进行节点排序
    if(lists.size() == 0) {
        return nullptr;
    }
    //创建虚拟头结点
    ListNode* dummy = new ListNode(-1);
    ListNode* head = dummy;
    //优先级队列，最小值
    for(auto node : lists) {
        if(node) q.push(node);
    }
    while(!q.empty()) {
        ListNode* node = q.top();
        q.pop();
        head->next = node;
        head = head->next;
        if(node->next) q.push(node->next);
    }
    return dummy->next;
    }
};

做这个题目之前一直记不住优先队列的自定义排序写法，所以现在重点记录下来。

//struct重载运算符的方法排序
struct cmp {
    bool operator()(ListNode* a, ListNode* b) {
        return a->val > b->val;
    }
};
    priority_queue<ListNode*, vector<ListNode*>,cmp> q;