Merge k Sorted Lists解法收集

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;
    }

};