[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()==0) return NULL;
        ListNode *res=lists[0];     //取出第一个链表
        for(int i=1;i<lists.size();i++)     //反复调用
            res=mergeTwoList(res,lists[i]);

        return res;    
    }

    //归并排序
    ListNode *mergeTwoList(ListNode *head1,ListNode *head2)
    {
        ListNode node(0);   //创建头结点的前置结点
        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==0)
            return NULL;

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

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

    ListNode *mergeTwoLists(ListNode *head1,ListNode *head2)
    {
        ListNode *nList=new ListNode(-1);
        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==0) return NULL;

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

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

        for(int i=0;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的博客。