Leetcode 23. Merge k Sorted Lists

23. Merge k Sorted Lists

• Total Accepted: 92690
• Total Submissions:385821
• Difficulty: Hard

 

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

 

思路：

可以先做21. Merge Two Sorted Lists。

 

方法一：直接按定义做，复杂度和下面的方法差不多。

方法二：每次递归归并lists中前2条列表，直到归并只剩1条列表。

方法三：首尾归并，每次归并后，lists规模减少一半。

 

 

注意，局部函数中的变量一般要先初始化！

 

代码：

方法一：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode* head=new ListNode(-1);
        ListNode* end=head;
        int i,num=0,k=lists.size();
        long long minnum=-1;
        while(minnum!=LONG_MAX){
            minnum=LONG_MAX;
            for(i=0;i<k;i++){
                if(!lists[i]) continue;
                if(minnum>lists[i]->val){
                    minnum=lists[i]->val;
                }
            }
            for(i=0;i<k;i++){
                if(lists[i]&&minnum==lists[i]->val){
                    end->next=new ListNode(minnum);
                    end=end->next;
                    lists[i]=lists[i]->next;
                }
            }
        }
        return head->next;
    }
};

 

方法二：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* a,ListNode* b){
        if(!a){
            return b;
        }
        if(!b){
            return a;
        }
        if(a->val>b->val){
            b->next=mergeTwoLists(a,b->next);
            return b;
        }
        a->next=mergeTwoLists(a->next,b);
        return a;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode* head=NULL;//一定要初始化！！
        while(lists.size()>1){
            lists.push_back(mergeTwoLists(lists[0],lists[1]));
            lists.erase(lists.begin());
            lists.erase(lists.begin());
        }
        if(lists.size()){
            head=lists[0];
        }
        return head;
    }
};

 

 

方法三：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 class Solution {
public:
    ListNode* mergeTwoLists(ListNode* a,ListNode* b){
        if(!a){
            return b;
        }
        if(!b){
            return a;
        }
        if(a->val>b->val){
            b->next=mergeTwoLists(a,b->next);
            return b;
        }
        a->next=mergeTwoLists(a->next,b);
        return a;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.empty()){
            return NULL;
        }
        int len=lists.size();
        int b=0,e=len-1;
        while(b<e){
            while(b<e){
               lists[b]=mergeTwoLists(lists[b],lists[e]);
               b++;
               e--;
            }
            b=0;
        }
        return lists[0];
    }
};

 

或者

 

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* a,ListNode* b){
        if(!a){
            return b;
        }
        if(!b){
            return a;
        }
        if(a->val>b->val){
            b->next=mergeTwoLists(a,b->next);
            return b;
        }
        a->next=mergeTwoLists(a->next,b);
        return a;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        vector<ListNode*> res;
        int i;
        for(i=0;i<lists.size();i++){
            if(lists[i]){
                res.push_back(lists[i]);
            }
        }
        if(!res.size()){
            return NULL;
        }
        int len=res.size();
        while(len>1){
            //设len=2q或者2q+1
            for(i=0;i<len/2;i++){//注意区分len是奇数还是偶数的情况
                res[i]=mergeTwoLists(res[i],res[len-1-i]);
            }
            //此时len应该等于q（len为偶数）或者q+1（len为奇数）
            len=(len+1)/2;
        }
        return res[0];
    }
};