数据结构 - heap - 堆 - 二叉堆

ゞ浴缸里的玫瑰 2022-10-29 03:14 203阅读 0赞

# **数据结构 - heap - 堆 - 二叉堆** #

## 0. 树 ##

树是包含一个或多个数据节点的集合，其中一个节点被指定为树的根，而其余节点称为根的子节点。在通用树中，一个节点可以具有任意数量的子节点，但它只能有一个父节点。下图显示了一棵树，其中节点 A 是树的根节点，而其它节点可以看作是 A 的子节点。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center]

根节点是树层次结构中的最顶层节点，根节点是没有任何父节点的节点。如果根节点不为空，则树 T1，T2 和 T3 称为根节点的子树。树的节点中没有任何子节点的节点称为叶节点。叶节点是树的最底部节点，也称为外部节点。

节点的祖先是从根到该节点的路径上的任何先前节点，根节点没有祖先节点。节点 F 的祖先是 B 和 A。

节点的度数等于子节点数，节点 B 的度数为 2。叶子节点的度数总是 0。在完整的二叉树中，每个节点的度数等于 2。为树的每个节点分配一个级别编号，使得每个节点都存在于高于其父级的一个级别。树的根节点始终是级别 0。

## 1. 二叉树 ##

链表 (linked list) 新的节点可以被快速插入，旧的节点可以被快速移除。链表 (linked list) 查找某个值，必须遍历所有的节点。

二叉树有利于快捷存取链接的元素。数据项必须有关键值，用于比较和排序。二叉树具有链表的灵活性，也具有“已排序数组”的优点，可以使用二元搜索方法快速地找到所要的数据。

*  二叉树的每个节点最多有两个直接的子节点。
 *  有一个“没有父节点”的节点，被称为树根。其它所有的节点都有一个父节点。
 *  叶节点是指“没有子节点”的节点。每个树的节点也被认为是其子树的根，子树包含所有子孙的节点。

二叉树的高度是“从根到叶”最长路径的长度。路径是由相连的节点所形成的链表。**路径的长度就是路径中节点数目，但不计算第一个节点。**只有一个节点的树，高度是 0。

![在这里插入图片描述][20210216185928245.png_pic_center]  
上图的树，高度是 3。

二叉树的每个节点最多可以有 2 个子节点。存在于最顶层的节点称为根节点。具有 0 个子节点的节点称为叶节点。

## 2. heap - 堆 - 二叉堆 ##

堆是一个可以被看做一棵完全二叉树的数组对象。

1.  堆中某个节点的值总是不大于或不小于其父节点的值。
2.  堆总是一棵完全二叉树。

二叉堆的根节点叫做堆顶。最大堆的堆顶是整个堆中的最大元素，最小堆的堆顶是整个堆中的最小元素。

根节点最大的堆叫做最大堆或大根堆。最大堆任何一个父节点的值，都大于等于它左右孩子节点的值。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 1]

根节点最小的堆叫做最小堆或小根堆。最小堆任何一个父节点的值，都小于等于它左右孩子节点的值。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 2]

堆是非线性数据结构，相当于一维数组，有两个直接后继。

树的高度是指从树的根节点到最低的叶节点所需要的步数。树的高度是指节点之间的边的最大值。

下图的树高度是 3，它有 4 层。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 3]

0 层 2^0   1
    1 层 2^1   2
    2 层 2^2   4
    3 层 2^3   8
    4 层 2^4   16
    …
    h 层 2^h   2^h

一个高度为  h h h 的堆有  h + 1 h+1 h\+1 层。

n n n 个结点的堆，高度  h = log ⁡ 2 n h = \\log\_2^n h=log2n。根为第 0 层，则第  i i i 层结点个数为  2 i 2^i 2i，考虑一个元素在堆中向下移动的距离，这种算法时间代价为  O ( h ) Ο(h) O(h)

由于堆有  log ⁡ 2 n \\log\_2^n log2n 层深，插入结点、删除节点的平均时间代价和时间复杂度都是  O ( log ⁡ 2 n ) Ο(\\log\_2^n) O(log2n)。

不必将值一个一个地插入堆中，通过交换形成堆。假设一个`小根堆`的左、右子树都已是堆，并且根的元素名为 root，其左右子节点为 left 和 right，这种情况下，有两种可能：  
(1) root <= left 并且 root <= right，此时堆已完成。  
(2) root >= left 或者 root >= right，此时 root 应与两个子女中值较小的一个交换，结果得到一个堆，除非 root 仍然大于其新子女的一个或全部的两个。这种情况下，只需简单地继续这种将 root “拉下来”的过程，直至到达某一个层使它小于它的子女，或者它成了叶结点。

### 2.1 等比数列求和公式 ###

公式中  a 1 a\_1 a1 为首项， a n a\_n an 为数列第  n n n 项。 q q q 为等比数列公比， S n S\_n Sn 为前  n n n 项和。  
![在这里插入图片描述][20210216210005376.png_pic_center]  
下图的树高度是 3，它有 4 层。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 3]

2^0 = 1
    2^1 = 2
    2^2 = 4
    2^3 = 8
    ……
    2^h = 2^h

如果一个堆有  n n n 个节点，它的高度是  h = floor ( log ⁡ 2 n ) h = \\text\{floor\}(\\log\_2^n) h=floor(log2n)。总是要将这一层完全填满以后才会填充新的一层。上图有 15 个节点，它的高度是  floor ( log ⁡ 2 15 ) = floor ( 3.9069 ) = 3 \\text\{floor\}(\\log\_2^\{15\}) = \\text\{floor\}(3.9069) = 3 floor(log215)=floor(3.9069)=3。

如果最下面的一层已经填满，那么那一层包含  2 h 2^h 2h 个节点。树中这一层以上所有的节点数目为  2 h − 1 2^h - 1 2h−1。上图最下面的一层有  2 3 = 8 2^3 = 8 23=8 个节点。前面的三层一共包含  2 3 − 1 = 8 − 1 = 7 2^3 - 1 = 8 - 1 = 7 23−1=8−1=7 个节点。

所以整个堆中的节点数目为： 2 ( h + 1 ) − 1 2^\{(h+1)\} - 1 2(h\+1)−1。上面的例子中， 2 4 − 1 = 16 − 1 = 15 2^4 - 1 = 16 - 1 = 15 24−1=16−1=15。

q = 2 q = 2 q=2  
 S n = a 1 ∗ ( 1 − q n ) / ( 1 − q ) = 1 ∗ ( 1 − 2 ( h + 1 ) ) / ( 1 − 2 ) = 2 ( h + 1 ) − 1 S\_n = a\_1 \* (1 - q^n) / (1 - q) = 1 \* (1 - 2^\{(h + 1)\}) / (1 - 2) = 2^\{(h + 1)\} - 1 Sn=a1∗(1−qn)/(1−q)=1∗(1−2(h\+1))/(1−2)=2(h\+1)−1  
 S n = ( a 1 − a n ∗ q ) / ( 1 − q ) = ( 1 − 2 h ∗ 2 ) / ( 1 − 2 ) = 2 ( h + 1 ) − 1 S\_n = (a\_1 - a\_n \* q) / (1 - q) = (1 - 2^h \* 2) / (1 - 2) = 2^\{(h + 1)\} - 1 Sn=(a1−an∗q)/(1−q)=(1−2h∗2)/(1−2)=2(h\+1)−1

### 2.2 STL ###

堆的 STL 包含于 `#include "algorithm"` 头文件中。

堆的 STL 支持以下的基本操作：  
建立一个空堆：

make_heap(first, last, comp);

向堆中插入一个新元素：

push_heap(first, last, comp);

获取当前堆顶元素的值：

top_heap(first, last, comp);

对当前堆进行排序：

sort_heap(first, last, comp);

## 3. 二叉堆的自我调整 ##

二叉堆是实现堆排序和优先队列的基础。

### 3.1 二叉堆的插入节点 ###

二叉堆的节点插入，插入位置是完全二叉树的最后一个位置。插入一个新节点，关键字数据为 0。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 4]

关键字数据为 0 的节点与它的父节点 (关键字数据为 5) 做比较。因为 0 小于 5，则让新节点上浮，同父节点交换位置。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 5]

继续用关键字数据为 0 的节点和关键字数据为 3 的父节点做比较，因为 0 小于 3，则让新节点继续上浮。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 6]  
继续比较，最终让关键字数据为 0 的新节点上浮到了堆顶位置。

### 3.2 二叉堆的删除节点 ###

二叉堆的节点删除过程和插入过程正好相反，所删除的是处于堆顶的节点。例如删除最小堆的关键字数据为 1 的堆顶节点。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 7]

为了维持完全二叉树的结构，将堆的最后一个关键字数据为 10 的节点补到原本堆顶的位置。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 8]

堆顶的关键字数据为 10 的节点和它的左右孩子中的最小值进行比较。**左右孩子中值最小的节点** (显然是关键字数据为 2 的节点) 小于关键字数据为 10 的节点，那么将关键字数据为 10 的节点下沉。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 9]

继续让关键字数据为 10 的节点和它的左右孩子最小值做比较，**左右孩子中值最小的节点**关键字数据为 7，由于 10 大于 7，让关键字数据为 10 的节点继续下沉。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 10]

### 3.2 二叉堆的构建 ###

构建二叉堆是把一个无序的完全二叉树调整为二叉堆，本质上就是让所有**非叶子节点依次下沉**。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 11]  
从最后一个非叶子节点开始，也就是从关键字数据为 10 的节点开始。如果关键字数据为 10 的节点大于其左右孩子中关键字数据最小的一个，则关键字数据为 10 节点下沉。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 12]  
接下来是关键字数据为 3 的节点。如果关键字数据为 3 的节点大于其左右孩子中最小的一个，则关键字数据为 3 的节点下沉。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 13]  
接下来是关键字数据为 1 的节点。如果是关键字数据为 1 的节点大于其左右孩子中最小的一个，则关键字数据为 1 的节点下沉。事实上关键字数据为 1 的节点小于它的左右孩子中的最小值，无需改变。

接下来是关键字数据为 7 的节点。如果关键字数据为 7 的节点大于它左右孩子中最小的一个，则关键字数据为 7 的节点下沉。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 14]

关键字数据为 7 节点继续比较，继续下沉。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 15]  
一颗无序的完全二叉树就构建成了一个最小堆。

## 4. 二叉堆的代码实现 ##

二叉堆是一颗完全二叉树，它的存储方式并不是链式存储，而是顺序存储。二叉堆的所有节点都存储在数组中。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70]  
上图的示例是定义数组索引从第 0 个开始。

0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
    1  3  2  6  5  7  8  9  10

依靠数组下标来计算父节点的左孩子和右孩子。

假设父节点的下标是 `parent`，那么它的左孩子下标就是 `2*parent+1`，它的右孩子下标就是 `2*parent+2`。

关键字数据为 6 的节点包含两个孩子 (关键字数据为 9 和关键字数据为 10)，关键字数据为 6 的节点在数组中的下标是 3，关键字数据为 9 的节点在数组中的下标是 7，关键字数据为 10 的节点在数组中的下标是 8。

7 = 2 * 3 + 1
    8 = 2 * 3 + 2

父节点和孩子节点做连续交换时，并不一定要真的交换，只需要先把交换一方的值存入 tmp 变量，做单向覆盖，循环结束后，再把 tmp 的值存入交换后的最终位置。

## 5. 堆排序 ##

二叉堆是一棵完全二叉树。

最大堆的堆顶是整个堆中的最大元素，删除一个最大堆的堆顶 (并不是完全删除，而是替换到最后面)，经过自我调节，第二大的元素就会被交换上来，成为最大堆的新堆顶。  
![在这里插入图片描述][20210217133459850.png_pic_center]

当删除值为 10 的堆顶节点，经过调节，值为 9 的新节点就会顶替上来。当删除值为 9 的堆顶节点，经过调节，值为 8 的新节点就会顶替上来。每一次删除旧堆顶，调整后的新堆顶都是大小仅次于旧堆顶的节点。只要反复删除堆顶，反复调节二叉堆，所得到的集合就成为了一个有序集合。

删除关键字数据为 9 的节点，关键字数据为 3 的节点被替换为堆顶，调整后关键字数据为 8 的节点成为新堆顶：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 16]  
删除关键字数据为 8 的节点，关键字数据为 2 的节点被替换为堆顶，调整后关键字数据为 7 的节点成为新堆顶：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 17]  
删除关键字数据为 7 的节点，关键字数据为 4 的节点被替换为堆顶，调整后关键字数据为 6 的节点成为新堆顶：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 18]  
删除关键字数据为 6 的节点，关键字数据为 2 的节点被替换为堆顶，调整后关键字数据为 5 的节点成为新堆顶：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 19]  
删除关键字数据为 5 的节点，关键字数据为 2 的节点被替换为堆顶，调整后关键字数据为 4 的节点成为新堆顶：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 20]  
删除关键字数据为 4 的节点，关键字数据为 2 的节点被替换为堆顶，调整后关键字数据为 3 的节点成为新堆顶：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 21]  
删除关键字数据为 3 的节点，关键字数据为 2 的节点被替换为堆顶，关键字数据为 2 的节点成为新堆顶：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 22]  
原本的最大堆已经变成了一个从小到大的有序集合。二叉堆实际存储在数组当中，数组中的元素排列如下：  
![在这里插入图片描述][20210217134041612.png_pic_center]

### 5.1 空间复杂度和时间复杂度 ###

二叉堆的节点下沉调整 (down\_adjust) 是堆排序算法的基础。

假设二叉堆总共有  n n n 个元素，那么下沉调整的最坏时间复杂度就等同于二叉堆的高度，也就是  O ( log ⁡ 2 n ) O(\\log\_2^n) O(log2n)。

**堆排序算法的步骤：**

1.  将无序数组构建成二叉堆，需要进行  n / 2 n/2 n/2 次循环。每次循环调用一次 down\_adjust 方法，第一步的计算规模是  n / 2 ∗ log ⁡ 2 n n/2 \* \\log\_2^n n/2∗log2n，时间复杂度  O ( n ∗ log ⁡ 2 n ) O(n \* \\log\_2^n) O(n∗log2n)。
2.  循环删除堆顶元素，移到集合尾部，调节堆产生新的堆顶。需要进行  n − 1 n-1 n−1 次循环，每次循环调用一次 down\_adjust 方法，第二步的计算规模是  ( n − 1 ) ∗ log ⁡ 2 n (n-1) \* \\log\_2^n (n−1)∗log2n ，时间复杂度  O ( n ∗ log ⁡ 2 n ) O(n \* \\log\_2^n) O(n∗log2n)。

两个步骤是并列关系，整体的时间复杂度同样是  O ( n ∗ log ⁡ 2 n ) O(n \* \\log\_2^n) O(n∗log2n)。

因为没有开辟额外的集合空间，堆排序空间复杂度为  O ( 1 ) O(1) O(1)。

堆排序和快速排序的平均时间复杂度都是  O ( n ∗ log ⁡ 2 n ) O(n \* \\log\_2^n) O(n∗log2n)，它们都是不稳定排序。

快速排序的最坏时间复杂度是  O ( n 2 ) O(n^2) O(n2)，而堆排序的最坏时间复杂度稳定在  O ( n ∗ log ⁡ 2 n ) O(n \* \\log\_2^n) O(n∗log2n)。

快速排序的递归和非递归方法空间复杂度都是  O ( n ) O(n) O(n)，而堆排序的空间复杂度是  O ( 1 ) O(1) O(1)。

## References ##

[http://www.cxyxiaowu.com/author/cxyxiaohuihui][http_www.cxyxiaowu.com_author_cxyxiaohuihui]  
[https://www.cxyxiaowu.com/5352.html][https_www.cxyxiaowu.com_5352.html]  
[https://www.cxyxiaowu.com/5393.html][https_www.cxyxiaowu.com_5393.html]  
[https://blog.csdn.net/bjweimengshu][https_blog.csdn.net_bjweimengshu]  
[https://github.com/raywenderlich/swift-algorithm-club/tree/master/Heap][https_github.com_raywenderlich_swift-algorithm-club_tree_master_Heap]  
[https://prepinsta.com/cpp-program/heap-sort/][https_prepinsta.com_cpp-program_heap-sort]

https://codechina.org/2019/05/leetcode-heap-heapsort/  
https://www.pianshen.com/article/8904380352/  
https://www.jianshu.com/p/6b526aa481b1

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/1a25442f8745403b93b2818072bf366a.png
[20210216185928245.png_pic_center]: /images/20221024/e7a3b4b0f59d4af288e01a4c16ddd880.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221024/8aed2a29d4ff4a27bdd26ea72964b8fc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221024/2be164a5b8df4c9e98029b6a3b129217.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221024/23e0248cdd6544afac39e4314bcd98a1.png
[20210216210005376.png_pic_center]: /images/20221024/07d12c69d5c44f92afa4efbd0a915339.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221024/3cb984721a7343a9bed62344f09178d3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221024/c0013c5330884fdca12284fc2b579bce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221024/4ed12173611b467686aeb16b9a5456ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221024/5e9365f0795e4588b788f6f8851872be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221024/5ec71a96bce245658e7196d165f0584e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221024/b20358b7039e4447a883b302c14bbf27.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221024/f1683592b4eb42e992cc157d75a9a22d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221024/d69d53b7996e4003a6b78f52afd323dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221024/bfe8edfe39a84c32b15e8dd54260b3b8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221024/116126f1c7bf43509bb7955baa570842.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20221024/b1642298407e4edc84aef21ebdd19098.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20221024/9885514a873e48629a8d6c95279b9d41.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70]: /images/20221024/4285f32a5f4c407188b6cc68c4af24f4.png
[20210217133459850.png_pic_center]: /images/20221024/bfa0685529f549a09556387d2f8603fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20221024/7c69b9b7c3394b1b9b38e13f4731efd9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 17]: /images/20221024/52decc8728974fa4a009ec58480a9dcd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 18]: /images/20221024/787aeb9e295c4e4d9a1919f4528b960a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 19]: /images/20221024/37551f5be03c4adda119baf0f80f5e4e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 20]: /images/20221024/cf3ad168cc624255befc0714671ba701.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 21]: /images/20221024/aa921fabd1a54cada4bf77bb873c0f66.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5neXExMTY_size_16_color_FFFFFF_t_70_pic_center 22]: /images/20221024/b0e907d5e0cc40e69cfa3133be546a66.png
[20210217134041612.png_pic_center]: /images/20221024/4c2e2a3440834222b34fc61858206a07.png
[http_www.cxyxiaowu.com_author_cxyxiaohuihui]: http://www.cxyxiaowu.com/author/cxyxiaohuihui
[https_www.cxyxiaowu.com_5352.html]: https://www.cxyxiaowu.com/5352.html
[https_www.cxyxiaowu.com_5393.html]: https://www.cxyxiaowu.com/5393.html
[https_blog.csdn.net_bjweimengshu]: https://blog.csdn.net/bjweimengshu
[https_github.com_raywenderlich_swift-algorithm-club_tree_master_Heap]: https://github.com/raywenderlich/swift-algorithm-club/tree/master/Heap
[https_prepinsta.com_cpp-program_heap-sort]: https://prepinsta.com/cpp-program/heap-sort/