lintcode:Merge k Sorted Lists

Merge k sorted linked lists and return it as one sorted list.

Analyze and describe its complexity.

方法一：2114ms

跟合并两个有序的链表一样，每次找出k个有序链表中最小的，加入到新的链表，直到k个链表都为null。
时间复杂度：O（Nk），N指的是k个链中的总节点数

/**
 * Definition of ListNode
 * class ListNode {
 * public:
 *     int val;
 *     ListNode *next;
 *     ListNode(int val) {
 *         this->val = val;
 *         this->next = NULL;
 *     }
 * }
 */
class Solution {
public:
    /**
     * @param lists: a list of ListNode
     * @return: The head of one sorted list.
     */
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        // write your code here

        if(lists.size()==0){
            return NULL;
        }

        if(lists.size()==1){
            return lists[0];
        }

        /*删除空的串*/
        vector<ListNode *>::iterator it=lists.begin();
        while(it!=lists.end()){
            if((*it)==NULL){
                it=lists.erase(it);
            }else{
                it++;
            }
        }

        ListNode *newHead=NULL;
        ListNode *newTail=NULL;

        bool flag=true;

        while(flag){
            int minVal=INT_MAX;
            int minptrIndex;

            int cnt=0;

            /*找出k个串中的最小值*/

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

                ListNode *node=lists[i];
                if(node==NULL){
                    cnt++;
                    if(cnt==lists.size()){
                        flag=false;
                        break;
                    }
                }else{
                    if(node->val<minVal){
                        minVal=node->val;
                        minptrIndex=i;
                    }
                }

            }

            if(!flag) break;

            /*加入新链*/
            ListNode *node=new ListNode(minVal);

            if(newHead==NULL){
                newHead=node;
                newTail=node;
            }else{
                newTail->next=node;
                newTail=node;
            }

            lists[minptrIndex]=lists[minptrIndex]->next;

        }

        return newHead;
    }
};

方法二68ms

方法一每次选k个链中最小值的时间是O（k），如果维持一个小顶堆，每次弹出堆顶，然后加入堆顶的next，这样每次选k个链中最小值的时间是O（log k）；而且空间复杂使是O（k）

/**
 * Definition of ListNode
 * class ListNode {
 * public:
 *     int val;
 *     ListNode *next;
 *     ListNode(int val) {
 *         this->val = val;
 *         this->next = NULL;
 *     }
 * }
 */
class Solution {
public:
    /**
     * @param lists: a list of ListNode
     * @return: The head of one sorted list.
     */
    struct myCmp{
        bool operator()(const ListNode* a,const ListNode *b)const{
            return a->val > b->val;
        }
    };

    ListNode *mergeKLists(vector<ListNode *> &lists) {
        // write your code here

        if(lists.size()==0){
            return NULL;
        }

        //cout<<lists.size()<<endl;

        ListNode *dummy=new ListNode(0);
        ListNode *p=dummy;

        priority_queue<ListNode*,vector<ListNode *>,myCmp>pq;

        for(ListNode* node:lists){
            if(node!=NULL){
                pq.push(node);
            }
        }

        while(!pq.empty()){
            ListNode* node=pq.top();
            pq.pop();

            p->next=node;
            p=node;

            if(node->next){
                pq.push(node->next);
            }
        }

        return dummy->next;

    }
};

方法三