【leetcode】合并 K 个升序链表-25-6

fighting的码农(zg)-GPT

于 2024-08-16 22:49:31 发布

阅读量109

点赞数

分类专栏： LeetCode 文章标签： leetcode 链表算法

本文链接：https://blog.csdn.net/qq_43552933/article/details/141271420

版权

LeetCode 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

在这里插入图片描述
方法：遍历+合并

/**
 * 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* twoMerge(ListNode* a,ListNode* b){
        if(!a){
            return b;
        }
        else if(!b){
            return a;
        }
        ListNode* tempa=a->val>=b->val?b:a;
        ListNode* tempb=a->val>=b->val?a:b;

        ListNode* aPre=tempa;
        ListNode* aNext=tempa;

        while(aNext && tempb){
                if(aNext->val<=tempb->val){
                    if(aPre==aNext){
                        aNext=aNext->next;
                    }else{
                        aNext=aNext->next;
                        aPre=aPre->next;
                    }
                }
                else{
                    aPre->next=tempb;
                    tempb=tempb->next;
                    aPre->next->next=aNext;
                    aPre=aPre->next;
                }
        }
        //aNext one elem
        if(aPre&& !aNext){
            aPre->next=tempb;
        }

        return tempa;



    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode* res=nullptr;
        for(int i=0;i<lists.size();i++){
            if(lists[i]){
                res=twoMerge(res,lists[i]);
            }
        }
        return res;
    }
};

在这里插入图片描述
方法：分治+合并

/**
 * 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* twoMerge(ListNode* a,ListNode* b){
        if(!a){
            return b;
        }
        else if(!b){
            return a;
        }
        ListNode* tempa=a->val>=b->val?b:a;
        ListNode* tempb=a->val>=b->val?a:b;

        ListNode* aPre=tempa;
        ListNode* aNext=tempa;

        while(aNext && tempb){
                if(aNext->val<=tempb->val){
                    if(aPre==aNext){
                        aNext=aNext->next;
                    }else{
                        aNext=aNext->next;
                        aPre=aPre->next;
                    }
                }
                else{
                    aPre->next=tempb;
                    tempb=tempb->next;
                    aPre->next->next=aNext;
                    aPre=aPre->next;
                }
        }
        //aNext one elem
        if(aPre&& !aNext){
            aPre->next=tempb;
        }

        return tempa;
    }

    ListNode* divideMerge(vector<ListNode*>& lists,int a,int b){
        if(a==b){
            return lists[a];
        }
        else if(a>b){
            return nullptr;
        }
        int n=(a+b)/2;
        ListNode* resA=divideMerge(lists,a,n);
        ListNode* resB=divideMerge(lists,n+1,b);

        ListNode* res=twoMerge(resA,resB);
        return res;
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode* res=nullptr;
        res=divideMerge(lists,0,lists.size()-1);
        return res;
    }
};

在这里插入图片描述
方法：结构体排序+优先队列

/**
 * 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:

    struct Status{
        int val;
        ListNode* ptr;
        bool operator < (const Status & rhs) const{
            return rhs.val< val;
        }
    };

    priority_queue <Status> q;
    
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode* res=new ListNode(-1);

        // for(auto elem:lists){
        //     if(elem){
        //         q.push(elem->val,elem);
        //     }
        // }
        for(int i=0;i<lists.size();i++){
            if(lists[i]){
                q.push({lists[i]->val,lists[i]});
            }
        }

        ListNode* finalRes=res;

        while(!q.empty()){
            Status temp=q.top();
            res->next=temp.ptr;
            q.pop();
            res=res->next;

            if(temp.ptr->next){
                q.push({temp.ptr->next->val,temp.ptr->next});
            }

        }

        res=finalRes;
        finalRes=finalRes->next;
        delete res;
        
        return finalRes;
    }
};