数据结构 堆以及堆排序

堆的概念:

堆可以看作是一棵完全二叉树,除最后一层外,每一层都是填满的,最后一层从左到右依次填入

在堆上,对任意一个结点来说,越接近顶部,权值就越大(一般指大顶堆),并且它的权值大于等于它所在子树所有点的权值

我们把根结点权值大于等于树中结点权值的称为大根堆,小于等于树种结点权值的称为小根堆

下图就是一个大根堆的示意图

 

就如上述大顶堆示意图一样,我们可以用一个数组来维护大根堆

堆具有的性质叫做堆序性,每次插入或者删除新元素,我们都要通过相应算法对堆序性进行维护

堆的建立:

堆的建立很简单,只需定义一个数组并用一个整数保存它的大小就可以了

template<typename Type>
class Heap {
private:
	Type* data;   //用来存储数据
	int size;     //用来存储元素个数
public:
	Heap(int length_input) {
		data = new Type[length_input];  //初始化堆的容量上限
		size = 0;
	}
	~Heap() {
		delete[] data;
	}
};

下面开始介绍堆中相应的各种算法:

堆的相应插入算法如下:

1.把新元素保存到数组的最后

2.找到新元素父节点的位置,比较大小

3.如果是大顶堆且该元素大于父结点,交换之,如果是小顶堆且该元素小于父节点,交换之

4.循环比较,直到该节点的父节点与其的大小满足堆序性

比如我们要在这个小顶堆中插入新元素7,先将7放入到堆的尾部,然后将7与其父节点11比较,7小于11,不满足堆序性,交换两者

再与其父节点10比较,依然不满足堆序性,交换之,再与其父节点4比较,此时满足堆序性,操作结束

大顶堆也执行相应类似的操作

template<typename Type>
void Heap<Type>::push(Type value)
{
	data[size] = value;   //先插入元素
	int current = size;   //当前位置
	int father = (current - 1) / 2;
	while (data[current] > data[father]) {  
		swap(data[current], data[father]); // 不满堆序列的话, 就要进行交换
		current = father;
		father = (current - 1) / 2;
	}
	size = size + 1;
}

 

堆的维护算法:

我们删除堆或者进行堆排序的话,我们每一次操作过后都需要一个算法来维护堆序列性

1.从根结点开始,分别与其左右子中最大的(大顶堆)或最小的(小顶堆)元素进行比较

2.如果不满足堆序性,则与该子节点进行交换

3.再与下两个子节点进行比较,直到该节点和其子节点满足堆序性或该节点为叶子节点

下面有两种实现算法供参考(递归型和非递归型的)

递归型

template<typename Type>
void Heap<Type>::updata(int pos, int n)
{
	//因为是从0开始计数,所以要分别加1加2
	int lchild = pos * 2 + 1;
	int rchild = pos * 2 + 2;
	
	int max_pos = pos;  //左右结点中最大的那个
	if (lchild < n && data[max_pos] < data[lchild]) {
		max_pos = lchild;
	}
	if (rchild < n && data[max_pos] < data[rchild]) {
		max_pos = rchild;
	}
	
	if (max_pos != pos) {
		swap(data[max_pos], data[pos]);
		updata(max_pos, n);   //这是从上到下的调整法
	}
}

非递归型

void downAdjust(int low, int high) {   
	int current = low, lchild = current * 2;    //low表示最低的元素下标,high表示数组的最后一个元素的下标
	while (lchild <= high) {     //while循环用来判断是超过范围(一般叶子节点*2就会超过范围)
		/*得出左右子中最大的哪一个*/
		//如果右孩子存在,且右孩子的值大于当前结点值
		if (lchild + 1 <= high && heap[lchild] < heap[lchild + 1]) {
			lchild = lchild + 1;   //改成右节点
		}
		//将子节点与当前结点进行比较,观察是否满足堆序性
		if (heap[lchild] > heap[current]) {
			swap(heap[lchild], heap[current]);
			current = lchild;
			lchild = current * 2;
		}
		else {
			break;
		}
	}
}

堆的删除算法:

1.将堆顶元素与最后一个元素交换

2.删除堆顶(现在是最后一个元素)

3.调用调整算法

template<typename Type>
void Heap<Type>::popt()
{
	swap(data[0], data[size - 1]);
	size = size - 1;
	updata(0, size);   //调整栈
}

堆排序:

将堆顶元素依次与堆中的元素交换位置,然后对堆顶元素和交换位置的元素的前一个元素进行调整即可

template<typename Type>
void Heap<Type>::heap_sort()
{
	for (int i = size - 1; i > 0; --i) {   //依次交换,然后排序
		swap(data[i], data[0]);
		updata(0, i);
}

整体实现代码如下:

#include <iostream>
#include <algorithm>
using namespace std;
// 请在下面实现堆类 Heap 
template<typename Type>
class Heap {
private:
	Type* data;   //用来存储数据
	int size;     //用来存储元素个数
	void updata(int pos, int n);   //调整堆元素序列
public:
	Heap(int length_input) {
		data = new Type[length_input];
		size = 0;
	}
	~Heap() {
		delete[] data;
	}
	
	void push(Type value);
	void output();
	Type top();    //输出栈顶元素
	void popt();   //弹出栈顶元素
	void heap_sort();  //堆排序
};

template<typename Type>
void Heap<Type>::popt()
{
	swap(data[0], data[size - 1]);
	size = size - 1;
	updata(0, size);   //调整栈
}

//输出栈顶元素
template<typename Type>
Type Heap<Type>::top()
{
	return data[0];
}

template<typename Type>
void Heap<Type>::push(Type value)
{
	data[size] = value;   //先插入元素
	int current = size;   //当前位置
	int father = (current - 1) / 2;
	while (data[current] > data[father]) {  
		swap(data[current], data[father]); // 不满堆序列的话, 就要进行交换
		current = father;
		father = (current - 1) / 2;
	}
	size = size + 1;
}

template<typename Type>
void Heap<Type>::output()
{
	for (int i = 0; i < size; ++i) {
		cout << data[i] << " ";
	}
	cout << endl;
}

template<typename Type>
void Heap<Type>::updata(int pos, int n)
{
	//因为是从0开始计数,所以要分别加1加2
	int lchild = pos * 2 + 1;
	int rchild = pos * 2 + 2;
	int max_pos = pos;  //左右结点中最大的那个
	if (lchild < n && data[max_pos] < data[lchild]) {
		max_pos = lchild;
	}
	if (rchild < n && data[max_pos] < data[rchild]) {
		max_pos = rchild;
	}
	
	if (max_pos != pos) {
		swap(data[max_pos], data[pos]);
		updata(max_pos, n);   //这是从上到下的调整法
	}
}

template<typename Type>
void Heap<Type>::heap_sort()
{
	for (int i = size - 1; i > 0; --i) {   //依次交换,然后排序
		swap(data[i], data[0]);
		updata(0, i);
	}
}

int main() {
	int arr[10] = { 12, 9, 30, 24, 30, 4, 55, 64, 22, 37 };
	Heap<int> heap(100);
	for (int i = 0; i < 10; i++) {
		heap.push(arr[i]);
	}
	heap.output();
	cout << heap.top() << endl;
	heap.popt();
	heap.output();
	heap.heap_sort();
	heap.output();

	system("PAUSE");
	return 0;
}