堆笔记（1）堆排序

比赛告一段落，恢复更新啦！

如何手写一个堆？

1、插入一个数

2、求集合当中的最小值

3、删除最小值

4、删除任意一个元素

5、修改任意一个元素

（前三个是STL里堆可以直接实现的，后两者是无法直接实现的。）

堆是一个完全二叉树（一棵非常平衡的二叉树，除了最后一层节点之外，所有节点都是满的，最后一层节点从左到右依次排布）

堆有一个递归性质：

以小根堆为例：每个点都小于等于其左右两个子结点。由此我们可以确定根节点就是最小值。

（把小于等于换成大于等于就是大根堆，本文均使用小根堆）

堆的存储：

凡是完全二叉树，我们都用一个一维数组存储：从上到下从左到右依次存储。第x个元素的两个子结点是 2 * x 和 2 * x + 1 个数。

堆的基本操作：

down()和up()，前者是往下调整（把一个节点往下移），后者是往上调整（把一个节点往上移），我们前面的五条操作都可以用这两个操作来实现。

比如我们有如下的一个堆：

 我们把根节点从1换成一个更大的数6

 接下来为了维护我们堆的性质——每个节点小于等于其子结点，我们需要将6和它的两个子结点3和4进行比较，得到最小值为3，接下来我们把3和6交换，变成：

 这样我们在前两层就成功维护的该性质，接下里我们发现6、3、5三个数又不满足该性质了，所以我们需要递归操作，将6和第三层的3进行交换：

 递归直到三者中最小值就是父节点本身为止。

上述操作就是down(x)操作，在我们将堆中的一个节点增大时负责维护我们堆的性质。

同理，up(x)就是在我们将一个节点减小时维护堆的性质。

接下来我们再回到之前讲的堆的五个操作：

1、插入一个数 heap[ ++ size] = x; up(size);

2、求集合当中的最小值 heap[1];

3、删除最小值 heap[1] = heap[size]; size --; down(1);

4、删除任意一个元素 heap[k] = heap[size]; size --; down(k); up(k);// 这里down和up只会执行一个

5、修改任意一个元素 heap[k] = x; down(k); up(k); // 这里down和up只会执行一个

（由于在数组中删除最后一个元素远比删除第一个元素简单，所以我们的删除操作就是用最后一个数覆盖第一个数，然后把最后一个数给删掉）

以下为堆排序的模板：

// h[N]存储堆中的值, h[1]是堆顶，x的左儿子是2x, 右儿子是2x + 1
// ph[k]存储第k个插入的点在堆中的位置
// hp[k]存储堆中下标是k的点是第几个插入的
int h[N], ph[N], hp[N], size;

// 交换两个点，及其映射关系
void heap_swap(int a, int b) {
    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 (u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
    if (u * 2 + 1 <= size && 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;
    }
}

// O(n)建堆
for (int i = n / 2; i; i -- ) down(i);

来一道模板题：

 AC代码如下：

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

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

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

int main() {
    scanf("%d%d", &n, &m);
    mysize = n;
    for (int i = 1; i <= n; i ++)
        scanf("%d", &h[i]);
    for (int i = n / 2; i; i --)
        down(i);

    while (m--) {
        printf("%d ", h[1]);
        h[1] = h[mysize --];
        down(1);
    }
    return 0;
}

堆排序的整体时间复杂是O(n*logn) 。