//執行程式碼前注意看程式碼的測試結構 
#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]);
} 
}