Leetcode 23 Merge k Sorted Lists

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

标为hard难度的一道题，有点interesting，

题意为把K条有序的链表归并为一条有序的链表。

开始想也没想直接暴力n*k的复杂度，果不其然T了，数据出现了n=10000，k=10000的情况，不然怎么对得起hard难度呢？

下面是T掉的代码，

/**
 * 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* result=new ListNode(0);
        ListNode* p=result;
        while(lists.size()>0)
        {
            int pos=-1,minn=INT_MAX;
            for(int i=0;i<lists.size();i++)
            {
                if(lists[i]==NULL)
                {
                    lists.erase(lists.begin()+i);
                    i--;                          //删掉就不存在了，不能忘记下标减一
                }
                else if(lists[i]->val<minn)
                {
                    minn=lists[i]->val;
                    pos=i;
            
                }
            }
            if(pos==-1)
                return result->next;
            p->next=lists[pos];
            p=p->next;
            lists[pos]=lists[pos]->next;
        }
        return result->next;
    }
};

然后我开始思考，之前做过两个链表合并的题目

http://blog.csdn.net/accepthjp/article/details/52372112

合并两个链表的复杂度为O(n+m)，如果用在这题中，虽然合并次数将很多，但到后来会形成长链和短链的合并，

长链的最后一部分往往是直接接入的，因而实际的平均复杂度并不会很高，但具体是多少，也不太好分析。

这种想法在一般的情况下，应当是优于第一种做法的，

可是后来我想到，如果K个链表都只有一个元素，且随循环合并的方向递增，那么算法又将退化为第一种方法，n=10000，k=10000，随循环合并的方向递增的情况还是会超时。

算法会退化，其实很大程度上还是由于没有改变逐个合并的思路，如果采用分治的方法合并两个链表呢？

很显然，效果会好很多，n*k的复杂度将变为nlogK的复杂度。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)   
    {  
        ListNode* p=new ListNode(0);  
        ListNode* result=p;  
        while(l1 && l2)  
        {  
            ListNode* t=new ListNode(0);  
            p->next=t;  
            p=p->next;  
            if(l1->val<l2->val)  
            {  
                p->val=l1->val;  
                l1=l1->next;  
            }  
            else  
            {  
                p->val=l2->val;  
                l2=l2->next;  
            }  
              
        }  
        p->next=l1?l1:l2;  
        return result->next;  
    }  
    ListNode* mergeKLists(vector<ListNode*>& lists) 
    {
        while(lists.size()>1)
        {
            lists.push_back(mergeTwoLists(lists[0],lists[1]));
            lists.erase(lists.begin());
            lists.erase(lists.begin());
        }
        if(lists.size()==0) 
            return NULL;
        return *(lists.begin());
    }
};