二叉堆

堆的性质：
1.堆是一颗完全二叉树

2.堆的顶端一定是“最大”，最小”的，但是要注意一个点，这里的大和小并不是传统意义下的大和小，它是相对于优先级而言的，当然你也可以把优先级定为传统意义下的大小，但一定要牢记这一点，初学者容易把堆的“大小”直接定义为传统意义下的大小，某些题就不是按数字的大小为优先级来进行堆的操作的

3.堆一般有两种样子，小根堆和大根堆，分别对应第二个性质中的“堆顶最大”“堆顶最小”，对于大根堆而言，任何一个非根节点，它的优先级都小于堆顶，对于小根堆而言，任何一个非根节点，它的优先级都大于堆顶

堆的操作：
1.插入
事实上堆的插入就是把新的元素放到堆底，然后检查它是否符合堆的性质，如果符合就丢在那里了，如果不符合，那就和它的父亲交换一下，一直交换交换交换，直到符合堆的性质，那么就插入完成了

void swap(int &x,int &y){int t=x;x=y;y=t;}//交换函数 
int heap[N];//定义一个数组来存堆
int siz;//堆的大小 
void push(int x){//要插入的数 
    heap[++siz]=x;
    now=siz;
    //插入到堆底 
    while(now){//还没到根节点，还能交换 
        ll nxt=now>>1;//找到它的父亲 
        if(heap[nxt]>heap[now])swap(heap[nxt],heap[now]);//父亲比它大，那就交换 
        else break;//如果比它父亲小，那就代表着插入完成了 
        now=nxt;//交换 
    }
    return; 
}

2.删除
代码中是直接把堆顶和堆底交换一下，然后把交换后的堆顶不断与它的子节点交换，直到这个堆重新符合堆性质

void pop(){
    swap(heap[siz],heap[1]);siz--;//交换堆顶和堆底，然后直接弹掉堆底 
    int now=1;
    while((now<<1)<=siz){//对该节点进行向下交换的操作 
        int nxt=now<<1;//找出当前节点的左儿子 
        if(nxt+1<=siz&&heap[nxt+1]<heap[nxt])nxt++;//看看是要左儿子还是右儿子跟它换 
        if(heap[nxt]<heap[now])swap(heap[now],heap[nxt]);//如果不符合堆性质就换 
        else break;//否则就完成了 
        now=nxt;//往下一层继续向下交换 
    }
}

3.查询
因为我们一直维护着这个堆使它满足堆性质，而堆最简单的查询就是查询优先级最低/最高的元素，对于我们维护的这个堆heap，它的优先级最低/最高的元素就是堆顶，所以查询之后输出heap[1]就好了

一般的题目里面查询操作是和删除操作捆绑的，查询完后顺便就删掉了，这个主要因题而异
PS：以上都是手写的代码，下面的stl是优先排序，非常非常快

堆的STL实现：

首先你需要一个头文件：#include<queue>
priority_queue<int> q;//这是一个大根堆q
priority_queue<int,vector<int>,greater<int> >q;//这是一个小根堆q
//注意某些编译器在定义一个小根堆的时候greater<int>和后面的>要隔一个空格，不然会被编译器识别成位运算符号>>

q.top()//取得堆顶元素，并不会弹出
q.pop()//弹出堆顶元素
q.push()//往堆里面插入一个元素
q.empty()//查询堆是否为空，为空则返回1否则返回0
q.size()//查询堆内元素数量

个人认为二叉堆还是比较难理解的，需要花点时间的功夫理解。
看个例子：
在一个果园里，达达已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。

达达决定把所有的果子合成一堆。

每一次合并，达达可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。

可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。

达达在合并果子时总共消耗的体力等于每次合并所耗体力之和。

因为还要花大力气把这些果子搬回家，所以达达在合并果子时要尽可能地节省体力。

假定每个果子重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使达达耗费的体力最少，并输出这个最小的体力耗费值。

例如有3种果子，数目依次为1，2，9。

可以先将1、2堆合并，新堆数目为3，耗费体力为3。

接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为12。

所以达达总共耗费体力=3+12=15。

可以证明15为最小的体力耗费值。

输入格式
输入包括两行，第一行是一个整数n，表示果子的种类数。

第二行包含n个整数，用空格分隔，第i个整数ai是第i种果子的数目。

输出格式
输出包括一行，这一行只包含一个整数，也就是最小的体力耗费值。

输入数据保证这个值小于231。

数据范围
1≤n≤10000,
1≤ai≤20000
输入样例：
3
1 2 9
输出样例：
15
基本就是运用上面讲的方法完成就好了.

#include<stdio.h>
int heap[20000]={0},size;
void swap(int &x,int &y)
{
    int z;
    z=x;
    x=y;
    y=z;
}
void push(int x)
{
    heap[++size]=x;
    int now=size;
    while(now)
    {
        long long int next=now>>1;
        if(heap[next]>heap[now])
        swap(heap[next],heap[now]);
        else break;
        now=next;
    }
    return;
}
int pop()
{
   if(size==0)
   return 0;
   int m=heap[1];
   swap(heap[size],heap[1]);
    size--;
    int now=1;
    long long int next;
    while((now<<1)<=size)
    {
         next=now<<1;
        if(next+1<=size&&heap[next+1]<heap[next])
        next++; 
        if(heap[next]<heap[now])
        swap(heap[now],heap[next]); 
        else break; 
        now=next;
    }
    return m;
}
int main()
{
    int n,i,s,sum=0,x,y;
    size=0;
    scanf("%d",&n);
    for(i=1;i<=n;i++)
    {
        scanf("%d",&s);
        push(s);
    }
    for(int i=1;i<n;i++)
    {
        x=pop();
        y=pop();
        sum+=x+y;
        push(x+y);
    }
    printf("%d\n",sum);
    return 0;
}