堆操作与堆排序

堆：堆是一个完全二叉树或者近似于一个完全二叉树

最大堆：父节点的值大于等于左右节点的值；

最小堆：父节点的值小于等于左右节点的值

堆可以用一个数组来存储：第i个节点的根节点是(i-1)/2,左节点为i*2+1,右节点为i*2+3;

堆有两种操作一种是插入，一种是删除

插入的时候插入在最后 然后进行向上维护

删除的时候需要将最后一个元素来替换这个元素的位置 然后向下维护；

删除和插入的操作都是log(n)的复杂度

每次操作都进行维护了 所以从每一个值的父节点到根节点都是一个有序的序列

下面是将所有操作 和 堆排序封装起来的一个代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 100000;

struct Heap{
    int heap[maxn];
    int Sort_heap[maxn];
    int size=0,cnt;
    void shift_up(int t){//向上维护
        bool done = 0;
        if(t == 0) return ;
        while(t && !done){
            if(heap[t]>heap[(t-1)/2])
                swap(heap[t],heap[(t-1)/2]);
            else
                done = 1;
            t=(t-1)/2;//返回根节点
        }
    }
    void shift_down(int t){//向下维护
        bool done = 0;
        if(2 * t + 1 > size) return ;
        while(2 * t + 1 < size && !done){
            t= 2 * t + 1;//找到子节点
            if(t+1 < size && heap[t+1] > heap[t]) t++;
            if(heap[(t-1)/2]<heap[t])
                swap(heap[(t-1)/2],heap[t]);
            else
                done = 1;
        }
    }
    void Insert(int x){
        heap[size]=x;
        shift_up(size++);
    }
    void Delete(int t){
        int last = heap[size-1];
        size--;
        if(t == size) return ;
        heap[t] = last;
        shift_down(t);
    }
    void Sort(){
        cnt = size;
        for(int i = 0; i < cnt; i++){
            Sort_heap[i]=heap[0];
            Delete(0);
        }
    }
};

int main()
{
    Heap h;
    int x;
    while(~scanf("%d",&x) && x){
        h.Insert(x);
    }
    h.Sort();
    for(int i=0;i<h.cnt;i++)
        cout<<h.Sort_heap[i]<<" ";
    cout<<endl;
    return 0;
}
/****
5 4 3 1 2
***/