堆排序模板（建议最小堆实现降序和最大堆实现升序）

堆排序时间复杂度：O(NlogN)

堆排序不稳定

无论是最小堆还是最大堆 都可以实现升序和降序两种排序。

但建议最小堆实现降序排序，最大堆实现升序排序

最小堆实现从小到大排序

#include 
using namespace std;
int h[10000];
int n;
void siftdown(int i);
int deletemin();  //最小堆实现从小到大排序
int main (){
    cin>>n;
    int i;
    for(i=1;i<=n;i++){
        cin>>h[i];
    }
    for(i=n/2;i>=1;i--){
        siftdown(i);
    }
    int num=n;
    for(i=1;i<=num;i++){
        if(i>1)cout<<" ";
        cout<

上面的代码排序后的数需输出或用另一个数组接收qaq

如果用最大堆实现从小到大排序会好一点，排完数放在原数组。

同理用最小堆实现最大到小排序，排完后数放在原数组。

最大堆实现从小到大排序

#include 
using namespace std;
int n;
int h[10000];
void siftdown(int i);
void heapsort();   //最大堆实现从小到大排序。
int main()
{
    cin >> n;
    int i;
    for (i = 1; i <= n; i++) {
        cin >> h[i];
    }
    for (i = n / 2; i >= 1; i--) {
        siftdown(i);   //建堆
    }
    int num=n;
    heapsort();   //最大堆排序
    for(i=1;i<=num;i++){
        if(i>1)cout<<" ";
        cout<1) {
        swap(h[1],h[n]);     //把最大的数h[1]放到最后即最后一个数变为最大的。
        n--;
        siftdown(1);
    }
    return ;
}
void siftdown(int i)   //跟最小堆类似
{
    int flag = 0;
    int t;
    while (flag == 0 && i * 2 <= n) {
        t = i;
        if (h[i * 2] > h[t]) {
            t = i * 2;
        }
        if (i * 2 + 1 <= n && h[i * 2 + 1] > h[t]) {
            t = i * 2 + 1;
        }
        if (t == i)
            flag = 1;
        else {
            swap(h[t], h[i]);
            i = t;
        }
    }
    return;
}
/*
8
1 5 2 3 6 4 8 9  //输入
1 2 3 4 5 6 8 9  //输出
*/

最小堆实现从大到小排序

相对于上一个代码只改了siftdown中的两个大于号qaq

#include 
using namespace std;
int n;
int h[10000];
void siftdown(int i);
void heapsort();     //最小堆实现从大到小排序
int main()
{
    cin >> n;
    int i;
    for (i = 1; i <= n; i++) {
        cin >> h[i];
    }
    for (i = n / 2; i >= 1; i--) {
        siftdown(i);
    }
    int num=n;
    heapsort();
    for(i=1;i<=num;i++){
        if(i>1)cout<<" ";
        cout<1) {
        swap(h[1],h[n]);
        n--;
        siftdown(1);
    }
    return ;
}
void siftdown(int i)
{
    int flag = 0;
    int t;
    while (flag == 0 && i * 2 <= n) {
        t = i;
        if (h[i * 2] < h[t]) {
            t = i * 2;
        }
        if (i * 2 + 1 <= n && h[i * 2 + 1] < h[t]) {
            t = i * 2 + 1;
        }
        if (t == i)
            flag = 1;
        else {
            swap(h[t], h[i]);
            i = t;
        }
    }
    return;
}
/*
8
1 2 6 4 2 9 2 1  //输入
9 6 4 2 2 2 1 1  //输出
*/