【数据结构】满二叉树、完全二叉树、堆的概念回顾，堆和堆排序的算法实现

本来只想整理两个内容：

• 无映射关系的堆排序（eg.堆排序）
• 有映射关系的堆排序（eg.模拟堆）

但是在实现过程中，因为堆的本质是完全二叉树，所以有些地方需要结合完全二叉树的性质来理解。而完全二叉树又是根据满二叉树定义的，所以先回顾一下满二叉树和完全二叉树的基本概念及性质。

1 基本概念及相关性质

1.1 满二叉树

定义：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为k，且结点总数是2^k - 1 ，则它就是满二叉树。
注：满二叉树的概念国内外定义是不同的¹，我们按国内的定义来。

1.2 完全二叉树

1.2.1 定义

一棵深度为k的有n个结点的二叉树，对树中的结点按从上至下、从左到右的顺序进行编号，如果编号为i（1≤i≤n）的结点与满二叉树中编号为i的结点在二叉树中的位置相同，则这棵二叉树称为完全二叉树。

1.2.2 性质

给出完全二叉树的性质是便于理解后面的堆，其中：性质5在后面的代码中用到的最多，性质4略有涉及。
我们假定树的深数k >= 1，则完全二叉树满足以下性质²：

• 性质1：
  第i层上至多有2^i-1个结点
• 性质2：
  深度为k的完全二叉树至多有2^k - 1个结点
• 性质3：
  n₀, n₁, n₂分别代表结点度数为0, 1, 2的结点。n为结点总数，N为边的总数，则满足：
  ①n = n₀ + n₁ + n₂
  ②N = n - 1 = n₁ + 2n₂
  ③n₀ = n₂ + 1
• 性质4：
  具有n个结点的完全二叉树的深度为└log₂n┘+ 1
• 性质5：
  如果对一颗有n个结点的完全二叉树（其深度为└log₂n┘+1）的结点按层序编号，对于任意结点i有：
  ①如果i = 1，则结点 i 是二叉树的根结点，无双亲；如果i > 1，则其双亲结点是└i/2┘
  ②如果2i > n，则节点 i 无左孩子；否则其左孩子就是 2i
  ③如果2i + 1 > n，则节点i无右孩子；否则其右孩子就是2i + 1

1.2.3 性质推导

• 性质3推导：
  这个推导印象还是很深的，老师当时上课讲的场景仍历历在目：从边出发即可，用N表示边的总数。
  树从下往上看，除了根结点，每个结点都由一条边引出：N = n₀ + n₁ + n₂ - 1
  树从上往下看，每个结点可以引出0/1/2条边：N = n₁ + 2n₂
  联立可得：n₀ = n₂ + 1
  （“从下往上"和"从上往下"可以分别从"入度”、“出度”）去理解。
• 性质4推导：
  对于完全二叉树来说：2^k-1 - 1 < n <= 2^k - 1
  同时+1可得：2^k-1 < n + 1 <= 2^k
  同时取对数：k - 1 < log₂(n+1) <= k
  可推导： log₂(n+1) <= k < log₂(n+1) + 1
  所以，具有n个结点的完全二叉树的深度为： └log₂n┘+ 1。（log₂n向下取整再加一）
• 性质5推导：
  简要概括就是：一个结点编号为x，它的左孩子（若存在）编号一定是2x，它的右孩子（若存在）编号一定是2x + 1

1.3 堆

堆是一棵特殊的完全二叉树，它的特殊体现在：堆中某个结点的值总是不大于或不小于其父结点的值。
以小顶堆为例：（小顶堆 = 小根堆 = 最小堆）每个结点都 <= 两个子结点的值

2 堆的算法实现

堆的算法实现中，我们以小顶堆为例子。

2.1 存储结构

前面在整理Trie树时，用到了son[M][N]作为存储结构，在堆这里选用一种全新的存储方式——使用一维数组做为存储，依据的原理就是上面提到的：一个结点编号为x，它的左孩子（若存在）编号一定是2x，它的右孩子（若存在）编号一定是2x + 1。
从这一点中也可以看到堆存放的数组应该从下标 = 1开始。

2.2 基本操作

下面的up()、down()、堆的初始化是堆的基本操作，也是最重要的操作。

• 堆的O(n)初始化
  从树的倒数第二层开始down()，保证了每个结点和它的子结点都构成了一个小堆，层层往上就可以递归地保证这是最小堆了。（从倒数第二层开始是因为最后一层单拎出来一个也是小堆，down()一遍不会改变什么）
• down() 往下调整
• up() 往上调整

#include<algorithm>

void down(int u){
	int t = u;	// 三个点里面的min
	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){
		swap(h[u], h[t]);
		down(t);
	}
}

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

// 堆的O(n)初始化
for(int i = n / 2; i; i --) down(i);

注：这里有人会疑问，两个操作会不会超时？其实不是，因为就算数据量是10⁶，log(n)即树高也就20。

2.3 堆支持的操作

堆应该支持以下5种操作，其中前3种操作是STL库有的，后2种操作是自己可以实现的。5种操作都可以通过down()和up()函数结合实现。

• 插入一个数
• 求集合当中最小值
• 删除最小值
• 删除任意一个元素
• 修改任意一个元素

①插入一个数

h[++ size] = x;
up(size);

②求集合当中最小值

h[1];

③删除最小值
删除最小值这里有个技巧：用整个堆的最后一个元素覆盖掉堆顶元素，然后size - 1，再down()就可以。
原因：删除最后一个元素操作简单，只需要size - 1

h[1] = h[size];
size --;
down(1);

④删除任意一个元素
和删除最小值唯一不同的是，我们不知道用最后一个元素替上去以后应该up还是down，最好的操作就是两个都写上，符合哪个用哪个。

h[k] = h[size];
size --;
down(k);
up(k);

⑤修改任意一个元素

heap[k] = x;
down(k);
up(k);

3 堆排序算法（无映射关系）

无映射关系的堆排序是最常见的堆排序，思路是：先把整个数组建成堆，每次输出栈顶即可。
堆排序只需要用到上面的两种操作：求集合当中的最小值、删除最小值。（其实就是down()操作了）
题目链接：堆排序
代码：

#include<iostream>
#include<algorithm>

using namespace std;

const int N = 100010;

int h[N];   // heap
int cnt;    // 结点总数

void down(int u){
    int t = u;  // 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(t != u){
        swap(h[t], h[u]);
        down(t);
    }
}

int main(){
    int n, m;
    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;
}

4 堆排序算法（有映射关系）

无映射关系的堆排序是比较常用的，所以重点还是前面的。
有映射关系的堆排序实现相对复杂，不常用，但是后面的Dijkstra算法会用到，所以整理一下。
本质上，引入映射关系是这样一个问题的出现：对第k个插入的数进行某种操作（比如删除），我们在次次swap()之后会丢失掉这个信息，所以需要开辟额外的空间存储堆的每一个结点和它的插入顺序的映射：

// p: pointer, h:heap
ph[k];	// 第k个插入的数的下标（也就是具体是哪个点）
hp[k];	// 堆里面的某个点是第几个插入的点

所有的操作都需要修改一遍，但最主要要改的操作是swap()函数。
用heap_swap()说清楚ph和hp的用法：
现在有两个结点，在堆数组h[]中的下标分别是a、b，那么肯定有：

• ph[i] = a, ph[j] = b
  hp[a] = i, hp[b] = j

当两个结点交换了之后：

• ph[i] = b, ph[j] = a
  hp[a] = j, hp[b] = i
  即：swap(ph[i], ph[j]), swap(hp[a], hp[b]);

因为我们目前只知道a、b，所以可以用最初的hp[a]、hp[b]来得出 i 和 j
那么这个过程的实现代码可以表示如下：（注意顺序）

void heap_swap(int a, int b){
	swap(h[a], h[b]);
	swap(ph[hp[a]], ph[hp[b]]);
	swap(hp[a], hp[b]);
}

为了凸显3的重要性（懒），这里就不专门列出来其他要改的所有操作了，在代码中会有注释。
题目链接：模拟堆
代码：

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

using namespace std;

const int N = 100010;

int h[N], cnt;
int hp[N], ph[N];

void heap_swap(int a, int b){
    swap(h[a], h[b]);
    swap(ph[hp[a]], ph[hp[b]]);
    swap(hp[a], hp[b]);
}

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

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)
    {
        heap_swap(u, t);
        down(t);
    }
}

int main(){
    int n, m = 0;
    scanf("%d", &n);
    while(n --){
        char op[5];
        int k, x;
        scanf("%s", op);
        if(!strcmp(op, "I")){
            // 插入一个数
            scanf("%d", &x);
            cnt ++;
            m ++;
            ph[m] = cnt, hp[cnt] = m;
            
            h[cnt] = x;
            up(cnt);
        }
        else if(!strcmp(op, "PM")) printf("%d\n", h[1]);
        else if(!strcmp(op, "DM")){
            // 删除最小值
            heap_swap(1, cnt);
            cnt --;
            down(1);
        }
        else if(!strcmp(op, "D")){
            // 删除第k个插入的数
            scanf("%d", &k);
            k = ph[k];
            heap_swap(k, cnt);
            cnt --;
            up(k);
            down(k);
        }
        else{
            // 修改第k个插入的数
            scanf("%d%d", &k, &x);
            k = ph[k];
            h[k] = x;
            up(k);
            down(k);
        }
    }
    return 0;
}

参考资料

[1] 百度百科：满二叉树
[2] 完全二叉树的性质