堆实现

标签：

一、堆排序 （Heap  sort）

     定义： 完全二叉树的非终端节点的值均不大于（不小于）子节点的值

     存储结构：  数组 ｜  vector

     逻辑结构：  完全二叉树

     性质：

              a.  节点编号 0...n-1

              b.  节点i， 左字节点＝ 2*i+1, 右子节点 ＝ 2*i ＋ 2；

              c.  最后一个非终端节点：n/2 - 1 (n为节点的个数)

     要分析的问题：

      1）如何由无序数组建立一个堆  

for i = n/2 -1, n>=0; i--
    heap_adjust(heap,i,n);   //向下调整当前i为根的树，从最后一个非终端节点开始

      2）输出堆顶元素后如何继续调整剩余的堆        

heap[0]＝ heap[n-1];
adjust(heap,0,n-1);  //从顶点向下开始调整

         关键：  heap_adjust (swift_down)向下调整函数

c语言实现

#include <stdio.h>
//从 1开始计数的最小堆
void heap_adjust(int heap[], int i,int len)
{
#if 0
     //递归实现
    int l = 2 * i + 1;
    int r = l + 1;
    int min = i;
    if(l < len && heap[l] < heap[i])  min = l;
    if(r < len && heap[r] < heap[min])  min = r;
    if(min != i)
    {
        int tmp = heap[min];
        heap[min] = heap[i];
        heap[i] = tmp;
        heap_adjust(heap,min,len);
    }
#else
    //非递归实现
    int tmp = heap[i];  //暂时存储
    int min;            //记录交换的节点
    for(int k=i; k<len;)
    {
        int l = k * 2 + 1;
        int r = l + 1;
        min = k;
        if(l < len && heap[l] < heap[k]) min = l;
        if(r < len && heap[r] < heap[min]) min = k;
        
        if(min == k)  break; 
        heap[k] = heap[min];
        k = min;    
    }    
    heap[min] = tmp;
#endif
}
void build_heap(int heap[], int len)
{
     for(int k = len/2-1; k >= 0; k--)
     {
         heap_adjust(heap,k,len);
     }    
}
void heap_sort(int heap[] ,int len)
{
     build_heap(heap, len);
     
     for(int i=len-1; i>0; i--){
         printf("%d->%d.\n",len-i,heap[0]);
         heap[0] = heap[i];
         heap_adjust(heap,0,i);
     }
}
int main()
{
     int arr[] = {96,85,53,47,56,38,36,12,24};
     heap_sort(arr,9);
     //build_heap(arr,9);
     return 0;
}

堆实现

标签：

原文地址：http://my.oschina.net/u/573270/blog/476206