力扣---23. 合并 K 个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

---

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

提示：

• k == lists.length
• 0 <= k <= 10^4
• 0 <= lists[i].length <= 500
• -10^4 <= lists[i][j] <= 10^4
• lists[i] 按 升序 排列
• lists[i].length 的总和不超过 10^4

/**
 * 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* selectMinList(vector<ListNode*>& lists) {
        ListNode* minNode = nullptr;
        int minIndex = -1;
        for (int i = 0; i < lists.size(); ++i) {
            if (lists[i]) {
                if (!minNode || lists[i]->val < minNode->val) {
                    minNode = lists[i];
                    minIndex = i;
                }
            }
        }
        if (minIndex != -1) {
            lists[minIndex] = lists[minIndex]->next;
        }
        return minNode;
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode* dummy = new ListNode();
        ListNode* tail = dummy;
        while (true) {
            ListNode* minNode = selectMinList(lists);
            if (!minNode) {
                break;
            }
            tail->next = minNode;
            tail = tail->next;
        }
        ListNode* mergedHead = dummy->next;
        delete dummy; // Free the dummy node
        return mergedHead;
    }
};

这个做法时间复杂度较高，下面是一个时间复杂度更小的算法。

代码解析

1. 定义链表结构：
   • 定义一个ListNode结构来表示链表节点。
2. 优先队列的比较对象：
   • 定义一个compare结构体，用于优先队列的元素比较，确保优先队列是一个小顶堆。
3. 合并函数：
   • 在Solution类中定义mergeKLists函数，将所有链表合并为一个升序链表。
   • 使用优先队列来存储每个链表的当前节点，并逐个取出最小的节点来构建新的链表。

/**
 * 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) {}
 * };
 */
struct compare {
    bool operator()(ListNode* a, ListNode* b) {
        return a->val > b->val;
    }
};

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<ListNode*, vector<ListNode*>, compare> pq;
        for (ListNode* list : lists) {
            if (list != nullptr) {
                pq.push(list);
            }
        }
        ListNode* dummy = new ListNode(0);
        ListNode* tail = dummy;

        while (!pq.empty()) {
            ListNode* minNode = pq.top();
            pq.pop();

            // Append it to the merged list
            tail->next = minNode;
            tail = tail->next;

            if (minNode->next != nullptr) {
                pq.push(minNode->next);
            }
        }

        
        ListNode* mergedHead = dummy->next;
        delete dummy; 
        return mergedHead;
    }
};

这段代码定义了一个优先队列（priority_queue），其元素是指向ListNode结构的指针。下面是对这段代码的详细解释：

priority_queue<ListNode*, vector<ListNode*>, compare> pq;

1. priority_queue

priority_queue 是 C++ 标准库提供的一种容器适配器，它提供了类似堆（heap）的功能，可以用来高效地获取和移除队列中优先级最高的元素。默认情况下，priority_queue 是一个最大堆，意思是它总是将最大的元素放在队列的顶部。

2. ListNode*

ListNode* 表示优先队列中的元素类型是 ListNode 结构的指针。

3. vector<ListNode*>

vector<ListNode*> 是用于存储 ListNode 指针的底层容器类型。在这个优先队列中，vector 被用作底层容器，保存实际的数据。

4. compare

compare 是一个函数对象，用于自定义优先队列中的元素比较规则。优先队列使用这个比较规则来决定元素的优先级。

自定义比较规则

要定义自定义的比较规则，可以创建一个结构体或类，并重载 operator() 运算符。例如：

struct compare {
    bool operator()(ListNode* a, ListNode* b) {
        return a->val > b->val; // 小顶堆：最小元素有最高优先级
    }
};

在这个自定义比较规则中，operator() 被重载为一个布尔运算符，用于比较两个 ListNode 指针 a 和 b。这里使用的是“小顶堆”的规则，即具有较小值的节点将被认为具有更高优先级（被认为“更大”），这样它们会排在队列的前面。