合并k个排序链表,返回合并后的排序链表,合并链表为一个升序链表
BM5合并k个已排序的链表描述合并k个升序的链表并将结果作为一个升序的链表返回其头节点。数据范围：节点总数满足，链表个数满足，每个链表的长度满足，每个节点的值满足要求：时间复杂度
示例一输入：
[{1,2,3},{4,5,6,7}]
返回值：
{1,2,3,4,5,6,7}
示例2输入：
[{1,2},{1,4,5},{6}]
返回值：
{1,1,2,4,5,6}
题解方法一：参考合并2个链表的方式进行k个链表合并#包含位/标准数据h。
结构列表节点
{
int值
结构列表节点*下一个
ListNode(int x) : val(x)，next(nullptr)
{
}
ListNode()=默认值；
};
ListNode * merge _ list(ListNode * left，ListNode *right)
{
if (left==nullptr)
{
向右返回；
}
if (right==nullptr)
{
向左返回；
}
如果(左阀右阀)
{
返回合并列表(右，左);
}
自动头=左；
自动尾节点=头
left=left-next；
而（左！=nullptr 对！=nullptr)
{
if (left==nullptr)
{
auto next=right-next；
tail _ node-next=right；
tail _ node=tail _ node-next；
右=下；
继续；
}
if (right==nullptr)
{
auto next=left-next；
tail _ node-next=left；
tail _ node=tail _ node-next；
左=下；
继续；
}
如果(左阀右阀)
{
auto next=left-next；
tail _ node-next=left；
tail _ node=tail _ node-next；
左=下；
}
其他
{
auto next=right-next；
tail _ node-next=right；
tail _ node=tail _ node-next；
右=下；
}
}
回程头；
}
类别解决方案
{
公共：
//时间复杂度超出题目规定
静态列表节点*合并列表（标准：矢量列表节点*列表)
{
if (lists.size()==0)
{
返回指针
}
if (lists.size()==1)
{
返回列表[0];
}
auto head=lists[0]；
for(int I=1；一.清单。size()；我)
{
auto right=lists[I]；
head=merge_list(头，右);
}
回程头；
}
};
ListNode * create _ list(const STD:vector int v)
{
链表结点头；
ListNode * phead=head
用于（自动数据：五)
{
自动节点=新列表节点
节点值=数据；
node-next=nullptr；
phead-next=node；
phead=phead-next；
}
返回头，下一个
}
STD:vector list node * create _ list _ n(const STD:vector STD:vector int v)
{
std:vector ListNode *列表；
for(int I=0；I . v . size()；我)
{
列表。push _ back(create _ list(v[I])；
}
返回列表；
}
int main()
{
STD:vector ListNode * lists=create _ list _ n(STD:vector STD:vector int { {-3，-3，-3}，{-9，-8，-7，-7，-6，-4，2}，{-2，3}，{-8，-4，-3，-2 } })；
auto head=Solution:mergeKLists(列表);
而（头！=nullptr)
{
STD:cout head-val " "；
head=head-next；
}
STD:cout STD:endl；
返回0;
}
代码实现很简单，但是存在时间复杂度不满足题目要求的问题。
方法二：借助于设置的实现//比较仿函数
金属波纹管级
{
公共：
弯曲件运算符()(常量列表节点*左，常量列表节点*右)
{
返回左值右值；
}
};
类别解决方案
{
公共：
ListNode *合并列表(STD:vector ListNode *列表)
{
if (lists.size()==0)
{
返回指针
}
if (lists.size()==1)
{
返回列表[0];
}
//这里要使用多重集，如果使用设置，那么会导致英国压力单位相同的节点被跳过！
std:multiset ListNode *，CMP s；
for(int I=0；一.清单。size()；我)
{
如果(列出[我]！=nullptr)
{
s .插入(列表【我】)；
}
}
ListNode * head=nullptr
ListNode * tail _ node=nullptr
而(!空的()
{
if (head==nullptr)
{
head=* s . begin()；
尾节点=头；
s。erase(s . begin())；
if (tail_node- next！=nullptr)
{
s。insert(tail _ node-next)；
}
继续；
}
auto cur _ node=* s . begin()；
auto next=cur _ node-next；
尾节点-下一个=当前节点；
tail _ node=tail _ node-next；
s。erase(s . begin())；
如果（下一个！=nullptr)
{
s .插入(下一个);
}
}
回程头；
}
};
上面的代码很简短，关键点就是使用设置自动排序，让其第一个元素永远存放最小的链表元素，每次取出开始，然后将开始的然后节点再次插入设置中，直到设置为空跳出循环。
方法三：使用归并的思想进行排序归并排序的思想是分而治之。对链表的归并排序实现和对数组的归并排序思路相似，代码如下：
ListNode * mergeKListsImp(STD:vector ListNode * lists，int left，int right)
{
如果（左/右)
{
返回指针
}
if (left==right)
{
返回列表[左];
}
auto a=mergeKListsImp(lists，left，(left right)/2)；
auto b=mergeKListsImp(列表，(左右)/2 1,右);
返回merge_list(a，b)；
}
ListNode *mergeKLists3(标准：矢量ListNode *列表)
{
返回mergeKListsImp(列表，0，列表。size()-1)；
}
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。