最大堆------2022年1月5日

和最小堆相比，只是比较条件改变，其他不变，思路一样

#include <iostream>
#include <cassert>
using namespace std;
const int DefaultSize = 1;
//最小堆有线性表的结构
//有头，顺序存储有搜索便捷的优点，直接根据下标。
template <class T, class E>
class MaxHeap
{// T为关键码的数据类型，E为记录的结构类型
public:
	MaxHeap(int sz)//构造函数：建立空堆
	{
		maxHeapSize = (DefaultSize < sz) ? sz : DefaultSize;
		heap = new E[maxHeapSize + 1];
		if (heap == NULL) { cerr << "堆分配失败！" << endl; exit(1); }
		currentSize = 0;
	}
	MaxHeap(E arr[], int n)	//构造函数：通过一个数组建堆
	{
		maxHeapSize = (DefaultSize < n) ? n : DefaultSize;
		heap = new E[maxHeapSize + 1];
		if (heap == NULL) { cerr << "堆分配失败！" << endl; exit(1); }
		for (int i = 0; i < n; i++)   heap[i] = arr[i];//给堆赋值
		currentSize = n;
		int currentPos = (currentSize - 2) / 2;
		while (currentPos >= 0)
		{
			siftDown(currentPos, currentSize - 1);
			currentPos--;
		}
	}
	~MaxHeap() {
		delete[]heap;
	}
	bool Insert(const E& x)//在最小堆里插入一个结点
	{
		heap[currentSize] = x; //把数据先放入其中
		siftUp(currentSize);
		currentSize++;
		return true;
	}
	bool RemoveMin(E& x)
	{
		if (!currentSize) {	//堆空, 返回false	
			cout << "Heap empty" << endl;
			return false;
		}
		x = heap[0];
		heap[0] = heap[currentSize - 1];
		currentSize--;
		siftDown(0, currentSize - 1);
		return true;
	}
	bool IsEmpty()const {
		return currentSize == 0;
	}
	bool IsFull()const {
		return currentSize == maxHeapSize;
	}
	void MakeEmpty() {
		delete heap;
		currentSize = 0;
	}
	void output() {//自定义函数，顺序输出最小堆元素	
		for (int i = 0; i < currentSize; i++)
			cout << heap[i] << " ";
		cout << endl;
	}
private:
	E* heap;						    //存放最小堆中元素的数组
	int currentSize;				   //最小堆中当前元素个数
	int maxHeapSize;				  //最小堆最多允许元素个数
	void siftDown(int start, int m)   //从start到m下滑调整成为最小堆
	{
		int i = start, j = 2 * i + 1;  //i 从根开始，j 是左结点
		E temp = heap[i];  //先把值保存起来  看后面比较要不要做交换
		while (j <= m)//在堆的范围内
		{
			//找子女中较大者
			if (j<m && heap[j]<heap[j + 1]) 
			{
				j++;
			}
			if (temp >= heap[j]) break;
			else
			{
				heap[i] = heap[j]; //给heap[i]较小值的值
				i = j;
				j = 2 * j + 1;
			}
		}
		heap[i] = temp;
	}
	void siftUp(int start)		//从start到0上滑调整成为最小堆
	{
		int j = start, i = (j - 1) / 2;
		E temp = heap[j];
		while (j > 0)
		{
			if (heap[i] >= temp) break;
			else
			{
				heap[j] = heap[i];
				j = i;
				i = (i - 1) / 2;
			}
		}
		heap[j] = temp;
	}
};