23. Merge k Sorted Lists

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

第一种方法：思路是每次取出两条，用merge2Lists的方法合并为一条，再将这条和下一条用merge2Lists来合并为一条，以此类推。假设每条链表平均有n个元素，此种时间复杂度是O(2n+3n+…+kn), 为O(nk²)，时间复杂度较高。

#include<stdio.h>
#include<stdlib.h>
struct ListNode {
   int val;
   struct ListNode *next;
 };
 struct ListNode* mergeTwoLists(struct ListNode* l1,struct ListNode* l2) 
    {
        struct ListNode *L,*p;
        L=malloc(sizeof(struct ListNode));
        L->next=NULL;
        p=L;
        while(l1&&l2)
        {
            if(l2==NULL||(l1!=NULL&&l1->val<l2->val))
            {
                p->next=l1;
                l1=l1->next;
                p=p->next;
            }
            else
            {
                p->next=l2;
                l2=l2->next;
                p=p->next;
            }
        }
        if(l1)
            p->next=l1;
        if(l2)
            p->next=l2;
        return L->next;
    }
struct ListNode* mergeKLists(struct ListNode** lists, int listsSize) {
    struct ListNode *L;
    int i;
    L=malloc(sizeof(struct ListNode));
    L=NULL;
    if(0==listsSize)
        return L;
    else if(1==listsSize)
    {
        L=lists[0];
        return L;
    }
    else
    {
        L=mergeTwoLists(lists[0],lists[1]);
        for(i=2;i<listsSize;i++)
            L=mergeTwoLists(L,lists[i]);
    }
    return L;
}
void main()
{
    struct ListNode *L,*p,*q,**list,*result;
    int N,K,i,j,temp;
    scanf("%d",&K);
    list=(struct ListNode**)malloc(sizeof(struct ListNode*)*K);
    for(i=0;i<K;i++)
    {
        scanf("%d",&N);
        list[i]=(struct ListNode*)malloc(sizeof(struct ListNode));
        list[i]=NULL;
        L= (struct ListNode*)malloc(sizeof(struct ListNode));
        L->next=NULL;
        p=L; 
        for(j=0;j<N;j++)
        {
            scanf("%d",&temp);  
            q= (struct ListNode*)malloc(sizeof(struct ListNode));
            q->val=temp;
            q->next=NULL;
            p->next=q;
            p=q;
        }
        list[i]=L->next;
    }
    result=mergeKLists(list,K);
    while(result)
    {
        printf("%d ",result->val);
        result=result->next;
    }
}

第二种方法：分治法

//分治递归的方法
#include<iostream>
#include<vector>
using namespace std;
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) 
    {
        ListNode *L,*p;
        L=(ListNode*)malloc(sizeof(ListNode));
        L->next=NULL;
        p=L;
        while(l1&&l2)
        {
            if(l2==NULL||(l1!=NULL&&l1->val<l2->val))
            {
                p->next=l1;
                l1=l1->next;
                p=p->next;
            }
            else
            {
                p->next=l2;
                l2=l2->next;
                p=p->next;
            }
        }
        if(l1)
            p->next=l1;
        if(l2)
            p->next=l2;
        return L->next;
    }
    ListNode* mergehelper(vector<ListNode*>& lists,int start,int end)
    {
        int mid;
        if(start==end)
            return lists[start];
        mid=(start+end)/2;
        ListNode *L=mergehelper(lists,start,mid);
        ListNode *R=mergehelper(lists,mid+1,end);
        return mergeTwoLists(L,R);
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) 
    {
        if(lists.size()==0)
            return NULL;
        return mergehelper(lists,0,lists.size()-1);
    }
};
int main()
{
    vector<ListNode*>L;
    int k,N,i,j,number; 
    cin>>k;
    for(i=0;i<k;i++)
    {
        cin>>N;
        ListNode *temp;
        temp=(ListNode*)malloc(sizeof(struct ListNode));
        temp->next=NULL;
        ListNode *p=temp;
        for(j=0;j<N;j++)
        {
            cin>>number;
            ListNode *q=(ListNode*)malloc(sizeof(struct ListNode));
            q->val=number;
            q->next=NULL;
            p->next=q;
            p=q;
        }
        L.push_back(temp->next);
        free(temp);
    }
    Solution solve;
    ListNode *result=solve.mergeKLists(L);
    while(result)
    {
        cout<<result->val<<' ';
        result=result->next;
    }
    return 0;
}

第三种方法： 将每个链表的表头元素取出来，建立一个小顶堆，因为k个链表中都排好序了，因此每次取堆顶的元素就是k个链表中的最小值，可以将其合并到合并链表中，再将这个元素的指针指向的下一个元素也加入到堆中，再调整堆，取出堆顶，合并链表。。。。以此类推，直到堆为空时，链表合并完毕。
建堆的时间复杂度是k/2logk, 每次取出堆顶再加入元素的复杂度是logk,假设每条链表平均有n个元素，则一共有nk-k次。因此总的时间复杂度为O(nklogk)。

#include<iostream>
#include<vector>
using namespace std;
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        // 使用堆排序, 
        // 1. 选出每个链表的头来插入小顶堆中，
        // 2. 再把堆顶接入合并链表中，
        // 3. 被选出的指针后移再加入小顶堆中,回到2
        // 4. 最后所有链表都为空时，返回合并链表的头指针
        if(lists.empty())
            return NULL;
        vector<ListNode* > heap;
        // 1. 选出每个链表的头来插入小顶堆中，
        for(int i = 0; i != lists.size(); i ++){
            if(lists[i]) heap.push_back(lists[i]);
        }
        makeHeap(heap);
        // 2. 再把堆顶接入合并链表中，
        ListNode head(-1); // 合并链表的表头
        ListNode* p = &head;
        while(!heap.empty()){
            ListNode* minNode = popHeap(heap);
            p->next = minNode; // 接入链表
            p = p->next;
            // 3. 被选出的指针后移再加入小顶堆中,回到2
            ListNode* next = minNode->next;
            if(next) pushHeap(heap, next);
        }
        // 4. 最后所有链表都为空时，返回合并链表的头指针
        return head.next;
    }
    // 建立小顶堆
    void makeHeap(vector<ListNode*> &heap){
        // 从最后一个元素的父节点开始建立小顶堆
        for(int i = (heap.size()-1)/2; i >= 0 ; i --)
        {
            minHeap(heap, i);
        }
    }
    // 调整小顶堆,以第i个元素为根建立小顶堆
    //位置从1开始
    void minHeap(vector<ListNode*> &heap, int i)
    {
        int child;
        ListNode* temp=heap[i];
        for(;2*i+1<heap.size();i=child)
        {
            child=2*i+1;
            if((child!=heap.size()-1)&&heap[child+1]->val<heap[child]->val)
                child++;
            if(temp->val>heap[child]->val)
                heap[i]=heap[child];
            else
                break;
        }
        heap[i]=temp;
    }
    // 在最小堆中插入一个元素
    void pushHeap(vector<ListNode*> &heap, ListNode* p)
    {
        heap.push_back(p);
        int child = heap.size()-1;
        int parent = (child-1)/2;
        for(;child!=0; parent = (child-1)/2)
        {
            if(heap[child]->val < heap[parent]->val)
            {
                swap(heap[child], heap[parent]);
                child=parent;
            }
            else
                break;
        }
    }
    // 弹出堆顶
    ListNode* popHeap(vector<ListNode*> &heap)
    {
        swap(heap[0], heap[heap.size()-1]);
        ListNode* p = heap.back();
        heap.pop_back();
        minHeap(heap, 0);
        return p;
    }
};
int main()
{
    vector<ListNode*>L;
    int k,N,i,j,number; 
    cin>>k;
    for(i=0;i<k;i++)
    {
        cin>>N;
        ListNode *temp;
        temp=(ListNode*)malloc(sizeof(struct ListNode));
        temp->next=NULL;
        ListNode *p=temp;
        for(j=0;j<N;j++)
        {
            cin>>number;
            ListNode *q=(ListNode*)malloc(sizeof(struct ListNode));
            q->val=number;
            q->next=NULL;
            p->next=q;
            p=q;
        }
        L.push_back(temp->next);
        free(temp);
    }
    Solution solve;
    ListNode *result=solve.mergeKLists(L);
    while(result)
    {
        cout<<result->val<<' ';
        result=result->next;
    }
    return 0;
}