堆(Heap)-c实现

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

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

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

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

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

#include <stdio.h>

//#define PF  printf("____________in Function___________ %s
", __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 + 1;
    *(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 1;
    }
    else if(*min == *r)
    {
        return 2;
    }else
    {// min = *t
        return 0;
    }
}
void PopEle(int *heap)
{
    //PF;
    *(heap+1) = *(heap + *heap);
    --(*heap);
}

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


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

}

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

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

        if(ret ==1)
        {
            //l is the min
            tmp = *top;
            *top = *l;
            *l = tmp;
        }
        else if(ret ==2)
        {
            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*2+1 <= *heap)
    {
        if((*(heap +pos) > *(heap + pos*2))
         || (*(heap +pos) > *(heap + pos*2+1)))
        {

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


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

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

    //用递归好写，偷点懒
    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[7]={6, 4, 5, 2, 1,3, 6};

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

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

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

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

    return 0;
}

运行结果贴下：

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