两种最大堆的建立方式

两种最大堆的建立方式

方法1：逐个插入

通过插入操作，将N个元素一个个相继插入到一个初始为空的堆中去。

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

#define MAXDATA 1000  /* 该值应根据具体情况定义为大于堆中所有可能元素的值（哨兵） */
#define ERROR -1 /* 错误标识应根据具体情况定义为堆中不可能出现的元素值 */
typedef int ElementType;
typedef struct HNode *Heap; /* 堆的类型定义 */
struct HNode {
    ElementType *Data; /* 存储元素的数组 */
    int Size;          /* 堆中当前元素个数 */
    int Capacity;      /* 堆的最大容量 */
};

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

    Heap H = (Heap)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( Heap H )
{
    return (H->Size == H->Capacity);
}

bool Insert( Heap 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;
}

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

ElementType DeleteMax( Heap 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 Print(Heap H )
{
	for(int i = 1; i <= H->Size; i++)
		printf("%d ", H->Data[i]);
	printf("\n");
}
int main()
{
	Heap H;
	int n = 12;
	
	H = CreateHeap(n);
	int A[] = {79,66,43,83,72,87,38,55,91,30,49,9};

	for(int i = 0; i < n; i++)
		Insert(H, A[i]);
	Print(H);

	printf("最大的三个元素为：");
	for(int j = 0; j < 3; j++)
		printf("%d ", DeleteMax(H));
	printf("\n删除他们后的堆为：\n");
	Print(H);

	return 0;
}

方法2：顺序存入，然后调整

（1）将N个元素按输入顺序存入，先满足完全二叉树的结构特性
（2）调整各结点位置，以满足最大堆的有序特性。

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

#define MAXDATA 1000  /* 该值应根据具体情况定义为大于堆中所有可能元素的值（哨兵） */
#define ERROR -1 /* 错误标识应根据具体情况定义为堆中不可能出现的元素值 */
typedef int ElementType;
typedef struct HNode *Heap; /* 堆的类型定义 */
struct HNode {
    ElementType *Data; /* 存储元素的数组 */
    int Size;          /* 堆中当前元素个数 */
    int Capacity;      /* 堆的最大容量 */
};

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

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

    return H;
}

/*----------- 建造最大堆 -----------*/
void PercDown( Heap 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( Heap H )
{ /* 调整H->Data[]中的元素，使满足最大堆的有序性  */
  /* 这里假设所有H->Size个元素已经存在H->Data[]中 */

    int i;

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

void Print(Heap H )
{
	for(int i = 1; i <= H->Size; i++)
		printf("%d ", H->Data[i]);
	printf("\n");
}
int main()
{
	Heap H;
	
	int n = 12;
	H = CreateHeap(n);
	int A[] = {79,66,43,83,72,87,38,55,91,30,49,9};

	printf("原始堆：\n");
	for(int i = 0; i < n; i++)
		H->Data[++H->Size] = A[i];
	Print(H);

	printf("\n最大堆：\n");
	BuildHeap( H );
	Print(H);

	return 0;
}