[230531 lc23] 合并 K 个升序链表

[230531 lc23] 合并 K 个升序链表

一 题目

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 = [[]]
输出：[]

二 双递归实现

2.1 整体思路

利用两个递归函数，外递归和内递归。外递归负责把一个 list 数组中的链表两两合并，将数组规模缩减至原数组的一半，递归地调用外层递归函数，直至数组地大小为 1。内递归负责把给定的两个链表合并成一个链表。

2.2 难点

难点在写好外递归函数：返回值为合并 k 个链表后的头节点；外递归处理中，注意如果数组大小为奇数，要把最后一个元素加入结果数组。

2.3 代码实现

/**
 * 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 {
private:
    ListNode* merge2Lists(ListNode* l1, ListNode* l2) {
		if(l1 == nullptr) {
            return l2;
        }
        if(l2 == nullptr) {
			return l1;
        }
        if(l1->val < l2->val) {
			l1->next = merge2Lists(l1->next, l2);
            return l1;
        } else {
            l2->next = merge2Lists(l1, l2->next);
            return l2;
        }
    }
	ListNode* merge(vector<ListNode*> &lists) {
        int size = lists.size();
        if(size == 0) {
            return nullptr;
        }
        if(size == 1) {
            return lists[0];
        }
        vector<ListNode*> tmp;
        for(int i = 0; i + 1 < size; i += 2) {
            tmp.push_back(merge2Lists(lists[i], lists[i + 1]));
        }
        if(size % 2 == 1) {
            tmp.push_back(lists.back());
        }
        return merge(tmp);
    }
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
		return merge(lists);
    }
};

三 优先级队列实现

3.1 整体思路

利用一个小顶堆，把数组中每一个链表的头节点都放入堆中，逐个弹出，弹出后，把该节点加入到结果链表，如果节点有下一个节点，就把下一个节点继续放入堆中，堆内会进行自动调整。

3.2 关键点

关键点应该在需要定义一个虚拟头节点，固定好头节点，方便返回。在 cur 指针迭代时，记住 cur 只是一个指针。

3.3 代码实现

class Solution {
private:
    class Less {
    public:
        bool operator()(ListNode* a, ListNode* b) {
            return a->val > b->val;
        }
    };
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<ListNode*, vector<ListNode*>, Less> que;
        for(int i = 0; i < lists.size(); ++i) {
            if(lists[i]) {
                que.push(lists[i]);
            }
        }
        ListNode* dummy = new ListNode();
        ListNode* cur = dummy;
        while(!que.empty()) {
            ListNode* node = que.top();
            que.pop();
            cur->next = node;
            cur = node;
            if(node->next) {
                que.push(node->next);
            }
        }
        return dummy->next;
    }
};