非递归版本

C++ 代码

#include<vector>

#include<iostream>

using namespace std;

//min heap
void adjustHeap(vector<int>&data,int parent,int n){
    int lchild=parent*2+1;
    int rchild=parent*2+2;
    int tmp=parent;
    while(lchild<n){
        if(lchild<n&&data[lchild]<data[parent]){
            tmp=lchild;
        }
         if(rchild<n&&data[rchild]<data[tmp]){
            tmp=rchild;
        }
        if(tmp==parent){
            break;
        }
        swap(data[tmp],data[parent]);
        parent = tmp;
        lchild = parent*2+1;
        rchild=parent*2+2;
    }
}




int main(){
    vector<int> datas={1,5,6,2,3,4};
    int n=datas.size();
    for(int i=n/2-1;i>=0;i--){
        adjustHeap(datas,i,n);
    }

    for(int i=n-1;i>0;i--){
        swap(datas[0],datas[i]);
        adjustHeap(datas,0,i);
    }
    for(const auto& it: datas){
        cout<<it<<endl;
    }
}

递归版本

#include<iostream>
#include<vector>
using namespace std;

//  建大根堆(len是arr的长度，index是第一个非叶子节点的下标)
void adjust(vector<int> &arr, int len, int index)
{
    int left = 2*index + 1; // index的左子节点
    int right = 2*index + 2;// index的右子节点

    int maxIdx = index;
    if(left<len && arr[left] > arr[maxIdx])     maxIdx = left;
    if(right<len && arr[right] > arr[maxIdx])     maxIdx = right;

    if(maxIdx != index)
    {
        swap(arr[maxIdx], arr[index]);
        adjust(arr, len, maxIdx);
    }

}

// 堆排序
void heapSort(vector<int> &arr, int size)
{
    // 构建大根堆 
    for(int i=size/2 - 1; i >= 0; i--)
    {
        adjust(arr, size, i);
    }

    // 调整大根堆
    for(int i = size - 1; i >= 1; i--)
    {
        swap(arr[0], arr[i]);           
        adjust(arr, i, 0);             
    }
}

int main()
{
    int N,M;
    cin>>N>>M;
    vector<int> arr;
    int num;
    for(int i=0;i<N;i++){
      cin>> num;
      arr.push_back(num);
    }
    heapSort(arr, arr.size());
    for(int i=0;i<arr.size();i++)
    {
        cout<<arr[i]<<endl;
    }
    return 0;
}