方法一:简单方法.时间复杂度O(k^2N),空间复杂度O(1)
class Solution {
public:
ListNode* merge2List(ListNode* AList, ListNode* BList)
{
ListNode* mergehead,*mergetemp;
mergehead = NULL;
if (!AList&&!BList)
return mergehead;
if (!AList)
return BList;
if (!BList)
return AList;
if (AList->val <= BList->val)
{
mergetemp = AList;
AList = AList->next;
}
else
{
mergetemp = BList;
BList = BList->next;
}
mergehead = mergetemp;
while (AList&&BList)
{
if (AList->val <= BList->val)
{
mergetemp->next = AList;
mergetemp = mergetemp->next;
AList = AList->next;
}
else
{
mergetemp->next = BList;
mergetemp = mergetemp->next;
BList = BList->next;
}
}
if (AList)
mergetemp->next = AList;
if (BList)
mergetemp->next = BList;
return mergehead;
}
ListNode* mergeKLists(vector<ListNode*>& lists) {
ListNode* anshead=NULL;
if (lists.empty())
return anshead;
if (lists.begin() + 1 == lists.end())
{
anshead = *(lists.begin());
}
for (auto iter = lists.begin(); iter + 1 != lists.end(); ++iter)
{
if (iter == lists.begin())
{
ListNode* A = *iter;
ListNode* B = *(iter + 1);
anshead = merge2List(A, B);
}
else
{
ListNode* B = *(iter + 1);
anshead = merge2List(anshead, B);
}
}
return anshead;
}
};
方法二:分治法。时间复杂度O(kn×logk),空间复杂度:因为递归了logk次,需要用到O(logk)空间代价的栈空间
class Solution {
public:
ListNode* merge2List(ListNode* AList, ListNode* BList)
{
ListNode* mergehead,*mergetemp;
mergehead = NULL;
if (!AList&&!BList)
return mergehead;
if (!AList)
return BList;
if (!BList)
return AList;
if (AList->val <= BList->val)
{
mergetemp = AList;
AList = AList->next;
}
else
{
mergetemp = BList;
BList = BList->next;
}
mergehead = mergetemp;
while (AList&&BList)
{
if (AList->val <= BList->val)
{
mergetemp->next = AList;
mergetemp = mergetemp->next;
AList = AList->next;
}
else
{
mergetemp->next = BList;
mergetemp = mergetemp->next;
BList = BList->next;
}
}
if (AList)
mergetemp->next = AList;
if (BList)
mergetemp->next = BList;
return mergehead;
}
ListNode* merge(vector<ListNode*>& lists, int left, int right)
{
if (left == right)
return lists[left];
if (left > right)//可能会出现mid+1>right
return nullptr;
int mid = (right + left)/2;
return merge2List(merge(lists, left, mid), merge(lists, mid + 1, right));
}
ListNode* mergeKLists(vector<ListNode*>& lists) {
ListNode* anshead=NULL;
anshead = merge(lists, 0, lists.size() - 1);
return anshead;
}
};
方法三:使用优先队列。优先队列中元素不超过k个,优先队列由二叉堆实现,则插入和删除的时间代价为O(logk)。最多有kn个点,每个点都被插入删除一次,则时间复杂度为O(kn×logk)。空间复杂度为O(k).
class Solution {
public:
struct Status
{
ListNode* head;
int val;
bool operator<(const Status& rhs)const
{
return val > rhs.val;//值越小优先级越高
}
};
priority_queue<Status> q;
ListNode* mergeKLists(vector<ListNode*>& lists) {
ListNode* anshead,*anstail;
anshead = nullptr;
anstail = nullptr;
for (auto node : lists)
{
if (node)
q.push({ node,node->val });
}
if (!q.empty())
{
ListNode* temp;
temp= q.top().head;
q.pop();
anstail = temp;
if(temp->next)
q.push({temp->next,temp->next->val});
}
anshead = anstail;
while (!q.empty())
{
ListNode* temp;
temp = q.top().head;
q.pop();
anstail->next = temp;
anstail = anstail->next;
if(temp->next)
q.push({ temp->next,temp->next->val });
}
return anshead;
}
};