堆的封装

代码

---

• Heap.h

#pragma once

#ifndef _HEAP_H_
#define _HEAP_H_

typedef int DataType;
typedef int(*Compare)(DataType left, DataType right);


typedef struct Heap
{
    DataType* _hp;
    int _capacity; // 空间的大小 
    int _size; // 堆中有效元素的个数 
    Compare _com;
}Heap;

void CreateHeap(Heap* pHp, DataType array[], int size, Compare com);//堆的创建
void InitHeap(Heap* pHp, Compare com);//初始化堆
void Insert(Heap* pHp, DataType data);//堆的插入
void Remove(Heap* pHp);//堆得删除
int EmptyHeap(Heap* pHp);//堆的判空
int SizeHeap(Heap* pHp);//堆的大小
void AdjustDown(Heap* pHp, int parent);//向下排序
void AdjustUp(Heap* pHp, int child);//向上排序
DataType Top(Heap* pHp);//取第一个元素
void CheckCapacity(Heap* pHp);//检查堆的空间

int Less(DataType left, DataType right);
int Greater(DataType left, DataType right);

#endif // !_HEAP_H_

• Heap.c

#include<assert.h>
#include<stdlib.h>
#include<string.h>
#include"Heap.h"

void CreateHeap(Heap* pHp, DataType array[], int size, Compare com)//堆的创建
{
    pHp->_hp = (DataType*)malloc(sizeof(DataType)*(size + 3));
    assert(pHp->_hp);

    for (int i = 0; i < size; i++)
    {
        pHp->_hp[i] = array[i];
    }

    pHp->_capacity = size + 3;
    pHp->_size = size;
    pHp->_com = com;

    for (int i = (size - 2) / 2; i >= 0; i--)
    {
         AdjustDown(pHp, i);
    }
}
void InitHeap(Heap* pHp, Compare com)//初始化堆
{
    pHp->_hp = (DataType*)malloc(sizeof(DataType) * 3);
    assert(pHp->_hp);

    pHp->_capacity = 3;
    pHp->_size = 0;
    pHp->_com = com;
}

void swap(DataType* data1,DataType* data2)//交换
{
    DataType x = *data1;
    *data1 = *data2;
    *data2 = x;
}

void Insert(Heap* pHp, DataType data)//堆的插入
{
    pHp->_size++;
    CheckCapacity(pHp);

    pHp->_hp[pHp->_size - 1] = data;

    AdjustUp(pHp, pHp->_size - 1);

}
void Remove(Heap* pHp)//堆得删除
{
    assert(pHp);

    swap(&pHp->_hp[0], &pHp->_hp[pHp->_size-1]);

    pHp->_size--;

    AdjustDown(pHp, 0);
}
int EmptyHeap(Heap* pHp)//堆的判空
{
    return  0 == pHp->_size;

}
int SizeHeap(Heap* pHp)//堆的大小
{
    return pHp->_size;
}
void AdjustDown(Heap* pHp, int parent)//向下调整
{
    assert(pHp);
    int child = parent * 2 + 1;
    while (child < pHp->_size)
    {
        if (child + 1 < pHp->_size && pHp->_com(pHp->_hp[child + 1], pHp->_hp[child]))
        {
            child += 1;
        }
        if (pHp->_com(pHp->_hp[child], pHp->_hp[parent]))
        {
            swap(&pHp->_hp[child], &pHp->_hp[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            return;
        }
    }

}
void AdjustUp(Heap* pHp, int child)//向上调整
{
    int parent = (child - 1) / 2;
    while (child > 0)
    {
        if (pHp->_com(pHp->_hp[child], pHp->_hp[parent]))
        {
            swap(&pHp->_hp[child], &pHp->_hp[parent]);
            child = parent;
            parent = (child - 1) / 2;
        }
        else return;
    }
}
DataType Top(Heap* pHp)//取第一个元素
{
    assert(pHp);
    return pHp->_hp[0];
}
void CheckCapacity(Heap* pHp)//检查堆的空间
{
    if (pHp->_size > pHp->_capacity)
    {

        DataType* pNew = (DataType*)malloc(sizeof(DataType) * (2 * pHp->_size + 3));

        assert(pNew);

        pHp->_capacity = 2 * pHp->_size + 3;

        memcpy(pNew, pHp->_hp, sizeof(DataType) *( pHp->_size - 1));

        free(pHp->_hp);
        pHp->_hp = pNew;
    }
}

int Less(DataType left, DataType right)
{
    return left <  right;
}
int Greater(DataType left, DataType right)
{
    return left > right;
}


//int main()//测试
//{
//  Heap pHp ;
//  int arr[] = { 9, 45, 84, 65, 12, 35, 87, 16, 10 };
//
//  CreateHeap(&pHp, arr, sizeof(arr) / sizeof(arr[0]), Less);
//
//  Remove(&pHp);
//
//  Insert(&pHp, 4);
//  Insert(&pHp, 2);
//  Insert(&pHp, 1);
//  Insert(&pHp, 0);
//
//  system("pause");
//  return 0;
//}