Fig. 页面编辑按键
+图：页面编辑按键
图片无法直接修改，需要通过新建 [Issue](https://github.com/krahets/hello-algo/issues) 或评论留言来描述问题，我们会尽快重新绘制并替换图片。 diff --git a/chapter_appendix/installation.md b/chapter_appendix/installation.md index d64477ea0..3a70b5670 100644 --- a/chapter_appendix/installation.md +++ b/chapter_appendix/installation.md @@ -48,7 +48,12 @@ comments: true 1. 下载并安装 [Swift](https://www.swift.org/download/)。 2. 在 VSCode 的插件市场中搜索 `swift` ，安装 [Swift for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=sswg.swift-lang)。 -## 16.1.9. Rust 环境 +## 16.1.9. Dart 环境 + +1. 下载并安装 [Dart](https://dart.dev/get-dart) 。 +2. 在 VSCode 的插件市场中搜索 `dart` ，安装 [Dart](https://marketplace.visualstudio.com/items?itemName=Dart-Code.dart-code) 。 + +## 16.1.10. Rust 环境 1. 下载并安装 [Rust](https://www.rust-lang.org/tools/install)。 2. 在 VSCode 的插件市场中搜索 `rust` ，安装 [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer)。 diff --git a/chapter_array_and_linkedlist/array.md b/chapter_array_and_linkedlist/array.md index 7008d9644..5063d8fb6 100755 --- a/chapter_array_and_linkedlist/array.md +++ b/chapter_array_and_linkedlist/array.md @@ -4,13 +4,17 @@ comments: true # 4.1. 数组 -「数组 Array」是一种线性数据结构，其将相同类型元素存储在连续的内存空间中。我们将元素在数组中的位置称为元素的「索引 Index」。 +「数组 Array」是一种线性数据结构，其将相同类型元素存储在连续的内存空间中。我们将某个元素在数组中的位置称为该元素的「索引 Index」。  -Fig. 数组定义与存储方式
+图：数组定义与存储方式
-**数组初始化**。通常有无初始值和给定初始值两种方式，我们可根据需求选择合适的方法。在大多数编程语言中，若未指定初始值，数组的所有元素通常会被默认初始化为 $0$ 。 +## 4.1.1. 数组常用操作 + +### 初始化数组 + +我们可以根据需求选用数组的两种初始化方式：无初始值、给定初始值。在未指定初始值的情况下，大多数编程语言会将数组元素初始化为 $0$ 。 === "Java" @@ -27,7 +31,7 @@ comments: true // 存储在栈上 int arr[5]; int nums[5] { 1, 3, 2, 5, 4 }; - // 存储在堆上 + // 存储在堆上（需要手动释放空间） int* arr1 = new int[5]; int* nums1 = new int[5] { 1, 3, 2, 5, 4 }; ``` @@ -114,31 +118,27 @@ comments: true let nums: VecFig. 数组元素的内存地址计算
+数组元素被存储在连续的内存空间中，这意味着计算数组元素的内存地址非常容易。给定数组内存地址（即首元素内存地址）和某个元素的索引，我们可以使用以下公式计算得到该元素的内存地址，从而直接访问此元素。 ```shell -# 元素内存地址 = 数组内存地址 + 元素长度 * 元素索引 +# 元素内存地址 = 数组内存地址（首元素内存地址） + 元素长度 * 元素索引 elementAddr = firtstElementAddr + elementLength * elementIndex ``` -!!! question "为什么数组元素的索引要从 $0$ 开始编号呢？" + - 观察上图，我们发现数组首个元素的索引为 $0$ ，这似乎有些反直觉，因为从 $1$ 开始计数会更自然。 - - 然而从地址计算公式的角度看，**索引本质上表示的是内存地址的偏移量**。首个元素的地址偏移量是 $0$ ，因此索引为 $0$ 也是合理的。 +图：数组元素的内存地址计算
-访问元素的高效性带来了诸多便利。例如，我们可以在 $O(1)$ 时间内随机获取数组中的任意一个元素。 +观察上图，我们发现数组首个元素的索引为 $0$ ，这似乎有些反直觉，因为从 $1$ 开始计数会更自然。但从地址计算公式的角度看，**索引的含义本质上是内存地址的偏移量**。首个元素的地址偏移量是 $0$ ，因此它的索引为 $0$ 也是合理的。 + +在数组中访问元素是非常高效的，我们可以在 $O(1)$ 时间内随机访问数组中的任意一个元素。 === "Java" ```java title="array.java" - /* 随机返回一个数组元素 */ + /* 随机访问元素 */ int randomAccess(int[] nums) { // 在区间 [0, nums.length) 中随机抽取一个数字 int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length); @@ -151,7 +151,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "C++" ```cpp title="array.cpp" - /* 随机返回一个数组元素 */ + /* 随机访问元素 */ int randomAccess(int *nums, int size) { // 在区间 [0, size) 中随机抽取一个数字 int randomIndex = rand() % size; @@ -176,7 +176,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "Go" ```go title="array.go" - /* 随机返回一个数组元素 */ + /* 随机访问元素 */ func randomAccess(nums []int) (randomNum int) { // 在区间 [0, nums.length) 中随机抽取一个数字 randomIndex := rand.Intn(len(nums)) @@ -189,7 +189,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "JS" ```javascript title="array.js" - /* 随机返回一个数组元素 */ + /* 随机访问元素 */ function randomAccess(nums) { // 在区间 [0, nums.length) 中随机抽取一个数字 const random_index = Math.floor(Math.random() * nums.length); @@ -202,7 +202,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "TS" ```typescript title="array.ts" - /* 随机返回一个数组元素 */ + /* 随机访问元素 */ function randomAccess(nums: number[]): number { // 在区间 [0, nums.length) 中随机抽取一个数字 const random_index = Math.floor(Math.random() * nums.length); @@ -215,7 +215,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "C" ```c title="array.c" - /* 随机返回一个数组元素 */ + /* 随机访问元素 */ int randomAccess(int *nums, int size) { // 在区间 [0, size) 中随机抽取一个数字 int randomIndex = rand() % size; @@ -228,7 +228,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "C#" ```csharp title="array.cs" - /* 随机返回一个数组元素 */ + /* 随机访问元素 */ int randomAccess(int[] nums) { Random random = new(); // 在区间 [0, nums.Length) 中随机抽取一个数字 @@ -242,7 +242,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "Swift" ```swift title="array.swift" - /* 随机返回一个数组元素 */ + /* 随机访问元素 */ func randomAccess(nums: [Int]) -> Int { // 在区间 [0, nums.count) 中随机抽取一个数字 let randomIndex = nums.indices.randomElement()! @@ -255,7 +255,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "Zig" ```zig title="array.zig" - // 随机返回一个数组元素 + // 随机访问元素 fn randomAccess(nums: []i32) i32 { // 在区间 [0, nums.len) 中随机抽取一个整数 var randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len); @@ -268,7 +268,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "Dart" ```dart title="array.dart" - /* 随机返回一个数组元素 */ + /* 随机访问元素 */ int randomAccess(List nums) { // 在区间 [0, nums.length) 中随机抽取一个数字 int randomIndex = Random().nextInt(nums.length); @@ -281,7 +281,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "Rust" ```rust title="array.rs" - /* 随机返回一个数组元素 */ + /* 随机访问元素 */ fn random_access(nums: &[i32]) -> i32 { // 在区间 [0, nums.len()) 中随机抽取一个数字 let random_index = rand::thread_rng().gen_range(0..nums.len()); @@ -291,9 +291,719 @@ elementAddr = firtstElementAddr + elementLength * elementIndex } ``` -## 4.1.2. 数组缺点 +### 插入元素 -**数组在初始化后长度不可变**。系统无法保证数组之后的内存空间是可用的，因此数组长度无法扩展。而若希望扩容数组，则需新建一个数组，然后把原数组元素依次拷贝到新数组。在数组很大的情况下，这是非常耗时的。 +数组元素在内存中是“紧挨着的”，它们之间没有空间再存放任何数据。这意味着如果想要在数组中间插入一个元素，则需要将该元素之后的所有元素都向后移动一位，之后再把元素赋值给该索引。 + +值得注意的是，由于数组的长度是固定的，因此插入一个元素必定会导致数组尾部元素的“丢失”。我们将这个问题的解决方案留在列表章节中讨论。 + + + +图：数组插入元素
+ +=== "Java" + + ```java title="array.java" + /* 在数组的索引 index 处插入元素 num */ + void insert(int[] nums, int num, int index) { + // 把索引 index 以及之后的所有元素向后移动一位 + for (int i = nums.length - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // 将 num 赋给 index 处元素 + nums[index] = num; + } + ``` + +=== "C++" + + ```cpp title="array.cpp" + /* 在数组的索引 index 处插入元素 num */ + void insert(int *nums, int size, int num, int index) { + // 把索引 index 以及之后的所有元素向后移动一位 + for (int i = size - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // 将 num 赋给 index 处元素 + nums[index] = num; + } + ``` + +=== "Python" + + ```python title="array.py" + def insert(nums: list[int], num: int, index: int): + """在数组的索引 index 处插入元素 num""" + # 把索引 index 以及之后的所有元素向后移动一位 + for i in range(len(nums) - 1, index, -1): + nums[i] = nums[i - 1] + # 将 num 赋给 index 处元素 + nums[index] = num + ``` + +=== "Go" + + ```go title="array.go" + /* 在数组的索引 index 处插入元素 num */ + func insert(nums []int, num int, index int) { + // 把索引 index 以及之后的所有元素向后移动一位 + for i := len(nums) - 1; i > index; i-- { + nums[i] = nums[i-1] + } + // 将 num 赋给 index 处元素 + nums[index] = num + } + ``` + +=== "JS" + + ```javascript title="array.js" + /* 在数组的索引 index 处插入元素 num */ + function insert(nums, num, index) { + // 把索引 index 以及之后的所有元素向后移动一位 + for (let i = nums.length - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // 将 num 赋给 index 处元素 + nums[index] = num; + } + ``` + +=== "TS" + + ```typescript title="array.ts" + /* 在数组的索引 index 处插入元素 num */ + function insert(nums: number[], num: number, index: number): void { + // 把索引 index 以及之后的所有元素向后移动一位 + for (let i = nums.length - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // 将 num 赋给 index 处元素 + nums[index] = num; + } + ``` + +=== "C" + + ```c title="array.c" + /* 在数组的索引 index 处插入元素 num */ + void insert(int *nums, int size, int num, int index) { + // 把索引 index 以及之后的所有元素向后移动一位 + for (int i = size - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // 将 num 赋给 index 处元素 + nums[index] = num; + } + ``` + +=== "C#" + + ```csharp title="array.cs" + /* 在数组的索引 index 处插入元素 num */ + void insert(int[] nums, int num, int index) { + // 把索引 index 以及之后的所有元素向后移动一位 + for (int i = nums.Length - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // 将 num 赋给 index 处元素 + nums[index] = num; + } + ``` + +=== "Swift" + + ```swift title="array.swift" + /* 在数组的索引 index 处插入元素 num */ + func insert(nums: inout [Int], num: Int, index: Int) { + // 把索引 index 以及之后的所有元素向后移动一位 + for i in sequence(first: nums.count - 1, next: { $0 > index + 1 ? $0 - 1 : nil }) { + nums[i] = nums[i - 1] + } + // 将 num 赋给 index 处元素 + nums[index] = num + } + ``` + +=== "Zig" + + ```zig title="array.zig" + // 在数组的索引 index 处插入元素 num + fn insert(nums: []i32, num: i32, index: usize) void { + // 把索引 index 以及之后的所有元素向后移动一位 + var i = nums.len - 1; + while (i > index) : (i -= 1) { + nums[i] = nums[i - 1]; + } + // 将 num 赋给 index 处元素 + nums[index] = num; + } + ``` + +=== "Dart" + + ```dart title="array.dart" + /* 在数组的索引 index 处插入元素 num */ + void insert(List nums, int num, int index) { + // 把索引 index 以及之后的所有元素向后移动一位 + for (var i = nums.length - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // 将 num 赋给 index 处元素 + nums[index] = num; + } + ``` + +=== "Rust" + + ```rust title="array.rs" + /* 在数组的索引 index 处插入元素 num */ + fn insert(nums: &mut Vec图：数组删除元素
+ +=== "Java" + + ```java title="array.java" + /* 删除索引 index 处元素 */ + void remove(int[] nums, int index) { + // 把索引 index 之后的所有元素向前移动一位 + for (int i = index; i < nums.length - 1; i++) { + nums[i] = nums[i + 1]; + } + } + ``` + +=== "C++" + + ```cpp title="array.cpp" + /* 删除索引 index 处元素 */ + void remove(int *nums, int size, int index) { + // 把索引 index 之后的所有元素向前移动一位 + for (int i = index; i < size - 1; i++) { + nums[i] = nums[i + 1]; + } + } + ``` + +=== "Python" + + ```python title="array.py" + def remove(nums: list[int], index: int): + """删除索引 index 处元素""" + # 把索引 index 之后的所有元素向前移动一位 + for i in range(index, len(nums) - 1): + nums[i] = nums[i + 1] + ``` + +=== "Go" + + ```go title="array.go" + /* 删除索引 index 处元素 */ + func remove(nums []int, index int) { + // 把索引 index 之后的所有元素向前移动一位 + for i := index; i < len(nums)-1; i++ { + nums[i] = nums[i+1] + } + } + ``` + +=== "JS" + + ```javascript title="array.js" + /* 删除索引 index 处元素 */ + function remove(nums, index) { + // 把索引 index 之后的所有元素向前移动一位 + for (let i = index; i < nums.length - 1; i++) { + nums[i] = nums[i + 1]; + } + } + ``` + +=== "TS" + + ```typescript title="array.ts" + /* 删除索引 index 处元素 */ + function remove(nums: number[], index: number): void { + // 把索引 index 之后的所有元素向前移动一位 + for (let i = index; i < nums.length - 1; i++) { + nums[i] = nums[i + 1]; + } + } + ``` + +=== "C" + + ```c title="array.c" + /* 删除索引 index 处元素 */ + // 注意：stdio.h 占用了 remove 关键词 + void removeItem(int *nums, int size, int index) { + // 把索引 index 之后的所有元素向前移动一位 + for (int i = index; i < size - 1; i++) { + nums[i] = nums[i + 1]; + } + } + ``` + +=== "C#" + + ```csharp title="array.cs" + /* 删除索引 index 处元素 */ + void remove(int[] nums, int index) { + // 把索引 index 之后的所有元素向前移动一位 + for (int i = index; i < nums.Length - 1; i++) { + nums[i] = nums[i + 1]; + } + } + ``` + +=== "Swift" + + ```swift title="array.swift" + /* 删除索引 index 处元素 */ + func remove(nums: inout [Int], index: Int) { + let count = nums.count + // 把索引 index 之后的所有元素向前移动一位 + for i in sequence(first: index, next: { $0 < count - 1 - 1 ? $0 + 1 : nil }) { + nums[i] = nums[i + 1] + } + } + ``` + +=== "Zig" + + ```zig title="array.zig" + // 删除索引 index 处元素 + fn remove(nums: []i32, index: usize) void { + // 把索引 index 之后的所有元素向前移动一位 + var i = index; + while (i < nums.len - 1) : (i += 1) { + nums[i] = nums[i + 1]; + } + } + ``` + +=== "Dart" + + ```dart title="array.dart" + /* 删除索引 index 处元素 */ + void remove(List nums, int index) { + // 把索引 index 之后的所有元素向前移动一位 + for (var i = index; i < nums.length - 1; i++) { + nums[i] = nums[i + 1]; + } + } + ``` + +=== "Rust" + + ```rust title="array.rs" + /* 删除索引 index 处元素 */ + fn remove(nums: &mut VecFig. 数组插入元素
+- **空间效率高**: 数组为数据分配了连续的内存块，无需额外的结构开销。 +- **支持随机访问**: 数组允许在 $O(1)$ 时间内访问任何元素。 +- **缓存局部性**: 当访问数组元素时，计算机不仅会加载它，还会缓存其周围的其他数据，从而借助高速缓存来提升后续操作的执行速度。 -=== "Java" +连续空间存储是一把双刃剑，它导致的缺点有： - ```java title="array.java" - /* 在数组的索引 index 处插入元素 num */ - void insert(int[] nums, int num, int index) { - // 把索引 index 以及之后的所有元素向后移动一位 - for (int i = nums.length - 1; i > index; i--) { - nums[i] = nums[i - 1]; - } - // 将 num 赋给 index 处元素 - nums[index] = num; - } - ``` +- **插入与删除效率低**:当数组中元素较多时，插入与删除操作需要移动大量的元素。 +- **长度不可变**: 数组在初始化后长度就固定了，扩容数组需要将所有数据复制到新数组，开销很大。 +- **空间浪费**: 如果数组分配的大小超过了实际所需，那么多余的空间就被浪费了。 -=== "C++" +## 4.1.3. 数组典型应用 - ```cpp title="array.cpp" - /* 在数组的索引 index 处插入元素 num */ - void insert(int *nums, int size, int num, int index) { - // 把索引 index 以及之后的所有元素向后移动一位 - for (int i = size - 1; i > index; i--) { - nums[i] = nums[i - 1]; - } - // 将 num 赋给 index 处元素 - nums[index] = num; - } - ``` - -=== "Python" - - ```python title="array.py" - def insert(nums: list[int], num: int, index: int): - """在数组的索引 index 处插入元素 num""" - # 把索引 index 以及之后的所有元素向后移动一位 - for i in range(len(nums) - 1, index, -1): - nums[i] = nums[i - 1] - # 将 num 赋给 index 处元素 - nums[index] = num - ``` - -=== "Go" - - ```go title="array.go" - /* 在数组的索引 index 处插入元素 num */ - func insert(nums []int, num int, index int) { - // 把索引 index 以及之后的所有元素向后移动一位 - for i := len(nums) - 1; i > index; i-- { - nums[i] = nums[i-1] - } - // 将 num 赋给 index 处元素 - nums[index] = num - } - ``` - -=== "JS" - - ```javascript title="array.js" - /* 在数组的索引 index 处插入元素 num */ - function insert(nums, num, index) { - // 把索引 index 以及之后的所有元素向后移动一位 - for (let i = nums.length - 1; i > index; i--) { - nums[i] = nums[i - 1]; - } - // 将 num 赋给 index 处元素 - nums[index] = num; - } - ``` - -=== "TS" - - ```typescript title="array.ts" - /* 在数组的索引 index 处插入元素 num */ - function insert(nums: number[], num: number, index: number): void { - // 把索引 index 以及之后的所有元素向后移动一位 - for (let i = nums.length - 1; i > index; i--) { - nums[i] = nums[i - 1]; - } - // 将 num 赋给 index 处元素 - nums[index] = num; - } - ``` - -=== "C" - - ```c title="array.c" - /* 在数组的索引 index 处插入元素 num */ - void insert(int *nums, int size, int num, int index) { - // 把索引 index 以及之后的所有元素向后移动一位 - for (int i = size - 1; i > index; i--) { - nums[i] = nums[i - 1]; - } - // 将 num 赋给 index 处元素 - nums[index] = num; - } - ``` - -=== "C#" - - ```csharp title="array.cs" - /* 在数组的索引 index 处插入元素 num */ - void insert(int[] nums, int num, int index) { - // 把索引 index 以及之后的所有元素向后移动一位 - for (int i = nums.Length - 1; i > index; i--) { - nums[i] = nums[i - 1]; - } - // 将 num 赋给 index 处元素 - nums[index] = num; - } - ``` - -=== "Swift" - - ```swift title="array.swift" - /* 在数组的索引 index 处插入元素 num */ - func insert(nums: inout [Int], num: Int, index: Int) { - // 把索引 index 以及之后的所有元素向后移动一位 - for i in sequence(first: nums.count - 1, next: { $0 > index + 1 ? $0 - 1 : nil }) { - nums[i] = nums[i - 1] - } - // 将 num 赋给 index 处元素 - nums[index] = num - } - ``` - -=== "Zig" - - ```zig title="array.zig" - // 在数组的索引 index 处插入元素 num - fn insert(nums: []i32, num: i32, index: usize) void { - // 把索引 index 以及之后的所有元素向后移动一位 - var i = nums.len - 1; - while (i > index) : (i -= 1) { - nums[i] = nums[i - 1]; - } - // 将 num 赋给 index 处元素 - nums[index] = num; - } - ``` - -=== "Dart" - - ```dart title="array.dart" - /* 在数组的索引 index 处插入元素 num */ - void insert(List nums, int num, int index) { - // 把索引 index 以及之后的所有元素向后移动一位 - for (var i = nums.length - 1; i > index; i--) { - nums[i] = nums[i - 1]; - } - // 将 num 赋给 index 处元素 - nums[index] = num; - } - ``` - -=== "Rust" - - ```rust title="array.rs" - /* 在数组的索引 index 处插入元素 num */ - fn insert(nums: &mut VecFig. 数组删除元素
- -=== "Java" - - ```java title="array.java" - /* 删除索引 index 处元素 */ - void remove(int[] nums, int index) { - // 把索引 index 之后的所有元素向前移动一位 - for (int i = index; i < nums.length - 1; i++) { - nums[i] = nums[i + 1]; - } - } - ``` - -=== "C++" - - ```cpp title="array.cpp" - /* 删除索引 index 处元素 */ - void remove(int *nums, int size, int index) { - // 把索引 index 之后的所有元素向前移动一位 - for (int i = index; i < size - 1; i++) { - nums[i] = nums[i + 1]; - } - } - ``` - -=== "Python" - - ```python title="array.py" - def remove(nums: list[int], index: int): - """删除索引 index 处元素""" - # 把索引 index 之后的所有元素向前移动一位 - for i in range(index, len(nums) - 1): - nums[i] = nums[i + 1] - ``` - -=== "Go" - - ```go title="array.go" - /* 删除索引 index 处元素 */ - func remove(nums []int, index int) { - // 把索引 index 之后的所有元素向前移动一位 - for i := index; i < len(nums)-1; i++ { - nums[i] = nums[i+1] - } - } - ``` - -=== "JS" - - ```javascript title="array.js" - /* 删除索引 index 处元素 */ - function remove(nums, index) { - // 把索引 index 之后的所有元素向前移动一位 - for (let i = index; i < nums.length - 1; i++) { - nums[i] = nums[i + 1]; - } - } - ``` - -=== "TS" - - ```typescript title="array.ts" - /* 删除索引 index 处元素 */ - function remove(nums: number[], index: number): void { - // 把索引 index 之后的所有元素向前移动一位 - for (let i = index; i < nums.length - 1; i++) { - nums[i] = nums[i + 1]; - } - } - ``` - -=== "C" - - ```c title="array.c" - /* 删除索引 index 处元素 */ - // 注意：stdio.h 占用了 remove 关键词 - void removeItem(int *nums, int size, int index) { - // 把索引 index 之后的所有元素向前移动一位 - for (int i = index; i < size - 1; i++) { - nums[i] = nums[i + 1]; - } - } - ``` - -=== "C#" - - ```csharp title="array.cs" - /* 删除索引 index 处元素 */ - void remove(int[] nums, int index) { - // 把索引 index 之后的所有元素向前移动一位 - for (int i = index; i < nums.Length - 1; i++) { - nums[i] = nums[i + 1]; - } - } - ``` - -=== "Swift" - - ```swift title="array.swift" - /* 删除索引 index 处元素 */ - func remove(nums: inout [Int], index: Int) { - let count = nums.count - // 把索引 index 之后的所有元素向前移动一位 - for i in sequence(first: index, next: { $0 < count - 1 - 1 ? $0 + 1 : nil }) { - nums[i] = nums[i + 1] - } - } - ``` - -=== "Zig" - - ```zig title="array.zig" - // 删除索引 index 处元素 - fn remove(nums: []i32, index: usize) void { - // 把索引 index 之后的所有元素向前移动一位 - var i = index; - while (i < nums.len - 1) : (i += 1) { - nums[i] = nums[i + 1]; - } - } - ``` - -=== "Dart" - - ```dart title="array.dart" - /* 删除索引 index 处元素 */ - void remove(List nums, int index) { - // 把索引 index 之后的所有元素向前移动一位 - for (var i = index; i < nums.length - 1; i++) { - nums[i] = nums[i + 1]; - } - } - ``` - -=== "Rust" - - ```rust title="array.rs" - /* 删除索引 index 处元素 */ - fn remove(nums: &mut VecFig. 链表定义与存储方式
+图：链表定义与存储方式
+ +观察上图，链表中的每个「节点 Node」对象都包含两项数据：节点的“值”、指向下一节点的“引用”。 + +- 链表的首个节点被称为“头节点”，最后一个节点被称为“尾节点”。 +- 尾节点指向的是“空”，它在 Java, C++, Python 中分别被记为 $\text{null}$ , $\text{nullptr}$ , $\text{None}$ 。 +- 在 C, C++, Go, Rust 等支持指针的语言中，上述的“引用”应被替换为“指针”。 + +如以下代码所示，链表以节点对象 `ListNode` 为单位，每个节点除了包含值，还需额外保存下一节点的引用（指针）。因此在相同数据量下，**链表通常比数组占用更多的内存空间**。 === "Java" @@ -20,7 +26,7 @@ comments: true /* 链表节点类 */ class ListNode { int val; // 节点值 - ListNode next; // 指向下一节点的指针（引用） + ListNode next; // 指向下一节点的引用 ListNode(int x) { val = x; } // 构造函数 } ``` @@ -31,7 +37,7 @@ comments: true /* 链表节点结构体 */ struct ListNode { int val; // 节点值 - ListNode *next; // 指向下一节点的指针（引用） + ListNode *next; // 指向下一节点的指针 ListNode(int x) : val(x), next(nullptr) {} // 构造函数 }; ``` @@ -43,7 +49,7 @@ comments: true """链表节点类""" def __init__(self, val: int): self.val: int = val # 节点值 - self.next: Optional[ListNode] = None # 指向下一节点的指针（引用） + self.next: Optional[ListNode] = None # 指向下一节点的引用 ``` === "Go" @@ -52,9 +58,9 @@ comments: true /* 链表节点结构体 */ type ListNode struct { Val int // 节点值 - Next *ListNode // 指向下一节点的指针（引用） + Next *ListNode // 指向下一节点的指针 } - + // NewListNode 构造函数，创建一个新的链表 func NewListNode(val int) *ListNode { return &ListNode{ @@ -98,7 +104,7 @@ comments: true /* 链表节点结构体 */ struct ListNode { int val; // 节点值 - struct ListNode *next; // 指向下一节点的指针（引用） + struct ListNode *next; // 指向下一节点的指针 }; typedef struct ListNode ListNode; @@ -130,7 +136,7 @@ comments: true /* 链表节点类 */ class ListNode { var val: Int // 节点值 - var next: ListNode? // 指向下一节点的指针（引用） + var next: ListNode? // 指向下一节点的引用 init(x: Int) { // 构造函数 val = x @@ -145,9 +151,9 @@ comments: true pub fn ListNode(comptime T: type) type { return struct { const Self = @This(); - + val: T = 0, // 节点值 - next: ?*Self = null, // 指向下一节点的指针（引用） + next: ?*Self = null, // 指向下一节点的指针 // 构造函数 pub fn init(self: *Self, x: i32) void { @@ -164,7 +170,7 @@ comments: true /* 链表节点类 */ class ListNode { int val; // 节点值 - ListNode? next; // 指向下一节点的指针（引用） + ListNode? next; // 指向下一节点的引用 ListNode(this.val, [this.next]); // 构造函数 } ``` @@ -178,19 +184,21 @@ comments: true #[derive(Debug)] struct ListNode { val: i32, // 节点值 - next: OptionFig. 链表插入节点
+图：链表插入节点
=== "Java" @@ -533,11 +543,15 @@ comments: true } ``` -在链表中删除节点也非常方便，只需改变一个节点的指针即可。如下图所示，尽管在删除操作完成后，节点 `P` 仍然指向 `n1` ，但实际上 `P` 已经不再属于此链表，因为遍历此链表时无法访问到 `P` 。 +### 删除节点 + +在链表中删除节点也非常简便，只需改变一个节点的引用（指针）即可。 + +请注意，尽管在删除操作完成后节点 `P` 仍然指向 `n1` ，但实际上遍历此链表已经无法访问到 `P` ，这意味着 `P` 已经不再属于该链表了。  -Fig. 链表删除节点
+图：链表删除节点
=== "Java" @@ -714,9 +728,9 @@ comments: true } ``` -## 4.2.2. 链表缺点 +### 访问节点 -**链表访问节点效率较低**。如上节所述，数组可以在 $O(1)$ 时间下访问任意元素。然而链表无法直接访问任意节点，因为程序需要从头节点出发，逐个向后遍历，直至找到目标节点。也就是说，如果想要访问链表中第 $i$ 个节点，则需要向后遍历 $i - 1$ 轮。 +**在链表访问节点的效率较低**。如上节所述，我们可以在 $O(1)$ 时间下访问数组中的任意元素。链表则不然，程序需要从头节点出发，逐个向后遍历，直至找到目标节点。也就是说，访问链表的第 $i$ 个节点需要循环 $i - 1$ 轮，时间复杂度为 $O(n)$ 。 === "Java" @@ -887,11 +901,9 @@ comments: true } ``` -**链表的内存占用较大**。链表以节点为单位，每个节点除了包含值，还需额外保存下一节点的引用（指针）。这意味着在相同数据量的情况下，链表比数组需要占用更多的内存空间。 +### 查找节点 -## 4.2.3. 链表常用操作 - -**遍历链表查找**。遍历链表，查找链表内值为 `target` 的节点，输出节点在链表中的索引。 +遍历链表，查找链表内值为 `target` 的节点，输出节点在链表中的索引。此过程也属于「线性查找」。 === "Java" @@ -1086,13 +1098,31 @@ comments: true } ``` -## 4.2.4. 常见链表类型 +## 4.2.2. 数组 VS 链表 -**单向链表**。即上述介绍的普通链表。单向链表的节点包含值和指向下一节点的指针（引用）两项数据。我们将首个节点称为头节点，将最后一个节点成为尾节点，尾节点指向空 $\text{None}$ 。 +下表总结对比了数组和链表的各项特点与操作效率。由于它们采用两种相反的存储策略，因此各种性质和操作效率也呈现对立的特点。 + +Fig. 常见链表种类
+图：常见链表种类
-## 4.2.5. 链表典型应用 +## 4.2.4. 链表典型应用 单向链表通常用于实现栈、队列、散列表和图等数据结构。 @@ -1305,7 +1335,7 @@ comments: true 双向链表常被用于需要快速查找前一个和下一个元素的场景。 -- **高级数据结构**：比如在红黑树、B 树中，我们需要知道一个节点的父节点，这可以通过在节点中保存一个指向父节点的指针来实现，类似于双向链表。 +- **高级数据结构**：比如在红黑树、B 树中，我们需要访问节点的父节点，这可以通过在节点中保存一个指向父节点的引用来实现，类似于双向链表。 - **浏览器历史**：在网页浏览器中，当用户点击前进或后退按钮时，浏览器需要知道用户访问过的前一个和后一个网页。双向链表的特性使得这种操作变得简单。 - **LRU 算法**：在缓存淘汰算法（LRU）中，我们需要快速找到最近最少使用的数据，以及支持快速地添加和删除节点。这时候使用双向链表就非常合适。 diff --git a/chapter_array_and_linkedlist/list.md b/chapter_array_and_linkedlist/list.md index 5b58b2c7f..e8400649e 100755 --- a/chapter_array_and_linkedlist/list.md +++ b/chapter_array_and_linkedlist/list.md @@ -4,13 +4,15 @@ comments: true # 4.3. 列表 -**数组长度不可变导致实用性降低**。在许多情况下，我们事先无法确定需要存储多少数据，这使数组长度的选择变得困难。若长度过小，需要在持续添加数据时频繁扩容数组；若长度过大，则会造成内存空间的浪费。 +**数组长度不可变导致实用性降低**。在实际中，我们可能事先无法确定需要存储多少数据，这使数组长度的选择变得困难。若长度过小，需要在持续添加数据时频繁扩容数组；若长度过大，则会造成内存空间的浪费。 -为解决此问题，出现了一种被称为「动态数组 Dynamic Array」的数据结构，即长度可变的数组，也常被称为「列表 List」。列表基于数组实现，继承了数组的优点，并且可以在程序运行过程中动态扩容。在列表中，我们可以自由添加元素，而无需担心超过容量限制。 +为解决此问题，出现了一种被称为「动态数组 Dynamic Array」的数据结构，即长度可变的数组，也常被称为「列表 List」。列表基于数组实现，继承了数组的优点，并且可以在程序运行过程中动态扩容。我们可以在列表中自由地添加元素，而无需担心超过容量限制。 ## 4.3.1. 列表常用操作 -**初始化列表**。通常我们会使用“无初始值”和“有初始值”的两种初始化方法。 +### 初始化列表 + +我们通常使用“无初始值”和“有初始值”这两种初始化方法。 === "Java" @@ -130,7 +132,9 @@ comments: true let list2: VecFig. 在前序遍历中搜索节点
+图：在前序遍历中搜索节点
## 13.1.1. 尝试与回退 @@ -501,6 +501,8 @@ comments: true === "<11>"  +图：尝试与回退
+ ## 13.1.2. 剪枝 复杂的回溯问题通常包含一个或多个约束条件，**约束条件通常可用于“剪枝”**。 @@ -797,7 +799,7 @@ comments: true  -Fig. 根据约束条件剪枝
+图：根据约束条件剪枝
## 13.1.3. 框架代码 @@ -1657,7 +1659,7 @@ comments: true  -Fig. 保留与删除 return 的搜索过程对比
+图：保留与删除 return 的搜索过程对比
相比基于前序遍历的代码实现，基于回溯算法框架的代码实现虽然显得啰嗦，但通用性更好。实际上，**许多回溯问题都可以在该框架下解决**。我们只需根据具体问题来定义 `state` 和 `choices` ，并实现框架中的各个方法即可。 diff --git a/chapter_backtracking/n_queens_problem.md b/chapter_backtracking/n_queens_problem.md index f6149a0bf..5e00bc18a 100644 --- a/chapter_backtracking/n_queens_problem.md +++ b/chapter_backtracking/n_queens_problem.md @@ -12,13 +12,13 @@ comments: true  -Fig. 4 皇后问题的解
+图：4 皇后问题的解
本题共包含三个约束条件：**多个皇后不能在同一行、同一列、同一对角线**。值得注意的是，对角线分为主对角线 `\` 和次对角线 `/` 两种。  -Fig. n 皇后问题的约束条件
+图：n 皇后问题的约束条件
### 逐行放置策略 @@ -30,7 +30,7 @@ comments: true  -Fig. 逐行放置策略
+图：逐行放置策略
本质上看，**逐行放置策略起到了剪枝的作用**，它避免了同一行出现多个皇后的所有搜索分支。 @@ -46,7 +46,7 @@ comments: true  -Fig. 处理列约束和对角线约束
+图：处理列约束和对角线约束
### 代码实现 diff --git a/chapter_backtracking/permutations_problem.md b/chapter_backtracking/permutations_problem.md index db825e917..24ed13041 100644 --- a/chapter_backtracking/permutations_problem.md +++ b/chapter_backtracking/permutations_problem.md @@ -32,7 +32,7 @@ comments: true  -Fig. 全排列的递归树
+图：全排列的递归树
### 重复选择剪枝 @@ -45,7 +45,7 @@ comments: true  -Fig. 全排列剪枝示例
+图：全排列剪枝示例
观察上图发现，该剪枝操作将搜索空间大小从 $O(n^n)$ 降低至 $O(n!)$ 。 @@ -483,7 +483,7 @@ comments: true  -Fig. 重复排列
+图：重复排列
那么如何去除重复的排列呢？最直接地，考虑借助一个哈希表，直接对排列结果进行去重。然而这样做不够优雅，**因为生成重复排列的搜索分支是没有必要的，应当被提前识别并剪枝**，这样可以进一步提升算法效率。 @@ -497,7 +497,7 @@ comments: true  -Fig. 重复排列剪枝
+图：重复排列剪枝
### 代码实现 @@ -914,4 +914,4 @@ comments: true  -Fig. 两种剪枝条件的作用范围
+图：两种剪枝条件的作用范围
diff --git a/chapter_backtracking/subset_sum_problem.md b/chapter_backtracking/subset_sum_problem.md index c692ca4ba..fe6385e99 100644 --- a/chapter_backtracking/subset_sum_problem.md +++ b/chapter_backtracking/subset_sum_problem.md @@ -438,7 +438,7 @@ comments: true  -Fig. 子集搜索与越界剪枝
+图：子集搜索与越界剪枝
为了去除重复子集，**一种直接的思路是对结果列表进行去重**。但这个方法效率很低，因为： @@ -460,7 +460,7 @@ comments: true  -Fig. 不同选择顺序导致的重复子集
+图：不同选择顺序导致的重复子集
总结来看，给定输入数组 $[x_1, x_2, \cdots, x_n]$ ，设搜索过程中的选择序列为 $[x_{i_1}, x_{i_2}, \cdots , x_{i_m}]$ ，则该选择序列需要满足 $i_1 \leq i_2 \leq \cdots \leq i_m$ ，**不满足该条件的选择序列都会造成重复，应当剪枝**。 @@ -916,7 +916,7 @@ comments: true  -Fig. 子集和 I 回溯过程
+图：子集和 I 回溯过程
## 13.3.2. 考虑重复元素的情况 @@ -930,7 +930,7 @@ comments: true  -Fig. 相等元素导致的重复子集
+图：相等元素导致的重复子集
### 相等元素剪枝 @@ -1438,4 +1438,4 @@ comments: true  -Fig. 子集和 II 回溯过程
+图：子集和 II 回溯过程
diff --git a/chapter_computational_complexity/performance_evaluation.md b/chapter_computational_complexity/performance_evaluation.md index d3181363e..b48d5b309 100644 --- a/chapter_computational_complexity/performance_evaluation.md +++ b/chapter_computational_complexity/performance_evaluation.md @@ -11,10 +11,10 @@ comments: true 因此在能够解决问题的前提下，算法效率成为主要的评价维度，包括： -- **时间效率**，即算法运行速度的快慢。 -- **空间效率**，即算法占用内存空间的大小。 +- **时间效率**：算法运行速度的快慢。 +- **空间效率**：算法占用内存空间的大小。 -简而言之，**我们的目标是设计“既快又省”的数据结构与算法**。而有效地评估算法效率至关重要，因为只有了解评价标准，我们才能对比分析各种算法，从而指导算法设计与优化过程。 +简而言之，**我们的目标是设计“既快又省”的数据结构与算法**。而有效地评估算法效率至关重要，因为只有这样我们才能将各种算法进行对比，从而指导算法设计与优化过程。 效率评估方法主要分为两种：实际测试和理论估算。 @@ -32,11 +32,11 @@ comments: true **复杂度分析评估的是算法运行效率随着输入数据量增多时的增长趋势**。这个定义有些拗口，我们可以将其分为三个重点来理解： -- “算法运行效率”可分为运行时间和占用空间两部分，与之对应地，复杂度可分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。 -- “随着输入数据量增多时”表示复杂度与输入数据量有关，反映了算法运行效率与输入数据量之间的关系。 -- “增长趋势”表示复杂度分析关注的是算法时间与空间的增长趋势，而非具体的运行时间或占用空间。 +1. “算法运行效率”可分为运行时间和占用空间两部分，与之对应地，复杂度可分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。 +2. “随着输入数据量增多时”意味着复杂度反映了算法运行效率与输入数据量之间的关系。 +3. “增长趋势”表示复杂度分析关注的是算法时间与空间的增长趋势，而非具体的运行时间或占用空间。 -**复杂度分析克服了实际测试方法的弊端**。首先，它独立于测试环境，因此分析结果适用于所有运行平台。其次，它可以体现不同数据量下的算法效率，尤其是在大数据量下的算法性能。 +**复杂度分析克服了实际测试方法的弊端**。首先，它独立于测试环境，分析结果适用于所有运行平台。其次，它可以体现不同数据量下的算法效率，尤其是在大数据量下的算法性能。 如果你对复杂度分析的概念仍感到困惑，无需担心，我们会在后续章节详细介绍。 diff --git a/chapter_computational_complexity/space_complexity.md b/chapter_computational_complexity/space_complexity.md index 6ea4a19d6..7fc10f037 100755 --- a/chapter_computational_complexity/space_complexity.md +++ b/chapter_computational_complexity/space_complexity.md @@ -26,7 +26,7 @@ comments: true  -Fig. 算法使用的相关空间
+图：算法使用的相关空间
=== "Java" @@ -85,7 +85,7 @@ comments: true """类""" def __init__(self, x: int): self.val: int = x # 节点值 - self.next: Optional[Node] = None # 指向下一节点的指针（引用） + self.next: Optional[Node] = None # 指向下一节点的引用 def function() -> int: """函数""" @@ -669,7 +669,7 @@ $$  -Fig. 空间复杂度的常见类型
+图：空间复杂度的常见类型
!!! tip @@ -967,8 +967,8 @@ $$ // 常量、变量、对象占用 O(1) 空间 final int a = 0; int b = 0; - ListFig. 递归函数产生的线性阶空间复杂度
+图：递归函数产生的线性阶空间复杂度
### 平方阶 $O(n^2)$ @@ -1605,7 +1605,6 @@ $$ ListFig. 递归函数产生的平方阶空间复杂度
+图：递归函数产生的平方阶空间复杂度
### 指数阶 $O(2^n)$ @@ -1969,7 +1968,7 @@ $$  -Fig. 满二叉树产生的指数阶空间复杂度
+图：满二叉树产生的指数阶空间复杂度
### 对数阶 $O(\log n)$ diff --git a/chapter_computational_complexity/time_complexity.md b/chapter_computational_complexity/time_complexity.md index ef79f4f68..ed752e870 100755 --- a/chapter_computational_complexity/time_complexity.md +++ b/chapter_computational_complexity/time_complexity.md @@ -436,7 +436,7 @@ $$  -Fig. 算法 A, B, C 的时间增长趋势
+图：算法 A, B, C 的时间增长趋势
相较于直接统计算法运行时间，时间复杂度分析有哪些特点呢？ @@ -634,7 +634,7 @@ $T(n)$ 是一次函数，说明时间的增长趋势是线性的，因此其时  -Fig. 函数的渐近上界
+图：函数的渐近上界
也就是说，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。 @@ -906,7 +906,7 @@ $$  -Fig. 时间复杂度的常见类型
+图：时间复杂度的常见类型
!!! tip @@ -1600,7 +1600,7 @@ $$  -Fig. 常数阶、线性阶、平方阶的时间复杂度
+图：常数阶、线性阶、平方阶的时间复杂度
以「冒泡排序」为例，外层循环执行 $n - 1$ 次，内层循环执行 $n-1, n-2, \cdots, 2, 1$ 次，平均为 $\frac{n}{2}$ 次，因此时间复杂度为 $O(n^2)$ 。 @@ -2110,7 +2110,7 @@ $$  -Fig. 指数阶的时间复杂度
+图：指数阶的时间复杂度
在实际算法中，指数阶常出现于递归函数。例如以下代码，其递归地一分为二，经过 $n$ 次分裂后停止。 @@ -2420,7 +2420,7 @@ $$  -Fig. 对数阶的时间复杂度
+图：对数阶的时间复杂度
与指数阶类似，对数阶也常出现于递归函数。以下代码形成了一个高度为 $\log_2 n$ 的递归树。 @@ -2745,7 +2745,7 @@ $$  -Fig. 线性对数阶的时间复杂度
+图：线性对数阶的时间复杂度
### 阶乘阶 $O(n!)$ @@ -2947,7 +2947,7 @@ $$  -Fig. 阶乘阶的时间复杂度
+图：阶乘阶的时间复杂度
请注意，因为 $n! > 2^n$ ，所以阶乘阶比指数阶增长地更快，在 $n$ 较大时也是不可接受的。 diff --git a/chapter_data_structure/character_encoding.md b/chapter_data_structure/character_encoding.md index 1e7617178..89bccd079 100644 --- a/chapter_data_structure/character_encoding.md +++ b/chapter_data_structure/character_encoding.md @@ -12,7 +12,7 @@ comments: true  -Fig. ASCII 码
+图：ASCII 码
然而，**ASCII 码仅能够表示英文**。随着计算机的全球化，诞生了一种能够表示更多语言的字符集「EASCII」。它在 ASCII 的 7 位基础上扩展到 8 位，能够表示 256 个不同的字符。 @@ -40,7 +40,7 @@ Unicode 是一种字符集标准，本质上是给每个字符分配一个编号  -Fig. Unicode 编码示例
+图：Unicode 编码示例
然而 ASCII 码已经向我们证明，编码英文只需要 1 字节。若采用上述方案，英文文本占用空间的大小将会是 ASCII 编码下大小的两倍，非常浪费内存空间。因此，我们需要一种更加高效的 Unicode 编码方法。 @@ -61,7 +61,7 @@ UTF-8 的编码规则并不复杂，分为两种情况：  -Fig. UTF-8 编码示例
+图：UTF-8 编码示例
除了 UTF-8 之外，常见的编码方式还包括： diff --git a/chapter_data_structure/classification_of_data_structure.md b/chapter_data_structure/classification_of_data_structure.md index c5d0f1fab..0fda76a14 100644 --- a/chapter_data_structure/classification_of_data_structure.md +++ b/chapter_data_structure/classification_of_data_structure.md @@ -17,7 +17,7 @@ comments: true  -Fig. 线性与非线性数据结构
+图：线性与非线性数据结构
非线性数据结构可以进一步被划分为树形结构和网状结构。 @@ -35,7 +35,7 @@ comments: true  -Fig. 内存条、内存空间、内存地址
+图：内存条、内存空间、内存地址
内存是所有程序的共享资源，当某块内存被某个程序占用时，则无法被其他程序同时使用了。**因此在数据结构与算法的设计中，内存资源是一个重要的考虑因素**。比如，算法所占用的内存峰值不应超过系统剩余空闲内存；如果缺少连续大块的内存空间，那么所选用的数据结构必须能够存储在离散的内存空间内。 @@ -43,7 +43,7 @@ comments: true  -Fig. 连续空间存储与离散空间存储
+图：连续空间存储与离散空间存储
值得说明的是，**所有数据结构都是基于数组、链表或二者的组合实现的**。例如，栈和队列既可以使用数组实现，也可以使用链表实现；而哈希表的实现可能同时包含数组和链表。 diff --git a/chapter_data_structure/number_encoding.md b/chapter_data_structure/number_encoding.md index 27843f41c..01871430b 100644 --- a/chapter_data_structure/number_encoding.md +++ b/chapter_data_structure/number_encoding.md @@ -20,7 +20,7 @@ comments: true  -Fig. 原码、反码与补码之间的相互转换
+图：原码、反码与补码之间的相互转换
显然「原码」最为直观。但实际上，**数字是以「补码」的形式存储在计算机中的**。这是因为原码存在一些局限性。 @@ -131,7 +131,7 @@ $$  -Fig. IEEE 754 标准下的 float 表示方式
+图：IEEE 754 标准下的 float 表示方式
给定一个示例数据 $\mathrm{S} = 0$ ， $\mathrm{E} = 124$ ，$\mathrm{N} = 2^{-2} + 2^{-3} = 0.375$ ，则有： diff --git a/chapter_divide_and_conquer/binary_search_recur.md b/chapter_divide_and_conquer/binary_search_recur.md index 74af47b45..b780260b0 100644 --- a/chapter_divide_and_conquer/binary_search_recur.md +++ b/chapter_divide_and_conquer/binary_search_recur.md @@ -43,7 +43,7 @@ status: new  -Fig. 二分查找的分治过程
+图：二分查找的分治过程
在实现代码中，我们声明一个递归函数 `dfs()` 来求解问题 $f(i, j)$ 。 diff --git a/chapter_divide_and_conquer/build_binary_tree_problem.md b/chapter_divide_and_conquer/build_binary_tree_problem.md index 5a0890c9f..0651860f1 100644 --- a/chapter_divide_and_conquer/build_binary_tree_problem.md +++ b/chapter_divide_and_conquer/build_binary_tree_problem.md @@ -11,7 +11,7 @@ status: new  -Fig. 构建二叉树的示例数据
+图：构建二叉树的示例数据
### 判断是否为分治问题 @@ -38,7 +38,7 @@ status: new  -Fig. 在前序和中序遍历中划分子树
+图：在前序和中序遍历中划分子树
### 基于变量描述子树区间 @@ -64,7 +64,7 @@ status: new  -Fig. 根节点和左右子树的索引区间表示
+图：根节点和左右子树的索引区间表示
### 代码实现 @@ -430,6 +430,8 @@ status: new === "<10>"  +图：构建二叉树的递归过程
+ 设树的节点数量为 $n$ ，初始化每一个节点（执行一个递归函数 `dfs()` ）使用 $O(1)$ 时间。**因此总体时间复杂度为 $O(n)$** 。 哈希表存储 `inorder` 元素到索引的映射，空间复杂度为 $O(n)$ 。最差情况下，即二叉树退化为链表时，递归深度达到 $n$ ，使用 $O(n)$ 的栈帧空间。**因此总体空间复杂度为 $O(n)$** 。 diff --git a/chapter_divide_and_conquer/divide_and_conquer.md b/chapter_divide_and_conquer/divide_and_conquer.md index ceaf7e345..2a9e91391 100644 --- a/chapter_divide_and_conquer/divide_and_conquer.md +++ b/chapter_divide_and_conquer/divide_and_conquer.md @@ -17,7 +17,7 @@ status: new  -Fig. 归并排序的分治策略
+图：归并排序的分治策略
## 12.1.1. 如何判断分治问题 @@ -49,7 +49,7 @@ $$  -Fig. 划分数组前后的冒泡排序
+图：划分数组前后的冒泡排序
接下来，我们计算以下不等式，其左边和右边分别为划分前和划分后的操作总数： @@ -77,7 +77,7 @@ $$  -Fig. 桶排序的并行计算
+图：桶排序的并行计算
## 12.1.3. 分治常见应用 diff --git a/chapter_divide_and_conquer/hanota_problem.md b/chapter_divide_and_conquer/hanota_problem.md index 3c40b40db..8f28c1ef8 100644 --- a/chapter_divide_and_conquer/hanota_problem.md +++ b/chapter_divide_and_conquer/hanota_problem.md @@ -17,7 +17,7 @@ status: new  -Fig. 汉诺塔问题示例
+图：汉诺塔问题示例
**我们将规模为 $i$ 的汉诺塔问题记做 $f(i)$** 。例如 $f(3)$ 代表将 $3$ 个圆盘从 `A` 移动至 `C` 的汉诺塔问题。 @@ -31,6 +31,8 @@ status: new === "<2>"  +图：规模为 1 问题的解
+ 对于问题 $f(2)$ ，即当有两个圆盘时，**由于要时刻满足小圆盘在大圆盘之上，因此需要借助 `B` 来完成移动**，包括三步： 1. 先将上面的小圆盘从 `A` 移至 `B` 。 @@ -51,6 +53,8 @@ status: new === "<4>"  +图：规模为 2 问题的解
+ ### 子问题分解 对于问题 $f(3)$ ，即当有三个圆盘时，情况变得稍微复杂了一些。由于已知 $f(1)$ 和 $f(2)$ 的解，因此可从分治角度思考，**将 `A` 顶部的两个圆盘看做一个整体**，执行以下步骤： @@ -73,6 +77,8 @@ status: new === "<4>"  +图：规模为 3 问题的解
+ 本质上看，**我们将问题 $f(3)$ 划分为两个子问题 $f(2)$ 和子问题 $f(1)$** 。按顺序解决这三个子问题之后，原问题随之得到解决。这说明子问题是独立的，而且解是可以合并的。 至此，我们可总结出汉诺塔问题的分治策略：将原问题 $f(n)$ 划分为两个子问题 $f(n-1)$ 和一个子问题 $f(1)$ 。子问题的解决顺序为： @@ -85,7 +91,7 @@ status: new  -Fig. 汉诺塔问题的分治策略
+图：汉诺塔问题的分治策略
### 代码实现 @@ -431,7 +437,7 @@ status: new  -Fig. 汉诺塔问题的递归树
+图：汉诺塔问题的递归树
!!! quote diff --git a/chapter_dynamic_programming/dp_problem_features.md b/chapter_dynamic_programming/dp_problem_features.md index e8d7f5bd5..b163f561b 100644 --- a/chapter_dynamic_programming/dp_problem_features.md +++ b/chapter_dynamic_programming/dp_problem_features.md @@ -25,7 +25,7 @@ status: new  -Fig. 爬到第 3 阶的最小代价
+图：爬到第 3 阶的最小代价
设 $dp[i]$ 为爬到第 $i$ 阶累计付出的代价，由于第 $i$ 阶只可能从 $i - 1$ 阶或 $i - 2$ 阶走来，因此 $dp[i]$ 只可能等于 $dp[i - 1] + cost[i]$ 或 $dp[i - 2] + cost[i]$ 。为了尽可能减少代价，我们应该选择两者中较小的那一个，即： @@ -248,7 +248,7 @@ $$  -Fig. 爬楼梯最小代价的动态规划过程
+图：爬楼梯最小代价的动态规划过程
本题也可以进行状态压缩，将一维压缩至零维，使得空间复杂度从 $O(n)$ 降低至 $O(1)$ 。 @@ -447,7 +447,7 @@ $$  -Fig. 带约束爬到第 3 阶的方案数量
+图：带约束爬到第 3 阶的方案数量
在该问题中，如果上一轮是跳 $1$ 阶上来的，那么下一轮就必须跳 $2$ 阶。这意味着，**下一步选择不能由当前状态（当前楼梯阶数）独立决定，还和前一个状态（上轮楼梯阶数）有关**。 @@ -469,7 +469,7 @@ $$  -Fig. 考虑约束下的递推关系
+图：考虑约束下的递推关系
最终，返回 $dp[n, 1] + dp[n, 2]$ 即可，两者之和代表爬到第 $n$ 阶的方案总数。 diff --git a/chapter_dynamic_programming/dp_solution_pipeline.md b/chapter_dynamic_programming/dp_solution_pipeline.md index 4ca8ed4e4..35c53f86f 100644 --- a/chapter_dynamic_programming/dp_solution_pipeline.md +++ b/chapter_dynamic_programming/dp_solution_pipeline.md @@ -44,7 +44,7 @@ status: new  -Fig. 最小路径和示例数据
+图：最小路径和示例数据
**第一步：思考每轮的决策，定义状态，从而得到 $dp$ 表** @@ -56,7 +56,7 @@ status: new  -Fig. 状态定义与 dp 表
+图：状态定义与 dp 表
!!! note @@ -76,7 +76,7 @@ $$  -Fig. 最优子结构与状态转移方程
+图：最优子结构与状态转移方程
!!! note @@ -92,7 +92,7 @@ $$  -Fig. 边界条件与状态转移顺序
+图：边界条件与状态转移顺序
!!! note @@ -322,7 +322,7 @@ $$  -Fig. 暴力搜索递归树
+图：暴力搜索递归树
每个状态都有向下和向右两种选择，从左上角走到右下角总共需要 $m + n - 2$ 步，所以最差时间复杂度为 $O(2^{m + n})$ 。请注意，这种计算方式未考虑临近网格边界的情况，当到达网络边界时只剩下一种选择。因此实际的路径数量会少一些。 @@ -586,7 +586,7 @@ $$  -Fig. 记忆化搜索递归树
+图：记忆化搜索递归树
### 方法三：动态规划 @@ -893,6 +893,8 @@ $$ === "<12>"  +图：最小路径和的动态规划过程
+ ### 状态压缩 由于每个格子只与其左边和上边的格子有关，因此我们可以只用一个单行数组来实现 $dp$ 表。 diff --git a/chapter_dynamic_programming/edit_distance_problem.md b/chapter_dynamic_programming/edit_distance_problem.md index ce04d6799..e7fd47152 100644 --- a/chapter_dynamic_programming/edit_distance_problem.md +++ b/chapter_dynamic_programming/edit_distance_problem.md @@ -17,7 +17,7 @@ status: new  -Fig. 编辑距离的示例数据
+图：编辑距离的示例数据
**编辑距离问题可以很自然地用决策树模型来解释**。字符串对应树节点，一轮决策（一次编辑操作）对应树的一条边。 @@ -27,7 +27,7 @@ status: new  -Fig. 基于决策树模型表示编辑距离问题
+图：基于决策树模型表示编辑距离问题
**第一步：思考每轮的决策，定义状态，从而得到 $dp$ 表** @@ -54,7 +54,7 @@ status: new  -Fig. 编辑距离的状态转移
+图：编辑距离的状态转移
根据以上分析，可得最优子结构：$dp[i, j]$ 的最少编辑步数等于 $dp[i, j-1]$ , $dp[i-1, j]$ , $dp[i-1, j-1]$ 三者中的最少编辑步数，再加上本次的编辑步数 $1$ 。对应的状态转移方程为： @@ -411,6 +411,8 @@ $$ === "<15>"  +图：编辑距离的动态规划过程
+ ### 状态压缩 由于 $dp[i,j]$ 是由上方 $dp[i-1, j]$ 、左方 $dp[i, j-1]$ 、左上方状态 $dp[i-1, j-1]$ 转移而来，而正序遍历会丢失左上方 $dp[i-1, j-1]$ ，倒序遍历无法提前构建 $dp[i, j-1]$ ，因此两种遍历顺序都不可取。 diff --git a/chapter_dynamic_programming/intro_to_dynamic_programming.md b/chapter_dynamic_programming/intro_to_dynamic_programming.md index 6e1d5c7dc..88ee31643 100644 --- a/chapter_dynamic_programming/intro_to_dynamic_programming.md +++ b/chapter_dynamic_programming/intro_to_dynamic_programming.md @@ -17,7 +17,7 @@ status: new  -Fig. 爬到第 3 阶的方案数量
+图：爬到第 3 阶的方案数量
本题的目标是求解方案数量，**我们可以考虑通过回溯来穷举所有可能性**。具体来说，将爬楼梯想象为一个多轮选择的过程：从地面出发，每轮选择上 $1$ 阶或 $2$ 阶，每当到达楼梯顶部时就将方案数量加 $1$ ，当越过楼梯顶部时就将其剪枝。 @@ -149,7 +149,7 @@ status: new // 当爬到第 n 阶时，方案数量加 1 if (state === n) res.set(0, res.get(0) + 1); // 遍历所有选择 - for (choice of choices) { + for (const choice of choices) { // 剪枝：不允许越过第 n 阶 if (state + choice > n) break; // 尝试：做出选择，更新状态 @@ -182,7 +182,7 @@ status: new // 当爬到第 n 阶时，方案数量加 1 if (state === n) res.set(0, res.get(0) + 1); // 遍历所有选择 - for (let choice of choices) { + for (const choice of choices) { // 剪枝：不允许越过第 n 阶 if (state + choice > n) break; // 尝试：做出选择，更新状态 @@ -382,7 +382,7 @@ $$  -Fig. 方案数量递推关系
+图：方案数量递推关系
我们可以根据递推公式得到暴力搜索解法： @@ -609,7 +609,7 @@ $$  -Fig. 爬楼梯对应递归树
+图：爬楼梯对应递归树
观察上图发现，**指数阶的时间复杂度是由于「重叠子问题」导致的**。例如：$dp[9]$ 被分解为 $dp[8]$ 和 $dp[7]$ ，$dp[8]$ 被分解为 $dp[7]$ 和 $dp[6]$ ，两者都包含子问题 $dp[7]$ 。 @@ -921,7 +921,7 @@ $$  -Fig. 记忆化搜索对应递归树
+图：记忆化搜索对应递归树
## 14.1.3. 方法三：动态规划 @@ -1165,7 +1165,7 @@ $$  -Fig. 爬楼梯的动态规划过程
+图：爬楼梯的动态规划过程
## 14.1.4. 状态压缩 diff --git a/chapter_dynamic_programming/knapsack_problem.md b/chapter_dynamic_programming/knapsack_problem.md index 4d894d8a5..36f7042b8 100644 --- a/chapter_dynamic_programming/knapsack_problem.md +++ b/chapter_dynamic_programming/knapsack_problem.md @@ -17,7 +17,7 @@ status: new  -Fig. 0-1 背包的示例数据
+图：0-1 背包的示例数据
我们可以将 0-1 背包问题看作是一个由 $n$ 轮决策组成的过程，每个物体都有不放入和放入两种决策，因此该问题是满足决策树模型的。 @@ -273,7 +273,7 @@ $$  -Fig. 0-1 背包的暴力搜索递归树
+图：0-1 背包的暴力搜索递归树
### 方法二：记忆化搜索 @@ -539,7 +539,7 @@ $$  -Fig. 0-1 背包的记忆化搜索递归树
+图：0-1 背包的记忆化搜索递归树
### 方法三：动态规划 @@ -822,6 +822,8 @@ $$ === "<14>"  +图：0-1 背包的动态规划过程
+ ### 状态压缩 由于每个状态都只与其上一行的状态有关，因此我们可以使用两个数组滚动前进，将空间复杂度从 $O(n^2)$ 将低至 $O(n)$ 。 @@ -851,6 +853,8 @@ $$ === "<6>"  +图：0-1 背包的状态压缩后的动态规划过程
+ 在代码实现中，我们仅需将数组 `dp` 的第一维 $i$ 直接删除，并且把内循环更改为倒序遍历即可。 === "Java" diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.md b/chapter_dynamic_programming/unbounded_knapsack_problem.md index da0cfbeb9..929c94a8a 100644 --- a/chapter_dynamic_programming/unbounded_knapsack_problem.md +++ b/chapter_dynamic_programming/unbounded_knapsack_problem.md @@ -15,7 +15,7 @@ status: new  -Fig. 完全背包问题的示例数据
+图：完全背包问题的示例数据
完全背包和 0-1 背包问题非常相似，**区别仅在于不限制物品的选择次数**。 @@ -294,6 +294,8 @@ $$ === "<6>"  +图：完全背包的状态压缩后的动态规划过程
+ 代码实现比较简单，仅需将数组 `dp` 的第一维删除。 === "Java" @@ -537,7 +539,7 @@ $$  -Fig. 零钱兑换问题的示例数据
+图：零钱兑换问题的示例数据
**零钱兑换可以看作是完全背包的一种特殊情况**，两者具有以下联系与不同点： @@ -907,6 +909,8 @@ $$ === "<15>"  +图：零钱兑换问题的动态规划过程
+ ### 状态压缩 零钱兑换的状态压缩的处理方式和完全背包一致。 @@ -1182,7 +1186,7 @@ $$  -Fig. 零钱兑换问题 II 的示例数据
+图：零钱兑换问题 II 的示例数据
相比于上一题，本题目标是组合数量，因此子问题变为：**前 $i$ 种硬币能够凑出金额 $a$ 的组合数量**。而 $dp$ 表仍然是尺寸为 $(n+1) \times (amt + 1)$ 的二维矩阵。 diff --git a/chapter_graph/graph.md b/chapter_graph/graph.md index 73b767cdb..5e8106a3e 100644 --- a/chapter_graph/graph.md +++ b/chapter_graph/graph.md @@ -16,7 +16,7 @@ $$  -Fig. 链表、树、图之间的关系
+图：链表、树、图之间的关系
那么，图与其他数据结构的关系是什么？如果我们把「顶点」看作节点，把「边」看作连接各个节点的指针，则可将「图」看作是一种从「链表」拓展而来的数据结构。**相较于线性关系（链表）和分治关系（树），网络关系（图）的自由度更高，从而更为复杂**。 @@ -29,7 +29,7 @@ $$  -Fig. 有向图与无向图
+图：有向图与无向图
根据所有顶点是否连通，可分为「连通图 Connected Graph」和「非连通图 Disconnected Graph」。 @@ -38,13 +38,13 @@ $$  -Fig. 连通图与非连通图
+图：连通图与非连通图
我们还可以为边添加“权重”变量，从而得到「有权图 Weighted Graph」。例如，在王者荣耀等手游中，系统会根据共同游戏时间来计算玩家之间的“亲密度”，这种亲密度网络就可以用有权图来表示。  -Fig. 有权图与无权图
+图：有权图与无权图
## 9.1.2. 图常用术语 @@ -64,7 +64,7 @@ $$  -Fig. 图的邻接矩阵表示
+图：图的邻接矩阵表示
邻接矩阵具有以下特性： @@ -80,7 +80,7 @@ $$  -Fig. 图的邻接表表示
+图：图的邻接表表示
邻接表仅存储实际存在的边，而边的总数通常远小于 $n^2$ ，因此它更加节省空间。然而，在邻接表中需要通过遍历链表来查找边，因此其时间效率不如邻接矩阵。 diff --git a/chapter_graph/graph_operations.md b/chapter_graph/graph_operations.md index 7b2190b5a..c8131e3f5 100644 --- a/chapter_graph/graph_operations.md +++ b/chapter_graph/graph_operations.md @@ -30,6 +30,8 @@ comments: true === "删除顶点"  +图：邻接矩阵的初始化、增删边、增删顶点
+ 以下是基于邻接矩阵表示图的实现代码。 === "Java" @@ -1147,6 +1149,8 @@ comments: true === "删除顶点"  +图：邻接表的初始化、增删边、增删顶点
+ 以下是基于邻接表实现图的代码示例。细心的同学可能注意到，**我们在邻接表中使用 `Vertex` 节点类来表示顶点**，这样做的原因有： - 如果我们选择通过顶点值来区分不同顶点，那么值重复的顶点将无法被区分。 @@ -1533,7 +1537,7 @@ comments: true // 在邻接表中删除顶点 vet 对应的链表 this.adjList.delete(vet); // 遍历其他顶点的链表，删除所有包含 vet 的边 - for (let set of this.adjList.values()) { + for (const set of this.adjList.values()) { const index = set.indexOf(vet); if (index > -1) { set.splice(index, 1); @@ -1622,7 +1626,7 @@ comments: true // 在邻接表中删除顶点 vet 对应的链表 this.adjList.delete(vet); // 遍历其他顶点的链表，删除所有包含 vet 的边 - for (let set of this.adjList.values()) { + for (const set of this.adjList.values()) { const index: number = set.indexOf(vet); if (index > -1) { set.splice(index, 1); diff --git a/chapter_graph/graph_traversal.md b/chapter_graph/graph_traversal.md index 62f9c8a1a..ad86dbf97 100644 --- a/chapter_graph/graph_traversal.md +++ b/chapter_graph/graph_traversal.md @@ -18,7 +18,7 @@ comments: true  -Fig. 图的广度优先遍历
+图：图的广度优先遍历
### 算法实现 @@ -427,6 +427,8 @@ BFS 通常借助「队列」来实现。队列具有“先入先出”的性质 === "<11>"  +图：图的广度优先遍历步骤
+ !!! question "广度优先遍历的序列是否唯一？" 不唯一。广度优先遍历只要求按“由近及远”的顺序遍历，**而多个相同距离的顶点的遍历顺序是允许被任意打乱的**。以上图为例，顶点 $1$ , $3$ 的访问顺序可以交换、顶点 $2$ , $4$ , $6$ 的访问顺序也可以任意交换。 @@ -443,7 +445,7 @@ BFS 通常借助「队列」来实现。队列具有“先入先出”的性质  -Fig. 图的深度优先遍历
+图：图的深度优先遍历
### 算法实现 @@ -835,6 +837,8 @@ BFS 通常借助「队列」来实现。队列具有“先入先出”的性质 === "<11>"  +图：图的深度优先遍历步骤
+ !!! question "深度优先遍历的序列是否唯一？" 与广度优先遍历类似，深度优先遍历序列的顺序也不是唯一的。给定某顶点，先往哪个方向探索都可以，即邻接顶点的顺序可以任意打乱，都是深度优先遍历。 diff --git a/chapter_greedy/fractional_knapsack_problem.md b/chapter_greedy/fractional_knapsack_problem.md index d4d68fb34..21ec67058 100644 --- a/chapter_greedy/fractional_knapsack_problem.md +++ b/chapter_greedy/fractional_knapsack_problem.md @@ -13,7 +13,7 @@ status: new  -Fig. 分数背包问题的示例数据
+图：分数背包问题的示例数据
本题和 0-1 背包整体上非常相似，状态包含当前物品 $i$ 和容量 $c$ ，目标是求不超过背包容量下的最大价值。 @@ -24,7 +24,7 @@ status: new  -Fig. 物品在单位重量下的价值
+图：物品在单位重量下的价值
### 贪心策略确定 @@ -36,7 +36,7 @@ status: new  -Fig. 分数背包的贪心策略
+图：分数背包的贪心策略
### 代码实现 @@ -373,4 +373,4 @@ status: new  -Fig. 分数背包问题的几何表示
+图：分数背包问题的几何表示
diff --git a/chapter_greedy/greedy_algorithm.md b/chapter_greedy/greedy_algorithm.md index f98849f48..5e52a17a5 100644 --- a/chapter_greedy/greedy_algorithm.md +++ b/chapter_greedy/greedy_algorithm.md @@ -22,7 +22,7 @@ status: new  -Fig. 零钱兑换的贪心策略
+图：零钱兑换的贪心策略
实现代码如下所示。你可能会不由地发出感叹：So Clean ！贪心算法仅用十行代码就解决了零钱兑换问题。 @@ -233,7 +233,7 @@ status: new  -Fig. 贪心无法找出最优解的示例
+图：贪心无法找出最优解的示例
也就是说，对于零钱兑换问题，贪心算法无法保证找到全局最优解，并且有可能找到非常差的解。它更适合用动态规划解决。 diff --git a/chapter_greedy/max_capacity_problem.md b/chapter_greedy/max_capacity_problem.md index 03e650ec2..15106ed1a 100644 --- a/chapter_greedy/max_capacity_problem.md +++ b/chapter_greedy/max_capacity_problem.md @@ -15,7 +15,7 @@ status: new  -Fig. 最大容量问题的示例数据
+图：最大容量问题的示例数据
容器由任意两个隔板围成，**因此本题的状态为两个隔板的索引，记为 $[i, j]$** 。 @@ -33,7 +33,7 @@ $$  -Fig. 初始状态
+图：初始状态
我们发现，**如果此时将长板 $j$ 向短板 $i$ 靠近，则容量一定变小**。这是因为在移动长板 $j$ 后： @@ -42,13 +42,13 @@ $$  -Fig. 向内移动长板后的状态
+图：向内移动长板后的状态
反向思考，**我们只有向内收缩短板 $i$ ，才有可能使容量变大**。因为虽然宽度一定变小，**但高度可能会变大**（移动后的短板 $i$ 可能会变长）。  -Fig. 向内移动长板后的状态
+图：向内移动长板后的状态
由此便可推出本题的贪心策略： @@ -84,6 +84,8 @@ $$ === "<9>"  +图：最大容量问题的贪心过程
+ ### 代码实现 代码循环最多 $n$ 轮，**因此时间复杂度为 $O(n)$** 。 @@ -305,7 +307,7 @@ $$  -Fig. 移动短板导致被跳过的状态
+图：移动短板导致被跳过的状态
观察发现，**这些被跳过的状态实际上就是将长板 $j$ 向内移动的所有状态**。而在第二步中，我们已经证明内移长板一定会导致容量变小。也就是说，被跳过的状态都不可能是最优解，**跳过它们不会导致错过最优解**。 diff --git a/chapter_greedy/max_product_cutting_problem.md b/chapter_greedy/max_product_cutting_problem.md index 02a6e9fff..6c899559d 100644 --- a/chapter_greedy/max_product_cutting_problem.md +++ b/chapter_greedy/max_product_cutting_problem.md @@ -11,7 +11,7 @@ status: new  -Fig. 最大切分乘积的问题定义
+图：最大切分乘积的问题定义
假设我们将 $n$ 切分为 $m$ 个整数因子，其中第 $i$ 个因子记为 $n_i$ ，即 @@ -45,7 +45,7 @@ $$  -Fig. 切分导致乘积变大
+图：切分导致乘积变大
接下来思考哪个因子是最优的。在 $1$ , $2$ , $3$ 这三个因子中，显然 $1$ 是最差的，因为 $1 \times (n-1) < n$ 恒成立，即切分出 $1$ 反而会导致乘积减小。 @@ -55,7 +55,7 @@ $$  -Fig. 最优切分因子
+图：最优切分因子
总结以上，可推出贪心策略： @@ -276,7 +276,7 @@ $$  -Fig. 最大切分乘积的计算方法
+图：最大切分乘积的计算方法
**时间复杂度取决于编程语言的幂运算的实现方法**。以 Python 为例，常用的幂计算函数有三种： diff --git a/chapter_hashing/hash_algorithm.md b/chapter_hashing/hash_algorithm.md index 1cc3df0be..749eb2de1 100644 --- a/chapter_hashing/hash_algorithm.md +++ b/chapter_hashing/hash_algorithm.md @@ -10,7 +10,7 @@ comments: true  -Fig. 哈希冲突的最佳与最差情况
+图：哈希冲突的最佳与最差情况
**键值对的分布情况由哈希函数决定**。回忆哈希函数的计算步骤，先计算哈希值，再对数组长度取模： @@ -439,13 +439,45 @@ index = hash(key) % capacity === "Dart" ```dart title="simple_hash.dart" - [class]{}-[func]{add_hash} + /* 加法哈希 */ + int addHash(String key) { + int hash = 0; + final int MODULUS = 1000000007; + for (int i = 0; i < key.length; i++) { + hash = (hash + key.codeUnitAt(i)) % MODULUS; + } + return hash; + } - [class]{}-[func]{mul_hash} + /* 乘法哈希 */ + int mulHash(String key) { + int hash = 0; + final int MODULUS = 1000000007; + for (int i = 0; i < key.length; i++) { + hash = (31 * hash + key.codeUnitAt(i)) % MODULUS; + } + return hash; + } - [class]{}-[func]{xor_hash} + /* 异或哈希 */ + int xorHash(String key) { + int hash = 0; + final int MODULUS = 1000000007; + for (int i = 0; i < key.length; i++) { + hash ^= key.codeUnitAt(i); + } + return hash & MODULUS; + } - [class]{}-[func]{rot_hash} + /* 旋转哈希 */ + int rotHash(String key) { + int hash = 0; + final int MODULUS = 1000000007; + for (int i = 0; i < key.length; i++) { + hash = ((hash << 4) ^ (hash >> 28) ^ key.codeUnitAt(i)) % MODULUS; + } + return hash; + } ``` === "Rust" @@ -584,7 +616,7 @@ $$ # 布尔量 True 的哈希值为 1 dec = 3.14159 - hash_dec = hash(dec) + hash_dec = hash(dec) # 小数 3.14159 的哈希值为 326484311674566659 str = "Hello 算法" @@ -692,23 +724,23 @@ $$ int num = 3; int hashNum = num.hashCode; // 整数 3 的哈希值为 34803 - + bool bol = true; int hashBol = bol.hashCode; // 布尔值 true 的哈希值为 1231 - + double dec = 3.14159; int hashDec = dec.hashCode; // 小数 3.14159 的哈希值为 2570631074981783 - + String str = "Hello 算法"; int hashStr = str.hashCode; // 字符串 Hello 算法 的哈希值为 468167534 - + List arr = [12836, "小哈"]; int hashArr = arr.hashCode; // 数组 [12836, 小哈] 的哈希值为 976512528 - + ListNode obj = new ListNode(0); int hashObj = obj.hashCode; // 节点对象 Instance of 'ListNode' 的哈希值为 1033450432 diff --git a/chapter_hashing/hash_collision.md b/chapter_hashing/hash_collision.md index 5989ea359..863df4ae2 100644 --- a/chapter_hashing/hash_collision.md +++ b/chapter_hashing/hash_collision.md @@ -19,7 +19,7 @@ comments: true  -Fig. 链式地址哈希表
+图：链式地址哈希表
链式地址下，哈希表的操作方法包括： @@ -542,7 +542,7 @@ comments: true for (let i = 0; i < bucket.length; i++) { if (bucket[i].key === key) { bucket.splice(i, 1); - this.size--; + this.#size--; break; } } @@ -1165,7 +1165,7 @@ comments: true  -Fig. 线性探测
+图：线性探测
然而，线性探测存在以下缺陷： diff --git a/chapter_hashing/hash_map.md b/chapter_hashing/hash_map.md index cb0f5521d..23a823843 100755 --- a/chapter_hashing/hash_map.md +++ b/chapter_hashing/hash_map.md @@ -10,7 +10,7 @@ comments: true  -Fig. 哈希表的抽象表示
+图：哈希表的抽象表示
除哈希表外，我们还可以使用数组或链表实现查询功能。若将学生数据看作数组（链表）元素，则有： @@ -464,7 +464,7 @@ index = hash(key) % capacity  -Fig. 哈希函数工作原理
+图：哈希函数工作原理
以下代码实现了一个简单哈希表。其中，我们将 `key` 和 `value` 封装成一个类 `Pair` ，以表示键值对。 @@ -1501,13 +1501,13 @@ index = hash(key) % capacity  -Fig. 哈希冲突示例
+图：哈希冲突示例
容易想到，哈希表容量 $n$ 越大，多个 `key` 被分配到同一个桶中的概率就越低，冲突就越少。因此，**我们可以通过扩容哈希表来减少哈希冲突**。如下图所示，扩容前键值对 `(136, A)` 和 `(236, D)` 发生冲突，扩容后冲突消失。  -Fig. 哈希表扩容
+图：哈希表扩容
类似于数组扩容，哈希表扩容需将所有键值对从原哈希表迁移至新哈希表，非常耗时。并且由于哈希表容量 `capacity` 改变，我们需要通过哈希函数来重新计算所有键值对的存储位置，这进一步提高了扩容过程的计算开销。为此，编程语言通常会预留足够大的哈希表容量，防止频繁扩容。 diff --git a/chapter_heap/build_heap.md b/chapter_heap/build_heap.md index d78f75b4b..ef7f1a3ae 100644 --- a/chapter_heap/build_heap.md +++ b/chapter_heap/build_heap.md @@ -171,7 +171,7 @@ comments: true _maxHeap = nums; // 堆化除叶节点以外的其他所有节点 for (int i = _parent(size() - 1); i >= 0; i--) { - _siftDown(i); + siftDown(i); } } ``` @@ -204,7 +204,7 @@ comments: true  -Fig. 完美二叉树的各层节点数量
+图：完美二叉树的各层节点数量
因此，我们可以将各层的“节点数量 $\times$ 节点高度”求和，**从而得到所有节点的堆化迭代次数的总和**。 diff --git a/chapter_heap/heap.md b/chapter_heap/heap.md index 2c7eb2445..a017fa414 100644 --- a/chapter_heap/heap.md +++ b/chapter_heap/heap.md @@ -11,7 +11,7 @@ comments: true  -Fig. 小顶堆与大顶堆
+图：小顶堆与大顶堆
堆作为完全二叉树的一个特例，具有以下特性： @@ -333,7 +333,7 @@ comments: true  -Fig. 堆的表示与存储
+图：堆的表示与存储
我们可以将索引映射公式封装成函数，方便后续使用。 @@ -708,6 +708,8 @@ comments: true === "<9>"  +图：元素入堆步骤
+ 设节点总数为 $n$ ，则树的高度为 $O(\log n)$ 。由此可知，堆化操作的循环轮数最多为 $O(\log n)$ ，**元素入堆操作的时间复杂度为 $O(\log n)$** 。 === "Java" @@ -994,10 +996,24 @@ comments: true // 添加节点 _maxHeap.add(val); // 从底至顶堆化 - _siftUp(size() - 1); + siftUp(size() - 1); } - [class]{MaxHeap}-[func]{siftUp} + /* 从节点 i 开始，从底至顶堆化 */ + void siftUp(int i) { + while (true) { + // 获取节点 i 的父节点 + int p = _parent(i); + // 当“越过根节点”或“节点无需修复”时，结束堆化 + if (p < 0 || _maxHeap[i] <= _maxHeap[p]) { + break; + } + // 交换两节点 + _swap(i, p); + // 循环向上堆化 + i = p; + } + } ``` === "Rust" @@ -1072,6 +1088,8 @@ comments: true === "<10>"  +图：堆顶元素出堆步骤
+ 与元素入堆操作相似，堆顶元素出堆操作的时间复杂度也为 $O(\log n)$ 。 === "Java" @@ -1480,12 +1498,28 @@ comments: true // 删除节点 int val = _maxHeap.removeLast(); // 从顶至底堆化 - _siftDown(0); + siftDown(0); // 返回堆顶元素 return val; } - [class]{MaxHeap}-[func]{siftDown} + /* 从节点 i 开始，从顶至底堆化 */ + void siftDown(int i) { + while (true) { + // 判断节点 i, l, r 中值最大的节点，记为 ma + int l = _left(i); + int r = _right(i); + int ma = i; + if (l < size() && _maxHeap[l] > _maxHeap[ma]) ma = l; + if (r < size() && _maxHeap[r] > _maxHeap[ma]) ma = r; + // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + if (ma == i) break; + // 交换两节点 + _swap(i, ma); + // 循环向下堆化 + i = ma; + } + } ``` === "Rust" diff --git a/chapter_heap/top_k.md b/chapter_heap/top_k.md index ccfc8852c..6aa03c934 100644 --- a/chapter_heap/top_k.md +++ b/chapter_heap/top_k.md @@ -18,11 +18,11 @@ comments: true  -Fig. 遍历寻找最大的 k 个元素
+图：遍历寻找最大的 k 个元素
!!! tip - 当 $k = n$ 时，我们可以得到从大到小的序列，等价于「选择排序」算法。 + 当 $k = n$ 时，我们可以得到从大到小的序列，等价于「选择排序」算法。 ## 8.3.2. 方法二：排序 @@ -32,7 +32,7 @@ comments: true  -Fig. 排序寻找最大的 k 个元素
+图：排序寻找最大的 k 个元素
## 8.3.3. 方法三：堆 @@ -70,6 +70,8 @@ comments: true === "<9>"  +图：基于堆寻找最大的 k 个元素
+ 总共执行了 $n$ 轮入堆和出堆，堆的最大长度为 $k$ ，因此时间复杂度为 $O(n \log k)$ 。该方法的效率很高，当 $k$ 较小时，时间复杂度趋向 $O(n)$ ；当 $k$ 较大时，时间复杂度不会超过 $O(n \log n)$ 。 另外，该方法适用于动态数据流的使用场景。在不断加入数据时，我们可以持续维护堆内的元素，从而实现最大 $k$ 个元素的动态更新。 @@ -227,7 +229,20 @@ comments: true === "Dart" ```dart title="top_k.dart" - [class]{}-[func]{top_k_heap} + /* 基于堆查找数组中最大的 k 个元素 */ + MinHeap topKHeap(List图：查字典步骤
+ 查阅字典这个小学生必备技能，实际上就是著名的「二分查找」。从数据结构的角度，我们可以把字典视为一个已排序的「数组」；从算法的角度，我们可以将上述查字典的一系列操作看作是「二分查找」算法。 **例二：整理扑克**。我们在打牌时，每局都需要整理扑克牌，使其从小到大排列，实现流程如下： @@ -39,7 +41,7 @@ comments: true  -Fig. 扑克排序步骤
+图：扑克排序步骤
上述整理扑克牌的方法本质上是「插入排序」算法，它在处理小型数据集时非常高效。许多编程语言的排序库函数中都存在插入排序的身影。 @@ -53,7 +55,7 @@ comments: true  -Fig. 货币找零过程
+图：货币找零过程
在以上步骤中，我们每一步都采取当前看来最好的选择（尽可能用大面额的货币），最终得到了可行的找零方案。从数据结构与算法的角度看，这种方法本质上是「贪心算法」。 diff --git a/chapter_introduction/what_is_dsa.md b/chapter_introduction/what_is_dsa.md index 5fef71fee..8b4a82dc6 100644 --- a/chapter_introduction/what_is_dsa.md +++ b/chapter_introduction/what_is_dsa.md @@ -35,13 +35,13 @@ comments: true  -Fig. 数据结构与算法的关系
+图：数据结构与算法的关系
数据结构与算法犹如拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。  -Fig. 拼装积木
+图：拼装积木
两者的详细对应关系如下表所示。 diff --git a/chapter_preface/about_the_book.md b/chapter_preface/about_the_book.md index bdc0f7f26..bd34348b2 100644 --- a/chapter_preface/about_the_book.md +++ b/chapter_preface/about_the_book.md @@ -32,7 +32,7 @@ comments: true  -Fig. Hello 算法内容结构
+图：Hello 算法内容结构
## 0.1.3. 致谢 diff --git a/chapter_preface/suggestions.md b/chapter_preface/suggestions.md index daef0e1dd..0a8fc1149 100644 --- a/chapter_preface/suggestions.md +++ b/chapter_preface/suggestions.md @@ -172,7 +172,7 @@ comments: true  -Fig. 动画图解示例
+图：动画图解示例
## 0.2.3. 在代码实践中加深理解 @@ -184,7 +184,7 @@ comments: true  -Fig. 运行代码示例
+图：运行代码示例
**第一步：安装本地编程环境**。请参照[附录教程](https://www.hello-algo.com/chapter_appendix/installation/)进行安装，如果已安装则可跳过此步骤。 @@ -198,13 +198,13 @@ git clone https://github.com/krahets/hello-algo.git  -Fig. 克隆仓库与下载代码
+图：克隆仓库与下载代码
**第三步：运行源代码**。如果代码块顶部标有文件名称，则可以在仓库的 `codes` 文件夹中找到相应的源代码文件。源代码文件将帮助你节省不必要的调试时间，让你能够专注于学习内容。  -Fig. 代码块与对应的源代码文件
+图：代码块与对应的源代码文件
## 0.2.4. 在提问讨论中共同成长 @@ -214,7 +214,7 @@ git clone https://github.com/krahets/hello-algo.git  -Fig. 评论区示例
+图：评论区示例
## 0.2.5. 算法学习路线 @@ -228,4 +228,4 @@ git clone https://github.com/krahets/hello-algo.git  -Fig. 算法学习路线
+图：算法学习路线
diff --git a/chapter_searching/binary_search.md b/chapter_searching/binary_search.md index 39fbc2507..506fb2605 100755 --- a/chapter_searching/binary_search.md +++ b/chapter_searching/binary_search.md @@ -12,7 +12,7 @@ comments: true  -Fig. 二分查找示例数据
+图：二分查找示例数据
对于上述问题，我们先初始化指针 $i = 0$ 和 $j = n - 1$ ，分别指向数组首元素和尾元素，代表搜索区间 $[0, n - 1]$ 。请注意，中括号表示闭区间，其包含边界值本身。 @@ -47,6 +47,8 @@ comments: true === "<7>"  +图：binary_search_step1
+ 值得注意的是，由于 $i$ 和 $j$ 都是 `int` 类型，**因此 $i + j$ 可能会超出 `int` 类型的取值范围**。为了避免大数越界，我们通常采用公式 $m = \lfloor {i + (j - i) / 2} \rfloor$ 来计算中点。 === "Java" @@ -627,7 +629,7 @@ comments: true  -Fig. 两种区间定义
+图：两种区间定义
## 10.1.2. 优点与局限性 diff --git a/chapter_searching/binary_search_edge.md b/chapter_searching/binary_search_edge.md index 0d5202ca9..c1bc9ee18 100644 --- a/chapter_searching/binary_search_edge.md +++ b/chapter_searching/binary_search_edge.md @@ -164,7 +164,7 @@ status: new  -Fig. 将查找右边界转化为查找左边界
+图：将查找右边界转化为查找左边界
请注意，返回的插入点是 $i$ ，因此需要将其减 $1$ ，从而获得 $j$ 。 @@ -321,7 +321,7 @@ status: new  -Fig. 将查找边界转化为查找元素
+图：将查找边界转化为查找元素
代码在此省略，值得注意的有： diff --git a/chapter_searching/binary_search_insertion.md b/chapter_searching/binary_search_insertion.md index 71fa34b9f..db61e915f 100644 --- a/chapter_searching/binary_search_insertion.md +++ b/chapter_searching/binary_search_insertion.md @@ -15,7 +15,7 @@ status: new  -Fig. 二分查找插入点示例数据
+图：二分查找插入点示例数据
如果想要复用上节的二分查找代码，则需要回答以下两个问题。 @@ -203,7 +203,7 @@ status: new  -Fig. 线性查找重复元素的插入点
+图：线性查找重复元素的插入点
此方法虽然可用，但其包含线性查找，因此时间复杂度为 $O(n)$ 。当数组中存在很多重复的 `target` 时，该方法效率很低。 @@ -238,6 +238,8 @@ status: new === "<8>"  +图：二分查找重复元素的插入点的步骤
+ 观察以下代码，判断分支 `nums[m] > target` 和 `nums[m] == target` 的操作相同，因此两者可以合并。 即便如此，我们仍然可以将判断条件保持展开，因为其逻辑更加清晰、可读性更好。 diff --git a/chapter_searching/replace_linear_by_hashing.md b/chapter_searching/replace_linear_by_hashing.md index 5df7b6ed1..1456b49f0 100755 --- a/chapter_searching/replace_linear_by_hashing.md +++ b/chapter_searching/replace_linear_by_hashing.md @@ -16,7 +16,7 @@ comments: true  -Fig. 线性查找求解两数之和
+图：线性查找求解两数之和
=== "Java" @@ -199,6 +199,7 @@ comments: true /* 方法一： 暴力枚举 */ List图：辅助哈希表求解两数之和
+ 实现代码如下所示，仅需单层循环即可。 === "Java" @@ -469,7 +472,9 @@ comments: true /* 方法二： 辅助哈希表 */ ListFig. 多种搜索策略
+图：多种搜索策略
上述几种方法的操作效率与特性如下表所示。 diff --git a/chapter_sorting/bubble_sort.md b/chapter_sorting/bubble_sort.md index b8232cf9e..44a20da18 100755 --- a/chapter_sorting/bubble_sort.md +++ b/chapter_sorting/bubble_sort.md @@ -29,6 +29,8 @@ comments: true === "<7>"  +图：利用元素交换操作模拟冒泡
+ ## 11.3.1. 算法流程 设数组的长度为 $n$ ，冒泡排序的步骤为： @@ -40,7 +42,7 @@ comments: true  -Fig. 冒泡排序流程
+图：冒泡排序流程
=== "Java" diff --git a/chapter_sorting/bucket_sort.md b/chapter_sorting/bucket_sort.md index 4d440bf3b..a75290b4c 100644 --- a/chapter_sorting/bucket_sort.md +++ b/chapter_sorting/bucket_sort.md @@ -18,7 +18,7 @@ comments: true  -Fig. 桶排序算法流程
+图：桶排序算法流程
=== "Java" @@ -411,10 +411,10 @@ comments: true  -Fig. 递归划分桶
+图：递归划分桶
如果我们提前知道商品价格的概率分布，**则可以根据数据概率分布设置每个桶的价格分界线**。值得注意的是，数据分布并不一定需要特意统计，也可以根据数据特点采用某种概率模型进行近似。如下图所示，我们假设商品价格服从正态分布，这样就可以合理地设定价格区间，从而将商品平均分配到各个桶中。  -Fig. 根据概率分布划分桶
+图：根据概率分布划分桶
diff --git a/chapter_sorting/counting_sort.md b/chapter_sorting/counting_sort.md index 8bc863b2d..098f714f3 100644 --- a/chapter_sorting/counting_sort.md +++ b/chapter_sorting/counting_sort.md @@ -16,7 +16,7 @@ comments: true  -Fig. 计数排序流程
+图：计数排序流程
=== "Java" @@ -362,6 +362,8 @@ $$ === "<8>"  +图：计数排序步骤
+ 计数排序的实现代码如下所示。 === "Java" diff --git a/chapter_sorting/heap_sort.md b/chapter_sorting/heap_sort.md index b098a6dd9..bbe36ecbe 100644 --- a/chapter_sorting/heap_sort.md +++ b/chapter_sorting/heap_sort.md @@ -62,6 +62,8 @@ comments: true === "<12>"  +图：堆排序步骤
+ 在代码实现中，我们使用了与堆章节相同的从顶至底堆化（Sift Down）的函数。值得注意的是，由于堆的长度会随着提取最大元素而减小，因此我们需要给 Sift Down 函数添加一个长度参数 $n$ ，用于指定堆的当前有效长度。 === "Java" diff --git a/chapter_sorting/insertion_sort.md b/chapter_sorting/insertion_sort.md index 6c8aaf4b8..3ca40a9f4 100755 --- a/chapter_sorting/insertion_sort.md +++ b/chapter_sorting/insertion_sort.md @@ -12,7 +12,7 @@ comments: true  -Fig. 单次插入操作
+图：单次插入操作
## 11.4.1. 算法流程 @@ -25,7 +25,7 @@ comments: true  -Fig. 插入排序流程
+图：插入排序流程
=== "Java" diff --git a/chapter_sorting/merge_sort.md b/chapter_sorting/merge_sort.md index c2011d7ae..3a9f553ce 100755 --- a/chapter_sorting/merge_sort.md +++ b/chapter_sorting/merge_sort.md @@ -11,7 +11,7 @@ comments: true  -Fig. 归并排序的划分与合并阶段
+图：归并排序的划分与合并阶段
## 11.6.1. 算法流程 @@ -52,6 +52,8 @@ comments: true === "<10>"  +图：归并排序步骤
+ 观察发现，归并排序的递归顺序与二叉树的后序遍历相同，具体来看： - **后序遍历**：先递归左子树，再递归右子树，最后处理根节点。 diff --git a/chapter_sorting/quick_sort.md b/chapter_sorting/quick_sort.md index 1cecabed9..15731464b 100755 --- a/chapter_sorting/quick_sort.md +++ b/chapter_sorting/quick_sort.md @@ -41,6 +41,8 @@ comments: true === "<9>"  +图：哨兵划分步骤
+ !!! note "快速排序的分治思想" 哨兵划分的实质是将一个较长数组的排序问题简化为两个较短数组的排序问题。 @@ -366,7 +368,7 @@ comments: true  -Fig. 快速排序流程
+图：快速排序流程
=== "Java" diff --git a/chapter_sorting/radix_sort.md b/chapter_sorting/radix_sort.md index 92e41be95..cec2175b6 100644 --- a/chapter_sorting/radix_sort.md +++ b/chapter_sorting/radix_sort.md @@ -18,7 +18,7 @@ comments: true  -Fig. 基数排序算法流程
+图：基数排序算法流程
下面来剖析代码实现。对于一个 $d$ 进制的数字 $x$ ，要获取其第 $k$ 位 $x_k$ ，可以使用以下计算公式： diff --git a/chapter_sorting/selection_sort.md b/chapter_sorting/selection_sort.md index 9cd9da7d1..7f43411b1 100644 --- a/chapter_sorting/selection_sort.md +++ b/chapter_sorting/selection_sort.md @@ -47,6 +47,8 @@ comments: true === "<11>"  +图：选择排序步骤
+ 在代码中，我们用 $k$ 来记录未排序区间内的最小元素。 === "Java" @@ -290,4 +292,4 @@ comments: true  -Fig. 选择排序非稳定示例
+图：选择排序非稳定示例
diff --git a/chapter_sorting/sorting_algorithm.md b/chapter_sorting/sorting_algorithm.md index 5daca9b15..b50859f47 100644 --- a/chapter_sorting/sorting_algorithm.md +++ b/chapter_sorting/sorting_algorithm.md @@ -10,7 +10,7 @@ comments: true  -Fig. 数据类型和判断规则示例
+图：数据类型和判断规则示例
## 11.1.1. 评价维度 diff --git a/chapter_sorting/summary.md b/chapter_sorting/summary.md index 142ae90f7..f27a1ccf9 100644 --- a/chapter_sorting/summary.md +++ b/chapter_sorting/summary.md @@ -15,7 +15,7 @@ comments: true  -Fig. 排序算法对比
+图：排序算法对比
## 11.11.1. Q & A diff --git a/chapter_stack_and_queue/deque.md b/chapter_stack_and_queue/deque.md index b439c07d2..b7b79a47d 100644 --- a/chapter_stack_and_queue/deque.md +++ b/chapter_stack_and_queue/deque.md @@ -8,7 +8,7 @@ comments: true  -Fig. 双向队列的操作
+图：双向队列的操作
## 5.3.1. 双向队列常用操作 @@ -351,6 +351,8 @@ comments: true === "popFirst()"  +图：基于链表实现双向队列的入队出队操作
+ 以下是具体实现代码。 === "Java" @@ -359,8 +361,8 @@ comments: true /* 双向链表节点 */ class ListNode { int val; // 节点值 - ListNode next; // 后继节点引用（指针） - ListNode prev; // 前驱节点引用（指针） + ListNode next; // 后继节点引用 + ListNode prev; // 前驱节点引用 ListNode(int val) { this.val = val; @@ -634,8 +636,8 @@ comments: true def __init__(self, val: int): """构造方法""" self.val: int = val - self.next: ListNode | None = None # 后继节点引用（指针） - self.prev: ListNode | None = None # 前驱节点引用（指针） + self.next: ListNode | None = None # 后继节点引用 + self.prev: ListNode | None = None # 前驱节点引用 class LinkedListDeque: """基于双向链表实现的双向队列""" @@ -1240,8 +1242,8 @@ comments: true /* 双向链表节点 */ class ListNode { public int val; // 节点值 - public ListNode? next; // 后继节点引用（指针） - public ListNode? prev; // 前驱节点引用（指针） + public ListNode? next; // 后继节点引用 + public ListNode? prev; // 前驱节点引用 public ListNode(int val) { this.val = val; @@ -1383,8 +1385,8 @@ comments: true /* 双向链表节点 */ class ListNode { var val: Int // 节点值 - var next: ListNode? // 后继节点引用（指针） - weak var prev: ListNode? // 前驱节点引用（指针） + var next: ListNode? // 后继节点引用 + weak var prev: ListNode? // 前驱节点引用 init(val: Int) { self.val = val @@ -1520,8 +1522,8 @@ comments: true const Self = @This(); val: T = undefined, // 节点值 - next: ?*Self = null, // 后继节点引用（指针） - prev: ?*Self = null, // 前驱节点引用（指针） + next: ?*Self = null, // 后继节点指针 + prev: ?*Self = null, // 前驱节点指针 // Initialize a list node with specific value pub fn init(self: *Self, x: i32) void { @@ -1677,8 +1679,8 @@ comments: true /* 双向链表节点 */ class ListNode { int val; // 节点值 - ListNode? next; // 后继节点引用（指针） - ListNode? prev; // 前驱节点引用（指针） + ListNode? next; // 后继节点引用 + ListNode? prev; // 前驱节点引用 ListNode(this.val, {this.next, this.prev}); } @@ -1807,8 +1809,8 @@ comments: true /* 双向链表节点 */ pub struct ListNode图：基于数组实现双向队列的入队出队操作
+ 以下是具体实现代码。 === "Java" diff --git a/chapter_stack_and_queue/queue.md b/chapter_stack_and_queue/queue.md index 78b02926a..a2e6dcb7e 100755 --- a/chapter_stack_and_queue/queue.md +++ b/chapter_stack_and_queue/queue.md @@ -10,7 +10,7 @@ comments: true  -Fig. 队列的先入先出规则
+图：队列的先入先出规则
## 5.2.1. 队列常用操作 @@ -308,6 +308,8 @@ comments: true === "pop()"  +图：基于链表实现队列的入队出队操作
+ 以下是用链表实现队列的示例代码。 === "Java" @@ -1200,6 +1202,8 @@ comments: true === "pop()"  +图：基于数组实现队列的入队出队操作
+ 你可能会发现一个问题：在不断进行入队和出队的过程中，`front` 和 `rear` 都在向右移动，**当它们到达数组尾部时就无法继续移动了**。为解决此问题，我们可以将数组视为首尾相接的「环形数组」。 对于环形数组，我们需要让 `front` 或 `rear` 在越过数组尾部时，直接回到数组头部继续遍历。这种周期性规律可以通过“取余操作”来实现，代码如下所示。 diff --git a/chapter_stack_and_queue/stack.md b/chapter_stack_and_queue/stack.md index 15345dd6e..78be8362b 100755 --- a/chapter_stack_and_queue/stack.md +++ b/chapter_stack_and_queue/stack.md @@ -12,7 +12,7 @@ comments: true  -Fig. 栈的先入后出规则
+图：栈的先入后出规则
## 5.1.1. 栈常用操作 @@ -310,6 +310,8 @@ comments: true === "pop()"  +图：基于链表实现栈的入栈出栈操作
+ 以下是基于链表实现栈的示例代码。 === "Java" @@ -1077,6 +1079,8 @@ comments: true === "pop()"  +图：基于数组实现栈的入栈出栈操作
+ 由于入栈的元素可能会源源不断地增加，因此我们可以使用动态数组，这样就无需自行处理数组扩容问题。以下为示例代码。 === "Java" diff --git a/chapter_tree/array_representation_of_tree.md b/chapter_tree/array_representation_of_tree.md index c1e444341..6a9920be6 100644 --- a/chapter_tree/array_representation_of_tree.md +++ b/chapter_tree/array_representation_of_tree.md @@ -16,7 +16,7 @@ comments: true  -Fig. 完美二叉树的数组表示
+图：完美二叉树的数组表示
**映射公式的角色相当于链表中的指针**。给定数组中的任意一个节点，我们都可以通过映射公式来访问它的左（右）子节点。 @@ -26,7 +26,7 @@ comments: true  -Fig. 层序遍历序列对应多种二叉树可能性
+图：层序遍历序列对应多种二叉树可能性
为了解决此问题，**我们可以考虑在层序遍历序列中显式地写出所有 $\text{None}$** 。如下图所示，这样处理后，层序遍历序列就可以唯一表示二叉树了。 @@ -124,13 +124,13 @@ comments: true  -Fig. 任意类型二叉树的数组表示
+图：任意类型二叉树的数组表示
值得说明的是，**完全二叉树非常适合使用数组来表示**。回顾完全二叉树的定义，$\text{None}$ 只出现在最底层且靠右的位置，**因此所有 $\text{None}$ 一定出现在层序遍历序列的末尾**。这意味着使用数组表示完全二叉树时，可以省略存储所有 $\text{None}$ ，非常方便。  -Fig. 完全二叉树的数组表示
+图：完全二叉树的数组表示
如下代码给出了数组表示下的二叉树的简单实现，包括以下操作： @@ -960,7 +960,96 @@ comments: true === "Dart" ```dart title="array_binary_tree.dart" - [class]{ArrayBinaryTree}-[func]{} + /* 数组表示下的二叉树类 */ + class ArrayBinaryTree { + late ListFig. AVL 树在删除节点后发生退化
+图：AVL 树在删除节点后发生退化
再例如，在以下完美二叉树中插入两个节点后，树将严重向左倾斜，查找操作的时间复杂度也随之恶化。  -Fig. AVL 树在插入节点后发生退化
+图：AVL 树在插入节点后发生退化
G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorithm for the organization of information" 中提出了「AVL 树」。论文中详细描述了一系列操作，确保在持续添加和删除节点后，AVL 树不会退化，从而使得各种操作的时间复杂度保持在 $O(\log n)$ 级别。换句话说，在需要频繁进行增删查改操作的场景中，AVL 树能始终保持高效的数据操作性能，具有很好的应用价值。 @@ -384,6 +384,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit ```dart title="avl_tree.dart" /* 获取节点高度 */ int height(TreeNode? node) { + // 空节点高度为 -1 ，叶节点高度为 0 return node == null ? -1 : node.height; } @@ -601,11 +602,13 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉 === "<4>"  +图：右旋操作步骤
+ 此外，如果节点 `child` 本身有右子节点（记为 `grandChild` ），则需要在「右旋」中添加一步：将 `grandChild` 作为 `node` 的左子节点。  -Fig. 有 grandChild 的右旋操作
+图：有 grandChild 的右旋操作
“向右旋转”是一种形象化的说法，实际上需要通过修改节点指针来实现，代码如下所示。 @@ -836,13 +839,13 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉  -Fig. 左旋操作
+图：左旋操作
同理，若节点 `child` 本身有左子节点（记为 `grandChild` ），则需要在「左旋」中添加一步：将 `grandChild` 作为 `node` 的右子节点。  -Fig. 有 grandChild 的左旋操作
+图：有 grandChild 的左旋操作
可以观察到，**右旋和左旋操作在逻辑上是镜像对称的，它们分别解决的两种失衡情况也是对称的**。基于对称性，我们可以轻松地从右旋的代码推导出左旋的代码。具体地，只需将「右旋」代码中的把所有的 `left` 替换为 `right` ，将所有的 `right` 替换为 `left` ，即可得到「左旋」代码。 @@ -1073,7 +1076,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉  -Fig. 先左旋后右旋
+图：先左旋后右旋
### 先右旋后左旋 @@ -1081,7 +1084,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉  -Fig. 先右旋后左旋
+图：先右旋后左旋
### 旋转的选择 @@ -1089,7 +1092,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉  -Fig. AVL 树的四种旋转情况
+图：AVL 树的四种旋转情况
在代码中，我们通过判断失衡节点的平衡因子以及较高一侧子节点的平衡因子的正负号，来确定失衡节点属于上图中的哪种情况。 diff --git a/chapter_tree/binary_search_tree.md b/chapter_tree/binary_search_tree.md index 21bb375d1..659b31da6 100755 --- a/chapter_tree/binary_search_tree.md +++ b/chapter_tree/binary_search_tree.md @@ -11,7 +11,7 @@ comments: true  -Fig. 二叉搜索树
+图：二叉搜索树
## 7.4.1. 二叉搜索树的操作 @@ -37,6 +37,8 @@ comments: true === "<4>"  +图：二叉搜索树查找节点示例
+ 二叉搜索树的查找操作与二分查找算法的工作原理一致，都是每轮排除一半情况。循环次数最多为二叉树的高度，当二叉树平衡时，使用 $O(\log n)$ 时间。 === "Java" @@ -270,7 +272,24 @@ comments: true === "Dart" ```dart title="binary_search_tree.dart" - [class]{BinarySearchTree}-[func]{search} + /* 查找节点 */ + TreeNode? search(int num) { + TreeNode? cur = _root; + // 循环查找，越过叶节点后跳出 + while (cur != null) { + // 目标节点在 cur 的右子树中 + if (cur.val < num) + cur = cur.right; + // 目标节点在 cur 的左子树中 + else if (cur.val > num) + cur = cur.left; + // 找到目标节点，跳出循环 + else + break; + } + // 返回目标节点 + return cur; + } ``` === "Rust" @@ -311,7 +330,7 @@ comments: true  -Fig. 在二叉搜索树中插入节点
+图：在二叉搜索树中插入节点
=== "Java" @@ -640,7 +659,31 @@ comments: true === "Dart" ```dart title="binary_search_tree.dart" - [class]{BinarySearchTree}-[func]{insert} + /* 插入节点 */ + void insert(int num) { + // 若树为空，直接提前返回 + if (_root == null) return; + TreeNode? cur = _root; + TreeNode? pre = null; + // 循环查找，越过叶节点后跳出 + while (cur != null) { + // 找到重复节点，直接返回 + if (cur.val == num) return; + pre = cur; + // 插入位置在 cur 的右子树中 + if (cur.val < num) + cur = cur.right; + // 插入位置在 cur 的左子树中 + else + cur = cur.left; + } + // 插入节点 + TreeNode? node = TreeNode(num); + if (pre!.val < num) + pre.right = node; + else + pre.left = node; + } ``` === "Rust" @@ -693,13 +736,13 @@ comments: true  -Fig. 在二叉搜索树中删除节点（度为 0）
+图：在二叉搜索树中删除节点（度为 0）
当待删除节点的度为 $1$ 时，将待删除节点替换为其子节点即可。  -Fig. 在二叉搜索树中删除节点（度为 1）
+图：在二叉搜索树中删除节点（度为 1）
当待删除节点的度为 $2$ 时，我们无法直接删除它，而需要使用一个节点替换该节点。由于要保持二叉搜索树“左 $<$ 根 $<$ 右”的性质，因此这个节点可以是右子树的最小节点或左子树的最大节点。 @@ -720,6 +763,8 @@ comments: true === "<4>"  +图：二叉搜索树删除节点示例
+ 删除节点操作同样使用 $O(\log n)$ 时间，其中查找待删除节点需要 $O(\log n)$ 时间，获取中序遍历后继节点需要 $O(\log n)$ 时间。 === "Java" @@ -1283,7 +1328,80 @@ comments: true === "Dart" ```dart title="binary_search_tree.dart" - [class]{BinarySearchTree}-[func]{remove} + /* 插入节点 */ + void insert(int num) { + // 若树为空，直接提前返回 + if (_root == null) return; + TreeNode? cur = _root; + TreeNode? pre = null; + // 循环查找，越过叶节点后跳出 + while (cur != null) { + // 找到重复节点，直接返回 + if (cur.val == num) return; + pre = cur; + // 插入位置在 cur 的右子树中 + if (cur.val < num) + cur = cur.right; + // 插入位置在 cur 的左子树中 + else + cur = cur.left; + } + // 插入节点 + TreeNode? node = TreeNode(num); + if (pre!.val < num) + pre.right = node; + else + pre.left = node; + } + + /* 删除节点 */ + void remove(int num) { + // 若树为空，直接提前返回 + if (_root == null) return; + + TreeNode? cur = _root; + TreeNode? pre = null; + // 循环查找，越过叶节点后跳出 + while (cur != null) { + // 找到待删除节点，跳出循环 + if (cur.val == num) break; + pre = cur; + // 待删除节点在 cur 的右子树中 + if (cur.val < num) + cur = cur.right; + // 待删除节点在 cur 的左子树中 + else + cur = cur.left; + } + // 若无待删除节点，直接返回 + if (cur == null) return; + // 子节点数量 = 0 or 1 + if (cur.left == null || cur.right == null) { + // 当子节点数量 = 0 / 1 时， child = null / 该子节点 + TreeNode? child = cur.left ?? cur.right; + // 删除节点 cur + if (cur != _root) { + if (pre!.left == cur) + pre.left = child; + else + pre.right = child; + } else { + // 若删除节点为根节点，则重新指定根节点 + _root = child; + } + } else { + // 子节点数量 = 2 + // 获取中序遍历中 cur 的下一个节点 + TreeNode? tmp = cur.right; + while (tmp!.left != null) { + tmp = tmp.left; + } + // 递归删除节点 tmp + remove(tmp.val); + // 用 tmp 覆盖 cur + cur.val = tmp.val; + } + } ``` === "Rust" @@ -1364,7 +1482,7 @@ comments: true  -Fig. 二叉搜索树的中序遍历序列
+图：二叉搜索树的中序遍历序列
## 7.4.2. 二叉搜索树的效率 @@ -1388,7 +1506,7 @@ comments: true  -Fig. 二叉搜索树的平衡与退化
+图：二叉搜索树的平衡与退化
## 7.4.3. 二叉搜索树常见应用 diff --git a/chapter_tree/binary_tree.md b/chapter_tree/binary_tree.md index fa24c2b40..df581105d 100644 --- a/chapter_tree/binary_tree.md +++ b/chapter_tree/binary_tree.md @@ -4,7 +4,7 @@ comments: true # 7.1. 二叉树 -「二叉树 Binary Tree」是一种非线性数据结构，代表着祖先与后代之间的派生关系，体现着“一分为二”的分治逻辑。与链表类似，二叉树的基本单元是节点，每个节点包含一个「值」和两个「指针」。 +「二叉树 Binary Tree」是一种非线性数据结构，代表着祖先与后代之间的派生关系，体现着“一分为二”的分治逻辑。与链表类似，二叉树的基本单元是节点，每个节点包含：值、左子节点引用、右子节点引用。 === "Java" @@ -12,8 +12,8 @@ comments: true /* 二叉树节点类 */ class TreeNode { int val; // 节点值 - TreeNode left; // 左子节点指针 - TreeNode right; // 右子节点指针 + TreeNode left; // 左子节点引用 + TreeNode right; // 右子节点引用 TreeNode(int x) { val = x; } } ``` @@ -37,8 +37,8 @@ comments: true """二叉树节点类""" def __init__(self, val: int): self.val: int = val # 节点值 - self.left: Optional[TreeNode] = None # 左子节点指针 - self.right: Optional[TreeNode] = None # 右子节点指针 + self.left: Optional[TreeNode] = None # 左子节点引用 + self.right: Optional[TreeNode] = None # 右子节点引用 ``` === "Go" @@ -53,9 +53,9 @@ comments: true /* 节点初始化方法 */ func NewTreeNode(v int) *TreeNode { return &TreeNode{ - Left: nil, - Right: nil, - Val: v, + Left: nil, // 左子节点指针 + Right: nil, // 右子节点指针 + Val: v, // 节点值 } } ``` @@ -66,8 +66,8 @@ comments: true /* 二叉树节点类 */ function TreeNode(val, left, right) { this.val = (val === undefined ? 0 : val); // 节点值 - this.left = (left === undefined ? null : left); // 左子节点指针 - this.right = (right === undefined ? null : right); // 右子节点指针 + this.left = (left === undefined ? null : left); // 左子节点引用 + this.right = (right === undefined ? null : right); // 右子节点引用 } ``` @@ -82,8 +82,8 @@ comments: true constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) { this.val = val === undefined ? 0 : val; // 节点值 - this.left = left === undefined ? null : left; // 左子节点指针 - this.right = right === undefined ? null : right; // 右子节点指针 + this.left = left === undefined ? null : left; // 左子节点引用 + this.right = right === undefined ? null : right; // 右子节点引用 } } ``` @@ -120,8 +120,8 @@ comments: true /* 二叉树节点类 */ class TreeNode { int val; // 节点值 - TreeNode? left; // 左子节点指针 - TreeNode? right; // 右子节点指针 + TreeNode? left; // 左子节点引用 + TreeNode? right; // 右子节点引用 TreeNode(int x) { val = x; } } ``` @@ -132,8 +132,8 @@ comments: true /* 二叉树节点类 */ class TreeNode { var val: Int // 节点值 - var left: TreeNode? // 左子节点指针 - var right: TreeNode? // 右子节点指针 + var left: TreeNode? // 左子节点引用 + var right: TreeNode? // 右子节点引用 init(x: Int) { val = x @@ -153,8 +153,8 @@ comments: true /* 二叉树节点类 */ class TreeNode { int val; // 节点值 - TreeNode? left; // 左子节点指针 - TreeNode? right; // 右子节点指针 + TreeNode? left; // 左子节点引用 + TreeNode? right; // 右子节点引用 TreeNode(this.val, [this.left, this.right]); } ``` @@ -171,7 +171,7 @@ comments: true  -Fig. 父节点、子节点、子树
+图：父节点、子节点、子树
## 7.1.1. 二叉树常见术语 @@ -188,7 +188,7 @@ comments: true  -Fig. 二叉树的常用术语
+图：二叉树的常用术语
!!! tip "高度与深度的定义" @@ -382,7 +382,7 @@ comments: true  -Fig. 在二叉树中插入与删除节点
+图：在二叉树中插入与删除节点
=== "Java" @@ -530,7 +530,7 @@ comments: true  -Fig. 完美二叉树
+图：完美二叉树
### 完全二叉树 @@ -538,7 +538,7 @@ comments: true  -Fig. 完全二叉树
+图：完全二叉树
### 完满二叉树 @@ -546,7 +546,7 @@ comments: true  -Fig. 完满二叉树
+图：完满二叉树
### 平衡二叉树 @@ -554,7 +554,7 @@ comments: true  -Fig. 平衡二叉树
+图：平衡二叉树
## 7.1.4. 二叉树的退化 @@ -565,7 +565,7 @@ comments: true  -Fig. 二叉树的最佳与最差结构
+图：二叉树的最佳与最差结构
如下表所示，在最佳和最差结构下，二叉树的叶节点数量、节点总数、高度等达到极大或极小值。 diff --git a/chapter_tree/binary_tree_traversal.md b/chapter_tree/binary_tree_traversal.md index 9b8885d4e..f2ada62ca 100755 --- a/chapter_tree/binary_tree_traversal.md +++ b/chapter_tree/binary_tree_traversal.md @@ -16,7 +16,7 @@ comments: true  -Fig. 二叉树的层序遍历
+图：二叉树的层序遍历
广度优先遍历通常借助「队列」来实现。队列遵循“先进先出”的规则，而广度优先遍历则遵循“逐层推进”的规则，两者背后的思想是一致的。 @@ -334,7 +334,7 @@ comments: true  -Fig. 二叉搜索树的前、中、后序遍历
+图：二叉搜索树的前、中、后序遍历
以下给出了实现代码，请配合上图理解深度优先遍历的递归过程。 @@ -794,3 +794,5 @@ comments: true === "<11>"  + +图：前序遍历的递归过程