堆（Heap）的原理与C++实现

最新推荐文章于 2025-06-20 09:50:43 发布

Lostgreen

最新推荐文章于 2025-06-20 09:50:43 发布

阅读量1.6k

点赞数 45

CC 4.0 BY-SA版权

分类专栏：数据结构&算法文章标签：数据结构堆堆排序

本文链接：https://blog.csdn.net/qqqqqwerttwtwe/article/details/145458329

1. 什么是堆？

堆（Heap）是一种特殊的树形数据结构，通常用于实现优先队列。堆可以分为两种类型：

最大堆（Max Heap）：每个节点的值都大于或等于其子节点的值。
最小堆（Min Heap）：每个节点的值都小于或等于其子节点的值。

堆通常是一个完全二叉树，这意味着除了最后一层，其他层都是完全填满的，并且最后一层的节点都尽可能地靠左排列。

2. 堆的性质

完全二叉树：堆是一个完全二叉树，这意味着它可以用数组来高效地表示。
堆序性质：在最大堆中，父节点的值总是大于或等于其子节点的值；在最小堆中，父节点的值总是小于或等于其子节点的值。

Tips: 堆是`完全二叉树`，并非`二叉搜索树`

在数据结构中，完全二叉树和二叉搜索树是两种常见的树形结构，它们虽然都属于二叉树的范畴，但在定义、性质和应用场景上有显著的区别。下面我们将详细分析它们的区别。

特性	完全二叉树	二叉搜索树
定义	节点从上到下、从左到右依次填充	左子树 < 根节点 < 右子树
有序性	不一定有序	中序遍历结果有序
结构要求	必须是完全填充的（最后一层靠左）	无特殊结构要求，只需满足有序性
查找效率	不支持高效查找	支持高效查找（平衡时 O(log n)）
插入和删除	通常用于堆操作，不支持动态插入删除	支持动态插入和删除
应用场景	堆、优先队列	查找、排序、数据库索引
数组表示	可以用数组高效表示	通常用指针或引用表示

完全二叉树示例

节点从上到下、从左到右依次填充。
最后一层的节点靠左排列。

二叉搜索树示例

        10
       /  \
      5    15
     / \   / \
    2   7 12 20

左子树的所有节点值小于根节点，右子树的所有节点值大于根节点。
中序遍历结果为 [2, 5, 7, 10, 12, 15, 20]，是一个有序序列。

3. 堆的操作

堆的主要操作包括：

插入（Insert）：将一个新元素插入堆中，并保持堆的性质。
删除（Delete）：删除元素，并保持堆的性质。
查询（Query）：查询堆顶元素
构建堆（Build Heap）：将一个无序数组构建成一个堆。

4. 堆的实现

堆通常使用数组来实现。在从数组下标0开始存储的堆，对于一个索引为 i 的节点：

其父节点的索引为 (i - 1) / 2
其左子节点的索引为 2 * i + 1
其右子节点的索引为 2 * i + 2

4.1 堆的性质维护

堆的插入过程

假设我们有一个最大堆，初始堆为：[100, 19, 36, 17, 3, 25, 1, 2, 7]，其对应的完全二叉树结构如下（用数组表示）：

        100
      /     \
    19       36
   /  \     /  \
  17   3   25   1
 / \
2  7

插入一个新元素40
将新元素添加到堆的末尾：堆的数组表示为 [100, 19, 36, 17, 3, 25, 1, 2, 7, 40]，对应的完全二叉树结构如下：

     100
    /      \
   19      36
  /   \    / \
 17    3  25  1
/ \    /
2  7  40

向上调整（上浮）：从新插入的节点开始，与其父节点比较。如果当前节点的值大于父节点的值，则交换它们的位置。

40 的父节点是 3，40 > 3，交换它们的位置：

        100
      /      \
     19       36
    /  \     /  \
   17   40  25   1
  / \   /
 2  7  3

40 的新父节点是 19，40 > 19，交换它们的位置：

      100
    /      \
   40       36
  /  \     /  \
17   19  25   1
/ \   /
2  7 3

40 的新父节点是 100，40 < 100，停止调整。
最终，插入 40 后的堆为：[100, 40, 36, 17, 19, 25, 1, 2, 7, 3]。

总结:堆在插入元素后，需要进行上浮（up）操作，是不断与父节点比较，若父节点小于当前节点，则交换位置。具体代码实现示例如下：

//存储下标从1开始，以大根堆为例
void heap_up(int idx){
   
   
    while(idx != 1){
   
   
        int parent = idx >> 1;
        if(heap[parent] < heap[idx]){
   
   
            swap(heap[parent], heap[idx]);
            idx = parent;
        }
        else{
   
   
            break;
        }
    }
}

堆的删除过程

假设我们从上述堆中删除最大值（堆顶元素 100）。

将堆顶元素与最后一个元素交换：交换 100 和 3 的位置，得到 [3, 40, 36, 17, 19, 25, 1, 2, 7, 100]，然后删除最后一个元素（100），得到 [3, 40, 36, 17, 19, 25, 1, 2, 7]。这是因为我们在用数组存储堆的时候，头部元素的删除面临整个数组的移动，相当消耗计算资源，于是我们选择将头部元素和尾部元素进行交换，进行删除尾部，再调整堆
向下调整（下沉）：从堆顶开始，比较当前节点与其子节点的值，将当前节点与较大的子节点交换，直到满足堆的性质。

当前堆顶是 3，其子节点是 40 和 36，40 > 36，选择 40 与 3 交换得到：

      40
    /      \
   3       36
  /  \     /  \
17   19  25   1
/ \  
2  7

3 的新位置是左子树的根，其子节点是 17 和 19，19 > 17，选择 19 与 3 交换：

      40
    /      \
   19       36
  /  \     /  \
17   3  25   1
/ \  
2  7

最终，删除 100 后的堆为：[40, 19, 36, 17, 3, 25, 1, 2, 7]。

void heap_down(int idx){
   
   
    int size = top;
    while(1){
   
   
        int leftChild = idx * 2;
        int rightChild = idx * 2 + 1;
        int largest = idx;
        if(leftChild < size && heap[largest] < heap[leftChild]){
   
   
            largest = leftChild;
        }
        if(rightChild < size && heap[largest]