C++实现堆、最大堆、最小堆 -- 堆排序插入删除操作

堆是一种经过排序的完全二叉树，其中任一非终端节点的数据值均不大于（或不小于）其左孩子和右孩子节点的值。

最大堆和最小堆是 二叉堆 的两种形式。

最大堆：根结点的键值是所有堆结点键值中最大者。

最小堆：根结点的键值是所有堆结点键值中最小者。

而最大-最小堆集结了最大堆和最小堆的优点，这也是其名字的由来。

最大-最小堆是最大层和最小层交替出现的 二叉树 ，即最大层结点的儿子属于最小层，最小层结点的儿子属于最大层。

以最大（小）层结点为根结点的子树保有最大（小）堆性质：根结点的键值为该子树结点键值中最大（小）项。 

                                                                                                                                                                                               

一：堆

  我们构建一个堆类，用最大堆和最小堆来继承他。

#ifndef _HEAP_H
#define _HEAP_H

#include 
using namespace std;

enum{DEFAULT_SIZE = 10};

template 
class Heap{
public:
	Heap() = default;
	virtual ~Heap() = default;
public: 
	virtual void show_heap()const = 0;
	virtual bool insert_heap(const T&) = 0;
	virtual bool remove_heap(T &) = 0;
};

//public interface

#endif   /*Heap.h*/

二：最大堆

  下面是最大堆的实现：

#ifndef _MAXHEAP_H
#define _MAXHEAP_H

#include 

#include "Heap.h"

template 
class MaxHeap : public Heap{
public:
	MaxHeap(int);
	MaxHeap(const T [], const int);
	~MaxHeap();
public:
	bool insert_heap(const T&);
	bool remove_heap(T &);

	void show_heap()const;
protected:
	void sift_down(int, int);
	void sift_up(int);
private:
	T *heap;
	int size;
	int capacity;
};

//public interface

template 
MaxHeap::MaxHeap(int sz = DEFAULT_SIZE)
{
	capacity = sz > DEFAULT_SIZE ? sz : DEFAULT_SIZE;
	heap = new T[capacity];
	assert(heap != NULL);
	size = 0;
}

template 
MaxHeap::MaxHeap(const T arr[], const int arrSize)
{
	capacity = arrSize > DEFAULT_SIZE ? arrSize : DEFAULT_SIZE;
	heap = new T[capacity];
	assert(heap != NULL);
	size = arrSize;

	for(int i=0; i= 0){
		sift_down(curPos, size-1);
		--curPos;
	}
	
}

template 
MaxHeap::~MaxHeap()
{
	delete []heap;
	heap = NULL;
	capacity = size = 0;
}

template 
bool MaxHeap::insert_heap(const T& val)
{
	if(size >= capacity)
		return false;
	
	heap[size] = val;
	sift_up(size);
	++size;
	return true;
}

template 
bool MaxHeap::remove_heap(T &val)
{
	if(size <= 0)
		return false;
	
	val = heap[0];
	heap[0] = heap[size-1];
	--size;
	sift_down(0, size-1);
	return true;
}

template 
void MaxHeap::show_heap()const
{
	for(int i=0; i
void MaxHeap::sift_down(int start, int end)
{
	int i = start;
	int j = i*2 + 1;

	T tmp = heap[i];
	while(j <= end){
		if(j+1 <= end && heap[j] < heap[j+1])
			++j;
		if(tmp < heap[j])
			heap[i] = heap[j];
		else
			break;

		i = j;
		j = j*2 + 1;
	}
	heap[i] = tmp;
}

template 
void MaxHeap::sift_up(int start)
{
	int j = start;
	int i = (start-1) / 2;

	T tmp = heap[j];
	while(j > 0){
		if(tmp < heap[i])
			break;
		else
			heap[j] = heap[i];
		
		j = i;
		i = (i-1) / 2;
	}
	heap[j] = tmp;
}

#endif   /*MaxHeap.h*/

三：最小堆

  下面是最小堆的实现：

#ifndef _MINHEAP_H
#define _MINHEAP_H

#include 

#include "Heap.h"

template 
class MinHeap : public Heap{
public:
	MinHeap(int);
	MinHeap(const T [], const int );
	~MinHeap();
public:
	bool insert_heap(const T&);
	bool remove_heap(T &);
	
	void show_heap()const;
protected:
	void sift_down(int, int);
	void sift_up(int);
private:
	T* heap;
	int size;
	int capacity;
};

//interface

template 
MinHeap::MinHeap(int sz = DEFAULT_SIZE)
{
	capacity = sz > DEFAULT_SIZE ? sz : DEFAULT_SIZE;
	heap = new T[capacity];
	assert(heap != NULL);
	size = 0;
}

template 
MinHeap::MinHeap(const T arr[], const int arrSize)
{
	capacity = arrSize > DEFAULT_SIZE ? arrSize : DEFAULT_SIZE;
	heap = new T[capacity];
	assert(heap != NULL);
	size = arrSize;

	for(int i=0; i= 0){
		sift_down(curPos, arrSize-1);
		--curPos;
	}
}

template 
MinHeap::~MinHeap()
{
	delete []heap;
	heap = NULL;
	capacity = size = 0;
}

template 
bool MinHeap::insert_heap(const T& val)
{
	if(size >= capacity)
		return false;
	
	heap[size] = val;
	sift_up(size);
	++size;
	return true;
}

template 
bool MinHeap::remove_heap(T& val)
{
	if(size <= 0)
		return false;
	
	val = heap[0];
	heap[0] = heap[size-1];
	--size;
	sift_down(0, size-1);
	return true;
}

template 
void MinHeap::show_heap()const
{
	for(int i=0; i
void MinHeap::sift_down(int start, int end)
{
	int i = start;
	int j = start*2 + 1;

	T tmp = heap[i];
	while(j <= end){
		if(j+1 < end && heap[j] > heap[j+1])
			++j;
		if(tmp < heap[j])
			break;
		else
			heap[i] = heap[j];
		
		i = j;
		j = j*2 + 1;
	}
	heap[i] = tmp;
}

template 
void MinHeap::sift_up(int start)
{
	int j = start;
	int i = (start-1) / 2;

	T tmp = heap[j];
	while(j > 0){
		if(tmp > heap[i])
			break;
		else
			heap[j] = heap[i];
		j = i;
		i = (i-1) / 2;
	}
	heap[j] = tmp;
}

#endif

四：测试如下：

#include "MinHeap.h"
#include "MaxHeap.h"
#include 
using namespace std;

int main()
{
	int array[] = {23, 9, 34, 2, 56, 89, 35, 54};
	
	cout << "***************************MinHeap***************************" << endl;
	MinHeap min_heap(array, sizeof(array)/sizeof(int));
	
	min_heap.show_heap();
	min_heap.insert_heap(1);
	min_heap.show_heap();
	for(int i=0; i<9; ++i){
		int val;
		min_heap.remove_heap(val);
		cout << val << " ";
	}
	cout << endl;
	
	MaxHeap max_heap(array, sizeof(array)/sizeof(int));
	cout << "***************************MaxHeap**************************" << endl; 
	max_heap.show_heap();
	max_heap.insert_heap(99);
	max_heap.show_heap();
	for(int i=0; i<9; ++i){
		int val;
		max_heap.remove_heap(val);
		cout << val << " ";
	}
	cout << endl;
	
	return 0;
}

结果如下：