从头做leetcode之leetcode 23 合并k个有序链表

合并K个有序链表

最新推荐文章于 2022-08-08 18:18:10 发布

原创最新推荐文章于 2022-08-08 18:18:10 发布 · 188 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #算法

从头做leetcode 专栏收录该内容

94 篇文章

订阅专栏

本文探讨了三种高效算法：暴力法、分治法及小顶堆法，用于合并多个有序链表。暴力法通过多次两两合并实现，分治法则借鉴归并排序思想，而小顶堆法则巧妙运用优先队列提升效率。

23.合并k个有序链表

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

暴力法

先用最容易想的办法，将k个链表的合并转化成k-1次两个链表的合并，利用之前做过的合并两个有序链表的算法
时间复杂度:O((k-1)*lists[0].size()+(k-2)lists[1].size()+ ··· +list[k-1].size())。

/**
 - Definition for singly-linked list.
 - struct ListNode {
 -     int val;
 -     ListNode *next;
 -     ListNode(int x) : val(x), next(NULL) {}
 - };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode *res=new ListNode;
        ListNode *p=res;
        if(l2==NULL) return l1;
        if(l1==NULL) return l2;
        while(l1 && l2){
            if(l1->val <= l2->val){
                p->next=l1;
                l1=l1->next;
            }
            else{
                p->next=l2;
                l2=l2->next;
            }
            p=p->next;
        }
        if(l1){
            p->next=l1;
        }
        if(l2){
            p->next=l2;
        }
        return res->next;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size()==0) return NULL;
        ListNode *finalres=new ListNode;
        finalres=lists[0];
        for(int i=1;i<lists.size();i++){
            finalres=mergeTwoLists(finalres,lists[i]);
        }
        return finalres;
    }
};

通过时间：
在这里插入图片描述

采用分治法优化

类似于归并排序，分别对中值两侧的元素进行归并，一直到两个链表归并，最后再整合到一起

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode *res=new ListNode;
        ListNode *p=res;
        if(l2==NULL) return l1;
        if(l1==NULL) return l2;
        while(l1 && l2){
            if(l1->val <= l2->val){
                p->next=l1;
                l1=l1->next;
            }
            else{
                p->next=l2;
                l2=l2->next;
            }
            p=p->next;
        }
        if(l1){
            p->next=l1;
        }
        if(l2){
            p->next=l2;
        }
        return res->next;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size()==0) return NULL;
        if(lists.size()==1) return lists[0];
        ListNode *finalres=new ListNode;
        finalres=lists[0];
        vector<ListNode*> leftlists,rightlists;
        for(int i=0;i<lists.size()/2;i++){
            leftlists.push_back(lists[i]);
        }
        int j=0;
        for(int i=lists.size()/2;i<lists.size();i++){
            rightlists.push_back(lists[i]);
            j++;
        }
        return mergeTwoLists(mergeKLists(leftlists),mergeKLists(rightlists));
    }
};

通过时间：
在这里插入图片描述

小顶堆（优先队列）

用构造一个小顶堆的方法，将每个链表的第一个结点放入优先队列中，每次弹出堆顶元素放入结果链表中，然后将堆顶元素的next结点（如果存在）放入优先队列。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
struct Listcompare{//自己写一个优先队列的比较函数
    bool operator()(ListNode* l1,ListNode* l2){
        return l1->val > l2->val;
    }
};
class Solution {
public:
        ListNode* mergeKLists(vector<ListNode*> &lists) {
        if(lists.size()==0) return NULL;
        if(lists.size()==1) return lists[0];
        priority_queue<ListNode*, vector<ListNode*>, Listcompare> heap;
        for (int i=0;i<lists.size();i++) {
            if(lists[i]!=NULL){//注意有些测试用例中的空链表
                heap.push(lists[i]);
            }
        }
        ListNode *res = new ListNode, *p = res;
        while (!heap.empty()) {
            ListNode *temp = heap.top();
            heap.pop();
            p->next = temp;
            if (temp->next) heap.push(temp->next);
            p = p->next;
        }
        return res->next;
    }
};

通过时间：
在这里插入图片描述