“用最小堆将k个已排序链表合并为一个排序链表”（算法导论 练习6.5-9）

问题：请给出一个时间为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个子链表（一个二维数组，为了省事就让每个子链表的元素个数相同）然后用冒泡排序分别对每个链表排序，然后合并它们。

 #include
 #include
 #include

 #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
     {
         printf("第%d个链表：",i);
         for(j=0;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
     {
         for(i=1;i
         {
             for(j=0;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
     {
         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
     {
         (*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
     {
         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]
         {//该子链表还未空，则继续从该子链表选取元素入堆
             //将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
         {
             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;
 }

转自http://blog.csdn.net/michealtx/article/details/7172910