Leetcode|Merge k Sorted Lists-优快云博客

本文链接：https://blog.youkuaiyun.com/mike_learns_to_rock/article/details/46672437

本文介绍了一种有效的算法来合并多个已排序的链表。通过对比两种不同的合并策略，展示了如何减少时间复杂度，避免超时问题。最终提供了一个符合LeetCode时间要求的解决方案。

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

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

借助合并两个链表的函数。

超时的解法：最坏时间复杂度O((n-1)*n1+(n-2)*n2+....)

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size()==0) return NULL;
        ListNode* p=lists[0];
        for(int i=1;i<lists.size();i++)//问题出在这里面，如果很多链表的话，k很大，那么越往后这个链表(p)越长，所消耗的时间越多。
        {
            p=mergeTwoLists(p,lists[i]);
        }
        return p;
    }
    
private:
    ListNode* mergeTwoLists(ListNode* p1,ListNode* p2){
        if(p1==NULL) return p2;
        if(p2==NULL) return p1;
        ListNode dummy(-1);
        ListNode* p(&dummy);
        for(;p1!=NULL&&p2!=NULL;p=p->next){
            if(p1->val<=p2->val)
            {
                p->next=p1;
                p1=p1->next;
            }else{
                p->next=p2;
                p2=p2->next;
            }
        }
        p->next=p1!=NULL?p1:p2;
        return dummy.next;
    }
    
};

上个解法超时，是因为像贪吃蛇一样，链表成都愈来越长。假设每个链表长度差不多，如果能把两个长度差不多的链表合并的话。就很好了。

符合leetcode时间要求的解法：

代码如下（C++）：

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size()==0) return NULL;
        if(lists.size()==1) return lists[0];
        ListNode* p(NULL);
        for(int i=0;i<lists.size();i+=2)
        {
            p=i+1<lists.size()?mergeTwoLists(lists[i],lists[i+1]):lists[i];//将前两个链表合并，并且加入到数组尾部。继续合并下两个链表。
            lists.insert(lists.end(),p);
        }
        return p;
    }
    
private:
    ListNode* mergeTwoLists(ListNode* p1,ListNode* p2){
        if(p1==NULL) return p2;
        if(p2==NULL) return p1;
        ListNode dummy(-1);
        ListNode* p(&dummy);
        for(;p1!=NULL&&p2!=NULL;p=p->next){
            if(p1->val<=p2->val)
            {
                p->next=p1;
                p1=p1->next;
            }else{
                p->next=p2;
                p2=p2->next;
            }
        }
        p->next=p1!=NULL?p1:p2;
        return dummy.next;
    }
    
};