C++类最小堆

{
return 2 * pos + 1; // 返回左孩子位置
}
template<class T>
int minheap<T>::rchild(int pos) const
{
return 2 * pos + 2; // 返回右孩子位置
}
template<class T>
if (cursize > 1)
siftdown(0); // 从堆顶开始筛选
return heaparray[cursize];
}
}
template<class T>
bool minheap<T>::remove(int pos, T& node)
#include <iostream>
using namespace std;
template <clheap
{
private:
T* heaparray;
int cursize;
int maxsize;
public:
void buildheap();
{
if (n <= 0)
return;
cursize = 0;
maxsize = n; // 初始化堆容量为n
heaparray = new T[maxsize]; // 创建堆空间
//buildheap(); // 此处进行堆元素的赋值工作
cout << "\n删除后为:";
a.RemoveMin();
a.show();
return 0;
}
void siftdown(int left); // 向下筛选，参数left表示开始处理的数组下标
void show(); //输出函数
};
template<class T> // 建堆
}
template<class T>
bool minheap<T>::isleaf(int pos) const
{
return (pos >= cursize / 2) && (pos < cursize);
}
template<class T>
int minheap<T>::lchild(int pos) const
void minheap<T>::siftup(int position) {
// 从position向上开始调整
int temppos = position;
T temp = heaparray[temppos];
while ((temppos>0) && (heaparray[parent(temppos)]>temp))
}
else break; //堆序满足，跳出
}
heaparray[i] = temp;
}
template <class T>
void minheap<T>::show()
{
int i = 0;
for (;i < cursize; i++)
cout << heaparray[i] << " ";
if (heaparray[parent(pos)] > heaparray[pos])
siftup(pos); // 当前元素小于父结点，需要上升调整
else
siftdown(pos); // 当前元素大于父结点，向下筛
return true;
}
template<class T>
{
heaparray[temppos] = heaparray[parent(temppos)];
temppos = parent(temppos);
}
heaparray[temppos] = temp;
}
template <class T>
void minheap<T>::siftdown(int left)
cursize++;
cin >> a;
}
for (int i = cursize / 2 - 1; i >= 0; i--) // 反复调用筛选函数
siftdown(i);
}
template<class T>
minheap<T>::minheap(const int n)
{ // 删除给定下标的元素
if ((pos < 0) || (pos >= cursize))
return false;
node = heaparray[pos];
heaparray[pos] = heaparray[--cursize]; // 用最后的元素值替代删除位置的元素
//若有右子结点，且小于左子结点
j++; // j指向右子结点
if (temp>heaparray[j])
{
//若父结点大于子节点的值则交换位置
heaparray[i] = heaparray[j];
i = j;
j = lchild(j);
bool insert(const T& newnode); // 向堆中插入新元素newNode
T& RemoveMin(); // 从堆顶删除最小值
bool remove(int pos, T& node); // 删除给定下标的元素
void siftup(int position); // 从position向上开始调整，使序列成为堆
}
//主函数
int main()
{
minheap<int> a(10);
int b;
a.buildheap();
a.show();
cout << "输入要插入的数据:";
cin >> b;
cout << "插入后为:";
a.insert(b);
a.show();
if (cursize == 0)
{
cout << "Can't Delete"; // 调用RemoveMin之前，需要判断堆非空
exit(1);
}
else
{
heaparray[0] = heaparray[--cursize]; // 交换堆顶和最后一个元素
heaparray[cursize] = newnode;
siftup(cursize); // 向上调整
cursize++;
return true;
}
template<class T>
T& minheap<T>::RemoveMin()
{
// 从堆顶删除最小值
int minheap<T>::parent(int pos) const
{
return (pos - 1) / 2; // 返回父结点位置
}
template <class T>
bool minheap<T>::insert(const T& newnode)
bool isleaf(int pos) const; // 如果是叶结点，返回TRUE
int lchild(int pos) const; // 返回左孩子位置
int rchild(int pos) const; // 返回右孩子位置
int parent(int pos) const; // 返回父结点位置
minheap(const int n); // 构造函数，n表示 堆的最大元素数目
virtual ~minheap(){ delete[]heaparray; }; // 析构函数
bool isempty(); // 如果堆空，则返回真
{
int i = left; // 标识父结点
int j = lchild(i); // 标识关键值较小的子结点
T temp = heaparray[i]; // 保存父结点
while (j < cursize)
{ // 过筛
if ((j <cursize - 1) && (heaparray[j]>heaparray[j + 1]))
{ // 向堆中插入新元素newNode
if (cursize == maxsize)
return false; // 堆空间已经满
void minheap<T>::buildheap()
{
T a, b;
cout << "请输入结束符号:";
cin >> b;
cout << "\n请输入数据（以" << b << "结束）";