堆

堆的实现

堆分为大顶堆和小顶堆

其操作：

　　（1）插入时，插入在最后，然后向上调整

　　（2）删除时，将最后一个元素调至到堆顶，然后向下调整

　　（3）堆的生成分两种：

　　　　　　①插入后再调整 ——-时间复杂度O(NlogN)

　　　　　　②先排成完全二叉树再调整 ——-时间复杂度O(N)

　　　　　　这两者区别，有时拍完后的二叉树不一定一样注意

练习题目链接：https://pta.patest.cn/pta/test/1342/exam/4/question/21731

这不能直接用下面的代码，否则最后一个测试点过不去，超时！

因为malloc，直接设为数组即可，还有就是用Insert，不能用BuileHeap，因为其和调整完和测试用例不符

---

下面是大顶堆，小顶堆改下< 和 minSize

#include<stdio.h>
#include<stdlib.h>
#define ElementType int
typedef struct HNode *Heap; // 堆的类型定义
struct HNode {
    ElementType *Data; // 存储元素的数组
    int Size;          // 堆中当前元素个数
    int Capacity;      // 堆的最大容量
};
typedef Heap MaxHeap; // 最大堆
typedef Heap MinHeap; // 最小堆

#define MAXDATA 1000  // 该值应根据具体情况定义为大于堆中所有可能元素的值

MaxHeap CreateHeap( int MaxSize )
{ // 创建容量为MaxSize的空的最大堆

    MaxHeap H = (MaxHeap)malloc(sizeof(struct HNode));
    H->Data = (ElementType *)malloc((MaxSize+1)*sizeof(ElementType));
    H->Size = 0;
    H->Capacity = MaxSize;
    H->Data[0] = MAXDATA; // 定义"哨兵"为大于堆中所有可能元素的值

    return H;
}

bool IsFull( MaxHeap H )
{
    return (H->Size == H->Capacity);
}

bool Insert( MaxHeap H, ElementType X )
{ // 将元素X插入最大堆H，其中H->Data[0]已经定义为哨兵
    int i;

    if ( IsFull(H) ) {
        printf("最大堆已满");
        return false;
    }
    i = ++H->Size; // i指向插入后堆中的最后一个元素的位置
    for ( ; H->Data[i/2] < X; i/=2 )
        H->Data[i] = H->Data[i/2]; // 上滤X
    H->Data[i] = X; // 将X插入
    return true;
}

#define ERROR -1 // 错误标识应根据具体情况定义为堆中不可能出现的元素值

bool IsEmpty( MaxHeap H )
{
    return (H->Size == 0);
}

ElementType DeleteMax( MaxHeap H )
{ // 从最大堆H中取出键值为最大的元素，并删除一个结点
    int Parent, Child;
    ElementType MaxItem, X;

    if ( IsEmpty(H) ) {
        printf("最大堆已为空");
        return ERROR;
    }

    MaxItem = H->Data[1]; // 取出根结点存放的最大值
    // 用最大堆中最后一个元素从根结点开始向上过滤下层结点
    X = H->Data[H->Size--]; // 注意当前堆的规模要减小
    for( Parent=1; Parent*2<=H->Size; Parent=Child ) {
        Child = Parent * 2;
        if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )
            Child++;  // Child指向左右子结点的较大者
        if( X >= H->Data[Child] ) break; // 找到了合适位置
        else  // 下滤X
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;

    return MaxItem;
}

//----------- 建造最大堆 -----------
void PercDown( MaxHeap H, int p )
{ // 下滤：将H中以H->Data[p]为根的子堆调整为最大堆
    int Parent, Child;
    ElementType X;

    X = H->Data[p]; // 取出根结点存放的值
    for( Parent=p; Parent*2<=H->Size; Parent=Child ) {
        Child = Parent * 2;
        if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )
            Child++;  // Child指向左右子结点的较大者
        if( X >= H->Data[Child] ) break; // 找到了合适位置
        else  // 下滤X
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;
}

void BuildHeap( MaxHeap H )
{ // 调整H->Data[]中的元素，使满足最大堆的有序性
  // 这里假设所有H->Size个元素已经存在H->Data[]中

    int i;

    // 从最后一个结点的父节点开始，到根结点1
    for( i = H->Size/2; i>0; i-- )
        PercDown( H, i );
}

int main(){
    int N, M;
    int i;
    int temp;
    MaxHeap maxHeap;
    scanf("%d %d\n", &N, &M);
    maxHeap = CreateHeap(N);
    for(i = 1; i <= N; ++i){
        scanf("%d", &temp);
        maxHeap -> Data[i] = temp;
    }
    for(i = 1; i <= N; ++i){
        printf("%d ", maxHeap -> Data[i]);
    }
    printf("\n");
    BuildHeap(maxHeap);
    for(i = 1; i <= N; ++i){
        printf("%d ", maxHeap -> Data[i]);
    }
    printf("\n");
    return 0;
}