[Leetcode] Merge k sorted lists 合并k个已排序的链表

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

思路：这题最容易想到的是，（假设有k个链表）链表1、2合并，然后其结果12和3合并，以此类推，最后是123--k-1和k合并。至于两链表合并的过程见merge two sorted lists的分析。复杂度的分析见JustDoIT的博客。算法复杂度：假设每个链表的平均长度是n，则1、2合并，遍历2n个节点；12结果和3合并，遍历3n个节点；....123...k-1的结果和k合并，遍历kn个节点，总共遍历n(2+3+4+....k)=n*(k^2+k-2)/2，因此时间复杂度是O(n*(k^2+k-2)/2)=O(nk^2)。     其次，可以想到用分治的思想，两两合并直至最后。

针对方法一，

 class Solution {
 public:
     //用向量存储链表
     ListNode *mergeKLists(vector<ListNode *> &lists)
     {
         if(lists.size()==) return NULL;
         ListNode *res=lists[];     //取出第一个链表
         for(int i=;i<lists.size();i++)     //反复调用
             res=mergeTwoList(res,lists[i]);

         return res;
     }

     //归并排序
     ListNode *mergeTwoList(ListNode *head1,ListNode *head2)
     {
         ListNode node();   //创建头结点的前置结点
         ListNode *res=&node;
         while(head1&&head2)
         {
             if(head1->val<=head2->val)
             {
                 res->next=head1;
                 head1=head1->next;
             }
             else
             {
                 res->next=head2;
                 head2=head2->next;
             }
             res=res->next;
         }

         if(head1)
             res->next=head1;
         else if(head2)
             res->next=head2;

         return node.next;
     }
 };

针对方法二：比较难想的是，两两合并时，链表的选取。

 /**
  * 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 len=lists.size();
         if(len==)
             return NULL;

         while(len>)
         {
             int k=(len+)>>;

             for(int i=;i<len/;++i)
             {
                 lists[i]=mergeTwoLists(lists[i],lists[i+k]);
             }
             len=k;
         }
         return lists[];
     }

     ListNode *mergeTwoLists(ListNode *head1,ListNode *head2)
     {
         ListNode *nList=new ListNode(-);
         nList->next=head1;
         ListNode *pre=nList;

         while(head1&&head2)
         {
             if(head1->val >head2->val)
             {
                 pre->next=head2;
                 head2=head2->next;
             }
             else
             {
                 pre->next=head1;
                 head1=head1->next;
             }
             pre=pre->next;
         }

         if(head1)
         {
             pre->next=head1;
         }
         else
             pre->next=head2;

         return nList->next;
     }
 };

还有一种方法是最小堆的方法，维护一个大小为k的最小堆，初始化堆中的元素为每个链表的表头，它们会自动排好序，然后取出其中的最小元素介入新的链表中，然后，将最小元素的后继压入堆中，下次再从堆中选取最小的元素。元素加入堆中的复杂度为O（longk），总共有kn个元素加入堆中，因此，复杂度也和算法2一样是O（nklogk）。具体代码如下：

 class Solution
 {
 private:
 struct cmp
 {
     bool operator()(const ListNode *a,const ListNode *b)
     {
         return a->val >b->val;
     }
 }
 public:
     //用向量存储链表
     ListNode *mergeKLists(vector<ListNode *> &lists)
     {
         int n=lists.size();
         if (n==) return NULL;

         ListNode node();
         ListNode *res=&node;

         priority_queue<ListNode*,vector<ListNode*>,cmp> que;

         for(int i=;i<n;i++)
         {
             if(lists[i])
                 que.push(list[i]);
         }

         while(! que.empty())
         {
             ListNode *p=que.top();
             que.pop();
             res->next=p;
             res=p;

             if(p->next)
                 que.push(p->next);
         }

         return node.next;
     }
 }

此篇中，有很多分析过程都是来自JustDoIT和Grandyang的博客。