堆

堆

堆(heap)是计算机科学中一类特殊的数据结构的统称.堆通常是一个可以被看做一棵树的数组对象.堆总是满足下列性质:

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

根节点最大的堆叫做最大堆或大根堆,根节点最小的堆叫做最小堆或小根堆.这里我们以最大堆为例来讲堆.
堆的实质就是树,不过它有些特殊,它是用数组存放的树!
堆的父结点和其左右子结点有何关系?如果父结点为i,那么其左子结点为2 * i +1,右子结点为2 * i +2.如果孩子结点为i,那么其父结点为(i - 1)/2.

结构体定义

提示:

1. 应有数据域
2. 当前堆的大小
3. 堆的最大值

typedef struct {
	int *data;//应有数据域
	int length;//当前堆的大小
	int maxsize;//堆的最大值
}Heap;

逻辑结构如下:

存储结构如下:

初始化

建堆时需要数据,而数据通常由一个乱序数组提供.
提示:

1. 提供数据的数组长度是否大于堆允许的最大长度?
2. 堆的动态内存分配是否成功?

bool initHeap(Heap &h, int *arr, int num) {
	if (num > MAXSIZE) {//提供数据的数组长度是否大于堆允许的最大长度?
		return false;
	}

	h.data = new int[MAXSIZE];
	if (!h.data) {//堆的动态内存分配是否成功?
		return false;
	}

	h.length = num;
	memcpy(h.data, arr, num * sizeof(int));//浅拷贝
	buildHeap(h);//建堆
	return true;
}

建堆的思想:从最后一个叶子结点开始,向前遍历每个结点,每次到达一个新结点,确保被遍历过的所有结点都符合堆的性质即可.

建堆的过程:从最后叶子结点的父结点开始,向前遍历,对每个结点,调用函数"adjustDown"向下调整.

void buildHeap(Heap &h) {
	for (int i = (h.length - 1) / 2; i >= 0; i--) {
		adjustDown(h, i);//向下调整
	}
}

向下调整:对每个父结点,与其左右子结点中最大的结点比较,如果父结点的值小,那么交换两者的值,并将交换的子结点看做新的父结点,重复该操作.
这是一个递归过程,为什么要递归呢?请看:
假设此时遍历结点已到达灰色结点.

2这个结点比它左右子树中最大的结点17小,所以应该交换.

可以看到,交换之前遍历过的所有结点符合最大堆的性质,但是交换后是有可能破坏最大堆的.其根本原因是,交换后的子结点"未遍历".

继续,父结点2比左右子结点中最大的4小,交换.

交换后还是有可能破坏最大堆,继续.

无左右结点,此次遍历结束.进行下一个结点的访问.

void adjustDown(Heap &h, int node) {
	int child = node * 2 + 1;
	if (child > h.length) {
		return;
	}

	if (child + 1 <= h.length && (h.data[child + 1] > h.data[child])) {
		child = node * 2 + 2;
	}

	int dat;
	if (h.data[node] < h.data[child]) {//孩子结点比父结点大,交换
		dat = h.data[node];
		h.data[node] = h.data[child];
		h.data[child] = dat;

		adjustDown(h, child);//向下调整孩子结点
	}
}

如何思路清晰地写一个递归的函数?很简单,先写递归结束的条件.在这里就是左子结点不存在,左子结点都不存在了,右子结点肯定也不存在,这时候不必向下调整,直接返回.然后写递归发生的条件,那就是父结点比孩子结点中最大的结点小,这时需要交换两者的值并向下调整交换了的孩子结点.把这两点写明白了,递归也就写好了,至于中间的运行逻辑,进行了几层递归,都不用去考虑了.

插入元素

提示:

1. 插入元素后是否还具有堆的性质?

void insertHeap(Heap &h, int data) {
	h.data[h.length++] = data;
	adjustUp(h, h.length-1);//向上调整
}

向上调整的基本思路和向下调整是一样的,这里不再阐述.

void adjustUp(Heap &h, int num) {
	if ((num - 1) / 2 < 0) {//父结点不存在
		return;
	}

	int data;
	if (h.data[num] > h.data[(num - 1) / 2]) {
		data = h.data[num];
		h.data[num] = h.data[(num - 1) / 2];
		h.data[(num - 1) / 2] = data;

		adjustUp(h, (num - 1) / 2);//向上调整父结点
	}
}

删除元素

删除元素时,总是删除根节点.
提示:

1. 将最后一个叶子结点的值赋给根结点,然后向下调整根节点.

void deleteHeap(Heap &h) {
	h.data[0] = h.data[h.length-1];
	adjustDown(h, 0);
	h.length--;
}

打印元素

无提示,选择自己喜欢的风格.

void printHeap(Heap &h) {
	for (int i = 0; i < h.length; i++) {
		cout << h.data[i] << "\t";
	}
	cout << endl;
}

全部代码及测试代码

#include <iostream>
#define MAXSIZE 30

using namespace std;

typedef struct {
	int *data;
	int length;
	int maxsize;
}Heap;

void adjustDown(Heap &h, int node) {
	int child = node * 2 + 1;
	if (child > h.length) {
		return;
	}

	if (child + 1 <= h.length && (h.data[child + 1] > h.data[child])) {
		child = node * 2 + 2;
	}

	int dat;
	if (h.data[node] < h.data[child]) {//孩子结点比父结点大,交换
		dat = h.data[node];
		h.data[node] = h.data[child];
		h.data[child] = dat;

		adjustDown(h, child);//向下调整孩子结点
	}
}

void buildHeap(Heap &h) {
	for (int i = (h.length - 1) / 2; i >= 0; i--) {
		adjustDown(h, i);
	}
}

bool initHeap(Heap &h, int *arr, int num) {
	if (num > MAXSIZE) {
		return false;
	}

	h.data = new int[MAXSIZE];
	if (!h.data) {
		return false;
	}

	h.length = num;
	memcpy(h.data, arr, num * sizeof(int));
	buildHeap(h);
	return true;
}

void adjustUp(Heap &h, int num) {
	if ((num - 1) / 2 < 0) {//父结点不存在
		return;
	}

	int data;
	if (h.data[num] > h.data[(num - 1) / 2]) {
		data = h.data[num];
		h.data[num] = h.data[(num - 1) / 2];
		h.data[(num - 1) / 2] = data;

		adjustUp(h, (num - 1) / 2);//向上调整父结点
	}
}

void insertHeap(Heap &h, int data) {
	h.data[h.length++] = data;
	adjustUp(h, h.length-1);
}

void deleteHeap(Heap &h) {
	h.data[0] = h.data[h.length-1];
	adjustDown(h, 0);
	h.length--;
}

void printHeap(Heap &h) {
	for (int i = 0; i < h.length; i++) {
		cout << h.data[i] << "\t";
	}
	cout << endl;
}

int main(void) {
	Heap h;
	int arr[] = { 1,2,3,87,93,82,92,86,95 };
	initHeap(h, arr, sizeof(arr) / sizeof(arr[0]));

	printHeap(h);

	insertHeap(h, 99);
	printHeap(h);

	deleteHeap(h);
	printHeap(h);

	system("pause");
	return 0;
}