堆排序算法，精简

原创已于 2023-10-17 20:43:24 修改 · 158 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#排序算法 #c++ #算法

于 2021-02-27 23:48:23 首次发布

C++ 专栏收录该内容

74 篇文章

订阅专栏

博客提及排序算法相关内容，回顾19年按“父节点下面的左右子节点”方式对数组倒序比较父节点并交换子父节点的寻址做法，认为当时做法较费脑，还给出原理和流程图参考链接。

19年

数组倒序比较其父节点，并交换适当情况下的子节点与父节点：

#include<iostream>
#include<functional>
using namespace std;
bool compare(int &a,int &b){
    return a<b;
}
// void heap_sort(int (&arr)[8],int istart,int iend,bool (*compare)(int&,int&)){
void heap_sort(int (&arr)[8],int istart,int iend,std::function<bool (int&,int&)> compare){
    if(istart>=iend)    return;
    for(int i(iend);i>istart;i--){
        if(compare(arr[i-istart],arr[(i-istart+1)/2-1]))
            std::swap(arr[i-istart],arr[(i-istart+1)/2-1]);
    }
    std::swap(arr[istart],arr[iend]);
    heap_sort(arr,istart,iend-1,compare);
}
int main(int argc,char **argv){
    int arr[]={3,1,4,1,5,9,2,6};
    int len(7);
    heap_sort(arr,0,len,compare);
    for(int i(0);i<=len;i++)
        cout<<arr[i]<<' ';
    cout<<endl;
}

21 年：

这是19年脑子抽非要按“父节点下面的左右子节点”方式来寻址的做法，现在回头看就是有点废脑子：

原理和流程图参见https://www.cnblogs.com/chengxiao/p/6129630.html

//堆排序
void heapSort(int arr[],int nsize){ 
    if(nsize<=1)return;
    //arr退化成指向当前子数组(堆)的首元素的指针，nsize是当前子数组的维数
    int iM(ceil((nsize-1-2)/2)); //最后一个非叶子节点
    while(iM>=0){
        if(iM*2+2>(nsize-1)){ //没有右子节点
            if(arr[iM]>=arr[iM*2+1]) ;
            else swap(arr[iM],arr[iM*2+1]);
            iM--;
            continue;
        }
        if( arr[iM]>=arr[iM*2+1]&&arr[iM]>=arr[iM*2+2] ) ;
        else{
            //如果arr[iM*2+1]==arr[iM*2+2]的话移动arr[iM+1]保持稳定
            if(arr[iM*2+1]>=arr[iM*2+2]) swap(arr[iM],arr[iM*2+1]); 
            else swap(arr[iM],arr[iM*2+2]); 
        }
        iM--;
        continue;
    }
    { //构建最大堆
        // heapSort(++arr,--nsize);
    }
    { //构建最小堆
        swap(arr[0],arr[nsize-1]);
        heapSort(arr,--nsize);
    }
}
void func9(){
    int arr[]={3,1,4,1,5,9,2,6};
    heapSort(arr,8);
    for(int &rele:arr)std::cout<<rele<<"\t";
    std::cout<<"\n";
}

22 年：

#include<iostream>
using namespace std;
/*
len = 4，最后一个非叶子节点下标(int)(len-1)/2
        0
    1       2
3     _  _      _

len = 5，最后一个非叶子节点下标(int)(len-1)/2
        0
    1       2
3      4 _      _

len = 6，最后一个非叶子节点下标(int)(len-1)/2
            0
        1       2(i)
    3     4   5(i*2+1)  6((i+1)*2)
7     8 _
*/
bool heap_sort(int arr[],int len)
{
    if(len <= 1)
        return true;
    int i = (int)(len-1)/2; // 最后一个非叶子节点下标
    while(i>=0)
    {
        int ileft = i*2+1, iright = (i+1)*2;
        if(iright<len && arr[i]<arr[iright]) // 有右子节点，不swap想等元素就是保持原位了
            std::swap(arr[i],arr[iright]);
        if(ileft<len && arr[i]<arr[ileft])  // 有左子节点
            std::swap(arr[i],arr[ileft]);
        i--;
    }
    std::swap(arr[0],arr[len-1]);
    heap_sort(arr,len-1);
    return true;
}
#define COUNT 8
int main(int argc,char* argv[])
{
    int arr[] = {3,1,4,1,5,9,2,6};
    heap_sort(arr,COUNT);
    for(int i=0;i<COUNT;i++)
        cout<<arr[i]<<' ';
    cout<<endl;
}