Merge k Sorted Lists

是分治思想。设k为链表个数，每个链表含有n个元素。则有T(k)=2T(k/2)+nk；由递归树可以求出时间复杂度为O(nklogk)。代码如下：

 ListNode *mergetwo(ListNode *l1, ListNode *l2) 
 {
       
        if(l1==NULL)return l2;
        if(l2==NULL)return l1;
        ListNode* node1=l1;
        ListNode* node2=l2;
        ListNode* cur=NULL;
        ListNode* result=NULL;
        while(node1&&node2)
        {
            if(result==NULL)
            {
                if(node1->val<node2->val)
                {
                    result=cur=node1;
                    node1=node1->next;
                    cur->next=NULL;
                }
                else
                {
                    result=cur=node2;
                    
                    node2=node2->next;
                    cur->next=NULL;
                    
                }
            }
            else
            {
                if(node1->val<node2->val)
                {
                    cur->next=node1;
                    cur=cur->next;
                    
                    node1=node1->next;
                    cur->next=NULL;
                }
                else
                {
                    cur->next=node2;
                    cur=cur->next;
                   
                    node2=node2->next;
                     cur->next=NULL;
                    
                }
            }
        }
        if(node1) cur->next=node1;
        else cur->next=node2;
        return result;
        
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size()<1)return NULL;
        if(lists.size()==1)return lists[0];
        int j=lists.size();
        int n=(j+1)/2;
        vector<ListNode*> node1(lists.begin(),lists.begin()+n);
        vector<ListNode*> node2(lists.begin()+n,lists.end());
        ListNode* l1 = mergeKLists(node1) ;  
        ListNode* l2 = mergeKLists(node2) ; 
       
        return mergetwo(l1,l2);
    }