最小堆

原博客：白话经典算法系列之八 MoreWindows白话经典算法之七大排序总结篇

/*
 说明：
 1、堆数组的下标从0开始；
 2、下标为i的父结点的下标为(i-1)/2，其子节点为2*i+1以及2*i+2;
 3、最后一个叶子节点（下标为i-1)的父节点为(n-1-1)/2即n/2-1.
 */
#include <iostream>
#include <vector>
using namespace std;

void MinHeapFixup(vector<int> &vi){
    //这个都是从末尾的元素开始向上调整，被插入函数所调用
    //这里的一个假设是：最后一个元素是新插入的堆中的元素，而最后一个元素之前的元素构成一个合法的最小堆。
    if(vi.size()<=1) return ;
    int i=vi.size()-1;
    int temp=vi[i];
    int j=i/2-1;
    while(j>=0){//这里跟插入排序一样。
        if(vi[j]<=vi[i]) break;
        vi[i]=vi[j];
        i=j;
        j=(i-1)/2;
    }
    vi[i]=temp;
}
//对MinHeapFixup使用swap在结构上进行优化，但效率上会低一点，和对插入排序的优化一样。
void MinHeapFixup1(vector<int> &vi){
    if(vi.size()<=1) return ;
    for(int i=vi.size()-1,j=(i-1)/2; j>=0 && vi[j]>vi[i]; i=j,j=(i-1)/2)
        swap(vi[j],vi[i]);
}

void insertMinHeap(vector<int> &vi, int value){//最小堆的插入函数
    vi.push_back(value);
    if(vi.size()<=1) return ;
    MinHeapFixup(vi);
//    MinHeapFixup1(vi);
}

void MinHeadFixdown(vector<int> &vi,int index=0){
    if(vi.size()<=1) return ;
    //这个函数被最小堆的删除函数所调用
    //在删除函数中已将第一个元素与最后一个元素互换了，且将最后一个元素给erase了，现在从第一个元素开始向下调整
    int n=vi.size();
    int i=index;//默认从根开始调整，由于这个函数还会被createMinHeap函数调用，所以增加一个index参数，指示开始调整的节点下标
    int j=i*2+1;
    int temp=vi[index];
    while(j<n){
        if(j+1<n && vi[j+1]<vi[j]) ++j;//j标记当前最小的父节点下标，比较巧妙
        if(vi[j]>temp) break;
        vi[i]=vi[j];//较小值上移
        i=j;
        j=i*2+1;
    }
    vi[i]=temp;
}

void deleteMinHeap(vector<int> &vi){
    if(vi.size()==0) return ;
    vi[0]=vi.back();
    vi.erase(--vi.end());//删除最后一个元素
    if(vi.size()<=1) return ;
    MinHeadFixdown(vi);
}

void createMinHeap(vector<int> &vi){
    //由一个数组构建最小堆，有两种做法，一是不停的插入、从下向上调整，这种方法略麻烦，效率不高；
    //二是直接对数组进行调整，依次从最在的父节点到根，对每个父节点调用向下调整方法来构建最小堆，这种方法最简单，效率高。
    if(vi.size()<=1) return ;
    int n=vi.size();
    //n/2-1是最后一个元素的父节点的下标，见最上面的说明。
    for(int i=n/2-1;i>=0;--i)
        MinHeadFixdown(vi,i);
}

void sortMinHeap(vector<int> &vi,int isdown=true){
    //从最小堆得到非递增数组
    //因为我实现的deleteMinHeap是真的把元素给删除了，所以这里需要一个临时的vector，
    //通过这个临时的vector我们可以得到非递增或者非递减数组.
    //由于使用最小堆一般都是为了快速得到前多少个最小值，所以，这里默认是返回非递增数组，与传统的最小堆的排序结果保持一致。
    vector<int> vitp;
    while(!vi.empty()){
        vitp.push_back(vi[0]);
        deleteMinHeap(vi);
    }
    if(isdown){//得到非递增数组
        //copy(vitp.begin(),vitp.end(),vi.begin());这里得满足vi有足够容纳vitp的空间，要不然，只会从vitp中复制vi.size()个元素
        //copy(vitp.begin(),vitp.end(),back_inserter(vi));
        //vi.swap(vitp);
        vi.assign(vitp.begin(), vitp.end());
    }
    else{
        //copy(vitp.rbegin(),vitp.rend(),back_inserter(vi));
        //reverse(vitp.begin(),vitp.end());
        //vi.swap(vitp);
        vi.assign(vitp.rbegin(),vitp.rend());
    }
}

int main(){
    vector<int> vi;
    vi={1,8,2,3,7,6,9,5,4};
    createMinHeap(vi);
    insertMinHeap(vi, 6);
    sortMinHeap(vi);
//    sortMinHeap(vi,false);
    for(auto ieh: vi)
        cout<<ieh<<" ";
    cout<<endl;
    return 0;
}