leetcode23. 合并 K 个升序链表,两种方法带你完全理解

合并 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

第一种方法，我们利用stl中的优先队列。

定义比较函数：首先定义了一个比较结构体cmp，该结构体重载了比较运算符operator()，用于比较两个链表节点的大小。比较逻辑是确保较小的节点值会被优先考虑。

初始化优先队列：使用priority_queue来创建一个小顶堆，它将根据cmp结构体中定义的比较逻辑来维护元素的顺序。

填充优先队列：遍历输入的链表数组lists，对于每个非空链表，将其头节点加入到优先队列中。

构建结果链表：初始化一个虚拟头节点res，用于构建最终的合并链表。使用一个指针head来跟踪新链表的最后一个节点。

循环处理：只要优先队列不为空，就执行以下操作：
从优先队列中取出当前最小的节点，将其添加到结果链表中（通过将head的next指向它）。
移动head指针到新添加的节点，以便下一个节点可以连接到它。
如果取出的节点有后继节点，将后继节点加入到优先队列中。

返回结果：循环结束后，优先队列为空，此时res->next指向的就是合并后链表的头节点，返回这个节点作为算法的输出。
具体代码如下：

class Solution {
  public:
    struct cmp {
        //重载小顶堆比较方式
        bool operator()(ListNode* a, ListNode* b) {
            return  a->val > b->val;
        }
    };
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        //小顶堆
        priority_queue<ListNode*, vector<ListNode*>, cmp> pq;
        //遍历所有链表第一个元素
        for (int i = 0; i < lists.size(); i++) {
            //不为空则加入小顶堆
            if (lists[i] != NULL)
                pq.push(lists[i]);
        }
        //加一个表头
        ListNode* res = new ListNode(-1);
        ListNode* head = res;
        //直到小顶堆为空
        while (!pq.empty()) {
            //取出最小的元素
            ListNode* temp = pq.top();
            pq.pop();
            //连接
            head->next = temp;
            head = head->next;
            //每次取出链表的后一个元素加入小顶堆
            if (temp->next != NULL)
                pq.push(temp->next);
        }
        return res->next;
    }
};

第二种方法，我们使用归并。

定义合并两个有序链表的函数 Merge2:
如果其中一个链表的头节点为空，则直接返回另一个链表。
创建一个新的虚拟头节点head，用于构建合并后的链表，并用cur指针来跟踪当前链表的末尾。
使用两个指针pHead1和pHead2分别遍历两个链表，比较节点的值，将较小的节点添加到结果链表中，并移动对应的指针。
当一个链表遍历完成后，将另一个链表剩余的部分直接连接到结果链表的末尾。
返回合并后链表的头节点，去掉了虚拟头节点。

定义递归分治的函数 divideMerge:
如果左右索引left和right的范围无效（left > right），则返回空。
如果只有一个链表（left == right），则直接返回该链表的头节点。
否则，计算中间索引mid，将问题分解为两个子问题：分别合并左半部分和右半部分的链表。
对左半部分和右半部分递归调用divideMerge函数，然后将得到的两个结果链表合并。
返回合并后的链表。

具体代码如下：

class Solution {
  public:
    //两个有序链表合并函数
    ListNode* Merge2(ListNode* pHead1, ListNode* pHead2) {
        //一个已经为空了，直接返回另一个
        if (pHead1 == NULL)
            return pHead2;
        if (pHead2 == NULL)
            return pHead1;
        //加一个表头
        ListNode* head = new ListNode(0);
        ListNode* cur = head;
        //两个链表都要不为空
        while (pHead1 && pHead2) {
            //取较小值的节点
            if (pHead1->val <= pHead2->val) {
                cur->next = pHead1;
                //只移动取值的指针
                pHead1 = pHead1->next;
            } else {
                cur->next = pHead2;
                //只移动取值的指针
                pHead2 = pHead2->next;
            }
            //指针后移
            cur = cur->next;
        }
        //哪个链表还有剩，直接连在后面
        if (pHead1)
            cur->next = pHead1;
        else
            cur->next = pHead2;
        //返回值去掉表头
        return head->next;
    }

    //划分合并区间函数
    ListNode* divideMerge(vector<ListNode*>& lists, int left, int right) {
        if (left > right)
            return NULL;
        //中间一个的情况
        else if (left == right)
            return lists[left];
        //从中间分成两段，再将合并好的两段合并
        int mid = (left + right) / 2;
        return Merge2(divideMerge(lists, left, mid), divideMerge(lists, mid + 1,
                      right));
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        //k个链表归并排序
        return divideMerge(lists, 0, lists.size() - 1);
    }
};