小顶堆第二弹-----堆降序排序（C语言非递归）

  现在po一下C语言版本的，留作以后接口使用.
  1 #include <stdio.h>
#include <stdlib.h>

#define HEAP_SIZE 100
#define HEAP_FULL_VALUE -100

#if 0
/*小顶堆存储结构*/
typedef struct small_heap
{
    int data[HEAP_SIZE];
    int num;
}SMALL_HEAP;
#endif


/*
 * name: heap_Swap
 *
 * purpose:
 *     swap two value of heap
 */
static void heap_Swap(int heap[],int index_src,int index_dst)
{
    int tmp = heap[index_src];

    heap[index_src] = heap[index_dst];
    heap[index_dst] = tmp;
}

/*
 * name: heap_Up
 *
 * purpose:
 *     move up value of the index position to adjust heap struct
 */
static void heap_Up(int heap[],int index)
{
    int parent = index / 2;
    
    while(parent >= 1)
    {
        if(heap[index] < heap[parent])
        {
            heap_Swap(heap,index,parent);
            index = parent;
        }
        else
        {
            break;
        }
    }
}

/*
 * name: heap_Down
 *
 * purpose:
 *     move down value of the index position to adjust heap struct
 */
static void heap_Down(int heap[],int index,int heap_data_num)
{
    if(index * 2 > heap_data_num)
    {//leaf node can not move down
        return;
    }

    while(index * 2 <= heap_data_num )
    {
        int child = index * 2; // left child 

        if(child > heap_data_num)
        { 
            return;
        }

        if(index * 2 < heap_data_num)
        {//the node have two child
            if(heap[child + 1] < heap[child])
            {
                child += 1; //right child is smaller update
            }

        }
        
        if(heap[child] < heap[index])
        {//the child samller than index swap value
            heap_Swap(heap,index,child);
            index = child;
        }
        else
        { 
            break;
        }
    }
}

/*
 * name: heap_Insert
 *
 * purpose:
 *     insert a value into heap and ajust heap struct
 */
void heap_Insert(int heap[],int *heap_data_num,int value)
{
    if(*heap_data_num == 0)
    {
        heap[0] = HEAP_FULL_VALUE; //data 0 do not save in the heap 
    }

    (*heap_data_num)++;    //update heap size
    heap[*heap_data_num] = value; //add value to heap

    heap_Up(heap,*heap_data_num); //adjust heap struct
}

/*
 * name: heap_Delete
 *
 * purpose:
 *     delete a value from heap
 */
void heap_Delete(int heap[],int *heap_data_num,int value)
{
    int index;
    
    for(index = 1; index <= *heap_data_num; index++)
    {
        if(heap[index] == value)
        {
            break;
        }
    }

    if(index > *heap_data_num)
    {//the value is not exist
        return;
    }

    heap[index] = heap[*heap_data_num]; //set the index value as final value
    
    (*heap_data_num)--;//the final value is not as the heap

    heap_Down(heap,index,*heap_data_num); //move down 
    
    int parent = index / 2; 
    if(parent > 0 && heap[index] < heap[parent])
    {//ajust to the special situation
        heap_Up(heap,index);
    }    
    
    heap[*heap_data_num + 1] = HEAP_FULL_VALUE; //delete final data
}

/*
 * name:heap_Init_Adjust
 *
 * purpose:
 *    to adjust the init heap
 *    time complex is O(n) better than insert value one by one
 *
 * explain:
 *     because the heap is a complete binary tree so just first half of heap data is not leaf node
 *
 */
void heap_Init_Adjust(int heap[],int heap_data_num)
{
    int index;

    for(index = heap_data_num / 2; index >= 1; index--)
    {
        heap_Down(heap,index,heap_data_num); //adjust the heap struct at index position
    }
}

void heap_Print(int heap[],int heap_data_num);
/*
 * name: heap_Sort
 *
 * purpose:
 *     to sort the heap to a descending order
 */    
void heap_Sort(int heap[],int heap_data_num)
{
    int index;
    
    for(index = heap_data_num; index > 1; index--)
    {
        heap_Swap(heap,1,index); //swap the heap top with the final value
        heap_Down(heap,1,index - 1); //to ajust the heap struct afert sort one value
        //heap_Print(heap,heap_data_num);
    }
}


/*
 * name: heap_Print
 *
 * purpose:
 *  print heap data as commen order
 */
void heap_Print(int heap[],int heap_data_num)
{
    int i;
    for(i = 1; i <= heap_data_num; i++)
    {
        printf("%d ",heap[i]);
    }

    printf("
");
}


int main()
{
    int heap[HEAP_SIZE];        
    int i,heap_data_num = 0;

    for(i = 0; i < heap_data_num; i++)
    {
        heap[i] = HEAP_FULL_VALUE;
    }
    
#if 1
    heap_Insert(heap,&heap_data_num,1);
    heap_Insert(heap,&heap_data_num,3);
    heap_Insert(heap,&heap_data_num,4);
    heap_Insert(heap,&heap_data_num,5);
    heap_Insert(heap,&heap_data_num,8);
    heap_Insert(heap,&heap_data_num,2);
    heap_Insert(heap,&heap_data_num,7);
    heap_Insert(heap,&heap_data_num,6);

    heap_Print(heap,heap_data_num);
    
    heap_Sort(heap,heap_data_num);
    heap_Print(heap,heap_data_num);

    heap_Init_Adjust(heap,heap_data_num);
    heap_Print(heap,heap_data_num);

    heap_Sort(heap,heap_data_num);
    heap_Print(heap,heap_data_num);
    
    heap_Delete(heap,&heap_data_num,2);
    heap_Print(heap,heap_data_num);
    heap_Delete(heap,&heap_data_num,1);
    heap_Print(heap,heap_data_num);

    heap_Sort(heap,heap_data_num);
    heap_Print(heap,heap_data_num);

    heap_Init_Adjust(heap,heap_data_num);
    heap_Print(heap,heap_data_num);
    
#endif

#if 0
    heap_Insert(heap,&heap_data_num,1);
    heap_Insert(heap,&heap_data_num,3);
    heap_Insert(heap,&heap_data_num,11);
    heap_Insert(heap,&heap_data_num,5);
    heap_Insert(heap,&heap_data_num,4);
    heap_Insert(heap,&heap_data_num,8);
    heap_Insert(heap,&heap_data_num,7);
    heap_Insert(heap,&heap_data_num,6);

    heap_Print(heap,heap_data_num);
    
    heap_Delete(heap,&heap_data_num,8);

    heap_Print(heap,heap_data_num);
#endif

}