数据结构：堆的实现与应用

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1
typedef int RcdType;
typedef int Status;
typedef int ElemType;
typedef struct {
    RcdType *rcd;//堆基，0号单元闲置
    int n;//堆的长度
    int size;//堆的容量
    int tag;//小堆顶与大堆顶的标志，tag=0小堆顶,tag=1大堆顶
    int (*prior)(KeyType,KeyType);//函数变量，用于关键字优先级比较
}Heap;//堆的类型
typedef struct{
    ElemType *elem;
	int size;//表的容量大小
	int length;//表的长度
}RcdSqList;

Status InitHeap(Heap *H,int size,int tag,int (*prior)(KeyType,KeyType));
void ShiftDown(Heap *H,int pos);
Status swapHeapElem(Heap *H,int i,int j);
Status InserHeap(Heap *H,RcdType e);
Status RemoveFirstHeap(Heap *H,RcdType *e);
void MakeHeap(Heap *H,RcdType *E,int n,int size,int tag,int (*prior)(KeyType,KeyType));
void HeapSort(RcdSqList *L);
void show(Heap *H);

int greatPrior(int x,int y){return x>=y;}//大顶堆优先函数
int lessPrior(int x,int y){return x<=y;}
Status InitHeap(Heap *H,int size,int tag,int (*prior)(KeyType,KeyType)){
    (*H).rcd=(int*)malloc(sizeof(RcdType)*size);
	(*H).size=size;
	(*H).n=0;
    (*H).tag=tag;
    if(tag==0)lessPrior;
    if(tag==1)greatPrior;
    return OK;
}
void ShiftDown(Heap *H,int pos){//对堆H中位置为pos的结点做筛选，将以pos为根的子树调整为子堆
    int c,rc;
    while(pos<=(*H).n/2){//若pos为叶子结点，循环结束
       c=pos*2;//c为pos结点的左孩子位置
       rc=pos*2+1;//rc为pos结点的右孩子位置
       //if(rc<=(*H).n&&(*H).prior((*H).rcd[rc].key,(*H).rcd[c].key))//
       if(rc<=(*H).n&&(*H).prior((*H).rcd[rc],(*H).rcd[c]))
        c=rc;//c为pos的左右孩子中较优先的位置
       //if((*H).prior((*H).rcd[pos].key,(*H).rcd[c].key))
       if((*H).prior((*H).rcd[pos],(*H).rcd[c]))
        return;//若pos较优先，则筛选结束
       swapHeapElem(H,pos,c);//否则pos和较优先者c交换位置
       pos=c;//继续向下调整
    }
}
Status swapHeapElem(Heap *H,int i,int j){//交换堆H中第i个结点与第j个结点
    RcdType t;
    if(i<=0||i>(*H).n||j<=0||j>(*H).n)return ERROR;
    t=(*H).rcd[i];(*H).rcd[i]=(*H).rcd[j];(*H).rcd[j]=t;
        return OK;
}
Status InserHeap(Heap *H,RcdType e){//将结点e插入至堆中
    int curr;
    if((*H).n>=(*H).size-1)return ERROR;//堆已满，插入失败
    curr=++(*H).n;(*H).rcd[curr]=e;//将插入元素加到堆尾
    //while(1!=curr&&(*H).prior((*H).rcd[curr].key,(*H).rcd[curr/2].key)){
    while(1!=curr&&(*H).prior((*H).rcd[curr],(*H).rcd[curr/2])){
        swapHeapElem(H,curr,curr/2);//交换curr与curr/2，即向上调整
        curr/=2;
    }
    return OK;
}
Status RemoveFirstHeap(Heap *H,RcdType *e){//删除堆的顶点，并用e返回
    if((*H).n<0)return ERROR;
    e=(*H).rcd[1];//取出堆顶结点
    swapHeapElem(H,1,(*H).n);(*H).n--;//交换堆顶与堆尾结点，堆长度减1
    if((*H).n>1)ShiftDown(H,1);//从堆顶位置向下筛选
    return OK;
}
void MakeHeap(Heap *H,RcdType *E,int n,int size,int tag,int (*prior)(KeyType,KeyType)){
//用E建立长度为n的堆H，容量为size，当tag为0，1时分别表示小顶堆，大顶堆，prior为优先函数
    int i;
    (*H).rcd=E;
    (*H).n=n;
	(*H).size=size;
    (*H).tag=tag;
	(*H).prior=prior;
    for(i=n/2;i>0;i--){ShiftDown(H,i);}//对以i结点为根的子树进行筛选
}
void HeapSort(RcdSqList *L){//堆排序
    Heap *H;
    int i;
    RcdType e;
    (*L).elem=e;
    MakeHeap(&H,L,(*L).length,(*L).size,1,greatPrior);//待排序列建顶大堆
    for(i=(*H).n;i>0;i--){
        RemoveFirstHeap(H,e);//堆顶与堆尾结点交换，堆cd减1，筛选新的堆顶结点
        printf("%d",e);
    }
}
void show(Heap *H){
	int i;
	printf("堆为\n");
	for(i=1;i<=(*H).n;i++){
		printf("%d ",(*H).rcd[i]);
	}
}
void main(){
    Heap H1;
    RcdSqList L1;
    int array[]={0,42,58,68,86,98,23};
	int s,d;
    if(InitHeap(&H1,100,1,array)){
        printf("堆的初始化成功");
    }else{
        printf("堆的初始化失败");
    }
	printf("\n");
	printf("大");
    MakeHeap(&H1,array,6,7,1,&greatPrior);
	show(&H1);
	printf("\n");
	printf("小");
	MakeHeap(&H1,array,6,7,0,&lessPrior);
    show(&H1);
	printf("\n");
	
	InitHeap(&H1,100,1,array);
	InserHeap(&H1,42);
	InserHeap(&H1,58);
	InserHeap(&H1,68);
	InserHeap(&H1,86);
	InserHeap(&H1,98);
	InserHeap(&H1,23);
	printf("请输入要插入的元素：");
		scanf("%d",&s);
	InserHeap(&H1,s);
	printf("插入后的");
	show(&H1);
	printf("\n");
	
	printf("请输入要删除的元素：");
		scanf("%d",&d);
	RemoveFirstHeap(&H1,d);
	printf("删除后的");
	show(&H1);
	printf("\n");

}