hello-algo/docs/chapter_heap/heap.md
2023-01-10 02:21:09 +08:00

258 lines
9.9 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# 堆
「堆 Heap」是一种特殊的树状数据结构并且是一颗「完全二叉树」。堆主要分为两种
- 「大顶堆 Max Heap」任意结点的值 $\geq$ 其子结点的值,因此根结点的值最大;
- 「小顶堆 Min Heap」任意结点的值 $\leq$ 其子结点的值,因此根结点的值最小;
(图)
!!! tip ""
大顶堆和小顶堆的定义、性质、操作本质上是相同的,区别只是大顶堆在求最大值,小顶堆在求最小值。
## 堆常用操作
值得说明的是,多数编程语言提供的是「优先队列 Priority Queue」其是一种抽象数据结构**定义为具有出队优先级的队列**。
而恰好,堆的定义与优先队列的操作逻辑完全吻合,大顶堆就是一个元素从大到小出队的优先队列。从使用角度看,我们可以将「优先队列」和「堆」理解为等价的数据结构。因此,本文与代码对两者不做特别区分,统一使用「堆」来命名。
堆的常用操作见下表(方法命名以 Java 为例)。
<p align="center"> Table. 堆的常用操作 </p>
<div class="center-table" markdown>
| 方法 | 描述 | 时间复杂度 |
| --------- | -------------------------------------------- | ----------- |
| add() | 元素入堆 | $O(\log n)$ |
| poll() | 堆顶元素出堆 | $O(\log n)$ |
| peek() | 访问堆顶元素(大 / 小顶堆分别为最大 / 小值) | $O(1)$ |
| size() | 获取堆的元素数量 | $O(1)$ |
| isEmpty() | 判断堆是否为空 | $O(1)$ |
</div>
我们可以直接使用编程语言提供的堆类(或优先队列类)。
```java
/* 初始化堆 */
// 初始化小顶堆
Queue<Integer> minHeap = new PriorityQueue<>();
// 初始化大顶堆(使用 lambda 表达式修改 Comparator 即可)
Queue<Integer> maxHeap = new PriorityQueue<>((a, b) -> { return b - a; });
/* 元素入堆 */
maxHeap.add(1);
maxHeap.add(3);
maxHeap.add(2);
maxHeap.add(5);
maxHeap.add(4);
/* 获取堆顶元素 */
int peek = maxHeap.peek();
/* 堆顶元素出堆 */
int val = heap.poll();
/* 获取堆大小 */
int size = maxHeap.size();
/* 判断堆是否为空 */
boolean isEmpty = maxHeap.isEmpty();
/* 输入列表并建堆 */
// 时间复杂度为 O(n) ,而非 O(nlogn)
minHeap = new PriorityQueue<>(Arrays.asList(1, 3, 2, 5, 4));
```
## 堆的实现
!!! tip
下文使用「大顶堆」来举例,将所有 $>$ ($<$) 替换为 $<$ ($>$) 即可实现「小顶堆」。
### 堆的存储与表示
在二叉树章节我们学过,「完全二叉树」非常适合使用「数组」来表示,而堆恰好是一颗完全二叉树,因而我们一般使用「数组」来存储「堆」。
**二叉树指针**。使用数组表示二叉树时,数组元素都代表结点值,索引代表结点在二叉树中的位置,**结点指针通过索引映射公式来实现**。具体地,给定索引 $i$ ,那么其左子结点索引为 $2i + 1$ 、右子结点索引为 $2i + 2$ 、父结点索引为 $(i - 1) / 2$ (向下整除)。当索引越界时,代表空结点或结点不存在。我们将以上映射公式封装成函数,以便使用。
(图)
```java
// 使用列表而非数组,这样无需考虑扩容问题
List<Integer> maxHeap;
/* 构造函数,建立空堆 */
public MaxHeap() {
maxHeap = new ArrayList<>();
}
/* 获取左子结点索引 */
int left(int i) {
return 2 * i + 1;
}
/* 获取右子结点索引 */
int right(int i) {
return 2 * i + 2;
}
/* 获取父结点索引 */
int parent(int i) {
return (i - 1) / 2; // 向下整除
}
```
### 访问堆顶元素
堆顶元素是二叉树的根结点,即列表首元素。
```java
/* 访问堆顶元素 */
public int peek() {
return maxHeap.get(0);
}
```
### 元素入堆
给定元素 `val` ,我们先将其添加到堆的末尾。由于 `val` 可能大于其它元素,此时堆的性质可能被破坏了,我们需要修复从插入结点到根结点这条路径上的各个结点,该操作被称为「堆化 Heapify」。
考虑从入堆结点开始,**从底至顶执行堆化**。具体地,比较插入结点与其父结点的值,若插入结点更大则将它们交换;并循环以上操作,从底至顶地修复堆中的各个结点;直至越过根结点时结束,或当遇到无需交换的结点时提前结束。
设堆长度为 $n$ **元素入堆操作的时间复杂度为 $O(\log n)$** 。这是因为树的高度为 $O(\log n)$ ,因此堆化操作的循环轮数最多为 $O(\log n)$ 。
(图)
```java
/* 元素入堆 */
void push(int val) {
// 添加结点
maxHeap.add(val);
// 从底至顶堆化
siftUp(size() - 1);
}
/* 从结点 i 开始,从底至顶堆化 */
void siftUp(int i) {
while (true) {
// 获取结点 i 的父结点
int p = parent(i);
// 若“越过根结点”或“结点无需修复”,则结束堆化
if (p < 0 || maxHeap.get(i) <= maxHeap.get(p))
break;
// 交换两结点
swap(i, p);
// 循环向上堆化
i = p;
}
}
```
### 堆顶元素出堆
堆顶元素是二叉树根结点,即列表首元素,如果我们直接将首元素从列表中删除,则二叉树中所有结点都产生移位,这样后续使用堆化修复就很麻烦了。为了尽量减少二叉树结点变动,采取以下操作步骤:
1. 交换列表首元素与尾元素(即交换根结点与最右叶结点);
2. 将尾元素从列表中删除(此时堆顶元素已被删除);
3. 从根结点开始,从顶至底堆化;
顾名思义,**从顶至底堆化的操作方向与从底至顶堆化相反**,我们比较根结点的值与其两个子结点的值,将最大的子结点与根结点执行交换,并循环以上操作,直到越过叶结点时结束,或当遇到无需交换的结点时提前结束。
(图)
```java
/* 元素出堆 */
int poll() {
// 判空处理
if (isEmpty())
throw new EmptyStackException();
// 交换根结点与最右叶结点(即交换首元素与尾元素)
swap(0, size() - 1);
// 删除结点
int val = maxHeap.remove(size() - 1);
// 从顶至底堆化
siftDown(0);
// 返回堆顶元素
return val;
}
/* 从结点 i 开始,从顶至底堆化 */
void siftDown(int i) {
while (true) {
// 判断结点 i, l, r 中值最大的结点,记为 ma
int l = left(i), r = right(i), ma = i;
if (l < size() && maxHeap.get(l) > maxHeap.get(ma))
ma = l;
if (r < size() && maxHeap.get(r) > maxHeap.get(ma))
ma = r;
// 若“结点 i 最大”或“越过叶结点”,则结束堆化
if (ma == i) break;
// 交换两结点
swap(i, ma);
// 循环向下堆化
i = ma;
}
}
```
### 输入数据并建堆 *
给定一个列表,我们也可以将其建堆。最直接地,可以通过调用「元素入堆」方法,将列表元素依次入堆。元素入堆的时间复杂度为 $O(n)$ ,而平均长度为 $\frac{n}{2}$ ,因此该方法的总体时间复杂度为 $O(n \log n)$ 。
然而,存在一种更加优雅的建堆方法。设结点数量为 $n$ ,我们先将列表所有元素原封不动添加进堆,**然后迭代地对各个结点执行「从顶至底堆化」**。当然,**无需对叶结点执行堆化,**因为其没有子结点。
```java
/* 构造函数,根据输入列表建堆 */
public MaxHeap(List<Integer> nums) {
// 将列表元素原封不动添加进堆
maxHeap = new ArrayList<>(nums);
// 堆化除叶结点以外的其他所有结点
for (int i = parent(size() - 1); i >= 0; i--) {
siftDown(i);
}
}
```
!!! tip
完全二叉树的叶结点数量为 $(n + 1) / 2$ ,其中 $/$ 为向下整除。
那么,第二种建堆方法的时间复杂度时多少呢?我们来做一下简单推算。叶结点和需要堆化结点的数量各占约一半,即为 $O(n)$ ,二叉树高度为 $O(\log n)$ ,可得时间复杂度为 $O(n \log n)$ 。该估算结果仍不够准确,因为我们没有考虑到二叉树“底层结点远多于顶层结点”的性质。
设二叉树(即堆)结点数量为 $n$ ,树高度为 $h$ 。如下图所示,我们将各层的“结点数量 $\times$ 子树高度”进行求和,即可得到准确的操作数量。
$$
S = 2^0h + 2^1(h-1) + 2^2(h-2) + \cdots + 2^{(h-1)}\times1
$$
(图)
求解上式需要借助中学的数列知识,先对 $S$ 乘以 $2$ ,可得
$$
\begin{aligned}
S & = 2^0h + 2^1(h-1) + 2^2(h-2) + \cdots + 2^{h-1}\times1 \\
2S & = 2^1h + 2^2(h-1) + 2^3(h-2) + \cdots + 2^{h}\times1 \\
\end{aligned}
$$
令下式 $2S$ 与上式 $S$ 错位相减,易得
$$
2S - S = S = -2^0h + 2^1 + 2^2 + \cdots + 2^{h-1} + 2^h
$$
观察发现,$S$ 是一个等比数列,可直接借助公式求和。并且,对于高度为 $h$ 的完全二叉树,结点数量范围为 $n \in [2^h, 2^{h+1} - 1]$ ,复杂度为 $n = O(n) = O(2^h)$。
$$
\begin{aligned}
S & = 2 \frac{1 - 2^h}{1 - 2} - h \\
& = 2^{h+1} - h \\
& = O(2^h) = O(n)
\end{aligned}
$$
以上推算表明,输入列表并建堆的时间复杂度为 $O(n)$ ,非常高效。
## 堆常见应用
- **优先队列**。堆常作为实现优先队列的首选数据结构,入队和出队操作时间复杂度为 $O(\log n)$ ,建队操作为 $O(n)$ ,皆非常高效。
- **堆排序**。给定一组数据,我们使用其建堆,并依次全部弹出,则可以得到有序的序列。当然,堆排序一般无需弹出元素,仅需每轮将堆顶元素交换至数组尾部并减小堆的长度即可。
- **获取最大的 $k$ 个元素**。这既是一道经典算法题目,也是一种常见应用,例如选取热度前 10 的新闻作为微博热搜,选取前 10 销量的商品等。