【leetcode】Merge k Sorted Lists

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

 

思路：

我自己的，每次找k个元素的最小的接在答案链表的后面。结果超时了。

    ListNode *mergeKLists(vector<ListNode *> &lists) {

        if(lists.size() == 0) 

            return NULL;

        else if(lists.size() == 1)

            return lists[0];

        else

        {

            int n = lists.size();

            ListNode * ans = NULL;

            ListNode * anshead = NULL;

            vector<ListNode *> cur = lists;

            for(int i = 0; i < cur.size(); i++) //把链表是NULL的删掉

            {

                if(cur[i] == NULL)

                {

                    cur.erase(cur.begin() + i);

                    i--;

                    n--;

                }

            }

            while(n > 1) //每次把链表剩下的是NULL的删掉，剩下的链表只要多于1个就继续

            {

                int min = getmin(cur);

                if(ans == NULL) //头结点特别处理

                {

                    ans = cur[min];

                    anshead = ans;

                }

                else //其他结点处理

                {

                    ans->next = cur[min];

                    ans = ans->next;

                }

                cur[min] = cur[min]->next;

                if(cur[min] == NULL) //如果空了 删除

                {

                    cur.erase(cur.begin() + min);

                    n--;

                }

                ans->next = NULL;

            }

            if(!cur.empty()) //最后如果还有剩下的加在答案链表最后

            {

                if(ans == NULL)

                {

                    ans = cur[0];

                    anshead = ans;

                }

                else

                {

                    ans->next = cur[0];

                }

            }

            return anshead;

        }

    }



    int getmin(vector<ListNode *> cur)

    {

        int min = 0;

        for(int i = 0; i < cur.size(); i++)

        {

            if(cur[i]->val < cur[min]->val)

                min = i;

        }

        return min;

    }

 

看其他人的思路，发现只需要把相邻的链表两两合并就可以。速度还很快，只要33ms

 class Solution {

        struct CompareNode {

            bool operator()(ListNode* const & p1, ListNode* const & p2) {

                // return "true" if "p1" is ordered before "p2", for example:

                return p1->val > p2->val;

               //Why not p1->val <p2->val; ??

            }

        };

    public:

        ListNode *mergeKLists(vector<ListNode *> &lists) {



            ListNode dummy(0);

            ListNode* tail=&dummy;



            priority_queue<ListNode*,vector<ListNode*>,CompareNode> queue;



            for (vector<ListNode *>::iterator it = lists.begin(); it != lists.end(); ++it){

                if (*it)

                queue.push(*it);

            }

            while (!queue.empty()){

                tail->next=queue.top();

                queue.pop();

                tail=tail->next;



                if (tail->next){

                    queue.push(tail->next);

                }

            }



            return dummy.next;

        }

    };

 

还有一种用堆的方法，没有仔细看，记录下来，里面关于堆的使用以后可能有用。

class Solution {



public:



    ListNode *mergeKLists(vector<ListNode *> &lists) {



        // Begin and end of our range of elements:

        auto it_begin = begin(lists);

        auto it_end = end(lists);



        // Removes empty lists:

        it_end = remove_if(it_begin, it_end, isNull);

        if (it_begin == it_end) return nullptr; // All lists where empty.



        // Head and tail of the merged list:

        ListNode *head = nullptr;

        ListNode *tail = nullptr;



        // Builds a min-heap over the list of lists:

        make_heap(it_begin, it_end, minHeapPred);



        // The first element in the heap is the head of our merged list:

        head = tail = *it_begin;



        while (distance(it_begin, it_end) > 1) {



            // Moves the heap's front list to its back:

            pop_heap(it_begin, it_end, minHeapPred);



            // And removes one node from it:

            --it_end;

            *it_end = (*it_end)->next;



            // If it is not empty it inserts it back into the heap:

            if (*it_end) {



                ++it_end;

                push_heap(it_begin, it_end, minHeapPred);

            }



            // After  the push we have our next node in front of the heap:

            tail->next = *it_begin;

            tail = tail->next;

        }



        return head;

    }



private:



    // Predicate to remove all null nodes from a vector:

    static bool isNull(const ListNode* a) {



        return a == nullptr;

    }



    // Predicate to generate a min heap of list node pointers:

    static bool minHeapPred(const ListNode* a,

                            const ListNode* b) {



        assert(a);

        assert(b);



        return a->val > b->val;

    }



};