【数据结构】堆

1.堆的特性

（1）结构性：用数组表示的完全二叉树
（2）有序性：任一结点的优先级是其子树所有结点的最大值/最小值
①最大堆(MaxHeap)/大顶堆：最大值
②最小堆(MinHeap)/小顶堆：最小值

2.堆的类型定义

typedef struct HNode *Heap; /* 堆的类型定义 */
struct HNode {
    ElementType *Data; /* 存储元素的数组 */
    int Size;          /* 堆中当前元素个数 */
    int Capacity;      /* 堆的最大容量 */
};
typedef Heap MaxHeap; /* 最大堆 */
typedef Heap MinHeap; /* 最小堆 */
 
#define MAXDATA 1000  /* 该值应根据具体情况定义为大于堆中所有可能元素的值 */

3.最大堆的操作

//空的最大堆的创建
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 )
    	//直接用当前i开始循环，故不需要写初始条件
    	//将待插入元素X与最底下的父结点比较，只要X>当前父结点说明X可以继续上浮，故执行循环
        H->Data[i] = H->Data[i/2]; 
        //当前父结点下沉【循环开始前就有i=++H->size，这就是给下沉预留的位置】
        //假设一次循环结束后执行i/=2得i=2，那么下一次循环开始时，X将与i=1结点比较
        //如果不符合循环开始的条件，即X < H->Data[1]，那么X会插入到Data[2]中
    H->Data[i] = X; /* 将X插入 */
    return true;
}

//最大堆的删除
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更新为右子节点
        //如果上述第二个条件不满足，child仍为左子结点
        //如此便保证 Child指向左右子结点的较大者
        if( X >= H->Data[Child] ) break; /* 找到了合适位置 */
        //如果根结点的值不小于其较大的那个子节点，则parent这个位置满足最大堆，跳出循环
        else  /* 下滤X */
            H->Data[Parent] = H->Data[Child];
        //否则子结点的值上浮（原来的父节点存放的值已经用X存起来了）
		//循环的最后有parent=child，即待计算的父节点位置下沉
    }
    H->Data[Parent] = X;
    //最终找到满足最大堆的parent位置，将存起来的值赋给这个位置
}
 
void BuildHeap( MaxHeap H )
//对整个堆的每一个父节点都用percdown函数调教一次，使得所有子堆都是最大堆
{ /* 调整H->Data[]中的元素，使满足最大堆的有序性  */
  /* 这里假设所有H->Size个元素已经存在H->Data[]中 */
 
    int i;
    /* 从最后一个结点的父节点开始，到根结点1 */
    for( i = H->Size/2; i>0; i-- )
        PercDown( H, i );
}