【数据结构】堆的概念及接口实现

1、堆的概念及特性

如果有一个关键码的集合K={k0,k1,k2,...,kn-1},把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki<=K2i+1且Ki<=K2i+2（Ki>=K2i+1且Ki<=K2i+2)i=0,1,2...,则称为小堆（或大堆）。将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。

堆的性质：

• 堆中某个节点的值总是不大于或不小于其父节点的值；
• 堆总是一棵完全二叉树。

2、堆的实现

实现堆的部分接口，具体内容详见头文件中的注释。

Heap.h

typedef int HPDatatype;
typedef struct Heap
{
	HPDatatype* _array;
	int _capacity;
	int _size;
}Heap;
 
//用数组初始化堆
void InitHeap(Heap* hp, HPDatatype* array, int size);

//初始化一个空堆
void InitEmptyHeap(Heap* hp, int capacity);

//在堆中插入值为data的元素
void InsertHeap(Heap* hp, HPDatatype data);

//删除堆顶元素
void EraseHeap(Heap* hp);

//获取堆中有效元素个数
int HeapSize(Heap* hp);

//检测堆是否为空堆
int HeapEmpty(Heap* hp);

//获取堆顶元素
HPDatatype HeapTop(Heap* hp);

//销毁堆
void DestoryHeap(Heap* hp);

初始化堆：申请一段连续的空间，将数组中的元素依次放入，代表一个完全二叉树，然后调整该二叉树，使其满足堆的性质。

void Swap(HPDatatype* pLeft, HPDatatype* pRight) {
	HPDatatype tmp = *pLeft;
	*pLeft = *pRight;
	*pRight = tmp;
}

void AdjustDown(HPDatatype* array, int size, int parent) {
	int child = parent * 2 + 1;//child标记了左孩子
	
	while (child < size) {
		//找双亲中较小的孩子，并用child标记较小的孩子
		if (child + 1 < size && array[child + 1] < array[child]) {
			child = child + 1;
		}

		if (array[child] < array[parent]) {
			Swap(&array[child], &array[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			return;
	}
}



void InitHeap(Heap* hp, HPDatatype* array, int size) {
	assert(hp);
	hp->_array = (HPDatatype*)malloc(sizeof(HPDatatype)*size);
	if (hp->_array == NULL) {
		assert(0);
		return;
	}
	hp->_capacity = size;
	for (int i = 0; i < size; ++i)
		hp->_array[i] = array[i];
	hp->_size = size;

	//将该完全二叉树进行调整使其满足堆的性质

	//找完全二叉树中倒数第一个非叶子节点
	int root = ((size - 1) >> 1);
	for (; root >= 0; --root)
		AdjustDown(hp->_array, size, root);
}

初始化一个空堆：类似于初始化一个顺序表

void InitEmptyHeap(Heap* hp, int capacity) {
	assert(hp);
	hp->_array = (HPDatatype*)malloc(sizeof(HPDatatype)*capacity);
	if (hp->_array == NULL) {
		assert(0);
		return;
	}
	hp->_capacity = capacity;
	hp->_size = 0;
}

删除堆顶元素：先将堆顶元素与最后一个节点元素交换，然后删除最后一个节点，最后将栈顶元素调整至合适位置即可。

void EraseHeap(Heap* hp) {
	if (HeapEmpty(hp))
		return;
	Swap(&hp->_array[0], &hp->_array[hp->_size - 1]);
	hp->_size--;
	AdjustDown(hp->_array, hp->_size, 0);
}

在堆中插入值为data的元素：首先需要检测容量是否足够，若不够需要先扩容；接着将值为data的元素插入到size对应的节点，并将size增加1，最后将这个插入的节点向上调整到合适的位置即可。

void AdjustUp(HPDatatype* array, int size, int child) {
	int parent = ((child - 1) >> 1);

	while (child) {
		if (array[child] < array[parent]) {
			Swap(&array[child], &array[parent]);
			child = parent;
			parent = ((child - 1) >> 1);
		}
		else
			return;
	}
	
}

void CheckCapacity(Heap* hp) {
	assert(hp);
	if (hp->_size == hp->_capacity) {
		int newCapacity = hp->_capacity * 2;
		HPDatatype* pTemp = (HPDatatype*)malloc(sizeof(HPDatatype)*newCapacity);
		if (pTemp == NULL) {
			assert(0);
			return;
		}
		for (int i = 0; i < hp->_size; ++i)
			pTemp[i] = hp->_array[i];
		free(hp->_array);
		hp->_array = pTemp;
		hp->_capacity = newCapacity;
	}
}

void InsertHeap(Heap* hp, HPDatatype data) {
	CheckCapacity(hp);
	hp->_array[hp->_size] = data;
	hp->_size++;
	AdjustUp(hp->_array, hp->_size, hp->_size - 1);
}

获取堆中有效元素个数：

int HeapSize(Heap* hp) {
	assert(hp);
	return hp->_size;
}

检测是否为空堆：

int HeapEmpty(Heap* hp) {
	assert(hp);
	return 0 == hp->_size;
}

返回堆顶元素：

HPDatatype HeapTop(Heap* hp) {
	assert(hp);
	return hp->_array[0];
}

销毁堆：

void DestoryHeap(Heap* hp) {
	assert(hp);
	if (hp->_array) {
		free(hp->_array);
		hp->_capacity = 0;
		hp->_size = 0;
	}
}

以上的接口大家可以按模块来检测，在这里，只放一个堆初始化的调试结果：

检测代码（部分）：

        Heap hp;
	int array[] = {2,6,7,3,9,1,4,0,5,8};//给定的数组
	InitHeap(&hp, array, sizeof(array)/sizeof(array[0]));
	printf("%d\n", HeapSize(&hp));
	printf("%d\n", HeapTop(&hp));

结果（小堆）：

堆中有效节点个数是10，堆顶元素是0。