AcWing 838. 堆排序

题目来源：AcWing 838. 堆排序

一、题目描述

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

输入格式
第一行包含整数 $n$ 和 $m$。

第二行包含 $n$ 个整数，表示整数数列。

输出格式
共一行，包含 $m$ 个整数，表示整数数列中前 $m$ 小的数。

数据范围
$1\le m\le n\le 10^5，$
$1\le$数列中元素$\le 10^9$

输入样例：

5 3
4 5 1 3 2

输出样例：

1 2 3

二、堆

堆是一棵完全二叉树，其有如下操作：

1. 插入一个数
2. 求堆中最值
3. 删除堆顶最值
4. 删除任意一个元素
5. 修改任意一个元素

堆的递归定义：以小根堆为例，每一个结点都 ≤ 左右子树的根结点。

堆的存储：因为堆是建立在完全二叉树上的，凡是涉及完全二叉树皆可以使用顺序存储。
假设堆存储在数组 $h$ 中，那么根结点始终为 $h[1]$，若某个结点的下标为 $i$，则其左儿子的下标为 $2i$，右儿子的下标为 $2i+1$。

堆的向下调整：down()操作
如果对某个结点 $u$ 执行down(u)操作，则需要将该结点的值和其左右儿子的值对比，与其中的最小值的结点进行交换，然后递归执行上述操作，该操作时间复杂度和树的高度成正比，因此为 $O(logn)$。

void down(int u)
{
	int t = u;
	if (u * 2 <= n && h[t] > h[u * 2]) t = u * 2;
	if (u * 2 + 1 <= n && h[t] > h[u * 2 + 1]) t = u * 2 + 1;
	if (t != u)
	{
		swap(h[t], h[u]);
		down(t);
	}
}

堆的向上调整：up(u)操作
如果对某个结点 $u$ 执行up(u)操作，则需要将该结点的值和其父结点的值对比，如果比其父结点的值小，则与父结点交换，然后递归执行上述操作，该操作时间复杂度和树的高度成正比，因此为 $O(logn)$。

void up(int u)
{
	while (u / 2 && h[u] < h[u / 2]) 
	{
		swap(h[u], h[u / 2]);
		u >>= 1;
	}
}

堆的插入操作
在整个堆的最后一个位置插入 $x$，即 h[++n] = x，然后将这个数向上调整 up(n)，时间复杂度 $O(logn)$。

void push(int x)
{
	h[++n] = x;
	up(x);
}

求堆的最值
堆顶元素一定是堆集合的最值：h[1]，时间复杂度 $O(1)$。

int top()
{
	return h[1];
}

删除堆顶最值
将整个堆中的最后一个元素覆盖堆顶元素即h[1] = h[n]，然后令n--，表示删除最后一个元素，然后让堆顶元素向下调整down(1)，该操作时间复杂度 $O(logn)$。
为什么要这样做呢？因为在堆中，直接删除堆顶元素比较困难，然而删除最后一个元素却很简单。

void pop()
{
	h[1] = h[n--];
	down(1);
}

删除任意位置上的一个元素
将整个堆中的最后一个元素覆盖 $h$ 中下标为 $k$ 位置的元素，即h[k] = h[n]，然后令n--，表示删除最后一个元素。此时需要分类讨论，如果 $h[k]$ 相对变大了，就需要down(k)；如果 $h[k]$ 相对变小了，就需要up(k)。其实，我们可以偷懒，不分类讨论，直接down(k), up(k)，这两个中最多只会执行一个，该操作时间复杂度 $O(logn)$。

void remove(int k)
{
	h[k] = h[n--];
	down(k), up(k);
}

修改任意位置上的一个元素
修改操作与删除某个位置上的元素类似，直接在 $h[k]$ 上修改，然后down(k), up(k)即可。

void update(int k, int x)
{
	h[k] = x;
	down(k), up(k);
}

如何快速的将一个数组建成堆
我们当然可以通过一个一个往堆中插入的方式插入数组元素，但是这样做的时间复杂度是 $O(nlogn)$，有一个快速的数组建堆方案是，从 $h$ 序列的 $\frac{n}{2}$ 处向 $1$ 逐个执行 $down()$ 操作即可，该操作时间复杂度可以优化到 $O(n)$，示意图如下。

三、代码

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

const int N = 100010;
int h[N];
int n, m;

void down(int u)
{
    int t = u;
    if (u * 2 <= n && h[u * 2] < h[t]) t = u * 2;
    if (u * 2 + 1 <= n && 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];
    for (int i = n / 2; i; i--) down(i);
    
    while (m--)
    {
        cout << h[1] << ' ';
        h[1] = h[n--];
        down(1);
    }
    
    return 0;
}