二叉堆

二叉堆

二叉堆是一种基础数据结构，二叉堆的操作内容包括插入，删除，查询等。
性质：
堆是一颗完全二叉树，堆的顶端一定是“最大”，最小”的，但是要注意一个点，这里的大和小并不是传统意义下的大和小，它是相对于优先级而言的。
堆有两种模式，小根堆和大根堆，分别对应第二个性质中的“堆顶最大”“堆顶最小”，对于大根堆而言，任何一个非根节点，它的优先级都小于堆顶，对于小根堆而言，任何一个非根节点，它的优先级都大于堆顶。

然而二叉堆的代码实现也有两种，包括手写堆和STL；
首先我们通过手写堆来实现对堆的理解。

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;
}

解释：就比如我要插入一个0，首先把他放在堆底，然后与他的上一级进行比较，如果比他小就和他进行交换，直到遇到比他还小的，或者到了堆顶就结束。

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]就好了。

第二种是堆的STL实现，手写堆相对来说比较好理解，但是在性能上他比不过STL，不管是在代码的复杂度，还是在时间度上。
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()//查询堆内元素数量

STL在删除上和手写堆有一定的差异，STL只支持删除堆顶，而不支持删除其他元素。不过可以用标记法来解决这个问题。

然后是有一个重载运算符
把一种运算符变成另外一种运算符（注意，都必须是原有的运算符），好处呢，就是之前我们就讲到了，大根堆，小根堆的“大”和“小”都不是传统意义下的“大”和“小”，重载运算符在STL的优先队列中就是用来解决这种“非传统意义的‘大’和‘小’”的
现在你有一个数列，它有权值和优先级两种属性，权值即该数的大小，优先级是给定的，现在要你按照优先级的大小从小到大输出这个数列

struct node{
    int val,rnd;
    bool operator < (const node&x) const {
        return rnd<x.rnd;
    }
}a[100];

首先这个玩意是bool类型的，因为你只需要判断这两个是大，还是小；然后，要重载运算符就必须加一个operator这个玩意，不然计算机怎么知道你要干嘛？后面接一个你要重载的运算符，这里是“<”，再后面的括号里面的东西则是你要比较的数据类型，这里是数据类型为node，并且加了一个指针&，将对这个x的修改同步到你实际上要修改的数据那里。然后就是记得加那两个const
然后两个大括号里面就是你重载的内容了，这里是把比较数的大小的小于号，重载成比较node这个数据类型里面的优先级的大小

最后一个就是堆排，就是用要排序的元素建一个堆（视情况而定是大根堆还是小根堆），然后依次弹出堆顶元素，最后得到的就是排序后的结果了

上例题：

在一个果园里，达达已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。达达决定把所有的果子合成一堆。每一次合并，达达可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。达达在合并果子时总共消耗的体力等于每次合并所耗体力之和。因为还要花大力气把这些果子搬回家，所以达达在合并果子时要尽可能地节省体力。假定每个果子重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使达达耗费的体力最少，并输出这个最小的体力耗费值。例如有3种果子，数目依次为1，2，9。可以先将1、2堆合并，新堆数目为3，耗费体力为3。接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为12。所以达达总共耗费体力=3+12=15。可以证明15为最小的体力耗费值。输入格式输入包括两行，第一行是一个整数n，表示果子的种类数。第二行包含n个整数，用空格分隔，第i个整数aiai是第i种果子的数目。输出格式输出包括一行，这一行只包含一个整数，也就是最小的体力耗费值。输入数据保证这个值小于231231。
数据范围
1≤n≤100001≤n≤10000,
1≤ai≤200001≤ai≤20000
输入样例：
3
1 2 9
输出样例：
15
难度：简单时/空限制：1s / 64MB总通过数：903总尝试数：1389来源：《算法竞赛进阶指南》, NOIP2004提高组 , 模板题算法标签

思路：这道题目是哈夫曼树的典型模板,也就是每次选择最小的两个果堆,然后将他们合并起来,再次压入堆中.

int main(){
    cin>>n;
        priority_queue<int,vector<int>,greater<int> > heap;//定义一个小根堆

    for(int i=0;i<n;i++)//输入n个数
    {
        int a;
        cin>>a;
        heap.push(a);
    }
        int res=0;
    while(heap.size()>1)//控制条件：堆元素大于一
    {
        int a=heap.top();
        heap.pop();
        int b=heap.top();
        heap.pop();//a b为最小的体力
        res+=a+b;//然后a，b的体力相加
        heap.push(a+b);//新的果子的个数
    }
    cout<<res<<endl;

来源：CSDN

作者：qq_46195692

链接：https://blog.csdn.net/qq_46195692/article/details/104201544