堆（heap）

堆：
完全二叉树+任一结点是其子树所有结点的最大（小）值。
以下为最大堆的代码。

struct  HeapStruct *MaxHeap;
struct  HeapStruct{
    ElementType *Elements;  // 存储堆元素的数组     
    int Size;    //堆 的当前元素个数
    int Capacity;    // 堆的最大容量
};

MaxHeap Create(int MaxSize)
{
    MaxHeap H = malloc(sizeof(struct HeapStruct));
    H->Elements = malloc((MaxSize+1) *sizeof(ElementType));
    H->Size = 0; 
    H->Capacity = MaxSize;
    H->Elements[0] = MaxData;  
   /* 定义“哨兵”为大(小)于堆中所有可能元素的值，便于以后更快操作,也就是堆元素从下标1开始存放*/
   return H;
}

//时间O(logn)
void Insert(MaxHeap H, ElementType item) 
{  //将元素item 插入最大堆H，其中H->Elements[0]已经定义为哨兵 
    int i;
    if(IsFull(H))
    {
        printf("最大堆已满");
        return;
    }
    i= ++H->Size; // i指向插入后堆中的最后一个元素的位置
    for (;H->Elements[i/2]<item;i/=2)
        H->Elements[i] = H->Elements[i/2]; // 向下过滤结点
    H->Elements[i] = item;
}

//时间O(logn)
ElementType DeleteMax(MaxHeap H) 
{  // 从最大堆H中取出键值为最大的元素，并删除一个结点
    int Parent, Child;
    ElementType MaxItem, temp;
    if(IsEmpty(H))
    {
        printf("最大堆已为空");
        return;
    }
    MaxItem = H->Elements[1];
    //用最大堆中最后一个元素从根结点开始向上过滤下层结点
    temp = H->Elements[H->Size--];
    for(Parent=1;Parent*2<=H->Size;Parent=Child)
    {
        Child = Parent * 2;
        if((Child!= H->Size) && (H->Elements[Child] < H->Elements[Child+1]))
            Child++;  // Child指向左右子结点的较大者
        if(temp >= H->Elements[Child])
            break;
        else
            H->Elements[Parent] = H->Elements[Child];
    }
    H->Elements[Parent] = temp;
    return MaxItem; 
}

/*
    已知n个元素，按最大堆建立：
    法一：按上面insert，一个一个插入。时间O(nlogn)
    法二：将那个元素输入数组形成完全二叉树性质；
         从最后一个结点的父节点到1每个结点调整一次。
*/
void MaxSort(MaxHeap H, int i) // i为要调整的结点下标,从i到1都要调整
{
    int temp;
    if(i*2==H->Size)
    {
        if(H->Elements[i]<H->Elements[i*2])
        { 
            temp = H->Elements[i];
            H->Elements[i] = H->Elements[i*2];
            H->Elements[i*2] = temp;
        }
    }
    if(i*2<H->Size)
    {
        if(H->Elements[2*i]>H->Elements[2*i+1] && H->Elements[2*i]>H->Elements[i])
        {
            temp = H->Elements[i];
            H->Elements[i] =H->Elements[2*i];
            H->Elements[i*2] = temp;
            MaxSort(H,2*i);
        }
        if(H->Elements[2*i+1]>H->Elements[2*i] && H->Elements[2*i+1]>H->Elements[i])
        {
            temp = H->Elements[i];
            H->Elements[i] = H->Elements[i*2+1];
            a[i*2+1] = temp;
            MaxSort(a, i*2+1);
        }
    }
}