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

---

前置知识

在解决这道题之前,我们需要先知道怎样合并两个有序链表

可以参考leetcode-21.合并两个有序链表

方法一

再回到这道题上,我们知道了两个有序链表的合并方法,就可以利用其写出K个链表的合并方法:
用一个变量 ans 来维护以及合并的链表，第 i 次循环把第 i 个链表和 ans 合并，答案保存到 ans 中。

Java :

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {

        ListNode ans = null;
        for (int i = 0; i < lists.length; ++i){
            ans = mergeTwoLists(ans, lists[i]);
        }

        return ans;

    }


    public ListNode mergeTwoLists(ListNode p1, ListNode p2) {
        ListNode setinel = new ListNode(-1, null);
        ListNode p = setinel; 
        while (p1 != null && p2 != null) {
           
            if (p1.val <= p2.val) {
                p.next = p1;
                p1 = p1.next;
            } else {
                p.next = p2;
                p2 = p2.next;
            }
            
            p = p.next;

        }
        
        if (p1 != null) {
            p.next = p1;
        }
        if (p2 != null) {
            p.next = p2;
        }

        return setinel.next;
    }
}

C++ :

/**
 * 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 *a, ListNode *b) //辅函数
{
    if ((!a) || (!b)) return a? a : b; 
    ListNode head, *tail = &head, *aPtr = a, *bPtr = b; 
    while (aPtr && bPtr) 
    {
        if (aPtr->val < bPtr->val)
        {
            tail->next = aPtr;
            aPtr = aPtr->next;
        }
        else                       
        {
            tail->next = bPtr;
            bPtr = bPtr->next;
        }

        tail = tail->next;        
    }
    tail->next = (aPtr? aPtr : bPtr); 
    return head.next;                
}
    ListNode* mergeKLists(vector<ListNode*>& lists)  //主函数
    {
        ListNode *ans = nullptr; // 初始化指向空指针
        for (size_t i = 0; i < lists.size(); ++i)
        {
            ans = mergeTwoLists(ans, lists[i]); //依次合并
        }
        return ans;
    }
};

---

方法二(优化):分治合并

我们可以利用分治的思想,将链表两两配对组合,然后合并后继续配对组合,链表数量将以k --> k/2 --> k/4 --> k/8最后合并为1,这样就会适当减少比较次数,举个例子,链表有5个,长度为1 3 2 2 5
那么就会1 3组合 2 2 组合 5自己组合–>然后变为 4 4 5–>再让4 4组合 5自己 -->8 5–>最后8 5合并
这样相比1+3=4,4+2=6,6+2=8,8+5=13,四次比较就变成了3次,从而达到优化的作用

Java :

class Solution {
    
    public ListNode mergeKLists(ListNode[] lists) {

        return mergepair(lists, 0, lists.length - 1);

    }

    //两两合并 递归 二分查找
    public ListNode mergepair(ListNode[] lists, int l, int r) {
        if (l == r) //只剩一个链表就返回
            return lists[l];
        if (l > r)  //非法返回null
            return null;

        int mid = (l + r) >>> 1; //二分查找中心
        //递归分治
        return mergeTwoLists(mergepair(lists, l, mid), mergepair(lists, mid + 1, r));
    }

    //合并两个链表
    public ListNode mergeTwoLists(ListNode p1, ListNode p2) {
        ListNode setinel = new ListNode(-1, null);
        ListNode p = setinel;
        while (p1 != null && p2 != null) {

            if (p1.val <= p2.val) {
                p.next = p1;
                p1 = p1.next;
            } else {
                p.next = p2;
                p2 = p2.next;
            }

            p = p.next;

        }

        if (p1 != null) {
            p.next = p1;
        }
        if (p2 != null) {
            p.next = p2;
        }

        return setinel.next;
    }
}

C++:

/**
 * 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 *a, ListNode *b) //辅函数1(合并两个链表)
{
    if ((!a) || (!b)) return a? a : b; 
    ListNode head, *tail = &head, *aPtr = a, *bPtr = b; 
    while (aPtr && bPtr) 
    {
        if (aPtr->val < bPtr->val)
        {
            tail->next = aPtr;
            aPtr = aPtr->next;
        }
        else                       
        {
            tail->next = bPtr;
            bPtr = bPtr->next;
        }

        tail = tail->next;        
    }
    tail->next = (aPtr? aPtr : bPtr); 
    return head.next;                
}
    ListNode* merge(vector<ListNode*>& lists, int l, int r)  //辅函数2
    {
       if (l == r) return lists[l]; // l==r代表合并为最后一个了
       if (l > r) return nullptr;   // l > r返回空指针
       int mid = (l + r) >> 1; // 等价于(l+r)/2
       return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));//递归分治
    }
    ListNode* mergeKLists(vector<ListNode*>& lists)
    {
        return merge(lists, 0, lists.size() - 1);
    }
};

---

方法三 : 优先队列合并

思路:用容量为K的最小堆优先队列，把链表的头结点都放进去，然后出队当前优先队列中最小的，挂上链表，，然后让出队的那个节点的下一个入队，再出队当前优先队列中最小的，直到优先队列为空。在选取最小元素的时候，我们就是用的优先队列来优化这个过程。

Java :

class Solution {

    //优先队列比较规则,按照val排序
    public class MyComparator implements Comparator<ListNode> {
        public int compare(ListNode a, ListNode b) {
            return a.val - b.val;
        }
    }

    public ListNode mergeKLists(ListNode[] lists) {
        //空链表情况
        if (lists.length == 0) return null;
        //构造优先队列(根据自定义规则排序)
        PriorityQueue<ListNode> q = new PriorityQueue<ListNode>(lists.length, new MyComparator());
        //每条链表的最小值入队
        for (ListNode node : lists) {
            if (node != null) q.add(node);
        }
        //设置哑元记录头
        ListNode dummy = new ListNode(-1, null);
        ListNode tail = dummy;
        //队列中已经排序好了
        while (!q.isEmpty()) {
			//依次出队串起来
            ListNode node = q.poll();
            tail.next = node;
            tail = tail.next;
            //出队的节点所属的链如果还有下一个元素就继续入队
            if (node.next != null) q.add(node.next);

        }

        return dummy.next;

    }
 
}

C++ :

class Solution 
{
public:
    struct comp //传入queue的比较规则
    {    
        bool operator()(ListNode* a, ListNode* b)
        {
            return a->val > b->val;
        }
    };
    // 创建优先队列(链表数组实现)
    priority_queue<ListNode*, vector<ListNode*>, comp> q;

    ListNode* mergeKLists(vector<ListNode*>& lists) 
    {
        for (auto node:lists) // 将所有链表的头存入队列(这里会自动按从小到大排序)
        {
            if (node)  q.push(node);
        }
        
        ListNode head; //记录头结点
        ListNode* tail = &head;//从头结点开始处理
        while (!q.empty())
        {
            //依次取出q中的最小头,临时存入node
            ListNode* node = q.top();
            q.pop();
            tail->next = node; //将最小node接在答案tail后面
            tail = tail->next; //tail后移
            //将刚才pop的那个元素所在链表的next入队(如果存在)---新头
            if (node->next)  q.push(node->next);
        }
        return head.next;//返回头结点的next
    }
};

---

优先队列的实现原理:

优先队列的实现原理(C++)