最大堆

1、最大堆的定义及其常用操作：

#include <stdio.h>
#include <stdlib.h>

#define true 1
#define false 0
#define ERROR -1
typedef int ElementType;
typedef int bool;

typedef struct HNode *Heap;    /* 堆的类型定义 */
struct HNode
{
    ElementType *Data;      /* 存储元素的数组 */
    int Size;               /* 堆中当前元素的个数 */
    int Capacity;           /* 堆的最大容量 */
};

typedef Heap MaxHeap;       /* 堆的最大容量 */

MaxHeap CreatHeap(int MaxSize);  /* 创建空的最大堆，其最大长度为MaxSize */
bool IsEmpty(MaxHeap H);         /* 判断最大堆是否为空 */
bool IsFull(MaxHeap H);          /* 判断最大堆是否已满 */
bool Insert(MaxHeap H, ElementType X);   /* 插入成功返回true，否则返回false */
ElementType DeleteMax(MaxHeap H);   /* 删除并返回H中最大的元素 */

 

2、函数实现：

MaxHeap CreatHeap(int MaxSize)
{
    MaxHeap H = (MaxHeap)malloc(sizeof(struct HNode));
    H->Data = (ElementType *)malloc((MaxSize+1) * sizeof(ElementType));   /* 数组起始单元为1，下标0没有存在堆中，是无用的，所以应该分配MaxSize+1个元素 */
    H->Size = 0;
    H->Capacity = MaxSize;

    return H;
}

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

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

bool Insert(MaxHeap H, ElementType X)
{
    if(IsFull(H))
    {
        printf("堆已满，插入失败！");
        return false;
    }

    ++H->Size;
    int i = H->Size;   /* i指向插入后堆中的最后一个元素的位置 */

    while(H->Data[i/2] < X && i > 1)  /*元素是从下标1开始存储的，所以i必须大于1 */
    {
        H->Data[i] = H->Data[i/2];  /* 上滤X */
        i = i/2;
    }
    H->Data[i] = X;     /* 将X插入到正确的位置 */
    return true;

}

ElementType DeleteMax(MaxHeap H)        /* 删除并返回H中最大的元素 */
{
    if(IsEmpty(H))
    {
        printf("堆为空，删除失败！");
        return ERROR;
    }
    ElementType MaxItem, X;
    MaxItem = H->Data[1];
    X = H->Data[H->Size];    /* 取出删除前堆的最后一个元素 */
    --H->Size;

    int Parent, Child;
    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(H->Data[Child] > X)      
            H->Data[Parent] = H->Data[Child];    /* 下滤X */
        else
            break;     /* 子节点都比X小，则找到了X的插入位置，跳出循环 */

    }
    H->Data[Parent] = X;

    return MaxItem;
}

3、最大堆的建立

目的：将已经存在的N个元素按照最大堆的要求存放在一个一维数组中。

方法1：通过插入操作，将N个元素一个个相继插入到一个初始为空的堆中去，其时间代价最大为O(NlogN)。

方法2：在线性时间复杂度O(N)下建立最大堆。

　 (1) 将N个元素按输入顺序存入，先满足完全二叉树的结构特性

　 (2) 调整个节点位置，以满足最大堆的有序特性

方法2的时间复杂度分析：

从一个无序的完全二叉树进行节点向下过滤操作是构建最大堆的主要工作。某一节点向下过滤要与其下层的子孙节点比较键值，

因此最大的比较次数是树中各节点高度的和，这个高度和也就决定了算法的复杂度。而关于各节点的高度，我们有如下结论：

　　一个高度为h的完全二叉树最多包含2^h - 1个节点(完美二叉树) ， 这些节点的高度和为 2^h - 1 - h。 ( 证明过程见《数据结构与算法分析-C语言描述》P141.)

又由于一个完全二叉树的节点个数N是在2^(h-1) 和 2^h - 1之间，因此节点的高度和为O(N)，说明最大堆建立算法的复杂度与节点个数呈线性关系。

用方法2构建最大堆的代码实现：

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(H->Data[Child] > X)      
            H->Data[Parent] = H->Data[Child];    /* 下滤X */
        else
            break;     /* 子节点都比X小，则找到了X的插入位置，跳出循环 */

    }
    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);
    
}

由于PercDown函数中的参数MaxHeap都必须是最大堆，所以BuildHeap必须从最后一个节点的父节点开始，逐渐把子树全部调整为最大堆。