堆(Heap)-c实现

这个堆的实现采用数组存储的完全二叉树实现。

最近有点烦躁，先是跳槽到了一个外包公司，感觉2016有点坑，另外一件事就是老婆怀孕了，但是在家里没人照顾，很担心。

这个堆的实现就暂时不优化了，基本的插入，删除实现。

还有，NJ，这个城市真热。

这周希望把剩下的几个数据结构给写了@2016-08-11 00:08:22

 #include <stdio.h>

 //#define PF  printf("____________in Function___________ %s\n", __FUNCTION__)
 #define PF

 #define HAVETWOSON  1  //表示其有2个子节点
 #define HAVEONLYLSON 2 //只有1个左孩子节点

 /*堆的实现采用数组，首先是构建完全二叉树的规则
 1.完全二叉树的性质
 2.子节点的value小于父节点
 3.为了保持数组下标和完全二叉树的对应关系，数组下标选择从1开始处理，第1个数组元素置为heap的大小
 4.最近比较事多，老婆怀孕，家里没人照顾，好烦躁。这个堆的实现push和pop有好的方法去实现，但是没心情去好好想，就偷懒了，具体的想法就是，push和pop操作的元素只是i,2i, 2i+1，希望有时间来改改吧。
 */
 void RevHeap(int *top, int *l, int *r);
 int GetMin(int *t, int *l, int *r, int *min);
 void PopEle(int *heap);
 void PrintBHeapWh(int *top);
 void PrintBHeapEl(int *top);
 int CheckHeap(int *heap, int pos);
 void ConsBHeap(int *heap);
 void PushEle(int *heap, int newEle);

 void PushEle(int *heap, int newEle)
 {
     *heap = *heap + ;
     *(heap + *heap) = newEle;
 }
 int GetMin(int *t, int *l, int *r, int *min)
 {
     PF;
     //min = (int *)malloc(sizeof(int));
     *min = *t;
     if(*min > *l)
     {
         *min = *l;
     }
     if(*min > *r)
     {
         *min = *r;
     }
     if(*min == *l)
     {
         return ;
     }
     else if(*min == *r)
     {
         return ;
     }else
     {// min = *t
         return ;
     }
 }
 void PopEle(int *heap)
 {
     //PF;
     *(heap+) = *(heap + *heap);
     --(*heap);
 }

 void PrintBHeapWh(int *top)
 {
     //PF;
     int i ;
     for(i=; i<*top+; i++)
     {
         printf("%d ", *(top+i));
     }
     printf("\n");
 }

 void PrintBHeapEl(int *top)
 {
     //PF;
     int i ;
     for(i=; i<*top+; i++)
     {
         printf("%d ", *(top+i));
     }
     printf("\n");

 }

 void RevHeap(int *top, int *l, int *r)
 {

     int *min = NULL;
     min = (int *)malloc(sizeof(int));
     int ret = -;
     int tmp;
     if(r != NULL)
     {
         ret = GetMin(top, l, r, min);

         if(ret ==)
         {
             //l is the min
             tmp = *top;
             *top = *l;
             *l = tmp;
         }
         else if(ret ==)
         {
             tmp = *top;
             *top = *r;
             *r = tmp;
         }
     }
     else
     {
         *min = *top;
         if(*min > *l)
         {
             tmp = *l;
             *l =*min;
             *min = tmp;
         }
         *top = *min;
     }
     return ;
 }
 int CheckHeap(int *heap, int pos)
 {
     //PF;
     if(pos*+ <= *heap)
     {
         if((*(heap +pos) > *(heap + pos*))
          || (*(heap +pos) > *(heap + pos*+)))
         {

             return HAVETWOSON;
         }
     }
     //只有左子树
     //if((pos*2 <= size)&&(pos*2+1 > size))
     if((pos* == *heap))
     {
         if(*(heap +pos) > *(heap + pos*))
         // || (*heap +pos > *heap + pos*2+1))
         {
             return HAVEONLYLSON;
         }
     }
     return ;
 }

 void ConsBHeap(int *heap)
 {
     PF;
     int i ;
     int isNeedCon = ;

     for(i = ; i < *heap+; i++)
     {
         if(CheckHeap(heap, i)==HAVETWOSON)
         {
             //printf("proc [%d]th elem [%d]\n", i, *(heap+i));
             RevHeap(heap +i, (heap + *i), (heap+ *i+));
             //printf("i=[%d] %d  %d %d \n", i, *(heap+i), *(heap + 2*i), *(heap+ 2*i+1));
             isNeedCon = ;
         }
         else if(CheckHeap(heap, i)== HAVEONLYLSON)
         {
             RevHeap(heap+i, (heap + *i), NULL);
             //printf("i=[%d] %d  %d \n", i, *(heap+i), *(heap + 2*i) );
             isNeedCon = ;
         }
         //printf("[%d]th change.", i);
         //PrintBHeapEl(heap);
     }
     printf("\n");

     //用递归好写，偷点懒
     if(isNeedCon)
     {
         ConsBHeap(heap);
     }
     return;
 }
 int main(void)
 {
     //int arr[12]={0,4, 5, 2, 1,3, 6, 8, 9, 7, 22, 11};
     int arr[]={, , , , ,, };

     //PrintBHeapEl(arr);
     printf("Berfore process the heap:\n");
     PrintBHeapWh(arr);

     ConsBHeap(arr);
     printf("Consturcct the heap:\n");
     PrintBHeapWh(arr);

     PopEle(arr);
     printf("Pop  the heap:\n");
     PrintBHeapWh(arr);
     ConsBHeap(arr);
     printf("Pop Con the heap:\n");
     PrintBHeapWh(arr);

     PushEle(arr, );
     printf("Pop  the heap:\n");
     PrintBHeapWh(arr);
     ConsBHeap(arr);
     printf("Push Con the heap:\n");
     PrintBHeapWh(arr);

     return ;
 }

运行结果贴下：

Berfore process the heap:
6 4 5 2 1 3 6

Consturcct the heap:
6 1 2 4 5 3 6
Pop  the heap:
5 6 2 4 5 3

Pop Con the heap:
5 2 3 4 5 6
Pop  the heap:
6 2 3 4 5 6 1

Push Con the heap:
6 1 3 2 5 6 4