1:优先队列
struct mycmp{
bool operator()(ListNode* l1, ListNode* l2){
return l1->val > l2->val;
}
};
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
/* Define a min heap */
priority_queue<ListNode*, vector<ListNode*>, mycmp> pq;
/* Define a dummy header */
ListNode tmpHead(-1);
ListNode* cur = &tmpHead;
int i;
/* Insert the head of each list */
for(auto list : lists) if(list) pq.push(list);
/* Keep pop from pq */
while(!pq.empty()){
ListNode* topNode = pq.top();
pq.pop();
/* We now have the minimal node */
cur->next = topNode;
if(topNode->next) pq.push(topNode->next);
cur = cur->next;
}
return tmpHead.next;
}
}
2.比我递归的代码简洁明了多了。
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode *head = nullptr;
ListNode **p = &head;
while (l1 && l2)
{
if (l1->val < l2->val)
{
*p = l1; l1 = l1->next;
}
else
{
*p = l2; l2 = l2->next;
}
p = &((*p)->next);
}
*p = (l1) ? (l1) : (l2);
return head;
}
ListNode* mergeKLists(vector<ListNode*>& lists) {
size_t k = lists.size();
if (0 == lists.size()) {return nullptr;}
while (k > 1)
{
const size_t half = (k + 1) / 2;
for (size_t i = 0; i < half; ++i)
{
if (i + half < lists.size())
{
lists[i] = mergeTwoLists(lists[i], lists[i + half]);
lists[i + half] = nullptr;
}
}
k = half;
}
return lists[0];
}
};
3.堆
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists)
{
lists.erase(std::remove(lists.begin(), lists.end(), nullptr), lists.end());
ListNode dummy(-1);
auto head = &dummy;
auto compare = [](ListNode* l, ListNode* r)
{
return l->val > r->val;
};
std::make_heap(lists.begin(), lists.end(), compare);
while (!lists.empty())
{
std::pop_heap(lists.begin(), lists.end(), compare);
head->next = lists.back();
head = head->next;
if (nullptr != lists.back()->next)
{
lists.back() = lists.back()->next;
std::push_heap(lists.begin(), lists.end(), compare);
}
else
{
lists.pop_back();
}
}
return dummy.next;
}
};