堆排序之“用最小堆将k个已排序链表合并为一个排序链表”

问题：请给出一个时间为O(nlgk)，用来将k个已排序链表合并为一个排序链表的算法。此处的n为所有输入链表中元素的总数。（提示：用一个最小堆来做k路合并）

编程思路：

假设k个链表都是非降序排列的。

（1）取k个元素建立最小堆，这k个元素分别是k个链表的第一个元素。建堆的时间复杂度O(k)。

（2）堆顶元素就是k个链表中最小的那个元素，取出它。时间复杂度O(1)。

（3）若堆顶元素所在链表不为空，则取下一个元素放到堆顶位置，这可能破坏了最小堆性质，所以进行堆调整。堆调整时间复杂度O(lgk)。若为空，则此子链表已经被合并完毕，则删除最小堆的堆顶元素，此时最小堆的heapSize减小了1 。删除指定元素时间复杂度O(lgk)。

（4）重复步骤（2）~（3）n-k次。总的时间复杂度是O(k)+O(nlgk)即O(nlgk)。

要先定义一个数据结构Node，主要是为了找链表所在索引方便，这个程序我先用随机函数生成4个子链表（一个二维数组，为了省事就让每个子链表的元素个数相同）然后用冒泡排序分别对每个链表排序，然后合并它们。

[cpp] view
plaincopy

#include <stdio.h>  

#include <string.h>  

#include <time.h>  

  

#define BUFFER_SIZE 10  

  

typedef struct  

{  

    int data;  

    int index;  

}Node;  

  

void Output(Node (*a)[BUFFER_SIZE],int k,int len)  

{  

    int i=0;  

    int j=0;  

    for(i=0;i<k;i++)  

    {  

        printf("第%d个链表：",i);   

        for(j=0;j<len;j++)  

        {  

            printf("%d ",a[i][j].data);  

        }  

        printf("\n");  

    }  

}   

  

  

void BubbleSort(Node (*a)[BUFFER_SIZE],int k,int len)  

{  

    int i=0;  

    int j=0;  

    int h=0;  

    int tmp=0;  

      

    for(h=0;h<k;h++)  

    {  

        for(i=1;i<len;i++)  

        {  

            for(j=0;j<len-i;j++)  

            {  

                if(a[h][j].data>a[h][j+1].data)  

                {//因为每一次都是在每个子链表内部排序，所以就没有必要交换index了，因为同一个子链表中的index都是一样的   

                    tmp=a[h][j].data;  

                    a[h][j].data=a[h][j+1].data;  

                    a[h][j+1].data=tmp;  

                }     

            }  

        }  

    }  

}  

//堆调整，保持堆的性质   

void MinHeapIfy(Node *a,int i,int heapSize)  

{  

    int smallest=0;  

    int left=0;  

    int right=0;  

    Node tmp;  

      

    while(i<heapSize)  

    {  

        left=i<<1;  

        right=(i<<1)+1;  

          

        if(left<=heapSize&&a[i].data>a[left].data)  

        {  

            smallest=left;  

        }  

        else  

        {  

            smallest=i;  

        }  

        if(right<=heapSize&&a[smallest].data>a[right].data)  

        {  

            smallest=right;  

        }  

          

        if(i!=smallest)  

        {//在C++中针对Node可以定义一个赋值构造函数就不用像下面这样子交换了   

            tmp.data=a[i].data;  

            tmp.index=a[i].index;  

            a[i].data=a[smallest].data;  

            a[i].index=a[smallest].index;  

            a[smallest].data=tmp.data;  

            a[smallest].index=tmp.index;  

              

            i=smallest;  

        }  

        else  

        {  

            break;  

        }  

    }  

      

}   

//建堆   

void BuildMinHeap(Node *a,int heapSize)  

{  

    int i=0;  

    for(i=heapSize/2;i>1;i--)  

    {  

        MinHeapIfy(a,i,heapSize);  

    }  

}   

  

//删除堆中指定元素  

void MinHeapDelete(Node *a,int i,int *heapSize)   

{  

    Node tmp;  

    tmp.data=a[i].data;  

    tmp.index=a[i].index;  

      

    a[i].data=a[*heapSize].data;  

    a[i].index=a[*heapSize].index;  

      

    if(a[i].data==tmp.data)  

    {  

        (*heapSize)--;  

    }  

    else if(a[i].data>tmp.data)  

    {  

        (*heapSize)--;  

        MinHeapIfy(a,i,*heapSize);  

    }  

    else if(a[i].data<tmp.data)  

    {  

        (*heapSize)--;  

        while(i>1&&a[i>>1].data>a[i].data)  

        {  

            tmp.data=a[i].data;  

            tmp.index=a[i].index;  

            a[i].data=a[i>>1].data;  

            a[i].index=a[i>>1].index;  

            a[i>>1].data=tmp.data;  

            a[i>>1].index=tmp.index;  

        }  

    }  

}  

//合并k个子链表   

void Merge(Node (*a)[BUFFER_SIZE],int k,Node *result)  

{  

    int heapSize=0;  

    int i=0;  

    Node tmp[BUFFER_SIZE+1];  

    int j=0;  

    int index=0;  

    int n=k*BUFFER_SIZE;//k个链表中的元素总数   

    int b[k];//用来记录每个子链表该哪个元素添加进堆中   

    memset(b,0,sizeof(b));   

    //用每个链表的第一个元素，共k个，建立最小堆   

    for(i=0;i<k;i++)  

    {  

        tmp[i+1].data=a[i][0].data;  

        tmp[i+1].index=a[i][0].index;  

        b[i]++;   

    }  

    heapSize=k;  

    BuildMinHeap(tmp,heapSize);  

    while(n>0)  

    {  

        //将堆顶元素放入输出链表   

        result[j].data=tmp[1].data;  

        result[j].index=tmp[1].index;  

        index=result[j].index;  

        j++;  

        n--;//子链表少了一个元素  

          

        if(b[index]<BUFFER_SIZE)  

        {//该子链表还未空，则继续从该子链表选取元素入堆   

            //将index子链表的下一个元素放到堆顶，然后进行堆调整   

            tmp[1].data=a[index][b[index]].data;  

            tmp[1].index=a[index][b[index]].index;  

            b[index]++;//index子链表待加入堆中的下一个元素   

            MinHeapIfy(tmp,1,heapSize);  

        }  

        else  

        {  

            MinHeapDelete(tmp,1,&heapSize);  

        }  

    }  

    BuildMinHeap(tmp,k);  

      

}  

int main()  

{  

    int i=0;  

    int j=0;  

    Node a[4][BUFFER_SIZE];  

    Node result[4*BUFFER_SIZE];  

    //随机生成k个链表，k=4   

    srand((unsigned)time(NULL));  

    for(i=0;i<4;i++)  

    {  

        for(j=0;j<BUFFER_SIZE;j++)  

        {  

            a[i][j].data=rand()%1000;  

            a[i][j].index=i;  

        }  

    }   

    printf("随机生成的k个链表：\n");  

    Output(a,4,BUFFER_SIZE);   

      

    BubbleSort(a,4,BUFFER_SIZE);  

    printf("对k个链表进行冒泡排序：\n");   

    Output(a,4,BUFFER_SIZE);  

      

    Merge(a,4,result);  

    printf("合并K个链表：\n");   

    for(i=0;i<4*BUFFER_SIZE;i++)  

    {  

        printf("%d ",result[i].data);  

    }  

    system("pause");  

    return 0;  

}