堆

C++STL中已经有了现成的堆即：优先级队列（priority_queue）,是大根堆

这里主要是用数组模拟的堆（小根堆）：

x的左儿子下标：2x

x的右儿子下标：2x+1

堆是一颗完全二叉树。

主要操作：

up操作：up操作是只与当前节点的父节点进行比较，若父结点比当前结点大，则进行交换，实现up

down操作：当前结点与其左右儿子结点进行比较，与最小的结点进行交换，实现down

1.插入一个数： heap[++size] = x, up[size] ，即把一个数插在堆的末尾然后up到合适位置。

2.求集合中最小值：即 heap[1] 堆顶

3.删除最小值：让堆的最后一个元素直接覆盖堆顶，然后再进行down操作 heap[1] = heap[size], size--, down(1)

4.删除任意一个元素：让最后一个元素直接覆盖此元素，然后up一遍，down一遍，因为up与down操作只会做一个，不需要再加特殊判断选择down还是up， heap[k] =heap[size], size--, down(k),up(k)

5.修改任意一个元素：直接覆盖，然后down，up， heap[k] = x, down(k), up(k)

堆排序

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

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

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

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

数据范围
1≤m≤n≤105，
1≤数列中元素≤109
输入样例：
5 3
4 5 1 3 2
输出样例：
1 2 3

构造这个堆， for(int i = n/2; i; i--) down(i); ，从n/2开始down是因为堆的最下边一层不需要down，而最后一层与上面几层的规模是1：1

down：

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

up

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

总代码：

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

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

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

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

int main()
{
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++) scanf("%d", &h[i]);
    cnt = n;

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

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

    return 0;
}