23. 合并 K 个升序链表

 

---

题目

题目链接：https://leetcode.cn/problems/merge-k-sorted-lists/

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

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

算法 = k 个指针分别指向 k 条链表 & 题目特征 = 合并俩个链表的升级版

合并 k 个有序链表的逻辑类似合并两个有序链表。

难点在于，如何快速得到 k 个节点中的最小节点，接到结果链表上？

维护一个最小节点的指针和对应的链表索引，依次选择最小的节点进行合并。

通过不断更新最小节点和链表指针，最终完成K个有序链表的合并。

假设有三个有序链表：

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

初始状态下，每个链表的指针如下：

List 1: 1 -> 4 -> 5
         ^
List 2: 1 -> 3 -> 4
         ^
List 3: 2 -> 6
         ^

首先，minNode和minPointer初始化为null和-1。

在第一次循环中，遍历三个链表，比较当前节点的值。minNode为null，所以将List 1的第一个节点1赋值给minNode，并将minPointer设为0（表示最小节点在List 1中）。

接下来，将minNode（即1）添加到结果链表中，然后更新List 1的指针，使其指向下一个节点。

结果链表：1
List 1: 4 -> 5
         ^
List 2: 1 -> 3 -> 4
         ^
List 3: 2 -> 6
         ^

在第二次循环中，再次遍历三个链表。minNode为1，minPointer为0（表示最小节点在List 1中）。

将minNode（即1）添加到结果链表中，然后更新List 2的指针，使其指向下一个节点。

结果链表：1 -> 1
List 1: 4 -> 5
              ^
List 2: 3 -> 4
         ^
List 3: 2 -> 6
         ^

在第三次循环中，再次遍历三个链表。minNode为1，minPointer为1（表示最小节点在List 2中）。

将minNode（即1）添加到结果链表中，然后更新List 1的指针，使其指向下一个节点。

结果链表：1 -> 1 -> 2
List 1: 4 -> 5
                   ^
List 2: 3 -> 4
              ^
List 3: 2 -> 6
         ^

继续循环直到所有链表遍历完毕。最终得到的合并后的有序链表为：1 -> 1 -> 2 -> 3 -> 4 -> 4 -> 5 -> 6。

完整代码：

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int k = lists.size();                          // 通过传入的 vector lists，获取链表的数量k
        ListNode* dummyHead = new ListNode(0);         // 创建一个虚拟头结点dummyHead
        ListNode* tail = dummyHead;                    // 将尾指针tail指向dummyHead
        while (true) {                                 // 进入一个无限循环，直到跳出循环为止
            ListNode* minNode = nullptr;               // 定义minNode指针，用于记录当前最小节点
            int minPointer = -1;                       // 定义minPointer变量，用于记录对应的链表索引
            for (int i = 0; i < k; i++) {              // 遍历k个链表，判断当前链表指针lists[i]是否为空
                if (lists[i] == nullptr)               // 如果为空
                    continue;                          // 则继续遍历下一个链表
                if (minNode == nullptr || lists[i]->val < minNode->val) {  // 如果minNode为空 或者 lists[i]的值小于minNode的值
                    minNode = lists[i];                // 则更新minNode为lists[i]
                    minPointer = i;                    // minPointer为i
                }
            }
            if (minPointer == -1)                        // 如果minPointer仍然为-1，说明所有链表已经遍历完毕
                break;                                   // 跳出循环
            tail->next = minNode;                        // 将minNode连接到结果链表的尾部，即tail->next = minNode
            tail = tail->next;                           // 并更新tail指针为minNode
            lists[minPointer] = lists[minPointer]->next; // 更新lists[minPointer]为下一个节点
        }
        return dummyHead->next;                          // 返回合并后的链表的头节点
    }
};

算法 = 最小堆 & 题目特征 = 快速获取 k 个节点中的最小节点

合并 k 个有序链表的逻辑类似合并两个有序链表。

难点在于，如何快速得到 k 个节点中的最小节点，接到结果链表上？

把链表节点放入一个最小堆，就可以每次获得 k 个节点中的最小节点。

对比前一种方法。

• 减少比较次数：在每次循环中，只需从优先级队列中取出最小节点，而不是遍历K个链表进行比较。

• 无需每次更新最小节点的指针：在之前的方法中，通过遍历K个链表并比较节点值，确定最小节点后需要更新该链表的指针。而在最小堆的方法中，只需将最小节点的下一个节点加入优先级队列，无需显式更新指针。

这样可以减少比较的次数，提高效率。

class Solution {
public:
    struct compare {
    bool operator()(const ListNode* a, const ListNode* b) {
        return a->val > b->val;
    }
};

ListNode* mergeKLists(vector<ListNode*>& lists) {
    if (lists.size() == 0) return nullptr;
    // 虚拟头结点
    ListNode* dummy = new ListNode(-1);
    ListNode* p = dummy;
    // 优先级队列，最小堆
    priority_queue<ListNode*, vector<ListNode*>, compare> pq;
    // 将 k 个链表的头结点加入最小堆
    for (ListNode* head : lists) {
        if (head != nullptr)
            pq.push(head);
    }

    while (!pq.empty()) {
        // 获取最小节点，接到结果链表中
        ListNode* node = pq.top();
        pq.pop();
        p->next = node;
        if (node->next != nullptr) 
            pq.push(node->next);
        // p 指针不断前进
        p = p->next;
    }
    return dummy->next;
	}
};