堆排序（如何手写堆）

堆 （如何手写堆）

作用：维护一个数据集合   

是一个完全二叉树，除了最后一层节点之外，上面都是非空的，最后一层从做到右以此排布

基本操作：

1.插入一个数   O(log(n))

2.求集合当中的最小值  O(1)

3.删除最小值  O(log(n))

4.删除任意一个元素  （stl中的堆不能 直接 实现）

5.修改一个元素  （stl中的堆不能 直接 实现）

以小根堆 为例

每个点都小于等于左右儿子，则根节点就是堆里面的最小值

存储;

用一维数组存储，下标从1开始，1为根节点，x的左儿子为2x，x的右儿子为2x+1

两个操作：

down（x） 把一个节点往下移     up（x）把一个节点往上移

其上五个基本操作均可用这两个完成

基本逻辑：

down：

up：

如何实现五种操作：

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

       同上面，不过不需要考虑是要往上移（k位置上的数变小了）还是往下移（k位置上的数变大了），down和up只会做一个。

5.修改一个元素   heap[k] = x; down (k); up (k);  

例题和代码 down操作（包括了插入和删除）

例题：

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

输入格式

第一行包含整数 n 和 m。

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

输出格式

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

数据范围

1 ≤ m ≤ n ≤ 10^5，
1 ≤ 数列中元素 ≤ 10^9

输入样例：

5 3
4 5 1 3 2

输出样例：

1 2 3

#include<iostream>
#include<algorithm>

using namespace std;

const int N = 1e5 + 10;

// 只需要用插入和删除，则只需要用down就行

int n, m;
int h[N], cnt; // h[N]是堆的整体 cnt是数组长度

void down(int u)
{
    int t = u; // t是三个里面最小值的下标
    if (u * 2 <= cnt && h[u * 2] < h[t]) t = u * 2; // 如果h[t]的左儿子小于h[t]的话，t变成左儿子的下标
    if (u * 2 + 1 <= cnt && h[u * 2 + 1] < h[t]) t = u * 2 + 1; // 如果如果h[t]的右儿子小于h[t]的话，t变成右儿子的下标
    // 此时t存的就是三个里面最小的那个数的下标
    if (u != t) // u不等于t的话说明根节点不是最小值
    {
        swap(h[u], h[t]); // 要交换一下，将根节点变成最小值
        down(t); // 递归处理，此时的t依旧是刚开始的根节点，将其一直往下移
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &h[i]);
    cnt = n;
    
    
    // 从n / 2开始down时间复杂度变为O（n） down完就排好序了
    for(int i = n / 2; i; i --) down(i);
    
    while(m --)
    {
        printf("%d ", h[1]);
        h[1] = h[cnt --]; // 将最后一个节点覆盖到第一个，并删除最后一个节点，再将其往下走，这样就删掉了第一个节点
        
        down(1);
    }
      
    
    return 0;
}

为什么要从n / 2开始往下down时间复杂度是O（n）呢？：

例题2：up操作及五种操作

例题​​​​​​​

维护一个集合，初始时集合为空，支持如下几种操作：

1. I x，插入一个数 x；
2. PM，输出当前集合中的最小值；
3. DM，删除当前集合中的最小值（数据保证此时的最小值唯一）；
4. D k，删除第 k 个插入的数；
5. C k x，修改第 k 个插入的数，将其变为 x；

现在要进行 N次操作，对于所有第 2个操作，输出当前集合的最小值。

输入格式

第一行包含整数 N。

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

输出格式

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

每个结果占一行。

数据范围

1 ≤ N ≤ 10^5
−10^9 ≤ x ≤ 10^9
数据保证合法。

输入样例：

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

输出样例：

-10
6

代码如下：

#include<iostream>
#include<algorithm>
#include<string.h>

using namespace std;

const int N = 1e5 + 10;

// 题中说要删除和修改第k个插入的数，则我们就需要凯两个数组存储第k个数是啥

int n, m;
int h[N], ph[N], hp[N], cnt; 
/* ph[i] = k存的是第i个插入的点的下标是k，hp[k] = i是堆里的小标是k的点是第i个插入的点，可以理解为反向指针， 两个是互逆的
也就是说我们用hp来找这个点是第几个插入的，ph找第x个插入的数在堆里的下标是多少，然后就可以用h来知道这个下标的值是多少
*/

void heap_swap(int a, int b) // 映射特有的swap
{
    swap(ph[hp[a]], ph[hp[b]]); 
    swap(hp[a], hp[b]); 
    swap(h[a], h[b]); 
}

void down(int u)
{
    int t = u; // t是三个里面最小值的下标
    if (u * 2 <= cnt && h[u * 2] < h[t]) t = u * 2; // 如果h[t]的左儿子小于h[t]的话，t变成左儿子的下标
    if (u * 2 + 1 <= cnt && h[u * 2 + 1] < h[t]) t = u * 2 + 1; // 如果如果h[t]的右儿子小于h[t]的话，t变成右儿子的下标
    // 此时t存的就是三个里面最小的那个数的下标
    if (u != t) // u不等于t的话说明根节点不是最小值
    {
        heap_swap(u, t); // 依旧是交换这两个点
        down(t); 
    }
}

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

int main()
{
   cin.tie(0);
   cout.tie(0);
   ios::sync_with_stdio(false);
   
   int n;
   cin >> n;
   
   while(n --)
   {
       string op;
       int k, x;
       
       cin >> op;
       
       if (op == "I")
       {
           cin >> x;
           cnt ++;
           m ++;
           ph[m] = cnt, hp[cnt] = m;
           h[cnt] = x;
           up(cnt);
           
       }
       else if (op == "PM") cout << h[1] << endl;
       else if (op == "DM")
       {
           heap_swap(1, cnt); // 交换第一个点和堆最后一个点
           cnt --; // 把最后一个点删除   就完成了删除最小值
           down(1);// 将其往下移
       }
       else if (op == "D")
       {
           cin >> k;
           k = ph[k];
           heap_swap(k, cnt);
           cnt --;
           down(k), up(k);
       }
       else
       {
           cin >> k >> x;
           k = ph[k];
           h[k] = x;
           down(k), up(k);
       }
   }
      
    
    return 0;
}

这种映射不常用，大部分使用的都是普通的up和down操作