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());    }};