23. Merge k Sorted 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) {
        int sz=lists.size();
        if(sz==0)
            return nullptr;
        while(sz>1){
            int k=(sz+1)>>1;
            int lim=sz>>1;
            for(int i=0;i<lim;i++)
                lists[i]=merge(lists[i], lists[i+k]);
            sz=k;
        }
        return lists[0];
    }
    
    ListNode* merge(ListNode* p1, ListNode* p2){
        ListNode* p = new ListNode(0);
        ListNode* cur=p;
        while(p1!=NULL&&p2!=NULL){
            if(p1->val<p2->val){
                p->next=p1;
                p1=p1->next;
                p=p->next;
            }
            else{
                p->next=p2;
                p2=p2->next;
                p=p->next;
            }
        }
        p->next = p1==NULL? p2:p1;
        return cur->next;
    }
};

其实有点像归并排序，两两一组进行排序，完事儿再对结果两两一组排序，直到排序完成。这个方法巧妙利用了下标，很强势。

排序的时候不是用的相邻两个链表，而是用的距离为k的两个链表目前已知的最快方法，20ms

 

/**
 * 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) {
        int sz=lists.size();
        if(sz==0)
            return nullptr;
        int right=sz-1;
        if(sz%2==1){
            lists.push_back(NULL);
            right=sz;
        }
        while(right>0){
            if((right+1)%2==1){
                lists[right+1]=NULL;
                ++right;
            }
            int count=0;
            
            for(int i=0;i<right;i+=2){
                lists[count]=merge(lists[i], lists[i+1]);
                ++count;
            }
            right=count-1;
        }
        return lists[0];
    }
    
    ListNode* merge(ListNode* p1, ListNode* p2){
        ListNode* p = new ListNode(0);
        ListNode* cur=p;
        while(p1!=NULL&&p2!=NULL){
            if(p1->val<p2->val){
                p->next=p1;
                p1=p1->next;
                p=p->next;
            }
            else{
                p->next=p2;
                p2=p2->next;
                p=p->next;
            }
        }
        p->next = p1==NULL? p2:p1;
        return cur->next;
    }
};

这个方法也还行，先对待排容器进行补充，保证待排容器的元素数量为偶数个

然后对相邻两个链表排序，结果依次存在容器头部

最后lists[0]就是排序完成的序列

速度也还可以，24ms