堆排序和堆模拟

堆排序

堆是一种树形结构，树的根是堆顶，堆顶始终保持为所有元素的最优值。有最大堆和最小堆，最大堆的根节点是堆的最大值，最小堆的根节点是最小值。堆一般用二叉树实现，称为二叉堆。二叉堆的典型应用就是堆排序和优先队列。

二叉堆的概念

二叉堆是一棵完全二叉树。用数组实现的二叉树堆，树中的每个节点与数组中存放的元素对应。树的每层，除了最后一层可能不满，其他都是满的。如下图所示，用数组实现一棵二叉树堆。

二叉堆中的每个节点，都是以它为父节点的子树的最小值。
用数组A[]存储完全二叉树，节点数量为n,A[1]为根节点，有以下性质：

1. i>1 的节点，其父节点位于i/2；
2. 如果2i>n,那么节点i没有孩子；如果2i+1>n，那么节点i没有右孩子；
3. 如果节点i有孩子，那么它的左孩子是2i，右孩子是2i+1。

堆的操作有进堆和出堆。

1. 进堆：每次把元素放进堆，都调整堆的形状，使根节点保持最小。
2. 出堆：每次取出的堆顶，就是整个堆的最小值；同时调整堆，使堆的堆顶最小。

二叉树只有O(log₂n)层，进堆和出堆逐层调整，计算复杂度都为O(log₂n)。

二叉堆的操作

堆的操作有两种：上浮和下沉。

上浮

某个节点的优先级上升，或者在堆底加入一个新元素(建堆，把新元素加入堆)，此时需要从下至上恢复堆的顺序，下图演示了上浮的过程。

下沉

某个节点的优先级下降，或者将根节点替换为一个较小的新元素(弹出堆顶，用其他元素替换它),此时需要从上至下恢复堆的顺序。下图演示了下沉的过程。


堆经常用于实现优先队列，上浮对应优先队列的插入操作push(),下沉对应优先队列的删除对头操作pop().

堆排序

问题描述

输入一个长度为 n的整数数列，从小到大输出前 m 小的数。

输入格式

第一行包含整数 n 和 m。
第二行包含 n个整数，表示整数数列。

输出格式

共一行，包含 m个整数，表示整数数列中前 m小的数。

数据范围

1≤m≤n≤10⁵，1≤数列中元素≤10⁹

输入样例

5 3
4 5 1 3 2

输出样例

1 2 3

代码

模拟堆写法

#include<bits/stdc++.h>
using namespace std;
const int N=100010;
int n,m;
int h[N],cnt;
void down(int u)
{
    int t=u;
    if(u*2<=cnt && h[u*2]<h[t]) t=u*2; // 如果左子节点存在且小于当前节点，则将左子节点作为新的根节点
    if(u*2+1<=cnt && h[u*2+1]<h[t]) t=u*2+1; // 如果右子节点存在且小于当前节点，则将右子节点作为新的根节点
    if(u!=t)
    {
        swap(h[u],h[t]); // 交换当前节点和新的根节点的值
        down(t); // 递归调整新的根节点
    }
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>h[i]; // 输入堆的元素
    cnt=n;
    //从n/2开始和2*n和2*n+1有关系z
    for(int i=n/2;i;i--) down(i); // 构建小根堆
    while(m--)
    {
        cout<<h[1]<<" "; // 输出堆顶元素
        h[1]=h[cnt--]; // 将最后一个元素放到堆顶，并更新堆的大小
        down(1); // 调整堆顶元素，使其满足小根堆的性质
    }
    return 0;
}

使用优先队列的写法

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m;
    cin>>n>>m;
    priority_queue<int,vector<int>,greater<int>> heap;
    for(int i=0;i<n;i++)
    {
        int x;
        cin>>x;
        heap.push(x);
    }
    for(int i=0;i<m;i++)
    {
        int x;
        x=heap.top();
        heap.pop();
        cout<<x<<" ";
    }
    return 0;
}

模拟堆

问题描述

维护一个集合，初始时集合为空，支持如下几种操作：
I x，插入一个数 x；
PM，输出当前集合中的最小值；
DM，删除当前集合中的最小值（数据保证此时的最小值唯一）；
D k，删除第 k个插入的数；
C k x，修改第 k个插入的数，将其变为 x；
现在要进行 N 次操作，对于所有第 2个操作，输出当前集合的最小值。

输入格式

第一行包含整数 N。
接下来 N 行，每行包含一个操作指令，操作指令为 I x，PM，DM，D k 或 C k x 中的一种。

输出格式

对于每个输出指令 PM，输出一个结果，表示当前集合中的最小值。
每个结果占一行。

数据范围

1≤N≤10⁵,−10⁹≤x≤10⁹数据保证合法。

输入样例

8
I -10
PM
I -10
D 1
C 2 8
I 6
PM
DM

输出样例

-10
6

代码

  简单说下 hp交换映射的逻辑。假设小明和小红 要互换住址，居委会那边可以查小明和小红的住址【ph】，同时小明身上的身份证【hp】用于修改地址 小红同理。
  那么搬家该怎么搬呢？
  首先 小明小红 先去居委会出示了 身份证 swap(ph[hp[小明]],ph[hp[小红]）更换了户口，户口换完了 当然的身份证信息也要修改啦~swap(hp[小红],ph[小明])，最后俩人找来搬家公司 搬完了东西 最后顺利入住了 swap(小明，小红)

#include<bits/stdc++.h>
using namespace std;
const int N=100010;
int h[N],ph[N],hp[N],cnt;
void heap_swap(int a,int b)
{
    // hp[a]表示的是代码上面的图中的节点
    // 这里如果不理解可以看一下下面的插入那里
    swap(ph[hp[a]],ph[hp[b]]); 
    swap(hp[a],hp[b]);
    swap(h[a],h[b]);
}
void down(int u)
{
    int t=u;
    if(2*u<=cnt && h[u*2]<h[t]) t=u*2;
    if(2*u+1<=cnt && h[u*2+1]<h[t]) t=u*2+1;
    if(u!=t)
    {
        heap_swap(u,t);
        down(t);
    }
}
void up(int u)
{
    while(u/2 && h[u]<h[u/2])
    {
        heap_swap(u,u/2);
        u>>=1;
    }
}
int main()
{
    int n,m=0;
    cin>>n;
    while(n--)
    {
        char op[5];
        int k,x;
        cin>>op;
        if(!strcmp(op,"I"))
        {
            cin>>x;
            cnt++;
            m++;
            ph[m]=cnt,hp[cnt]=m;
            //将x放到最后
            h[cnt]=x;
            //x上浮
            up(cnt);
        }
        // 输出集合的最小值
        else if(!strcmp(op,"PM")) cout<<h[1]<<endl;
        // 删除当前集合的最小值
        else if(!strcmp(op,"DM"))
        {
            // 第一个数和最后一个交换位置
            heap_swap(1,cnt);
            //删除最后一个
            cnt--;
            // 将第一个下沉
            down(1);
        }
        // 删除第k个插入数
        else if(!strcmp(op,"D"))
        {
            cin>>k;
            k=ph[k];
            heap_swap(k,cnt);
            cnt--;
            //这里的up和down只执行一个
            up(k);
            down(k);
        }
        else
        {
            cin>>k>>x;
            k=ph[k];
            h[k]=x;
            //这里的up和down只执行一个
            up(k);
            down(k);
        }
    }
    return 0;
}