堆与最优级队列

heap.h

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

typedef int DataType; 

void AdjustDown(DataType* a, size_t n, int root){
	int child;
	while(root<n){
		child= root*2+1;
		if(child+1<n&&a[child]<a[child+1])
			++child;
		if(child<n&&a[root]<a[child]){
			int tmp=a[root];
			a[root]=a[child];
			a[child]=tmp;
			root=child;
		}
		else{
			break;
		}
	}
}

void MakeHeap(DataType* a, size_t n) {
	int i=(n-2)/2,tmp;
	for(i;i>=0;--i){
		AdjustDown(a,n,i);
	}
}



void AdjustUp(DataType* a, size_t n, int child){
	int i,parent,tmp;
	while(child>0){
		parent=(child-1)/2;
		if(a[parent]<a[child]){
			tmp = a[parent];
			a[parent] = a[child];
			a[child] = tmp;
		}
		else{
			break;
		}
		child = parent;
	}
}
void MakeHeap1(DataType* a, size_t n) {
	int i=0;
	for(i;i<n;i++){
		AdjustUp(a,n,i);
	}
}

// topk 最大的前K 
void TopK(DataType* a, size_t n, size_t k){
	int i=0;
	MakeHeap(a,n);
	for(i;i<k;i++){
		printf("%d ",a[0]);
		a[0]=a[n-i-1];
		MakeHeap(a,n-i-1);
	}
	printf("\n");
}


void TestHeap() {
	int i = 0; 
	DataType a[] = {10,11, 13, 12, 16, 18, 15, 17, 14, 19}; 
	DataType NArray[1000]; 
//	MakeHeap(a, sizeof(a)/sizeof(DataType)); 
	MakeHeap1(a, sizeof(a)/sizeof(DataType));
	for(i=0;i<10;i++){
		printf("%d  ",a[i]);
	}
	printf("\n");
//**********************

	srand(time(0)); 
	for (i = 0; i < 1000; ++i) { 
		NArray[i] = rand()%10000; 
	} 
	NArray[30] = 10001; 
	NArray[350] = 10002; 
	NArray[999] = 10003; 
	NArray[158] = 10004; 
	NArray[334] = 10005; 

	TopK(NArray, 1000, 5); 
} 

PriorityQueue.h

#include"Heap.h"

#define N 1000

typedef struct PriorityQueue 
{ 
	DataType _a[N]; 
	size_t _size; 

	//DataType* _a; 
	//size_t _size; 
	//size_t _capacity; 
}PriorityQueue; 

PriorityQueue* PriorityQueueInit(); 
void PriorityQueuePush(PriorityQueue* q, DataType x); 
void PriorityQueuePop(PriorityQueue* q); 
DataType PriorityQueueTop(PriorityQueue* q); 
size_t PriorityQueueSize(PriorityQueue* q); 
size_t PriorityQueueEmpty(PriorityQueue* q); 
//************************************

PriorityQueue* PriorityQueueInit(){
	PriorityQueue* q;
	q=(PriorityQueue*)malloc(sizeof(PriorityQueue));
	q->_size=0;
	memset(q->_a, 0, N);
	return q;
}

void PriorityQueuePush(PriorityQueue* q, DataType x){
	q->_a[q->_size]=x;
	q->_size++;
	AdjustUp(q->_a,q->_size,q->_size-1);
}

void PriorityQueuePop(PriorityQueue* q){
	q->_a[0]=q->_a[q->_size-1];
	q->_size--;
	MakeHeap1(q->_a,q->_size);
}

DataType PriorityQueueTop(PriorityQueue* q){
	return q->_a[0];
}

size_t PriorityQueueSize(PriorityQueue* q){
	return q->_size;
}

size_t PriorityQueueEmpty(PriorityQueue* q){
	return q->_size;
}


void TestPriorityQueue() 
{ 
	int i=0;
	PriorityQueue *q; 
	q=PriorityQueueInit(); 

	PriorityQueuePush(q, 5); 
	PriorityQueuePush(q, 2); 
	PriorityQueuePush(q, 3); 
	PriorityQueuePush(q, 7); 
	PriorityQueuePush(q, 6); 
	PriorityQueuePush(q, 1); 
	PriorityQueuePush(q, 4); 

	for(i;i<7;i++){
		printf("%d ",q->_a[i]);
	}
	printf("\n");

	while (PriorityQueueEmpty(q) != 0) 
	{ 
	printf("%d ", PriorityQueueTop(q)); 
	PriorityQueuePop(q); 
	} 
	printf("\n"); 
} 

//堆排序，利用大堆，将顶部元素取出，继续调整取出
void HeapSort(DataType* a, size_t n){
	int i=0;
	MakeHeap1(a,n);
	for(i;i<n;i++){
		printf("%d ",a[0]);
		a[0]=a[n-i-1];
		MakeHeap1(a,n-i-1);
	}
}

main.c

#include"BinSearchTree.h"
#include"PriorityQueue.h"
int main(){
	TestHeap() ;
	TestBSTree();
	int a[]={9,5,8,4,1,3,7,2,6};
	TestPriorityQueue();
	HeapSort(a,9);
	system("pause");
}