leetcode 23: Merge k Sorted Lists

最新推荐文章于 2024-04-03 21:24:25 发布

原创最新推荐文章于 2024-04-03 21:24:25 发布 · 200 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

201 篇文章

订阅专栏

本文介绍了一种使用堆优化的算法来合并K个单链表的方法，详细解释了算法实现过程和效率提升。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode* res=new ListNode(-1);
        ListNode* curr=res;
        vector<ListNode*> heap;
        heap.push_back(res);
        for(int i=0;i<lists.size();i++)
            if(lists[i])
                heap.push_back(lists[i]);
        for(int i=(heap.size()-1)/2;i>0;i--)
            minheap(heap,i);
        while(heap.size()>1)
        {
            curr->next=heap[1];
            curr=curr->next;
            if(heap[1]->next)
                heap[1]=heap[1]->next;
            else
            {
                swap(heap[1],heap[heap.size()-1]);
                heap.pop_back();
            }
            minheap(heap,1);
        }
        return res->next;
    }
    void minheap(vector<ListNode*>& heap,int n)
    {
        if(n<1)
            return;
        int left=n<<1;
        int right=left+1;
        int mid=n;
        if(left<heap.size()&&heap[left]->val<heap[mid]->val)
            mid=left;
        if(right<heap.size()&&heap[right]->val<heap[mid]->val)
            mid=right;
        if(mid!=n)
        {
            swap(heap[mid],heap[n]);
            minheap(heap,mid);
        }
    }
};

The following code uses the heap from STL.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        vector<ListNode*> minHeap;
        ListNode* dummyHead=new ListNode(0);
        int size=lists.size();
        for(int i=0;i<size;i++)
            if(lists[i])
                minHeap.push_back(lists[i]);
        make_heap(minHeap.begin(),minHeap.end(),cmp);
        ListNode* curr=dummyHead;
        while(!minHeap.empty())
        {
            curr->next=new ListNode(minHeap[0]->val);
            curr=curr->next;
            pop_heap(minHeap.begin(),minHeap.end(),cmp);
            minHeap.back()=minHeap.back()->next;
            if(minHeap.back())
                push_heap(minHeap.begin(),minHeap.end(),cmp);
            else
                minHeap.pop_back();
            
        }
        return dummyHead->next;
    }
private:
    static bool cmp(const ListNode* a,const ListNode* b)
    {
        return a->val>b->val;
    }
};