力扣 23. 合并K个排序链表链表+归并+优先队列

最新推荐文章于 2021-08-27 09:33:21 发布

csu_xiji

最新推荐文章于 2021-08-27 09:33:21 发布

阅读量251

点赞数

分类专栏：力扣思维链表

本文链接：https://blog.csdn.net/xiji333/article/details/107860168

版权

力扣同时被 3 个专栏收录

282 篇文章 2 订阅

订阅专栏

思维

181 篇文章 1 订阅

订阅专栏

链表

38 篇文章 0 订阅

订阅专栏

https://leetcode-cn.com/problems/merge-k-sorted-lists/
在这里插入图片描述

思路一：暴力合并，即利用 $m e r g e$ 算法，逐一合并两个链表。为方便分析复杂度，我们假设有 $k$ 个链表，每个链表的最大长度为 $n$ ，那么该算法的时间复杂度为 $O(n*k^2)$ 。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    //合并两个有序链表
    ListNode* merge(ListNode* l,ListNode* r){
        ListNode head(0),*cur=&head;
        while(l&&r){
            if(l->val<=r->val)
                cur->next=l,cur=l,l=l->next;
            else
                cur->next=r,cur=r,r=r->next;
        }
        cur->next=l?l:r;
        return head.next;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int siz=lists.size();
        if(!siz)
            return nullptr;
        ListNode *ans=lists[0];
        for(int i=1;i<siz;i++)
            ans=merge(ans,lists[i]);
        return ans;
    }
};

思路二：归并合并链表，即首先两个两个合并构成新的一层链表，然后再两个两个合并……时间复杂度为 $O (k l o g k * n)$

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    //合并两个有序链表
    ListNode* merge(ListNode* l,ListNode* r){
        ListNode head(0),*cur=&head;
        while(l&&r){
            if(l->val<=r->val)
                cur->next=l,cur=l,l=l->next;
            else
                cur->next=r,cur=r,r=r->next;
        }
        cur->next=l?l:r;
        return head.next;
    }
    ListNode* mergeLists(vector<ListNode*>& list,int l,int r){
        if(l==r)
            return nullptr;
        if(l+1==r)
            return list[l];
        int mid=(l+r)>>1;
        return merge(mergeLists(list,l,mid),mergeLists(list,mid,r));
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int siz=lists.size();
        if(!siz)
            return nullptr;
        return mergeLists(lists,0,siz);
    }
};

思路三：利用优先队列。考虑一次合并 $k$ 个链表，那么我们肯定想获得这 $k$ 个节点中最小的那个节点的值，套个优先队列就行了。时间复杂度也是 $O (k l o g k * n)$ 。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool cmp(ListNode *&a,ListNode *&b){
        return a->val<b->val;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int siz=lists.size();
        if(!siz)
            return nullptr;
        auto cmp=[](ListNode *&a,ListNode *&b){ return a->val>b->val; };
        priority_queue<ListNode*,vector<ListNode*>,decltype(cmp)> q(cmp);
        for(int i=0;i<siz;i++){
            if(lists[i])
                q.push(lists[i]);
        }
        ListNode head(0),*cur=&head,*tmp;
        while(!q.empty()){
            tmp=q.top();
            q.pop();
            cur->next=tmp;
            cur=tmp;
            tmp=tmp->next;
            if(tmp)
                q.push(tmp);
        }
        return head.next;
    }
};