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

1. 什么是堆？

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

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

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

2. 堆的性质

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

---

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

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

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

完全二叉树示例

        10/  \5    15/ \   /2   7 12

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

二叉搜索树示例

        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

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

• 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）。

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

• 当前堆顶是 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] < heap[rightChild]){largest = rightChild;}if (largest != idx) {swap(heap[idx], heap[largest]);idx = largest;} else {break;}}
}

4.2 C++ 实现最大堆

这里展示一个封装成对象的大根堆

#include <iostream>
#include <vector>
#include <algorithm>class MaxHeap {
private:std::vector<int> heap;void heapifyUp(int index) {while (index > 0) {int parentIndex = (index - 1) / 2;if (heap[index] > heap[parentIndex]) {std::swap(heap[index], heap[parentIndex]);index = parentIndex;} else {break;}}}void heapifyDown(int index) {int size = heap.size();while (true) {int leftChild = 2 * index + 1;int rightChild = 2 * index + 2;int largest = index;if (leftChild < size && heap[leftChild] > heap[largest]) {largest = leftChild;}if (rightChild < size && heap[rightChild] > heap[largest]) {largest = rightChild;}if (largest != index) {std::swap(heap[index], heap[largest]);index = largest;} else {break;}}}public:void insert(int value) {heap.push_back(value);heapifyUp(heap.size() - 1);}int extractMax() {if (heap.empty()) {throw std::out_of_range("Heap is empty");}int maxValue = heap[0];heap[0] = heap.back();heap.pop_back();heapifyDown(0);return maxValue;}void buildHeap(const std::vector<int>& array) {heap = array;for (int i = (heap.size() / 2) - 1; i >= 0; --i) {heapifyDown(i);}}void printHeap() const {for (int value : heap) {std::cout << value << " ";}std::cout << std::endl;}
};int main() {MaxHeap maxHeap;maxHeap.insert(10);maxHeap.insert(20);maxHeap.insert(15);maxHeap.insert(30);maxHeap.insert(40);std::cout << "Max Heap: ";maxHeap.printHeap();std::cout << "Extracted Max: " << maxHeap.extractMax() << std::endl;std::cout << "Max Heap after extraction: ";maxHeap.printHeap();std::vector<int> array = {5, 3, 8, 1, 9};maxHeap.buildHeap(array);std::cout << "Max Heap built from array: ";maxHeap.printHeap();return 0;
}

4.2 代码解析

• heapifyUp：用于在插入新元素后，从下往上调整堆，确保堆的性质。
• heapifyDown：用于在删除堆顶元素后，从上往下调整堆，确保堆的性质。
• insert：将新元素插入堆中，并调用 heapifyUp 进行调整。
• extractMax：删除并返回堆顶元素，然后调用 heapifyDown 进行调整。
• buildHeap：将一个无序数组构建成一个堆。

5. 堆的应用

• 优先队列：堆是实现优先队列的理想数据结构，因为可以快速获取和删除最大或最小元素。
• 堆排序：堆排序是一种基于堆的比较排序算法，时间复杂度为 O(n log n)。
• Dijkstra算法：在图的单源最短路径算法中，堆用于高效地选择下一个要处理的节点。

6. 总结

堆是一种非常高效的数据结构，特别适用于需要频繁获取最大或最小元素的场景。通过数组实现堆，可以充分利用其完全二叉树的性质，使得插入、删除和构建堆的操作都能在 O(log n) 的时间内完成。

7.练习

ACWing模拟堆
这个题相较普通的堆，增添了一个需要维护的对象，就是这个数字是第几次插入的。所以我们需要额外维护两个数组pos和inv_pos，分别表示第k个插入的数在堆数组中的索引，和堆数组中第i个数是第几个插入的，完整代码如下：

#include <iostream>
#include <cstring>
#include <string>
using namespace std;
const int maxn = 1e5 + 7;
int heap[maxn], top;
int pos[maxn], inv_pos[maxn];
void heap_swap(int a, int b){swap(heap[a], heap[b]);swap(pos[inv_pos[a]], pos[inv_pos[b]]);swap(inv_pos[a], inv_pos[b]);
}
void down(int idx){while(1){int leftChild = idx * 2;int rightChild = idx * 2 + 1;int smallest = idx;if(leftChild <= top && heap[leftChild] < heap[smallest])smallest = leftChild;if(rightChild <= top && heap[rightChild] < heap[smallest])smallest = rightChild;if(idx != smallest) {heap_swap(idx, smallest);idx = smallest;}elsebreak;}
}
void up(int idx){while(idx != 1){int parent = idx >> 1;if(heap[parent] > heap[idx]){heap_swap(idx, parent);idx = parent;}else{break;}}
}
int main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int n;cin>>n;string op;int x, k, cnt = 0;while(n--){cin>>op;if(op == "I"){cin>>x;heap[++top] = x;pos[++cnt] = top;inv_pos[top] = cnt;up(top);}else if(op == "PM"){cout<<heap[1]<<endl;}else if(op == "DM"){heap_swap(1, top);top--;down(1);}else if(op == "D"){cin>>k;int now = pos[k];heap_swap(now, top);top --;down(now);up(now);}else if(op == "C"){cin>>k>>x;heap[pos[k]] = x;up(pos[k]);down(pos[k]);}}return 0;
}