最小堆及基于最小堆的最小优先队列

最小堆具有的性质：最小堆的父亲节点比子节点的值小

在最小堆的类中我们定义的函数主要有：维护最小堆、建立最小堆和利用最小堆进行排序

以下是最小堆的定义：

//name:myMinHeap.h
#ifndef MY_MIN_HEAP_H
#define MY_MIN_HEAP_H

#include<vector>
#include<algorithm>

using namespace std;
using std::vector;

template<typename T>
class myMinHeap {
	template<typename T>
	friend class myMinPriQue;

	vector<T> minHeap;
public:
	myMinHeap() { }

	myMinHeap(vector<T> vec) {
		minHeap = vec;
		build_min_heap(minHeap);
	}

	//构建最小堆
	void build_min_heap(vector<T> &vec) {
		int i;
		for (i = getParent(vec.size()); i >= 0; i--)
			min_heapfy(vec, i);
	}

	//堆排序
	void heapSort(vector<T> &vec, vector<T> &sortedVec) {
		build_min_heap(vec);
		for (int i = vec.size() - 1; i > 0; i--) {
			swap(vec[i], vec[0]);
			sortedVec.push_back(vec[i]);
			vec.pop_back();
			min_heapfy(vec, 0);
		}
		sortedVec.push_back(vec[0]);
	}

private:
	int getParent(int i) {
		return (i - 1) / 2;
	}

	int getLChild(int i) {
		return 2 * i + 1;
	}

	int getRChild(int i) {
		return 2 * i + 2;
	}

	//维护最小堆的性质
	void min_heapfy(vector<T> &minHeap, int i) {
		int lChild, rChild;
		int minimum = i;
		lChild = getLChild(i);
		rChild = getRChild(i);
		if (lChild < minHeap.size() && minHeap[lChild] < minHeap[i])
			minimum = lChild;
		if (rChild < minHeap.size() && minHeap[rChild] < minHeap[minimum])
			minimum = rChild;
		if (minimum != i) {
			swap(minHeap[i], minHeap[minimum]);
			min_heapfy(minHeap, minimum);
		}
	}
};

#endif

以下是基于最小堆实现的最小优先队列

最小优先队列具有的性质有：返回队列中的最小元素、返回并删除队列中的最小元素、向最小优先队列中插入元素

以下是最小优先队列类的定义

//name:myMinPriQue.h
//最小优先队列
#ifndef MY_MIN_PRI_QUE_H
#define MY_MIN_PRI_QUE_H

#include"myMinHeap.h"

#define MAXNUMBER 10000

template<typename T>
class myMinPriQue {
private:
	myMinHeap<T> minPriQue;
public:
	myMinPriQue(vector<T> vec) {
		minPriQue = myMinHeap<T>(vec);
	}

	//返回堆中最小的元素
	T heap_minimum() {
		return minPriQue.minHeap[0];
	}

	//删除并返回最小堆中的元素
	T heap_extract_min() {
		if (minPriQue.minHeap.size() < 1)
			cout << "heap underflow" << endl;
		int minNum = minPriQue.minHeap[0];
		minPriQue.minHeap.erase(minPriQue.minHeap.begin());
		minPriQue.min_heapfy(minPriQue.minHeap, 0);
		return minNum;
	}

	//将i位置的关键字增大至value的值
	void heap_decrease_key(int i, T value) {
		if (value > minPriQue.minHeap[i])
			cout << "new value is bigger than current key" << endl;
		minPriQue.minHeap[i] = value;
		while (i > 0 && minPriQue.minHeap[minPriQue.getParent(i)] > minPriQue.minHeap[i]) {
			swap(minPriQue.minHeap[i], minPriQue.minHeap[minPriQue.getParent(i)]);
			i = minPriQue.getParent(i);
		}
	}

	//将关键字的值value插入到队列中
	void min_heap_insert(T value) {
		minPriQue.minHeap.push_back((T)MAXNUMBER);
		int heap_size = minPriQue.minHeap.size() - 1;
		heap_decrease_key(heap_size, value);
	}

	int sizeOf() {
		return minPriQue.minHeap.size();
	}
};

#endif

以下是对最小堆和最小优先队列的测试：

//name:main.cpp
#include<iostream>
#include"myMinHeap.h"
#include"myMinPriQue.h"

using namespace std;

int main(void) {
	//检测最小优先队列
	/*
	vector<int> vec = { 6,9,12,4,35,1,5,24 };
	vector<int> sortedVec;

	myMinHeap<int> minHeap = myMinHeap<int>();
	minHeap.heapSort(vec, sortedVec);

	for (int i = 0; i < sortedVec.size(); i++) {
		cout << sortedVec[i] << " ";
	}
	cout << endl;
	*/

	vector<int> vec = { 6,9,12,4,35,1,5,24 };
	myMinPriQue<int> minQueue = myMinPriQue<int>(vec);
	minQueue.min_heap_insert(20);
	int scount = minQueue.sizeOf();
	vector<int> minVec;
	for (int i = 0; i < scount; i++) {
		int temp = minQueue.heap_extract_min();
		minVec.push_back(temp);
	}

	return 0;
}