最大堆与堆排序

//运行代码前注意看代码的测试结构 
#include"iostream"
#include"stdlib.h"
#include"time.h"
using namespace std;
//不是叶子节点的个数等于 总结点除2 
template<typename T>
class MaxHead{
public:
MaxHead(int capacity)
{
this->capacity=capacity;
data=new T[capacity+1];
count=0;
}
MaxHead(T arr,int n)
{
//堆排序1(堆排序2 依次插入节点 但这种的慢)
//时间复杂度分析：将n个元素逐个插入到一个空堆中，算法复杂度是O(nlogn);
//heapify过程(堆排序1，这个构造函数的实现)，算法复杂度为O(n); 
this->capacity=n;
data=new T[capacity+1];
count=n;
for(int i=0;i<n;i++)
{
data[i+1]=data[i];
} 
//堆的非叶子节点个数为总结点数除2  
//将数组赋值给data后对堆的结构进行调整则得到一个最大堆 
for(int i=count/2;i>0;i--)
shiftDown(i);
}
~MaxHead()
{
delete [] data;
} 
//将元素插入尾部 然后跟父亲比较然后调整 
void insert(T t)
{
data[++count]=t;
shiftUp(count);
}
//要取最大堆的最大值时 将树顶取出 跟尾节点交换 然后调整堆 
T extractMax()
{
T set=data[1];
swap(data[1],data[count--]);
shiftDown(1);
return set;
}
bool isEmpty()
{
return !count;
}
int number()
{
return count;
}
private:
void shiftUp(int k)
{
//若父节点大于子节点则交换两个的值并循环 
while(k>1&&data[k/2]<data[k])
{
swap(data[k/2],data[k]);
k/=2;
}
}
void shiftDown(int k)
{
//保证该节点有孩子节点 
while(2*k<=count)
{
int j=2*k;
//找到相对较大的孩子 
if(j+1<=count&&data[j+1]>data[j])
{
j++;
}
//判断孩子跟父亲的大小关系 
if(data[k]>=data[j])
{
break;
}
swap(data[k],data[j]);
k=j;
} 
}
private:

T *data;
int count;
int capacity;
};
//测试堆 
int main01()
{
MaxHead<int> mh=MaxHead<int>(20);
srand(time(NULL));
for(int i=0;i<20;i++){

mh.insert(rand()%20+10);
}
while(!mh.isEmpty())
{
printf("%d\n",mh.extractMax());
} 
}
void __shiftDown(int a[],int n,int k)
{
while((k*2+1)<n)
{
int j=k*2+1;
if((j+1)<n&&a[j+1]>a[j])
{
j++;
}
if(a[k]>=a[j])
break;
swap(a[k],a[j]);
k=j;
}

}
void heapSort(int a[],int n)
{
for(int i=(n-1)/2;i>=0;i--)
{
//将数组a的n个元素的第i个节点进行位置调整形成最大堆 
//数组索引从0开始的堆 共有 (n-1)/2个非叶子节点 
__shiftDown(a,n,i);
}
//创建好最大堆后进行堆排序
for(int i=n-1;i>0;i--)
{
swap(a[0],a[i]);
//将共有i个节点的堆a，第0个节点进行调整 
__shiftDown(a,i,0);
}
}
//改进版堆排序 
int main()
{
int a[20];
for(int i=0;i<20;i++){

a[i]=rand()%20+10;
}
heapSort(a,20);
for(int i=0;i<20;i++)
{
printf("%d\n",a[i]);
} 
}