二叉堆C语言实现

#ifndef PRIORITYQUEUE_H
#define PRIORITYQUEUE_H

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

#define assert(condition,msg){\
			if(!(condition)){\
				fprintf(stderr,"%s [func:%s,line:%d]\n",msg,__func__,__LINE__);\
				exit(EXIT_FAILURE);\
			}\
		}


#ifndef ELEMENTTYPE
#define ELEMENTTYPE
typedef void* ElementType;
char* toString(ElementType data){
	return (char*)data;
}
void freeElement(ElementType data){
	//free(data);
}
int compare(ElementType data1,ElementType data2){
	return strcmp((char*)data1,(char*)data2);
}
#endif

struct HeapStack{
	int capacity;
	int index;
	ElementType* datas;
};

typedef struct HeapStack HeapStack;
typedef HeapStack* PriorityQueue;

//functions prototype
PriorityQueue initialize(int level);//OK
void increaseCapacity(PriorityQueue queue);//OK
void insert(ElementType data,PriorityQueue queue);//OK
ElementType findMin(PriorityQueue queue);//OK
ElementType deleteMin(PriorityQueue queue);//OK
void destory(PriorityQueue* queue);//OK
void show(PriorityQueue queue);//OK
bool isFull(PriorityQueue queue);//OK
bool isEmpty(PriorityQueue queue);//OK
PriorityQueue buildHeap(ElementType* datas,int count);//OK
void heapify(PriorityQueue queue,int i);//OK


PriorityQueue initialize(int level){
	assert(level > 0,"Parameter Invalid!");
	PriorityQueue reval = calloc(1,sizeof(struct HeapStack));
	reval->capacity = 1<<level;
	reval->index = 0;
	reval->datas = calloc(reval->capacity,sizeof(ElementType));
	return reval;
}

void increaseCapacity(PriorityQueue queue){
	assert(queue,"Parameter NULL!");
	queue->capacity <<= 1;
	queue->datas = realloc(queue->datas,queue->capacity * sizeof(ElementType));
}

void insert(ElementType data,PriorityQueue queue){
	assert(queue,"Parameter NULL!");
	if(isFull(queue)){
		increaseCapacity(queue);
	}
	queue->datas[++queue->index] = data;
	int i = 0;
	for(i = queue->index ; i / 2 != 0 ; i = i / 2){
		if(compare(data,queue->datas[i / 2]) < 0){
			queue->datas[i] = queue->datas[i / 2];
		}else{
			break;
		}
	}
	queue->datas[i] = data;
}

ElementType findMin(PriorityQueue queue){
	assert(queue,"Parameter NULL!");
	if(isEmpty(queue)){
		return 0;
	}
	return queue->datas[1];
}

ElementType deleteMin(PriorityQueue queue){
	assert(queue,"Parameter NULL!");
	if(isEmpty(queue)){
		return 0;
	}
	ElementType reval = queue->datas[1];
	ElementType last = queue->datas[queue->index--];
	int i = 0;
	int child = 0;
	for(i = 1 ; 2 * i <= queue->index ; i = child){
		child = 2 * i;
		if(child + 1 <= queue->index && compare(queue->datas[child],queue->datas[child + 1]) > 0){
			child ++;
		}
		if(compare(last,queue->datas[child]) > 0){
			queue->datas[i] = queue->datas[child];
		}else{
			break;
		}
	}
	queue->datas[i] = last;
	return reval;
}

void destory(PriorityQueue* ptrQueue){
	assert(ptrQueue,"Parameter NULL!");
	PriorityQueue queue = *ptrQueue;
	assert(queue,"Parameter NULL!");
	for(int i = 1 ; i <= queue->index ; i ++){
		freeElement(queue->datas[i]);
	}
	queue->index = 0;
	queue->capacity = 0;
	free(queue);
	*ptrQueue = NULL;
}

void show(PriorityQueue oQueue){
	assert(oQueue,"Paramter NULL!");
	PriorityQueue queue = calloc(1,sizeof(struct HeapStack));
	queue->capacity = oQueue->capacity;
	queue->index = oQueue->index;
	queue->datas = calloc(oQueue->index + 1,sizeof(ElementType));
	memcpy(queue->datas,oQueue->datas,(queue->index + 1) * sizeof(ElementType));
	while(!isEmpty(queue)){
		printf("%s ",toString(deleteMin(queue)));
	}
	printf("\n");
	destory(&queue);
}

bool isFull(PriorityQueue queue){
	assert(queue,"Parameter NULL!");
	return queue->index == queue->capacity - 1;
}

bool isEmpty(PriorityQueue queue){
	return queue->index == 0;
}

void normalShow(PriorityQueue queue){
	assert(queue,"Parameter NULL!");
	for(int i = 1 ; i <= queue->index ; i ++){
		printf("%s ",toString(queue->datas[i]));
	}
	printf("\n");
}


PriorityQueue buildHeap(ElementType* datas,int count){
	assert(count > 0,"Parameter Invalid!");
	PriorityQueue queue = calloc(1,sizeof(struct HeapStack));
	queue->capacity = count + 1;
	queue->index = count;
	queue->datas = calloc(queue->capacity,sizeof(ElementType));
	memcpy(queue->datas + 1,datas,count * sizeof(ElementType));
	for(int i = queue->index ; i > 0 ; i --){
		heapify(queue,i);
	}
	return queue;
}


void heapify(PriorityQueue queue,int i){
	assert(queue,"Parameter NULL!");
	assert(i >= 1 && i <= queue->index,"Parameter Invalid!");
	if(2 * i > queue->index){
		return;
	}

	int child = 2 * i;
	if(child + 1 <= queue->index && compare(queue->datas[child],queue->datas[child + 1]) > 0){
		child ++;
	}
	
	ElementType temp = 0;
	if(compare(queue->datas[i],queue->datas[child]) > 0){
		temp = queue->datas[i];
		queue->datas[i] = queue->datas[child];
		queue->datas[child] = temp;
		heapify(queue,child);
	}

}


#endif

int main(void){
	void* strs[] = {"06","05","00","08","09","03","10","02","01"};
	PriorityQueue queue = buildHeap(strs,sizeof(strs) / sizeof(strs[0]));
	show(queue);
	destory(&queue);

	/*
	queue = initialize(1);
	for(int i = 0 ; i < sizeof(strs) / sizeof(strs[0]) ; i ++){
		insert(strs[i],queue);
	}
	show(queue);
	destory(&queue);
	*/

	return 0;
}