xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-08-13 20:20:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2023-12-28 17:18:37 +08:00
parent 8d49c46234
commit d1f1473539
67 changed files with 604 additions and 609 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/chapter_heap/build_heap.md
+2 -2
View File
@@ -223,7 +223,7 @@ $$
T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \dots + 2^{(h-1)}\times1
$$
化简上式需要借助中学的数列知识，先对 $T(h)$ 乘以 $2$ ，得到：
化简上式需要借助中学的数列知识，将对 $T(h)$ 乘以 $2$ ，得到：
$$
\begin{aligned}
@@ -248,4 +248,4 @@ T(h) & = 2 \frac{1 - 2^h}{1 - 2} - h \newline
\end{aligned}
$$
进一步地，高度为 $h$ 的完美二叉树的节点数量为 $n = 2^{h+1} - 1$ ，易得复杂度为 $O(2^h) = O(n)$ 。以上推算表明，**输入列表并建堆的时间复杂度为 $O(n)$ ，非常高效**。
进一步，高度为 $h$ 的完美二叉树的节点数量为 $n = 2^{h+1} - 1$ ，易得复杂度为 $O(2^h) = O(n)$ 。以上推算表明，**输入列表并建堆的时间复杂度为 $O(n)$ ，非常高效**。
docs/chapter_heap/heap.md
+50 -50
View File
@@ -6,8 +6,8 @@ comments: true
「堆 heap」是一种满足特定条件的完全二叉树，主要可分为两种类型，如图 8-1 所示。
- 「大顶堆 max heap」：任意节点的值 $\geq$ 其子节点的值。
- 「小顶堆 min heap」：任意节点的值 $\leq$ 其子节点的值。
- 「大顶堆 max heap」：任意节点的值 $\geq$ 其子节点的值。
![小顶堆与大顶堆](heap.assets/min_heap_and_max_heap.png){ class="animation-figure" }
@@ -17,11 +17,11 @@ comments: true
- 最底层节点靠左填充，其他层的节点都被填满。
- 我们将二叉树的根节点称为“堆顶”，将底层最靠右的节点称为“堆底”。
- 对于大顶堆（小顶堆），堆顶元素（根节点）的值分别是最大（最小）的。
- 对于大顶堆（小顶堆），堆顶元素（根节点）的值是最大（最小）的。
## 8.1.1   堆常用操作
## 8.1.1   堆的常用操作
需要指出的是，许多编程语言提供的是「优先队列 priority queue」，这是一种抽象数据结构，定义为具有优先级排序的队列。
需要指出的是，许多编程语言提供的是「优先队列 priority queue」，这是一种抽象的数据结构，定义为具有优先级排序的队列。
实际上，**堆通常用于实现优先队列，大顶堆相当于元素按从大到小的顺序出队的优先队列**。从使用角度来看，我们可以将“优先队列”和“堆”看作等价的数据结构。因此，本书对两者不做特别区分，统一称作“堆”。
@@ -31,13 +31,13 @@ comments: true
<div class="center-table" markdown>
| 方法名 | 描述 | 时间复杂度 |
| --------- | -------------------------------------------- | ----------- |
| push() | 元素入堆 | $O(\log n)$ |
| pop() | 堆顶元素出堆 | $O(\log n)$ |
| peek() | 访问堆顶元素（大 / 小顶堆分别为最大 / 小值） | $O(1)$ |
| size() | 获取堆的元素数量 | $O(1)$ |
| isEmpty() | 判断堆是否为空 | $O(1)$ |
| 方法名 | 描述 | 时间复杂度 |
| ----------- | ------------------------------------------------ | ----------- |
| `push()` | 元素入堆 | $O(\log n)$ |
| `pop()` | 堆顶元素出堆 | $O(\log n)$ |
| `peek()` | 访问堆顶元素（对于大 / 小顶堆分别为最大 / 小值） | $O(1)$ |
| `size()` | 获取堆的元素数量 | $O(1)$ |
| `isEmpty()` | 判断堆是否为空 | $O(1)$ |
</div>
@@ -363,7 +363,7 @@ comments: true
当使用数组表示二叉树时，元素代表节点值，索引代表节点在二叉树中的位置。**节点指针通过索引映射公式来实现**。
如图 8-2 所示，给定索引 $i$ ，其左子节点索引为 $2i + 1$ ，右子节点索引为 $2i + 2$ ，父节点索引为 $(i - 1) / 2$（向下整除）。当索引越界时，表示空节点或节点不存在。
如图 8-2 所示，给定索引 $i$ ，其左子节点的索引为 $2i + 1$ ，右子节点的索引为 $2i + 2$ ，父节点的索引为 $(i - 1) / 2$（向下整除）。当索引越界时，表示空节点或节点不存在。
![堆的表示与存储](heap.assets/representation_of_heap.png){ class="animation-figure" }
@@ -375,32 +375,32 @@ comments: true
```python title="my_heap.py"
def left(self, i: int) -> int:
"""获取左子节点索引"""
"""获取左子节点的索引"""
return 2 * i + 1
def right(self, i: int) -> int:
"""获取右子节点索引"""
"""获取右子节点的索引"""
return 2 * i + 2
def parent(self, i: int) -> int:
"""获取父节点索引"""
"""获取父节点的索引"""
return (i - 1) // 2 # 向下整除
```
=== "C++"
```cpp title="my_heap.cpp"
/* 获取左子节点索引 */
/* 获取左子节点的索引 */
int left(int i) {
return 2 * i + 1;
}
/* 获取右子节点索引 */
/* 获取右子节点的索引 */
int right(int i) {
return 2 * i + 2;
}
/* 获取父节点索引 */
/* 获取父节点的索引 */
int parent(int i) {
return (i - 1) / 2; // 向下整除
}
@@ -409,17 +409,17 @@ comments: true
=== "Java"
```java title="my_heap.java"
/* 获取左子节点索引 */
/* 获取左子节点的索引 */
int left(int i) {
return 2 * i + 1;
}
/* 获取右子节点索引 */
/* 获取右子节点的索引 */
int right(int i) {
return 2 * i + 2;
}
/* 获取父节点索引 */
/* 获取父节点的索引 */
int parent(int i) {
return (i - 1) / 2; // 向下整除
}
@@ -428,17 +428,17 @@ comments: true
=== "C#"
```csharp title="my_heap.cs"
/* 获取左子节点索引 */
/* 获取左子节点的索引 */
int Left(int i) {
return 2 * i + 1;
}
/* 获取右子节点索引 */
/* 获取右子节点的索引 */
int Right(int i) {
return 2 * i + 2;
}
/* 获取父节点索引 */
/* 获取父节点的索引 */
int Parent(int i) {
return (i - 1) / 2; // 向下整除
}
@@ -447,17 +447,17 @@ comments: true
=== "Go"
```go title="my_heap.go"
/* 获取左子节点索引 */
/* 获取左子节点的索引 */
func (h *maxHeap) left(i int) int {
return 2*i + 1
}
/* 获取右子节点索引 */
/* 获取右子节点的索引 */
func (h *maxHeap) right(i int) int {
return 2*i + 2
}
/* 获取父节点索引 */
/* 获取父节点的索引 */
func (h *maxHeap) parent(i int) int {
// 向下整除
return (i - 1) / 2
@@ -467,17 +467,17 @@ comments: true
=== "Swift"
```swift title="my_heap.swift"
/* 获取左子节点索引 */
/* 获取左子节点的索引 */
func left(i: Int) -> Int {
2 * i + 1
}
/* 获取右子节点索引 */
/* 获取右子节点的索引 */
func right(i: Int) -> Int {
2 * i + 2
}
/* 获取父节点索引 */
/* 获取父节点的索引 */
func parent(i: Int) -> Int {
(i - 1) / 2 // 向下整除
}
@@ -486,17 +486,17 @@ comments: true
=== "JS"
```javascript title="my_heap.js"
/* 获取左子节点索引 */
/* 获取左子节点的索引 */
#left(i) {
return 2 * i + 1;
}
/* 获取右子节点索引 */
/* 获取右子节点的索引 */
#right(i) {
return 2 * i + 2;
}
/* 获取父节点索引 */
/* 获取父节点的索引 */
#parent(i) {
return Math.floor((i - 1) / 2); // 向下整除
}
@@ -505,17 +505,17 @@ comments: true
=== "TS"
```typescript title="my_heap.ts"
/* 获取左子节点索引 */
/* 获取左子节点的索引 */
left(i: number): number {
return 2 * i + 1;
}
/* 获取右子节点索引 */
/* 获取右子节点的索引 */
right(i: number): number {
return 2 * i + 2;
}
/* 获取父节点索引 */
/* 获取父节点的索引 */
parent(i: number): number {
return Math.floor((i - 1) / 2); // 向下整除
}
@@ -524,17 +524,17 @@ comments: true
=== "Dart"
```dart title="my_heap.dart"
/* 获取左子节点索引 */
/* 获取左子节点的索引 */
int _left(int i) {
return 2 * i + 1;
}
/* 获取右子节点索引 */
/* 获取右子节点的索引 */
int _right(int i) {
return 2 * i + 2;
}
/* 获取父节点索引 */
/* 获取父节点的索引 */
int _parent(int i) {
return (i - 1) ~/ 2; // 向下整除
}
@@ -543,17 +543,17 @@ comments: true
=== "Rust"
```rust title="my_heap.rs"
/* 获取左子节点索引 */
/* 获取左子节点的索引 */
fn left(i: usize) -> usize {
2 * i + 1
}
/* 获取右子节点索引 */
/* 获取右子节点的索引 */
fn right(i: usize) -> usize {
2 * i + 2
}
/* 获取父节点索引 */
/* 获取父节点的索引 */
fn parent(i: usize) -> usize {
(i - 1) / 2 // 向下整除
}
@@ -562,17 +562,17 @@ comments: true
=== "C"
```c title="my_heap.c"
/* 获取左子节点索引 */
/* 获取左子节点的索引 */
int left(MaxHeap *maxHeap, int i) {
return 2 * i + 1;
}
/* 获取右子节点索引 */
/* 获取右子节点的索引 */
int right(MaxHeap *maxHeap, int i) {
return 2 * i + 2;
}
/* 获取父节点索引 */
/* 获取父节点的索引 */
int parent(MaxHeap *maxHeap, int i) {
return (i - 1) / 2;
}
@@ -581,17 +581,17 @@ comments: true
=== "Zig"
```zig title="my_heap.zig"
// 获取左子节点索引
// 获取左子节点的索引
fn left(i: usize) usize {
return 2 * i + 1;
}
// 获取右子节点索引
// 获取右子节点的索引
fn right(i: usize) usize {
return 2 * i + 2;
}
// 获取父节点索引
// 获取父节点的索引
fn parent(i: usize) usize {
// return (i - 1) / 2; // 向下整除
return @divFloor(i - 1, 2);
@@ -711,7 +711,7 @@ comments: true
### 3. &nbsp; 元素入堆
给定元素 `val` ，我们首先将其添加到堆底。添加之后，由于 val 可能大于堆中其他元素，堆的成立条件可能已被破坏，**因此需要修复从插入节点到根节点的路径上的各个节点**，这个操作被称为「堆化 heapify」。
给定元素 `val` ，我们首先将其添加到堆底。添加之后，由于 `val` 可能大于堆中其他元素，堆的成立条件可能已被破坏，**因此需要修复从插入节点到根节点的路径上的各个节点**，这个操作被称为「堆化 heapify」。
考虑从入堆节点开始，**从底至顶执行堆化**。如图 8-3 所示，我们比较插入节点与其父节点的值，如果插入节点更大，则将它们交换。然后继续执行此操作，从底至顶修复堆中的各个节点，直至越过根节点或遇到无须交换的节点时结束。
@@ -1597,7 +1597,7 @@ comments: true
}
```
## 8.1.3 &nbsp; 堆常见应用
## 8.1.3 &nbsp; 堆的常见应用
- **优先队列**：堆通常作为实现优先队列的首选数据结构，其入队和出队操作的时间复杂度均为 $O(\log n)$ ，而建队操作为 $O(n)$ ，这些操作都非常高效。
- **堆排序**：给定一组数据，我们可以用它们建立一个堆，然后不断地执行元素出堆操作，从而得到有序数据。然而，我们通常会使用一种更优雅的方式实现堆排序，详见“堆排序”章节。
docs/chapter_heap/index.md
+1 -1
View File
@@ -21,5 +21,5 @@ icon: material/family-tree
- [8.1 &nbsp; 堆](https://www.hello-algo.com/chapter_heap/heap/)
- [8.2 &nbsp; 建堆操作](https://www.hello-algo.com/chapter_heap/build_heap/)
- [8.3 &nbsp; Top-K 问题](https://www.hello-algo.com/chapter_heap/top_k/)
- [8.3 &nbsp; Top-k 问题](https://www.hello-algo.com/chapter_heap/top_k/)
- [8.4 &nbsp; 小结](https://www.hello-algo.com/chapter_heap/summary/)
docs/chapter_heap/summary.md
+2 -2
View File
@@ -12,10 +12,10 @@ comments: true
- 完全二叉树非常适合用数组表示，因此我们通常使用数组来存储堆。
- 堆化操作用于维护堆的性质，在入堆和出堆操作中都会用到。
- 输入 $n$ 个元素并建堆的时间复杂度可以优化至 $O(n)$ ，非常高效。
- Top-K 是一个经典算法问题，可以使用堆数据结构高效解决，时间复杂度为 $O(n \log k)$ 。
- Top-k 是一个经典算法问题，可以使用堆数据结构高效解决，时间复杂度为 $O(n \log k)$ 。
### 2. &nbsp; Q & A
!!! question "数据结构的“堆”与内存管理的“堆”是同一个概念吗？"
两者不是同一个概念，只是碰巧都叫堆。计算机系统内存中的堆是动态内存分配的一部分，程序在运行时可以使用它来存储数据。程序可以请求一定量的堆内存，用于存储如对象和数组等复杂结构。当这些数据不再需要时，程序需要释放这些内存，以防止内存泄漏。相较于栈内存，堆内存的管理和使用需要更谨慎，使用不当可能会导致内存泄漏和野指针等问题。
两者不是同一个概念，只是碰巧都叫“堆”。计算机系统内存中的堆是动态内存分配的一部分，程序在运行时可以使用它来存储数据。程序可以请求一定量的堆内存，用于存储如对象和数组等复杂结构。当这些数据不再需要时，程序需要释放这些内存，以防止内存泄漏。相较于栈内存，堆内存的管理和使用需要更谨慎，使用不当可能会导致内存泄漏和野指针等问题。
docs/chapter_heap/top_k.md
+4 -4
View File
@@ -2,11 +2,11 @@
comments: true
---
# 8.3 &nbsp; Top-K 问题
# 8.3 &nbsp; Top-k 问题
!!! question
给定一个长度为 $n$ 的无序数组 `nums` ，请返回数组中前 $k$ 大的元素。
给定一个长度为 $n$ 的无序数组 `nums` ，请返回数组中最大的 $k$ 个元素。
对于该问题，我们先介绍两种思路比较直接的解法，再介绍效率更高的堆解法。
@@ -36,7 +36,7 @@ comments: true
## 8.3.3 &nbsp; 方法三：堆
我们可以基于堆更加高效地解决 Top-K 问题，流程如图 8-8 所示。
我们可以基于堆更加高效地解决 Top-k 问题，流程如图 8-8 所示。
1. 初始化一个小顶堆，其堆顶元素最小。
2. 先将数组的前 $k$ 个元素依次入堆。
@@ -419,4 +419,4 @@ comments: true
总共执行了 $n$ 轮入堆和出堆，堆的最大长度为 $k$ ，因此时间复杂度为 $O(n \log k)$ 。该方法的效率很高，当 $k$ 较小时，时间复杂度趋向 $O(n)$ ；当 $k$ 较大时，时间复杂度不会超过 $O(n \log n)$ 。
另外，该方法适用于动态数据流的使用场景。在不断加入数据时，我们可以持续维护堆内的元素，从而实现最大 $k$ 个元素的动态更新。
另外，该方法适用于动态数据流的使用场景。在不断加入数据时，我们可以持续维护堆内的元素，从而实现最大的 $k$ 个元素的动态更新。