23. Merge k Sorted Lists

最新推荐文章于 2021-12-08 15:59:42 发布

原创最新推荐文章于 2021-12-08 15:59:42 发布 · 240 阅读

0 ·

CC 4.0 BY-SA版权

leetcode-List 专栏收录该内容

23 篇文章

订阅专栏

本文介绍两种高效合并K个已排序链表的方法：一种是手工实现堆排序以优化合并过程；另一种则利用STL中的堆操作简化实现。这两种方法都能有效解决合并问题，并保持良好的时间复杂度。

方法1:

堆排序，否则会超时

class Solution {
public:
    void MinHeadFixup(vector<ListNode*>& vec,ListNode* p,int len)
    {
        vec.push_back(p);
        for(int i=len-1,j=(i-1)/2;(j>=0&&i!=0)&&vec[i]->val<vec[j]->val;i=j,j=(i-1)/2)
        {
            swap(vec[i],vec[j]);
        }
    }
    
    void MinHeadFixdown(vector<ListNode*>& vec,int k,int len)
    {
        for(int i=k,j=i*2+1;j<len;i=j,j=i*2+1)
        {
            if(j+1<len&&vec[j]->val>vec[j+1]->val)
                j++;
            if(vec[i]->val<=vec[j]->val)
                break;
            swap(vec[i],vec[j]);
        }
    }
    
    void MinHeadDel(vector<ListNode*>& vec,int len)
    {
        swap(vec[0],vec[len-1]);
        vec.pop_back();
        MinHeadFixdown(vec, 0,len-1);
    }
    
    void MinHeadBuild(vector<ListNode*>& vec,int len)
    {
        for(int i=len/2-1;i>=0;i--)
        {
            MinHeadFixdown(vec, i,len);
        }
    }
    
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int len=lists.size();
        ListNode *head=new ListNode(-1),*pre=head,*t=NULL;
        
        int i;
        
        vector<ListNode*> vec;
        for(i=0;i<len;i++)
        {
            if(lists[i])
            {
                vec.push_back(lists[i]);
            }
        }
        
        int _size=vec.size();
        MinHeadBuild(vec,_size);
        i=1;
        while(_size)
        {
            pre->next=vec[0];
            pre=vec[0];
            t=vec[0];
            MinHeadDel(vec, _size);
            t=t->next;
            if(t==NULL)
                _size--;
            else
                MinHeadFixup(vec, t, _size);
            
        }
        
        ListNode* h=head->next;
        delete head;
        return h;
    }
    
};

方法2:使用stl中的heap

struct CompareNode{
    bool operator()(const ListNode* a,const ListNode* b)const{
        return a->val>b->val;
    }
};

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        vector<ListNode*> vec;
        int len=lists.size();
        for(int i=0;i<len;i++)
            if(lists[i])vec.push_back(lists[i]);
        
        std::make_heap(vec.begin(), vec.end(), CompareNode());
        
        ListNode* head=new ListNode(-1),*p=head,*t=NULL;
        while(vec.size())
        {
            p=p->next=vec[0];
            t=vec[0]->next;
            pop_heap(vec.begin(), vec.end(), CompareNode());
            vec.pop_back();
            if(t)
            {
                vec.push_back(t);
                push_heap(vec.begin(), vec.end(), CompareNode());
            }
        }
        return head->next;
    }
    
};