From 68e11cfa345d1553def8b5a6dce72caed129e9e1 Mon Sep 17 00:00:00 2001 From: krahets Date: Sun, 20 Aug 2023 14:52:31 +0800 Subject: [PATCH] build --- chapter_appendix/installation.md | 2 +- chapter_array_and_linkedlist/array.md | 4 +- chapter_array_and_linkedlist/linked_list.md | 2 +- chapter_array_and_linkedlist/list.md | 2 +- chapter_array_and_linkedlist/summary.md | 2 +- chapter_backtracking/subset_sum_problem.md | 2 +- chapter_computational_complexity/index.md | 4 +- .../performance_evaluation.md | 20 +- .../space_complexity.md | 38 ++-- chapter_computational_complexity/summary.md | 30 +-- .../time_complexity.md | 175 +++++++++--------- chapter_data_structure/basic_data_types.md | 2 +- chapter_data_structure/number_encoding.md | 2 +- .../binary_search_recur.md | 2 +- chapter_divide_and_conquer/summary.md | 2 +- .../dp_problem_features.md | 2 +- .../edit_distance_problem.md | 2 +- .../intro_to_dynamic_programming.md | 4 +- chapter_dynamic_programming/summary.md | 2 +- .../unbounded_knapsack_problem.md | 2 +- chapter_graph/graph_operations.md | 2 +- chapter_greedy/max_product_cutting_problem.md | 2 +- chapter_heap/build_heap.md | 2 +- chapter_heap/heap.md | 52 +++--- .../algorithms_are_everywhere.md | 18 +- chapter_introduction/summary.md | 8 +- chapter_introduction/what_is_dsa.md | 15 +- chapter_searching/binary_search.md | 4 +- chapter_searching/binary_search_edge.md | 2 +- .../searching_algorithm_revisited.md | 4 +- chapter_searching/summary.md | 4 +- chapter_sorting/bubble_sort.md | 2 +- chapter_sorting/heap_sort.md | 22 +-- chapter_sorting/insertion_sort.md | 2 +- chapter_sorting/merge_sort.md | 2 +- chapter_sorting/selection_sort.md | 2 +- chapter_sorting/sorting_algorithm.md | 2 +- chapter_stack_and_queue/stack.md | 2 +- chapter_tree/avl_tree.md | 24 +-- chapter_tree/binary_search_tree.md | 2 +- 40 files changed, 239 insertions(+), 235 deletions(-) diff --git a/chapter_appendix/installation.md b/chapter_appendix/installation.md index 14614a2a3..195ee32d2 100644 --- a/chapter_appendix/installation.md +++ b/chapter_appendix/installation.md @@ -15,7 +15,7 @@ comments: true ## 16.1.3   C/C++ 环境 -1. Windows 系统需要安装 [MinGW](https://sourceforge.net/projects/mingw-w64/files/)（[配置教程](https://blog.csdn.net/qq_33698226/article/details/129031241)），MacOS 自带 Clang 无需安装。 +1. Windows 系统需要安装 [MinGW](https://sourceforge.net/projects/mingw-w64/files/)（[配置教程](https://blog.csdn.net/qq_33698226/article/details/129031241)），MacOS 自带 Clang 无须安装。 2. 在 VSCode 的插件市场中搜索 `c++` ，安装 C/C++ Extension Pack 。 3. （可选）打开 Settings 页面，搜索 `Clang_format_fallback Style` 代码格式化选项，设置为 `{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }` 。 diff --git a/chapter_array_and_linkedlist/array.md b/chapter_array_and_linkedlist/array.md index 9df64a3df..f11af3992 100755 --- a/chapter_array_and_linkedlist/array.md +++ b/chapter_array_and_linkedlist/array.md @@ -472,7 +472,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex 同理，如果我们想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。 -请注意，删除元素完成后，原先末尾的元素变得“无意义”了，所以我们无需特意去修改它。 +请注意，删除元素完成后，原先末尾的元素变得“无意义”了，所以我们无须特意去修改它。 ![数组删除元素](array.assets/array_remove_element.png) @@ -1208,7 +1208,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex 数组存储在连续的内存空间内，且元素类型相同。这包含丰富的先验信息，系统可以利用这些信息来优化操作和运行效率，包括： -- **空间效率高**: 数组为数据分配了连续的内存块，无需额外的结构开销。 +- **空间效率高**: 数组为数据分配了连续的内存块，无须额外的结构开销。 - **支持随机访问**: 数组允许在 $O(1)$ 时间内访问任何元素。 - **缓存局部性**: 当访问数组元素时，计算机不仅会加载它，还会缓存其周围的其他数据，从而借助高速缓存来提升后续操作的执行速度。 diff --git a/chapter_array_and_linkedlist/linked_list.md b/chapter_array_and_linkedlist/linked_list.md index 6a7c1f5a1..c1fb9cd8e 100755 --- a/chapter_array_and_linkedlist/linked_list.md +++ b/chapter_array_and_linkedlist/linked_list.md @@ -6,7 +6,7 @@ comments: true 内存空间是所有程序的公共资源，在一个复杂的系统运行环境下，空闲的内存空间可能散落在内存各处。我们知道，存储数组的内存空间必须是连续的，而当数组非常大时，内存可能无法提供如此大的连续空间。此时链表的灵活性优势就体现出来了。 -「链表 Linked List」是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，我们可以通过它从当前节点访问到下一个节点。这意味着链表的各个节点可以被分散存储在内存各处，它们的内存地址是无需连续的。 +「链表 Linked List」是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，我们可以通过它从当前节点访问到下一个节点。这意味着链表的各个节点可以被分散存储在内存各处，它们的内存地址是无须连续的。 ![链表定义与存储方式](linked_list.assets/linkedlist_definition.png) diff --git a/chapter_array_and_linkedlist/list.md b/chapter_array_and_linkedlist/list.md index d157ab6e0..0fee90312 100755 --- a/chapter_array_and_linkedlist/list.md +++ b/chapter_array_and_linkedlist/list.md @@ -6,7 +6,7 @@ comments: true **数组长度不可变导致实用性降低**。在实际中，我们可能事先无法确定需要存储多少数据，这使数组长度的选择变得困难。若长度过小，需要在持续添加数据时频繁扩容数组；若长度过大，则会造成内存空间的浪费。 -为解决此问题，出现了一种被称为「动态数组 Dynamic Array」的数据结构，即长度可变的数组，也常被称为「列表 List」。列表基于数组实现，继承了数组的优点，并且可以在程序运行过程中动态扩容。我们可以在列表中自由地添加元素，而无需担心超过容量限制。 +为解决此问题，出现了一种被称为「动态数组 Dynamic Array」的数据结构，即长度可变的数组，也常被称为「列表 List」。列表基于数组实现，继承了数组的优点，并且可以在程序运行过程中动态扩容。我们可以在列表中自由地添加元素，而无须担心超过容量限制。 ## 4.3.1   列表常用操作 diff --git a/chapter_array_and_linkedlist/summary.md b/chapter_array_and_linkedlist/summary.md index 3c2588a03..e64e098c5 100644 --- a/chapter_array_and_linkedlist/summary.md +++ b/chapter_array_and_linkedlist/summary.md @@ -59,7 +59,7 @@ comments: true 假如把列表元素换成链表节点 `n = [n1, n2, n3, n4, n5]` ，通常情况下这五个节点对象也是被分散存储在内存各处的。然而，给定一个列表索引，我们仍然可以在 $O(1)$ 时间内获取到节点内存地址，从而访问到对应的节点。这是因为数组中存储的是节点的引用，而非节点本身。 - 与许多语言不同的是，在 Python 中数字也被包装为对象，列表中存储的不是数字本身，而是对数字的引用。因此，我们会发现两个数组中的相同数字拥有同一个 id ，并且这些数字的内存地址是无需连续的。 + 与许多语言不同的是，在 Python 中数字也被包装为对象，列表中存储的不是数字本身，而是对数字的引用。因此，我们会发现两个数组中的相同数字拥有同一个 id ，并且这些数字的内存地址是无须连续的。 !!! question "C++ STL 里面的 std::list 已经实现了双向链表，但好像一些算法的书上都不怎么直接用这个，是不是有什么局限性呢?" diff --git a/chapter_backtracking/subset_sum_problem.md b/chapter_backtracking/subset_sum_problem.md index 20f989839..6f013024a 100644 --- a/chapter_backtracking/subset_sum_problem.md +++ b/chapter_backtracking/subset_sum_problem.md @@ -19,7 +19,7 @@ comments: true 类似于全排列问题，我们可以把子集的生成过程想象成一系列选择的结果，并在选择过程中实时更新“元素和”，当元素和等于 `target` 时，就将子集记录至结果列表。 -而与全排列问题不同的是，**本题集合中的元素可以被无限次选取**，因此无需借助 `selected` 布尔列表来记录元素是否已被选择。我们可以对全排列代码进行小幅修改，初步得到解题代码。 +而与全排列问题不同的是，**本题集合中的元素可以被无限次选取**，因此无须借助 `selected` 布尔列表来记录元素是否已被选择。我们可以对全排列代码进行小幅修改，初步得到解题代码。 === "Java" diff --git a/chapter_computational_complexity/index.md b/chapter_computational_complexity/index.md index b6673a306..73fbe5355 100644 --- a/chapter_computational_complexity/index.md +++ b/chapter_computational_complexity/index.md @@ -13,9 +13,9 @@ icon: material/timer-sand !!! abstract - 复杂度犹如浩瀚的算法宇宙中的指南针。 + 复杂度犹如浩瀚的算法宇宙中的时空向导。 - 它引导我们在时间与空间的维度上深入探索，寻找更优雅的解决方案。 + 它带领我们在时间与空间这两个维度上深入探索，寻找更优雅的解决方案。 ## 本章内容 diff --git a/chapter_computational_complexity/performance_evaluation.md b/chapter_computational_complexity/performance_evaluation.md index a02a96888..500bed562 100644 --- a/chapter_computational_complexity/performance_evaluation.md +++ b/chapter_computational_complexity/performance_evaluation.md @@ -4,12 +4,12 @@ comments: true # 2.1   算法效率评估 -在算法设计中，我们先后追求以下两个层面的目标： +在算法设计中，我们先后追求以下两个层面的目标。 1. **找到问题解法**：算法需要在规定的输入范围内，可靠地求得问题的正确解。 2. **寻求最优解法**：同一个问题可能存在多种解法，我们希望找到尽可能高效的算法。 -因此在能够解决问题的前提下，算法效率成为主要的评价维度，包括： +因此，在能够解决问题的前提下，算法效率已成为衡量算法优劣的主要评价指标，它包括以下两个维度。 - **时间效率**：算法运行速度的快慢。 - **空间效率**：算法占用内存空间的大小。 @@ -22,28 +22,28 @@ comments: true 假设我们现在有算法 `A` 和算法 `B` ，它们都能解决同一问题，现在需要对比这两个算法的效率。最直接的方法是找一台计算机，运行这两个算法，并监控记录它们的运行时间和内存占用情况。这种评估方式能够反映真实情况，但也存在较大局限性。 -**难以排除测试环境的干扰因素**。硬件配置会影响算法的性能表现。比如在某台计算机中，算法 `A` 的运行时间比算法 `B` 短；但在另一台配置不同的计算机中，我们可能得到相反的测试结果。这意味着我们需要在各种机器上进行测试，统计平均效率，而这是不现实的。 +一方面，**难以排除测试环境的干扰因素**。硬件配置会影响算法的性能表现。比如在某台计算机中，算法 `A` 的运行时间比算法 `B` 短；但在另一台配置不同的计算机中，我们可能得到相反的测试结果。这意味着我们需要在各种机器上进行测试，统计平均效率，而这是不现实的。 -**展开完整测试非常耗费资源**。随着输入数据量的变化，算法会表现出不同的效率。例如，在输入数据量较小时，算法 `A` 的运行时间比算法 `B` 更少；而输入数据量较大时，测试结果可能恰恰相反。因此，为了得到有说服力的结论，我们需要测试各种规模的输入数据，而这样需要耗费大量的计算资源。 +另一方面，**展开完整测试非常耗费资源**。随着输入数据量的变化，算法会表现出不同的效率。例如，在输入数据量较小时，算法 `A` 的运行时间比算法 `B` 更少；而输入数据量较大时，测试结果可能恰恰相反。因此，为了得到有说服力的结论，我们需要测试各种规模的输入数据，而这样需要耗费大量的计算资源。 ## 2.1.2   理论估算 -由于实际测试具有较大的局限性，我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为「渐近复杂度分析 Asymptotic Complexity Analysis」，简称为「复杂度分析」。 +由于实际测试具有较大的局限性，我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为「渐近复杂度分析 asymptotic complexity analysis」，简称「复杂度分析」。 -复杂度分析评估的是算法执行所需的时间和空间资源。**它被表示为一个函数，描述了随着输入数据大小的增加，算法所需时间（空间）的增长趋势**。这个定义有些拗口，我们可以将其分为三个重点来理解： +复杂度分析评估的是算法运行所需的时间和空间资源，**它描述了随着输入数据大小的增加，算法所需时间（空间）的增长趋势**。这个定义有些拗口，我们可以将其分为三个重点来理解。 -1. “时间（空间）”分别对应「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。 +1. “时间和空间资源”分别对应「时间复杂度 time complexity」和「空间复杂度 space complexity」。 2. “随着输入数据大小的增加”意味着复杂度反映了算法运行效率与输入数据体量之间的关系。 3. “增长趋势”表示复杂度分析关注的是算法时间与空间的增长趋势，而非具体的运行时间或占用空间。 **复杂度分析克服了实际测试方法的弊端**。首先，它独立于测试环境，分析结果适用于所有运行平台。其次，它可以体现不同数据量下的算法效率，尤其是在大数据量下的算法性能。 -如果你对复杂度分析的概念仍感到困惑，无需担心，我们会在后续章节详细介绍。 +如果你对复杂度分析的概念仍感到困惑，无须担心，我们会在后续章节中详细介绍。 ## 2.1.3   复杂度的重要性 复杂度分析为我们提供了一把评估算法效率的“标尺”，帮助我们衡量了执行某个算法所需的时间和空间资源，并使我们能够对比不同算法之间的效率。 -复杂度是个数学概念，对于初学者可能比较抽象，学习难度相对较高。从这个角度看，复杂度分析可能不太适合作为第一章的内容。 +复杂度是个数学概念，对于初学者可能比较抽象，学习难度相对较高。从这个角度看，复杂度分析可能不太适合作为第 1 章的内容。 -然而，当我们讨论某个数据结构或算法的特点时，难以避免要分析其运行速度和空间使用情况。因此，在深入学习数据结构与算法之前，**建议你先对复杂度建立初步的了解，能够完成简单算法的复杂度分析**。 +然而，当我们讨论某个数据结构或算法的特点时，难以避免要分析其运行速度和空间使用情况。因此，在深入学习数据结构与算法之前，**建议你先对复杂度建立初步的了解，以便能够完成简单算法的复杂度分析**。 diff --git a/chapter_computational_complexity/space_complexity.md b/chapter_computational_complexity/space_complexity.md index d51f57337..4ab71a894 100755 --- a/chapter_computational_complexity/space_complexity.md +++ b/chapter_computational_complexity/space_complexity.md @@ -4,25 +4,25 @@ comments: true # 2.3   空间复杂度 -「空间复杂度 Space Complexity」用于衡量算法占用内存空间随着数据量变大时的增长趋势。这个概念与时间复杂度非常类似，只需将“运行时间”替换为“占用内存空间”。 +「空间复杂度 space complexity」用于衡量算法占用内存空间随着数据量变大时的增长趋势。这个概念与时间复杂度非常类似，只需将“运行时间”替换为“占用内存空间”。 ## 2.3.1   算法相关空间 -算法运行过程中使用的内存空间主要包括以下几种： +算法在运行过程中使用的内存空间主要包括以下几种。 - **输入空间**：用于存储算法的输入数据。 -- **暂存空间**：用于存储算法运行过程中的变量、对象、函数上下文等数据。 +- **暂存空间**：用于存储算法在运行过程中的变量、对象、函数上下文等数据。 - **输出空间**：用于存储算法的输出数据。 一般情况下，空间复杂度的统计范围是“暂存空间”加上“输出空间”。 -暂存空间可以进一步划分为三个部分： +暂存空间可以进一步划分为三个部分。 - **暂存数据**：用于保存算法运行过程中的各种常量、变量、对象等。 - **栈帧空间**：用于保存调用函数的上下文数据。系统在每次调用函数时都会在栈顶部创建一个栈帧，函数返回后，栈帧空间会被释放。 - **指令空间**：用于保存编译后的程序指令，在实际统计中通常忽略不计。 -因此在分析一段程序的空间复杂度时，**我们通常统计暂存数据、输出数据、栈帧空间三部分**。 +在分析一段程序的空间复杂度时，**我们通常统计暂存数据、栈帧空间和输出数据三部分**。 ![算法使用的相关空间](space_complexity.assets/space_types.png) @@ -294,7 +294,7 @@ comments: true ## 2.3.2   推算方法 -空间复杂度的推算方法与时间复杂度大致相同，只需将统计对象从“计算操作数量”转为“使用空间大小”。 +空间复杂度的推算方法与时间复杂度大致相同，只需将统计对象从“操作数量”转为“使用空间大小”。 而与时间复杂度不同的是，**我们通常只关注「最差空间复杂度」**。这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。 @@ -432,7 +432,7 @@ comments: true ``` -**在递归函数中，需要注意统计栈帧空间**。例如以下代码： +**在递归函数中，需要注意统计栈帧空间**。例如在以下代码中： - 函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。 - 递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()` ，从而占用 $O(n)$ 的栈帧空间。 @@ -658,7 +658,7 @@ comments: true ## 2.3.3   常见类型 -设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）： +设输入数据大小为 $n$ ，下图展示了常见的空间复杂度类型（从低到高排列）。 $$ \begin{aligned} @@ -667,19 +667,19 @@ O(1) < O(\log n) < O(n) < O(n^2) < O(2^n) \newline \end{aligned} $$ -![空间复杂度的常见类型](space_complexity.assets/space_complexity_common_types.png) +![常见的空间复杂度类型](space_complexity.assets/space_complexity_common_types.png) -

图：空间复杂度的常见类型

+

图：常见的空间复杂度类型

!!! tip - 部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果你遇到看不懂的地方，可以在学习完后面章节后再来复习。 + 部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果你遇到看不懂的地方，可以在学完后面章节后再来复习。 ### 1.   常数阶 $O(1)$ 常数阶常见于数量与输入数据大小 $n$ 无关的常量、变量、对象。 -需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，即不会累积占用空间，空间复杂度仍为 $O(1)$ 。 +需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，即不会累积占用空间，空间复杂度仍为 $O(1)$ ： === "Java" @@ -1010,7 +1010,7 @@ $$ ### 2.   线性阶 $O(n)$ -线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等。 +线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等： === "Java" @@ -1274,7 +1274,7 @@ $$ } ``` -以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间。 +以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间： === "Java" @@ -1421,7 +1421,7 @@ $$ ### 3.   平方阶 $O(n^2)$ -平方阶常见于矩阵和图，元素数量与 $n$ 成平方关系。 +平方阶常见于矩阵和图，元素数量与 $n$ 成平方关系： === "Java" @@ -1800,7 +1800,7 @@ $$ ### 4.   指数阶 $O(2^n)$ -指数阶常见于二叉树。高度为 $n$ 的「满二叉树」的节点数量为 $2^n - 1$ ，占用 $O(2^n)$ 空间。 +指数阶常见于二叉树。高度为 $n$ 的「满二叉树」的节点数量为 $2^n - 1$ ，占用 $O(2^n)$ 空间： === "Java" @@ -1974,9 +1974,9 @@ $$ 对数阶常见于分治算法和数据类型转换等。 -例如“归并排序”算法，输入长度为 $n$ 的数组，每轮递归将数组从中点划分为两半，形成高度为 $\log n$ 的递归树，使用 $O(\log n)$ 栈帧空间。 +例如归并排序算法，输入长度为 $n$ 的数组，每轮递归将数组从中点划分为两半，形成高度为 $\log n$ 的递归树，使用 $O(\log n)$ 栈帧空间。 -再例如“数字转化为字符串”，输入任意正整数 $n$ ，它的位数为 $\log_{10} n$ ，即对应字符串长度为 $\log_{10} n$ ，因此空间复杂度为 $O(\log_{10} n) = O(\log n)$ 。 +再例如将数字转化为字符串，输入任意正整数 $n$ ，它的位数为 $\log_{10} n + 1$ ，即对应字符串长度为 $\log_{10} n + 1$ ，因此空间复杂度为 $O(\log_{10} n + 1) = O(\log n)$ 。 ## 2.3.4   权衡时间与空间 @@ -1984,4 +1984,4 @@ $$ **降低时间复杂度通常需要以提升空间复杂度为代价，反之亦然**。我们将牺牲内存空间来提升算法运行速度的思路称为“以空间换时间”；反之，则称为“以时间换空间”。 -选择哪种思路取决于我们更看重哪个方面。在大多数情况下，时间比空间更宝贵，因此以空间换时间通常是更常用的策略。当然，在数据量很大的情况下，控制空间复杂度也是非常重要的。 +选择哪种思路取决于我们更看重哪个方面。在大多数情况下，时间比空间更宝贵，因此“以空间换时间”通常是更常用的策略。当然，在数据量很大的情况下，控制空间复杂度也是非常重要的。 diff --git a/chapter_computational_complexity/summary.md b/chapter_computational_complexity/summary.md index e2494b2e0..a138dc5da 100644 --- a/chapter_computational_complexity/summary.md +++ b/chapter_computational_complexity/summary.md @@ -6,45 +6,45 @@ comments: true **算法效率评估** -- 时间效率和空间效率是评价算法性能的两个关键维度。 +- 时间效率和空间效率是衡量算法优劣的两个主要评价指标。 - 我们可以通过实际测试来评估算法效率，但难以消除测试环境的影响，且会耗费大量计算资源。 - 复杂度分析可以克服实际测试的弊端，分析结果适用于所有运行平台，并且能够揭示算法在不同数据规模下的效率。 **时间复杂度** -- 时间复杂度用于衡量算法运行时间随数据量增长的趋势，可以有效评估算法效率，但在某些情况下可能失效，如在输入数据量较小或时间复杂度相同时，无法精确对比算法效率的优劣。 -- 最差时间复杂度使用大 $O$ 符号表示，即函数渐近上界，反映当 $n$ 趋向正无穷时，$T(n)$ 的增长级别。 -- 推算时间复杂度分为两步，首先统计计算操作数量，然后判断渐近上界。 -- 常见时间复杂度从小到大排列有 $O(1)$ , $O(\log n)$ , $O(n)$ , $O(n \log n)$ , $O(n^2)$ , $O(2^n)$ , $O(n!)$ 等。 +- 时间复杂度用于衡量算法运行时间随数据量增长的趋势，可以有效评估算法效率，但在某些情况下可能失效，如在输入的数据量较小或时间复杂度相同时，无法精确对比算法效率的优劣。 +- 最差时间复杂度使用大 $O$ 符号表示，对应函数渐近上界，反映当 $n$ 趋向正无穷时，操作数量 $T(n)$ 的增长级别。 +- 推算时间复杂度分为两步，首先统计操作数量，然后判断渐近上界。 +- 常见时间复杂度从小到大排列有 $O(1)$ 、$O(\log n)$ 、$O(n)$ 、$O(n \log n)$ 、$O(n^2)$ 、$O(2^n)$ 、$O(n!)$ 等。 - 某些算法的时间复杂度非固定，而是与输入数据的分布有关。时间复杂度分为最差、最佳、平均时间复杂度，最佳时间复杂度几乎不用，因为输入数据一般需要满足严格条件才能达到最佳情况。 - 平均时间复杂度反映算法在随机数据输入下的运行效率，最接近实际应用中的算法性能。计算平均时间复杂度需要统计输入数据分布以及综合后的数学期望。 **空间复杂度** -- 类似于时间复杂度，空间复杂度用于衡量算法占用空间随数据量增长的趋势。 +- 空间复杂度的作用类似于时间复杂度，用于衡量算法占用空间随数据量增长的趋势。 - 算法运行过程中的相关内存空间可分为输入空间、暂存空间、输出空间。通常情况下，输入空间不计入空间复杂度计算。暂存空间可分为指令空间、数据空间、栈帧空间，其中栈帧空间通常仅在递归函数中影响空间复杂度。 - 我们通常只关注最差空间复杂度，即统计算法在最差输入数据和最差运行时间点下的空间复杂度。 -- 常见空间复杂度从小到大排列有 $O(1)$ , $O(\log n)$ , $O(n)$ , $O(n^2)$ , $O(2^n)$ 等。 +- 常见空间复杂度从小到大排列有 $O(1)$ 、$O(\log n)$ 、$O(n)$ 、$O(n^2)$ 、$O(2^n)$ 等。 ## 2.4.1   Q & A !!! question "尾递归的空间复杂度是 $O(1)$ 吗？" - 理论上，尾递归函数的空间复杂度可以被优化至 $O(1)$ 。不过绝大多数编程语言（例如 Java, Python, C++, Go, C# 等）都不支持自动优化尾递归，因此通常认为空间复杂度是 $O(n)$ 。 + 理论上，尾递归函数的空间复杂度可以被优化至 $O(1)$ 。不过绝大多数编程语言（例如 Java 、Python 、C++ 、Go 、C# 等）都不支持自动优化尾递归，因此通常认为空间复杂度是 $O(n)$ 。 !!! question "函数和方法这两个术语的区别是什么？" - 函数（function）可以独立被执行，所有参数都以显式传递。方法（method）与一个对象关联，方法被隐式传递给调用它的对象，方法能够对类的实例中包含的数据进行操作。 + 函数（function）可以被独立执行，所有参数都以显式传递。方法（method）与一个对象关联，被隐式传递给调用它的对象，能够对类的实例中包含的数据进行操作。 - 以几个常见的编程语言为例： + 下面以几个常见的编程语言来说明。 - - C 语言是过程式编程语言，没有面向对象的概念，所以只有函数。但我们可以通过创建结构（struct）来模拟面向对象编程，与结构体相关联的函数就相当于其他语言中的方法。 - - Java, C# 是面向对象的编程语言，代码块（方法）通常都是作为某个类的一部分。静态方法的行为类似于函数，因为它被绑定在类上，不能访问特定的实例变量。 - - C++, Python 既支持过程式编程（函数）也支持面向对象编程（方法）。 + - C 语言是过程式编程语言，没有面向对象的概念，所以只有函数。但我们可以通过创建结构体（struct）来模拟面向对象编程，与结构体相关联的函数就相当于其他语言中的方法。 + - Java 和 C# 是面向对象的编程语言，代码块（方法）通常都是作为某个类的一部分。静态方法的行为类似于函数，因为它被绑定在类上，不能访问特定的实例变量。 + - C++ 和 Python 既支持过程式编程（函数），也支持面向对象编程（方法）。 -!!! question "图片“空间复杂度的常见类型”反映的是否是占用空间的绝对大小？" +!!! question "图“空间复杂度的常见类型”反映的是否是占用空间的绝对大小？" - 不是，该图片展示的是空间复杂度，其反映的是即增长趋势，而不是占用空间的绝对大小。 + 不是，该图片展示的是空间复杂度，其反映的是增长趋势，而不是占用空间的绝对大小。 假设取 $n = 8$ ，你可能会发现每条曲线的值与函数对应不上。这是因为每条曲线都包含一个常数项，用于将取值范围压缩到一个视觉舒适的范围内。 diff --git a/chapter_computational_complexity/time_complexity.md b/chapter_computational_complexity/time_complexity.md index 538282385..20ac78e7e 100755 --- a/chapter_computational_complexity/time_complexity.md +++ b/chapter_computational_complexity/time_complexity.md @@ -7,14 +7,10 @@ comments: true 运行时间可以直观且准确地反映算法的效率。如果我们想要准确预估一段代码的运行时间，应该如何操作呢？ 1. **确定运行平台**，包括硬件配置、编程语言、系统环境等，这些因素都会影响代码的运行效率。 -2. **评估各种计算操作所需的运行时间**，例如加法操作 `+` 需要 1 ns，乘法操作 `*` 需要 10 ns，打印操作需要 5 ns 等。 +2. **评估各种计算操作所需的运行时间**，例如加法操作 `+` 需要 1 ns，乘法操作 `*` 需要 10 ns，打印操作 `print()` 需要 5 ns 等。 3. **统计代码中所有的计算操作**，并将所有操作的执行时间求和，从而得到运行时间。 -例如以下代码，输入数据大小为 $n$ 。根据以上方法，可以得到算法运行时间为 $6n + 12$ ns 。 - -$$ -1 + 1 + 10 + (1 + 5) \times n = 6n + 12 -$$ +例如在以下代码中，输入数据大小为 $n$ ： === "Java" @@ -185,28 +181,34 @@ $$ } ``` -但实际上，**统计算法的运行时间既不合理也不现实**。首先，我们不希望预估时间和运行平台绑定，因为算法需要在各种不同的平台上运行。其次，我们很难获知每种操作的运行时间，这给预估过程带来了极大的难度。 +根据以上方法，可以得到算法运行时间为 $6n + 12$ ns ： + +$$ +1 + 1 + 10 + (1 + 5) \times n = 6n + 12 +$$ + +但实际上，**统计算法的运行时间既不合理也不现实**。首先，我们不希望将预估时间和运行平台绑定，因为算法需要在各种不同的平台上运行。其次，我们很难获知每种操作的运行时间，这给预估过程带来了极大的难度。 ## 2.2.1   统计时间增长趋势 「时间复杂度分析」采取了一种不同的方法，其统计的不是算法运行时间，**而是算法运行时间随着数据量变大时的增长趋势**。 -“时间增长趋势”这个概念比较抽象，我们通过一个例子来加以理解。假设输入数据大小为 $n$ ，给定三个算法函数 `A` , `B` , `C` 。 +“时间增长趋势”这个概念比较抽象，我们通过一个例子来加以理解。假设输入数据大小为 $n$ ，给定三个算法函数 `A` 、 `B` 和 `C` ： === "Java" ```java title="" - // 算法 A 时间复杂度：常数阶 + // 算法 A 的时间复杂度：常数阶 void algorithm_A(int n) { System.out.println(0); } - // 算法 B 时间复杂度：线性阶 + // 算法 B 的时间复杂度：线性阶 void algorithm_B(int n) { for (int i = 0; i < n; i++) { System.out.println(0); } } - // 算法 C 时间复杂度：常数阶 + // 算法 C 的时间复杂度：常数阶 void algorithm_C(int n) { for (int i = 0; i < 1000000; i++) { System.out.println(0); @@ -217,17 +219,17 @@ $$ === "C++" ```cpp title="" - // 算法 A 时间复杂度：常数阶 + // 算法 A 的时间复杂度：常数阶 void algorithm_A(int n) { cout << 0 << endl; } - // 算法 B 时间复杂度：线性阶 + // 算法 B 的时间复杂度：线性阶 void algorithm_B(int n) { for (int i = 0; i < n; i++) { cout << 0 << endl; } } - // 算法 C 时间复杂度：常数阶 + // 算法 C 的时间复杂度：常数阶 void algorithm_C(int n) { for (int i = 0; i < 1000000; i++) { cout << 0 << endl; @@ -238,14 +240,14 @@ $$ === "Python" ```python title="" - # 算法 A 时间复杂度：常数阶 + # 算法 A 的时间复杂度：常数阶 def algorithm_A(n: int): print(0) - # 算法 B 时间复杂度：线性阶 + # 算法 B 的时间复杂度：线性阶 def algorithm_B(n: int): for _ in range(n): print(0) - # 算法 C 时间复杂度：常数阶 + # 算法 C 的时间复杂度：常数阶 def algorithm_C(n: int): for _ in range(1000000): print(0) @@ -254,17 +256,17 @@ $$ === "Go" ```go title="" - // 算法 A 时间复杂度：常数阶 + // 算法 A 的时间复杂度：常数阶 func algorithm_A(n int) { fmt.Println(0) } - // 算法 B 时间复杂度：线性阶 + // 算法 B 的时间复杂度：线性阶 func algorithm_B(n int) { for i := 0; i < n; i++ { fmt.Println(0) } } - // 算法 C 时间复杂度：常数阶 + // 算法 C 的时间复杂度：常数阶 func algorithm_C(n int) { for i := 0; i < 1000000; i++ { fmt.Println(0) @@ -275,17 +277,17 @@ $$ === "JS" ```javascript title="" - // 算法 A 时间复杂度：常数阶 + // 算法 A 的时间复杂度：常数阶 function algorithm_A(n) { console.log(0); } - // 算法 B 时间复杂度：线性阶 + // 算法 B 的时间复杂度：线性阶 function algorithm_B(n) { for (let i = 0; i < n; i++) { console.log(0); } } - // 算法 C 时间复杂度：常数阶 + // 算法 C 的时间复杂度：常数阶 function algorithm_C(n) { for (let i = 0; i < 1000000; i++) { console.log(0); @@ -297,17 +299,17 @@ $$ === "TS" ```typescript title="" - // 算法 A 时间复杂度：常数阶 + // 算法 A 的时间复杂度：常数阶 function algorithm_A(n: number): void { console.log(0); } - // 算法 B 时间复杂度：线性阶 + // 算法 B 的时间复杂度：线性阶 function algorithm_B(n: number): void { for (let i = 0; i < n; i++) { console.log(0); } } - // 算法 C 时间复杂度：常数阶 + // 算法 C 的时间复杂度：常数阶 function algorithm_C(n: number): void { for (let i = 0; i < 1000000; i++) { console.log(0); @@ -318,17 +320,17 @@ $$ === "C" ```c title="" - // 算法 A 时间复杂度：常数阶 + // 算法 A 的时间复杂度：常数阶 void algorithm_A(int n) { printf("%d", 0); } - // 算法 B 时间复杂度：线性阶 + // 算法 B 的时间复杂度：线性阶 void algorithm_B(int n) { for (int i = 0; i < n; i++) { printf("%d", 0); } } - // 算法 C 时间复杂度：常数阶 + // 算法 C 的时间复杂度：常数阶 void algorithm_C(int n) { for (int i = 0; i < 1000000; i++) { printf("%d", 0); @@ -339,17 +341,17 @@ $$ === "C#" ```csharp title="" - // 算法 A 时间复杂度：常数阶 + // 算法 A 的时间复杂度：常数阶 void algorithm_A(int n) { Console.WriteLine(0); } - // 算法 B 时间复杂度：线性阶 + // 算法 B 的时间复杂度：线性阶 void algorithm_B(int n) { for (int i = 0; i < n; i++) { Console.WriteLine(0); } } - // 算法 C 时间复杂度：常数阶 + // 算法 C 的时间复杂度：常数阶 void algorithm_C(int n) { for (int i = 0; i < 1000000; i++) { Console.WriteLine(0); @@ -360,19 +362,19 @@ $$ === "Swift" ```swift title="" - // 算法 A 时间复杂度：常数阶 + // 算法 A 的时间复杂度：常数阶 func algorithmA(n: Int) { print(0) } - // 算法 B 时间复杂度：线性阶 + // 算法 B 的时间复杂度：线性阶 func algorithmB(n: Int) { for _ in 0 ..< n { print(0) } } - // 算法 C 时间复杂度：常数阶 + // 算法 C 的时间复杂度：常数阶 func algorithmC(n: Int) { for _ in 0 ..< 1000000 { print(0) @@ -389,17 +391,17 @@ $$ === "Dart" ```dart title="" - // 算法 A 时间复杂度：常数阶 + // 算法 A 的时间复杂度：常数阶 void algorithmA(int n) { print(0); } - // 算法 B 时间复杂度：线性阶 + // 算法 B 的时间复杂度：线性阶 void algorithmB(int n) { for (int i = 0; i < n; i++) { print(0); } } - // 算法 C 时间复杂度：常数阶 + // 算法 C 的时间复杂度：常数阶 void algorithmC(int n) { for (int i = 0; i < 1000000; i++) { print(0); @@ -410,17 +412,17 @@ $$ === "Rust" ```rust title="" - // 算法 A 时间复杂度：常数阶 + // 算法 A 的时间复杂度：常数阶 fn algorithm_A(n: i32) { println!("{}", 0); } - // 算法 B 时间复杂度：线性阶 + // 算法 B 的时间复杂度：线性阶 fn algorithm_B(n: i32) { for _ in 0..n { println!("{}", 0); } } - // 算法 C 时间复杂度：常数阶 + // 算法 C 的时间复杂度：常数阶 fn algorithm_C(n: i32) { for _ in 0..1000000 { println!("{}", 0); @@ -434,21 +436,19 @@ $$ 算法 `C` 中的打印操作需要循环 $1000000$ 次，虽然运行时间很长，但它与输入数据大小 $n$ 无关。因此 `C` 的时间复杂度和 `A` 相同，仍为「常数阶」。 -![算法 A, B, C 的时间增长趋势](time_complexity.assets/time_complexity_simple_example.png) +![算法 A 、B 和 C 的时间增长趋势](time_complexity.assets/time_complexity_simple_example.png) -

图：算法 A, B, C 的时间增长趋势

+

图：算法 A 、B 和 C 的时间增长趋势

相较于直接统计算法运行时间，时间复杂度分析有哪些特点呢？ -**时间复杂度能够有效评估算法效率**。例如，算法 `B` 的运行时间呈线性增长，在 $n > 1$ 时比算法 `A` 更慢，在 $n > 1000000$ 时比算法 `C` 更慢。事实上，只要输入数据大小 $n$ 足够大，复杂度为“常数阶”的算法一定优于“线性阶”的算法，这正是时间增长趋势所表达的含义。 - -**时间复杂度的推算方法更简便**。显然，运行平台和计算操作类型都与算法运行时间的增长趋势无关。因此在时间复杂度分析中，我们可以简单地将所有计算操作的执行时间视为相同的“单位时间”，从而将“计算操作的运行时间的统计”简化为“计算操作的数量的统计”，这样以来估算难度就大大降低了。 - -**时间复杂度也存在一定的局限性**。例如，尽管算法 `A` 和 `C` 的时间复杂度相同，但实际运行时间差别很大。同样，尽管算法 `B` 的时间复杂度比 `C` 高，但在输入数据大小 $n$ 较小时，算法 `B` 明显优于算法 `C` 。在这些情况下，我们很难仅凭时间复杂度判断算法效率高低。当然，尽管存在上述问题，复杂度分析仍然是评判算法效率最有效且常用的方法。 +- **时间复杂度能够有效评估算法效率**。例如，算法 `B` 的运行时间呈线性增长，在 $n > 1$ 时比算法 `A` 更慢，在 $n > 1000000$ 时比算法 `C` 更慢。事实上，只要输入数据大小 $n$ 足够大，复杂度为“常数阶”的算法一定优于“线性阶”的算法，这正是时间增长趋势所表达的含义。 +- **时间复杂度的推算方法更简便**。显然，运行平台和计算操作类型都与算法运行时间的增长趋势无关。因此在时间复杂度分析中，我们可以简单地将所有计算操作的执行时间视为相同的“单位时间”，从而将“计算操作的运行时间的统计”简化为“计算操作的数量的统计”，这样以来估算难度就大大降低了。 +- **时间复杂度也存在一定的局限性**。例如，尽管算法 `A` 和 `C` 的时间复杂度相同，但实际运行时间差别很大。同样，尽管算法 `B` 的时间复杂度比 `C` 高，但在输入数据大小 $n$ 较小时，算法 `B` 明显优于算法 `C` 。在这些情况下，我们很难仅凭时间复杂度判断算法效率的高低。当然，尽管存在上述问题，复杂度分析仍然是评判算法效率最有效且常用的方法。 ## 2.2.2   函数渐近上界 -给定一个函数 `algorithm()` ： +给定一个输入大小为 $n$ 的函数： === "Java" @@ -609,15 +609,15 @@ $$ } ``` -设算法的计算操作数量是一个关于输入数据大小 $n$ 的函数，记为 $T(n)$ ，则以上函数的的操作数量为： +设算法的操作数量是一个关于输入数据大小 $n$ 的函数，记为 $T(n)$ ，则以上函数的的操作数量为： $$ T(n) = 3 + 2n $$ -$T(n)$ 是一次函数，说明时间的增长趋势是线性的，因此其时间复杂度是线性阶。 +$T(n)$ 是一次函数，说明其运行时间的增长趋势是线性的，因此它的时间复杂度是线性阶。 -我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号称为「大 $O$ 记号 Big-$O$ Notation」，表示函数 $T(n)$ 的「渐近上界 Asymptotic Upper Bound」。 +我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号称为「大 $O$ 记号 big-$O$ notation」，表示函数 $T(n)$ 的「渐近上界 asymptotic upper bound」。 时间复杂度分析本质上是计算“操作数量函数 $T(n)$”的渐近上界。接下来，我们来看函数渐近上界的数学定义。 @@ -632,27 +632,27 @@ $T(n)$ 是一次函数，说明时间的增长趋势是线性的，因此其时 T(n) = O(f(n)) $$ +如下图所示，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。 + ![函数的渐近上界](time_complexity.assets/asymptotic_upper_bound.png)

图：函数的渐近上界

-也就是说，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。 - ## 2.2.3   推算方法 -渐近上界的数学味儿有点重，如果你感觉没有完全理解，也无需担心。因为在实际使用中，我们只需要掌握推算方法，数学意义可以逐渐领悟。 +渐近上界的数学味儿有点重，如果你感觉没有完全理解，也无须担心。因为在实际使用中，我们只需要掌握推算方法，数学意义就可以逐渐领悟。 根据定义，确定 $f(n)$ 之后，我们便可得到时间复杂度 $O(f(n))$ 。那么如何确定渐近上界 $f(n)$ 呢？总体分为两步：首先统计操作数量，然后判断渐近上界。 ### 1.   第一步：统计操作数量 -针对代码，逐行从上到下计算即可。然而，由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，**因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数简化技巧： +针对代码，逐行从上到下计算即可。然而，由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，**因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数简化技巧。 1. **忽略 $T(n)$ 中的常数项**。因为它们都与 $n$ 无关，所以对时间复杂度不产生影响。 2. **省略所有系数**。例如，循环 $2n$ 次、$5n + 1$ 次等，都可以简化记为 $n$ 次，因为 $n$ 前面的系数对时间复杂度没有影响。 3. **循环嵌套时使用乘法**。总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用上述 `1.` 和 `2.` 技巧。 -以下示例展示了使用上述技巧前、后的统计结果。两者推出的时间复杂度相同，即为 $O(n^2)$ 。 +以下代码与公式分别展示了使用上述技巧前后的统计结果。两者推出的时间复杂度相同，都为 $O(n^2)$ 。 $$ \begin{aligned} @@ -880,7 +880,8 @@ $$ **时间复杂度由多项式 $T(n)$ 中最高阶的项来决定**。这是因为在 $n$ 趋于无穷大时，最高阶的项将发挥主导作用，其他项的影响都可以被忽略。 以下表格展示了一些例子，其中一些夸张的值是为了强调“系数无法撼动阶数”这一结论。当 $n$ 趋于无穷大时，这些常数变得无足轻重。 -

表：多项式时间复杂度示例

+ +

表：不同操作数量对应的时间复杂度

@@ -905,19 +906,19 @@ O(1) < O(\log n) < O(n) < O(n \log n) < O(n^2) < O(2^n) < O(n!) \newline \end{aligned} $$ -![时间复杂度的常见类型](time_complexity.assets/time_complexity_common_types.png) +![常见的时间复杂度类型](time_complexity.assets/time_complexity_common_types.png) -

图：时间复杂度的常见类型

+

图：常见的时间复杂度类型

!!! tip - 部分示例代码需要一些预备知识，包括数组、递归等。如果你遇到不理解的部分，可以在学习完后面章节后再回顾。现阶段，请先专注于理解时间复杂度的含义和推算方法。 + 部分示例代码需要一些预备知识，包括数组、递归等。如果你遇到不理解的部分，可以在学完后面章节后再回顾。现阶段，请先专注于理解时间复杂度的含义和推算方法。 ### 1.   常数阶 $O(1)$ 常数阶的操作数量与输入数据大小 $n$ 无关，即不随着 $n$ 的变化而变化。 -对于以下算法，尽管操作数量 `size` 可能很大，但由于其与数据大小 $n$ 无关，因此时间复杂度仍为 $O(1)$ 。 +对于以下算法，尽管操作数量 `size` 可能很大，但由于其与输入数据大小 $n$ 无关，因此时间复杂度仍为 $O(1)$ ： === "Java" @@ -1084,7 +1085,7 @@ $$ ### 2.   线性阶 $O(n)$ -线性阶的操作数量相对于输入数据大小以线性级别增长。线性阶通常出现在单层循环中。 +线性阶的操作数量相对于输入数据大小 $n$ 以线性级别增长。线性阶通常出现在单层循环中： === "Java" @@ -1234,7 +1235,7 @@ $$ } ``` -遍历数组和遍历链表等操作的时间复杂度均为 $O(n)$ ，其中 $n$ 为数组或链表的长度。 +遍历数组和遍历链表等操作的时间复杂度均为 $O(n)$ ，其中 $n$ 为数组或链表的长度： === "Java" @@ -1402,11 +1403,11 @@ $$ } ``` -值得注意的是，**数据大小 $n$ 需根据输入数据的类型来具体确定**。比如在第一个示例中，变量 $n$ 为输入数据大小；在第二个示例中，数组长度 $n$ 为数据大小。 +值得注意的是，**输入数据大小 $n$ 需根据输入数据的类型来具体确定**。比如在第一个示例中，变量 $n$ 为输入数据大小；在第二个示例中，数组长度 $n$ 为数据大小。 ### 3.   平方阶 $O(n^2)$ -平方阶的操作数量相对于输入数据大小以平方级别增长。平方阶通常出现在嵌套循环中，外层循环和内层循环都为 $O(n)$ ，因此总体为 $O(n^2)$ 。 +平方阶的操作数量相对于输入数据大小以平方级别增长。平方阶通常出现在嵌套循环中，外层循环和内层循环都为 $O(n)$ ，因此总体为 $O(n^2)$ ： === "Java" @@ -1599,11 +1600,13 @@ $$ } ``` -![常数阶、线性阶、平方阶的时间复杂度](time_complexity.assets/time_complexity_constant_linear_quadratic.png) +下图对比了常数阶、线性阶和平方阶三种时间复杂度。 -

图：常数阶、线性阶、平方阶的时间复杂度

+![常数阶、线性阶和平方阶的时间复杂度](time_complexity.assets/time_complexity_constant_linear_quadratic.png) -以「冒泡排序」为例，外层循环执行 $n - 1$ 次，内层循环执行 $n-1, n-2, \cdots, 2, 1$ 次，平均为 $\frac{n}{2}$ 次，因此时间复杂度为 $O(n^2)$ 。 +

图：常数阶、线性阶和平方阶的时间复杂度

+ +以冒泡排序为例，外层循环执行 $n - 1$ 次，内层循环执行 $n-1, n-2, \cdots, 2, 1$ 次，平均为 $\frac{n}{2}$ 次，因此时间复杂度为 $O(n^2)$ ： $$ O((n - 1) \frac{n}{2}) = O(n^2) @@ -1883,9 +1886,7 @@ $$ ### 4.   指数阶 $O(2^n)$ -生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 $1$ 个细胞，分裂一轮后变为 $2$ 个，分裂两轮后变为 $4$ 个，以此类推，分裂 $n$ 轮后有 $2^n$ 个细胞。 - -以下代码模拟了细胞分裂的过程。 +生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 $1$ 个细胞，分裂一轮后变为 $2$ 个，分裂两轮后变为 $4$ 个，以此类推，分裂 $n$ 轮后有 $2^n$ 个细胞。相关代码如下： === "Java" @@ -2109,11 +2110,13 @@ $$ } ``` +下图展示了细胞分裂的过程。 + ![指数阶的时间复杂度](time_complexity.assets/time_complexity_exponential.png)

图：指数阶的时间复杂度

-在实际算法中，指数阶常出现于递归函数。例如以下代码，其递归地一分为二，经过 $n$ 次分裂后停止。 +在实际算法中，指数阶常出现于递归函数中。例如以下代码，其递归地一分为二，经过 $n$ 次分裂后停止： === "Java" @@ -2248,7 +2251,7 @@ $$ ### 5.   对数阶 $O(\log n)$ -与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。 +与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。相关代码如下： === "Java" @@ -2423,7 +2426,7 @@ $$

图：对数阶的时间复杂度

-与指数阶类似，对数阶也常出现于递归函数。以下代码形成了一个高度为 $\log_2 n$ 的递归树。 +与指数阶类似，对数阶也常出现于递归函数中。以下代码形成了一个高度为 $\log_2 n$ 的递归树： === "Java" @@ -2554,13 +2557,11 @@ $$ } ``` -对数阶常出现于基于「分治」的算法中，体现了“一分为多”和“化繁为简”的算法思想。它增长缓慢，是理想的时间复杂度，仅次于常数阶。 +对数阶常出现于基于分治策略的算法中，体现了“一分为多”和“化繁为简”的算法思想。它增长缓慢，是理想的时间复杂度，仅次于常数阶。 ### 6.   线性对数阶 $O(n \log n)$ -线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。 - -主流排序算法的时间复杂度通常为 $O(n \log n)$ ，例如快速排序、归并排序、堆排序等。 +线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。相关代码如下： === "Java" @@ -2748,6 +2749,8 @@ $$

图：线性对数阶的时间复杂度

+主流排序算法的时间复杂度通常为 $O(n \log n)$ ，例如快速排序、归并排序、堆排序等。 + ### 7.   阶乘阶 $O(n!)$ 阶乘阶对应数学上的“全排列”问题。给定 $n$ 个互不重复的元素，求其所有可能的排列方案，方案数量为： @@ -2756,7 +2759,7 @@ $$ n! = n \times (n - 1) \times (n - 2) \times \cdots \times 2 \times 1 $$ -阶乘通常使用递归实现。例如以下代码，第一层分裂出 $n$ 个，第二层分裂出 $n - 1$ 个，以此类推，直至第 $n$ 层时终止分裂。 +阶乘通常使用递归实现。例如在以下代码中，第一层分裂出 $n$ 个，第二层分裂出 $n - 1$ 个，以此类推，直至第 $n$ 层时停止分裂： === "Java" @@ -2950,16 +2953,16 @@ $$

图：阶乘阶的时间复杂度

-请注意，因为 $n! > 2^n$ ，所以阶乘阶比指数阶增长地更快，在 $n$ 较大时也是不可接受的。 +请注意，因为 $n! > 2^n$ ，所以阶乘阶比指数阶增长得更快，在 $n$ 较大时也是不可接受的。 ## 2.2.5   最差、最佳、平均时间复杂度 -**算法的时间效率往往不是固定的，而是与输入数据的分布有关**。假设输入一个长度为 $n$ 的数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的，任务目标是返回元素 $1$ 的索引。我们可以得出以下结论： +**算法的时间效率往往不是固定的，而是与输入数据的分布有关**。假设输入一个长度为 $n$ 的数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，每个数字只出现一次，但元素顺序是随机打乱的，任务目标是返回元素 $1$ 的索引。我们可以得出以下结论。 - 当 `nums = [?, ?, ..., 1]` ，即当末尾元素是 $1$ 时，需要完整遍历数组，**达到最差时间复杂度 $O(n)$** 。 -- 当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，**达到最佳时间复杂度 $\Omega(1)$** 。 +- 当 `nums = [1, ?, ?, ...]` ，即当首个元素为 $1$ 时，无论数组多长都不需要继续遍历，**达到最佳时间复杂度 $\Omega(1)$** 。 -「最差时间复杂度」对应函数渐近上界，使用大 $O$ 记号表示。相应地，「最佳时间复杂度」对应函数渐近下界，用 $\Omega$ 记号表示。 +「最差时间复杂度」对应函数渐近上界，使用大 $O$ 记号表示。相应地，「最佳时间复杂度」对应函数渐近下界，用 $\Omega$ 记号表示： === "Java" @@ -3315,10 +3318,10 @@ $$ 从上述示例可以看出，最差或最佳时间复杂度只出现于“特殊的数据分布”，这些情况的出现概率可能很小，并不能真实地反映算法运行效率。相比之下，**「平均时间复杂度」可以体现算法在随机输入数据下的运行效率**，用 $\Theta$ 记号来表示。 -对于部分算法，我们可以简单地推算出随机数据分布下的平均情况。比如上述示例，由于输入数组是被打乱的，因此元素 $1$ 出现在任意索引的概率都是相等的，那么算法的平均循环次数则是数组长度的一半 $\frac{n}{2}$ ，平均时间复杂度为 $\Theta(\frac{n}{2}) = \Theta(n)$ 。 +对于部分算法，我们可以简单地推算出随机数据分布下的平均情况。比如上述示例，由于输入数组是被打乱的，因此元素 $1$ 出现在任意索引的概率都是相等的，那么算法的平均循环次数就是数组长度的一半 $\frac{n}{2}$ ，平均时间复杂度为 $\Theta(\frac{n}{2}) = \Theta(n)$ 。 但对于较为复杂的算法，计算平均时间复杂度往往是比较困难的，因为很难分析出在数据分布下的整体数学期望。在这种情况下，我们通常使用最差时间复杂度作为算法效率的评判标准。 !!! question "为什么很少看到 $\Theta$ 符号？" - 可能由于 $O$ 符号过于朗朗上口，我们常常使用它来表示「平均复杂度」，但从严格意义上看，这种做法并不规范。在本书和其他资料中，若遇到类似“平均时间复杂度 $O(n)$”的表述，请将其直接理解为 $\Theta(n)$ 。 + 可能由于 $O$ 符号过于朗朗上口，我们常常使用它来表示平均时间复杂度。但从严格意义上看，这种做法并不规范。在本书和其他资料中，若遇到类似“平均时间复杂度 $O(n)$”的表述，请将其直接理解为 $\Theta(n)$ 。 diff --git a/chapter_data_structure/basic_data_types.md b/chapter_data_structure/basic_data_types.md index 09214e3ff..2fe8e17d1 100644 --- a/chapter_data_structure/basic_data_types.md +++ b/chapter_data_structure/basic_data_types.md @@ -20,7 +20,7 @@ comments: true - 整数类型 `byte` 占用 $1$ byte = $8$ bits ，可以表示 $2^{8}$ 个数字。 - 整数类型 `int` 占用 $4$ bytes = $32$ bits ，可以表示 $2^{32}$ 个数字。 -下表列举了各种基本数据类型的占用空间、取值范围和默认值。此表格无需硬背，大致理解即可，需要时可以通过查表来回忆。 +下表列举了各种基本数据类型的占用空间、取值范围和默认值。此表格无须硬背，大致理解即可，需要时可以通过查表来回忆。

表：基本数据类型的占用空间和取值范围

diff --git a/chapter_data_structure/number_encoding.md b/chapter_data_structure/number_encoding.md index a85bce265..e86a7b406 100644 --- a/chapter_data_structure/number_encoding.md +++ b/chapter_data_structure/number_encoding.md @@ -88,7 +88,7 @@ $$ 请注意，这并不意味着计算机只能做加法。**通过将加法与一些基本逻辑运算结合，计算机能够实现各种其他的数学运算**。例如，计算减法 $a - b$ 可以转换为计算加法 $a + (-b)$ ；计算乘法和除法可以转换为计算多次加法或减法。 -现在我们可以总结出计算机使用补码的原因：基于补码表示，计算机可以用同样的电路和操作来处理正数和负数的加法，不需要设计特殊的硬件电路来处理减法，并且无需特别处理正负零的歧义问题。这大大简化了硬件设计，提高了运算效率。 +现在我们可以总结出计算机使用补码的原因：基于补码表示，计算机可以用同样的电路和操作来处理正数和负数的加法，不需要设计特殊的硬件电路来处理减法，并且无须特别处理正负零的歧义问题。这大大简化了硬件设计，提高了运算效率。 补码的设计非常精妙，因篇幅关系我们就先介绍到这里，建议有兴趣的读者进一步深度了解。 diff --git a/chapter_divide_and_conquer/binary_search_recur.md b/chapter_divide_and_conquer/binary_search_recur.md index 624bb4148..4ed285044 100644 --- a/chapter_divide_and_conquer/binary_search_recur.md +++ b/chapter_divide_and_conquer/binary_search_recur.md @@ -19,7 +19,7 @@ status: new - **问题可以被分解**：二分查找递归地将原问题（在数组中进行查找）分解为子问题（在数组的一半中进行查找），这是通过比较中间元素和目标元素来实现的。 - **子问题是独立的**：在二分查找中，每轮只处理一个子问题，它不受另外子问题的影响。 -- **子问题的解无需合并**：二分查找旨在查找一个特定元素，因此不需要将子问题的解进行合并。当子问题得到解决时，原问题也会同时得到解决。 +- **子问题的解无须合并**：二分查找旨在查找一个特定元素，因此不需要将子问题的解进行合并。当子问题得到解决时，原问题也会同时得到解决。 分治能够提升搜索效率，本质上是因为暴力搜索每轮只能排除一个选项，**而分治搜索每轮可以排除一半选项**。 diff --git a/chapter_divide_and_conquer/summary.md b/chapter_divide_and_conquer/summary.md index c4e2d5444..09ba51f31 100644 --- a/chapter_divide_and_conquer/summary.md +++ b/chapter_divide_and_conquer/summary.md @@ -8,7 +8,7 @@ status: new - 分治算法是一种常见的算法设计策略，包括分（划分）和治（合并）两个阶段，通常基于递归实现。 - 判断是否是分治算法问题的依据包括：问题能否被分解、子问题是否独立、子问题是否可以被合并。 - 归并排序是分治策略的典型应用，其递归地将数组划分为等长的两个子数组，直到只剩一个元素时开始逐层合并，从而完成排序。 -- 引入分治策略往往可以带来算法效率的提升。一方面，分治策略减少了计算操作数量；另一方面，分治后有利于系统的并行优化。 +- 引入分治策略往往可以带来算法效率的提升。一方面，分治策略减少了操作数量；另一方面，分治后有利于系统的并行优化。 - 分治既可以解决许多算法问题，也广泛应用于数据结构与算法设计中，处处可见其身影。 - 相较于暴力搜索，自适应搜索效率更高。时间复杂度为 $O(\log n)$ 的搜索算法通常都是基于分治策略实现的。 - 二分查找是分治思想的另一个典型应用，它不包含将子问题的解进行合并的步骤。我们可以通过递归分治实现二分查找。 diff --git a/chapter_dynamic_programming/dp_problem_features.md b/chapter_dynamic_programming/dp_problem_features.md index 16ac54909..074c7d151 100644 --- a/chapter_dynamic_programming/dp_problem_features.md +++ b/chapter_dynamic_programming/dp_problem_features.md @@ -435,7 +435,7 @@ $$ 「无后效性」是动态规划能够有效解决问题的重要特性之一，定义为：**给定一个确定的状态，它的未来发展只与当前状态有关，而与当前状态过去所经历过的所有状态无关**。 -以爬楼梯问题为例，给定状态 $i$ ，它会发展出状态 $i+1$ 和状态 $i+2$ ，分别对应跳 $1$ 步和跳 $2$ 步。在做出这两种选择时，我们无需考虑状态 $i$ 之前的状态，它们对状态 $i$ 的未来没有影响。 +以爬楼梯问题为例，给定状态 $i$ ，它会发展出状态 $i+1$ 和状态 $i+2$ ，分别对应跳 $1$ 步和跳 $2$ 步。在做出这两种选择时，我们无须考虑状态 $i$ 之前的状态，它们对状态 $i$ 的未来没有影响。 然而，如果我们向爬楼梯问题添加一个约束，情况就不一样了。 diff --git a/chapter_dynamic_programming/edit_distance_problem.md b/chapter_dynamic_programming/edit_distance_problem.md index f8008ba50..8abb64a64 100644 --- a/chapter_dynamic_programming/edit_distance_problem.md +++ b/chapter_dynamic_programming/edit_distance_problem.md @@ -64,7 +64,7 @@ $$ dp[i, j] = \min(dp[i, j-1], dp[i-1, j], dp[i-1, j-1]) + 1 $$ -请注意，**当 $s[i-1]$ 和 $t[j-1]$ 相同时，无需编辑当前字符**，这种情况下的状态转移方程为： +请注意，**当 $s[i-1]$ 和 $t[j-1]$ 相同时，无须编辑当前字符**，这种情况下的状态转移方程为： $$ dp[i, j] = dp[i-1, j-1] diff --git a/chapter_dynamic_programming/intro_to_dynamic_programming.md b/chapter_dynamic_programming/intro_to_dynamic_programming.md index b459a1ddf..21a850f8c 100644 --- a/chapter_dynamic_programming/intro_to_dynamic_programming.md +++ b/chapter_dynamic_programming/intro_to_dynamic_programming.md @@ -929,7 +929,7 @@ $$ 与之相反，**动态规划是一种“从底至顶”的方法**：从最小子问题的解开始，迭代地构建更大子问题的解，直至得到原问题的解。 -由于动态规划不包含回溯过程，因此只需使用循环迭代实现，无需使用递归。在以下代码中，我们初始化一个数组 `dp` 来存储子问题的解，它起到了记忆化搜索中数组 `mem` 相同的记录作用。 +由于动态规划不包含回溯过程，因此只需使用循环迭代实现，无须使用递归。在以下代码中，我们初始化一个数组 `dp` 来存储子问题的解，它起到了记忆化搜索中数组 `mem` 相同的记录作用。 === "Java" @@ -1169,7 +1169,7 @@ $$ ## 14.1.4   状态压缩 -细心的你可能发现，**由于 $dp[i]$ 只与 $dp[i-1]$ 和 $dp[i-2]$ 有关，因此我们无需使用一个数组 `dp` 来存储所有子问题的解**，而只需两个变量滚动前进即可。 +细心的你可能发现，**由于 $dp[i]$ 只与 $dp[i-1]$ 和 $dp[i-2]$ 有关，因此我们无须使用一个数组 `dp` 来存储所有子问题的解**，而只需两个变量滚动前进即可。 === "Java" diff --git a/chapter_dynamic_programming/summary.md b/chapter_dynamic_programming/summary.md index c63ebeffc..314f37e36 100644 --- a/chapter_dynamic_programming/summary.md +++ b/chapter_dynamic_programming/summary.md @@ -24,5 +24,5 @@ status: new **编辑距离问题** - 编辑距离（Levenshtein 距离）用于衡量两个字符串之间的相似度，其定义为从一个字符串到另一个字符串的最小编辑步数，编辑操作包括添加、删除、替换。 -- 编辑距离问题的状态定义为将 $s$ 的前 $i$ 个字符更改为 $t$ 的前 $j$ 个字符所需的最少编辑步数。当 $s[i] \ne t[j]$ 时，具有三种决策：添加、删除、替换，它们都有相应的剩余子问题。据此便可以找出最优子结构与构建状态转移方程。而当 $s[i] = t[j]$ 时，无需编辑当前字符。 +- 编辑距离问题的状态定义为将 $s$ 的前 $i$ 个字符更改为 $t$ 的前 $j$ 个字符所需的最少编辑步数。当 $s[i] \ne t[j]$ 时，具有三种决策：添加、删除、替换，它们都有相应的剩余子问题。据此便可以找出最优子结构与构建状态转移方程。而当 $s[i] = t[j]$ 时，无须编辑当前字符。 - 在编辑距离中，状态依赖于其正上方、正左方、左上方的状态，因此状态压缩后正序或倒序遍历都无法正确地进行状态转移。为此，我们利用一个变量暂存左上方状态，从而转化到与完全背包等价的情况，可以在状态压缩后进行正序遍历。 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.md b/chapter_dynamic_programming/unbounded_knapsack_problem.md index 6763654db..81899c6cc 100644 --- a/chapter_dynamic_programming/unbounded_knapsack_problem.md +++ b/chapter_dynamic_programming/unbounded_knapsack_problem.md @@ -1202,7 +1202,7 @@ $$ dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]] $$ -当目标金额为 $0$ 时，无需选择任何硬币即可凑出目标金额，因此应将首列所有 $dp[i, 0]$ 都初始化为 $1$ 。当无硬币时，无法凑出任何 $>0$ 的目标金额，因此首行所有 $dp[0, a]$ 都等于 $0$ 。 +当目标金额为 $0$ 时，无须选择任何硬币即可凑出目标金额，因此应将首列所有 $dp[i, 0]$ 都初始化为 $1$ 。当无硬币时，无法凑出任何 $>0$ 的目标金额，因此首行所有 $dp[0, a]$ 都等于 $0$ 。 ### 2.   代码实现 diff --git a/chapter_graph/graph_operations.md b/chapter_graph/graph_operations.md index 753eaf453..8c22cc2be 100644 --- a/chapter_graph/graph_operations.md +++ b/chapter_graph/graph_operations.md @@ -1155,7 +1155,7 @@ comments: true - 如果我们选择通过顶点值来区分不同顶点，那么值重复的顶点将无法被区分。 - 如果类似邻接矩阵那样，使用顶点列表索引来区分不同顶点。那么，假设我们想要删除索引为 $i$ 的顶点，则需要遍历整个邻接表，将其中 $> i$ 的索引全部减 $1$ ，这样操作效率较低。 -- 因此我们考虑引入顶点类 `Vertex` ，使得每个顶点都是唯一的对象，此时删除顶点时就无需改动其余顶点了。 +- 因此我们考虑引入顶点类 `Vertex` ，使得每个顶点都是唯一的对象，此时删除顶点时就无须改动其余顶点了。 === "Java" diff --git a/chapter_greedy/max_product_cutting_problem.md b/chapter_greedy/max_product_cutting_problem.md index e1441d3cd..ff09a790f 100644 --- a/chapter_greedy/max_product_cutting_problem.md +++ b/chapter_greedy/max_product_cutting_problem.md @@ -66,7 +66,7 @@ $$ ### 2.   代码实现 -在代码中，我们无需通过循环来切分整数，而可以利用向下整除运算得到 $3$ 的个数 $a$ ，用取模运算得到余数 $b$ ，此时有： +在代码中，我们无须通过循环来切分整数，而可以利用向下整除运算得到 $3$ 的个数 $a$ ，用取模运算得到余数 $b$ ，此时有： $$ n = 3 a + b diff --git a/chapter_heap/build_heap.md b/chapter_heap/build_heap.md index 79b063947..456e3512b 100644 --- a/chapter_heap/build_heap.md +++ b/chapter_heap/build_heap.md @@ -16,7 +16,7 @@ comments: true 有趣的是，存在一种更高效的建堆方法，其时间复杂度可以达到 $O(n)$ 。我们先将列表所有元素原封不动添加到堆中，然后倒序遍历该堆，依次对每个节点执行“从顶至底堆化”。 -请注意，因为叶节点没有子节点，所以无需堆化。在代码实现中，我们从最后一个节点的父节点开始进行堆化。 +请注意，因为叶节点没有子节点，所以无须堆化。在代码实现中，我们从最后一个节点的父节点开始进行堆化。 === "Java" diff --git a/chapter_heap/heap.md b/chapter_heap/heap.md index 6487c2f85..597baeec2 100644 --- a/chapter_heap/heap.md +++ b/chapter_heap/heap.md @@ -680,7 +680,7 @@ comments: true 给定元素 `val` ，我们首先将其添加到堆底。添加之后，由于 val 可能大于堆中其他元素，堆的成立条件可能已被破坏。因此，**需要修复从插入节点到根节点的路径上的各个节点**，这个操作被称为「堆化 Heapify」。 -考虑从入堆节点开始，**从底至顶执行堆化**。具体来说，我们比较插入节点与其父节点的值，如果插入节点更大，则将它们交换。然后继续执行此操作，从底至顶修复堆中的各个节点，直至越过根节点或遇到无需交换的节点时结束。 +考虑从入堆节点开始，**从底至顶执行堆化**。具体来说，我们比较插入节点与其父节点的值，如果插入节点更大，则将它们交换。然后继续执行此操作，从底至顶修复堆中的各个节点，直至越过根节点或遇到无须交换的节点时结束。 === "<1>" ![元素入堆步骤](heap.assets/heap_push_step1.png) @@ -729,7 +729,7 @@ comments: true while (true) { // 获取节点 i 的父节点 int p = parent(i); - // 当“越过根节点”或“节点无需修复”时，结束堆化 + // 当“越过根节点”或“节点无须修复”时，结束堆化 if (p < 0 || maxHeap.get(i) <= maxHeap.get(p)) break; // 交换两节点 @@ -756,7 +756,7 @@ comments: true while (true) { // 获取节点 i 的父节点 int p = parent(i); - // 当“越过根节点”或“节点无需修复”时，结束堆化 + // 当“越过根节点”或“节点无须修复”时，结束堆化 if (p < 0 || maxHeap[i] <= maxHeap[p]) break; // 交换两节点 @@ -782,7 +782,7 @@ comments: true while True: # 获取节点 i 的父节点 p = self.parent(i) - # 当“越过根节点”或“节点无需修复”时，结束堆化 + # 当“越过根节点”或“节点无须修复”时，结束堆化 if p < 0 or self.max_heap[i] <= self.max_heap[p]: break # 交换两节点 @@ -807,7 +807,7 @@ comments: true for true { // 获取节点 i 的父节点 p := h.parent(i) - // 当“越过根节点”或“节点无需修复”时，结束堆化 + // 当“越过根节点”或“节点无须修复”时，结束堆化 if p < 0 || h.data[i].(int) <= h.data[p].(int) { break } @@ -835,7 +835,7 @@ comments: true while (true) { // 获取节点 i 的父节点 const p = this.#parent(i); - // 当“越过根节点”或“节点无需修复”时，结束堆化 + // 当“越过根节点”或“节点无须修复”时，结束堆化 if (p < 0 || this.#maxHeap[i] <= this.#maxHeap[p]) break; // 交换两节点 this.#swap(i, p); @@ -861,7 +861,7 @@ comments: true while (true) { // 获取节点 i 的父节点 const p = this.parent(i); - // 当“越过根节点”或“节点无需修复”时，结束堆化 + // 当“越过根节点”或“节点无须修复”时，结束堆化 if (p < 0 || this.maxHeap[i] <= this.maxHeap[p]) break; // 交换两节点 this.swap(i, p); @@ -894,7 +894,7 @@ comments: true while (true) { // 获取节点 i 的父节点 int p = parent(h, i); - // 当“越过根节点”或“节点无需修复”时，结束堆化 + // 当“越过根节点”或“节点无须修复”时，结束堆化 if (p < 0 || h->data[i] <= h->data[p]) { break; } @@ -922,7 +922,7 @@ comments: true while (true) { // 获取节点 i 的父节点 int p = parent(i); - // 若“越过根节点”或“节点无需修复”，则结束堆化 + // 若“越过根节点”或“节点无须修复”，则结束堆化 if (p < 0 || maxHeap[i] <= maxHeap[p]) break; // 交换两节点 @@ -950,7 +950,7 @@ comments: true while true { // 获取节点 i 的父节点 let p = parent(i: i) - // 当“越过根节点”或“节点无需修复”时，结束堆化 + // 当“越过根节点”或“节点无须修复”时，结束堆化 if p < 0 || maxHeap[i] <= maxHeap[p] { break } @@ -979,7 +979,7 @@ comments: true while (true) { // 获取节点 i 的父节点 var p = parent(i); - // 当“越过根节点”或“节点无需修复”时，结束堆化 + // 当“越过根节点”或“节点无须修复”时，结束堆化 if (p < 0 or self.max_heap.?.items[i] <= self.max_heap.?.items[p]) break; // 交换两节点 try self.swap(i, p); @@ -1005,7 +1005,7 @@ comments: true while (true) { // 获取节点 i 的父节点 int p = _parent(i); - // 当“越过根节点”或“节点无需修复”时，结束堆化 + // 当“越过根节点”或“节点无须修复”时，结束堆化 if (p < 0 || _maxHeap[i] <= _maxHeap[p]) { break; } @@ -1037,7 +1037,7 @@ comments: true } // 获取节点 i 的父节点 let p = Self::parent(i); - // 当“节点无需修复”时，结束堆化 + // 当“节点无须修复”时，结束堆化 if self.max_heap[i] <= self.max_heap[p] { break; } @@ -1057,7 +1057,7 @@ comments: true 2. 交换完成后，将堆底从列表中删除（注意，由于已经交换，实际上删除的是原来的堆顶元素）。 3. 从根节点开始，**从顶至底执行堆化**。 -顾名思义，**从顶至底堆化的操作方向与从底至顶堆化相反**，我们将根节点的值与其两个子节点的值进行比较，将最大的子节点与根节点交换；然后循环执行此操作，直到越过叶节点或遇到无需交换的节点时结束。 +顾名思义，**从顶至底堆化的操作方向与从底至顶堆化相反**，我们将根节点的值与其两个子节点的值进行比较，将最大的子节点与根节点交换；然后循环执行此操作，直到越过叶节点或遇到无须交换的节点时结束。 === "<1>" ![堆顶元素出堆步骤](heap.assets/heap_pop_step1.png) @@ -1120,7 +1120,7 @@ comments: true ma = l; if (r < size() && maxHeap.get(r) > maxHeap.get(ma)) ma = r; - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (ma == i) break; // 交换两节点 @@ -1153,12 +1153,12 @@ comments: true while (true) { // 判断节点 i, l, r 中值最大的节点，记为 ma int l = left(i), r = right(i), ma = i; - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (l < size() && maxHeap[l] > maxHeap[ma]) ma = l; if (r < size() && maxHeap[r] > maxHeap[ma]) ma = r; - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (ma == i) break; swap(maxHeap[i], maxHeap[ma]); @@ -1194,7 +1194,7 @@ comments: true ma = l if r < self.size() and self.max_heap[r] > self.max_heap[ma]: ma = r - # 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + # 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if ma == i: break # 交换两节点 @@ -1236,7 +1236,7 @@ comments: true if r < h.size() && h.data[r].(int) > h.data[max].(int) { max = r } - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if max == i { break } @@ -1274,7 +1274,7 @@ comments: true let ma = i; if (l < this.size() && this.#maxHeap[l] > this.#maxHeap[ma]) ma = l; if (r < this.size() && this.#maxHeap[r] > this.#maxHeap[ma]) ma = r; - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (ma === i) break; // 交换两节点 this.#swap(i, ma); @@ -1310,7 +1310,7 @@ comments: true let ma = i; if (l < this.size() && this.maxHeap[l] > this.maxHeap[ma]) ma = l; if (r < this.size() && this.maxHeap[r] > this.maxHeap[ma]) ma = r; - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (ma === i) break; // 交换两节点 this.swap(i, ma); @@ -1355,7 +1355,7 @@ comments: true if (r < size(h) && h->data[r] > h->data[max]) { max = r; } - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (max == i) { break; } @@ -1438,7 +1438,7 @@ comments: true if r < size(), maxHeap[r] > maxHeap[ma] { ma = r } - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if ma == i { break } @@ -1477,7 +1477,7 @@ comments: true var ma = i; if (l < self.size() and self.max_heap.?.items[l] > self.max_heap.?.items[ma]) ma = l; if (r < self.size() and self.max_heap.?.items[r] > self.max_heap.?.items[ma]) ma = r; - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (ma == i) break; // 交换两节点 try self.swap(i, ma); @@ -1513,7 +1513,7 @@ comments: true int ma = i; if (l < size() && _maxHeap[l] > _maxHeap[ma]) ma = l; if (r < size() && _maxHeap[r] > _maxHeap[ma]) ma = r; - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (ma == i) break; // 交换两节点 _swap(i, ma); @@ -1553,7 +1553,7 @@ comments: true if r < self.size() && self.max_heap[r] > self.max_heap[ma] { ma = r; } - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if ma == i { break; } diff --git a/chapter_introduction/algorithms_are_everywhere.md b/chapter_introduction/algorithms_are_everywhere.md index d81f60445..1dbcaf28d 100644 --- a/chapter_introduction/algorithms_are_everywhere.md +++ b/chapter_introduction/algorithms_are_everywhere.md @@ -8,11 +8,11 @@ comments: true 在正式探讨算法之前，有一个有趣的事实值得分享：**你已经在不知不觉中学会了许多算法，并习惯将它们应用到日常生活中了**。下面，我将举几个具体例子来证实这一点。 -**例一：查阅字典**。在字典里，每个汉字都对应一个拼音，而字典是按照拼音的英文字母顺序排列的。假设我们需要查找一个拼音首字母为 $r$ 的字，通常会这样操作： +**例一：查阅字典**。在字典里，每个汉字都对应一个拼音，而字典是按照拼音字母顺序排列的。假设我们需要查找一个拼音首字母为 $r$ 的字，通常会按照下图所示的方式实现。 -1. 翻开字典约一半的页数，查看该页首字母是什么，假设首字母为 $m$ 。 -2. 由于在英文字母表中 $r$ 位于 $m$ 之后，所以排除字典前半部分，查找范围缩小到后半部分。 -3. 不断重复步骤 1-2 ，直至找到拼音首字母为 $r$ 的页码为止。 +1. 翻开字典约一半的页数，查看该页的首字母是什么，假设首字母为 $m$ 。 +2. 由于在拼音字母表中 $r$ 位于 $m$ 之后，所以排除字典前半部分，查找范围缩小到后半部分。 +3. 不断重复步骤 `1.` 和 步骤 `2.` ，直至找到拼音首字母为 $r$ 的页码为止。 === "<1>" ![查字典步骤](algorithms_are_everywhere.assets/binary_search_dictionary_step_1.png) @@ -31,9 +31,9 @@ comments: true

图：查字典步骤

-查阅字典这个小学生必备技能，实际上就是著名的「二分查找」。从数据结构的角度，我们可以把字典视为一个已排序的「数组」；从算法的角度，我们可以将上述查字典的一系列操作看作是「二分查找」算法。 +查阅字典这个小学生必备技能，实际上就是著名的二分查找算法。从数据结构的角度，我们可以把字典视为一个已排序的「数组」；从算法的角度，我们可以将上述查字典的一系列操作看作是「二分查找」。 -**例二：整理扑克**。我们在打牌时，每局都需要整理扑克牌，使其从小到大排列，实现流程如下： +**例二：整理扑克**。我们在打牌时，每局都需要整理扑克牌，使其从小到大排列，实现流程如下图所示。 1. 将扑克牌划分为“有序”和“无序”两部分，并假设初始状态下最左 1 张扑克牌已经有序。 2. 在无序部分抽出一张扑克牌，插入至有序部分的正确位置；完成后最左 2 张扑克已经有序。 @@ -45,9 +45,9 @@ comments: true 上述整理扑克牌的方法本质上是「插入排序」算法，它在处理小型数据集时非常高效。许多编程语言的排序库函数中都存在插入排序的身影。 -**例三：货币找零**。假设我们在超市购买了 $69$ 元的商品，给收银员付了 $100$ 元，则收银员需要给我们找 $31$ 元。他会很自然地完成以下思考： +**例三：货币找零**。假设我们在超市购买了 $69$ 元的商品，给收银员付了 $100$ 元，则收银员需要找我们 $31$ 元。他会很自然地完成如下图所示的思考。 -1. 可选项是比 $31$ 元面值更小的货币，包括 $1$ , $5$ , $10$ , $20$ 元。 +1. 可选项是比 $31$ 元面值更小的货币，包括 $1$ 元、$5$ 元、$10$ 元、$20$ 元。 2. 从可选项中拿出最大的 $20$ 元，剩余 $31 - 20 = 11$ 元。 3. 从剩余可选项中拿出最大的 $10$ 元，剩余 $11 - 10 = 1$ 元。 4. 从剩余可选项中拿出最大的 $1$ 元，剩余 $1 - 1 = 0$ 元。 @@ -63,4 +63,4 @@ comments: true !!! tip - 阅读至此，如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，那么太好了！因为这正是本书存在的意义。接下来，这本书将引导你一步步深入数据结构与算法的知识殿堂。 + 阅读至此，如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，请继续往下阅读，因为这正是本书存在的意义。接下来，这本书将引导你一步步深入数据结构与算法的知识殿堂。 diff --git a/chapter_introduction/summary.md b/chapter_introduction/summary.md index e936c88f7..2e4b5a606 100644 --- a/chapter_introduction/summary.md +++ b/chapter_introduction/summary.md @@ -5,9 +5,9 @@ comments: true # 1.3   小结 - 算法在日常生活中无处不在，并不是遥不可及的高深知识。实际上，我们已经在不知不觉中学会了许多算法，用以解决生活中的大小问题。 -- 查阅字典的原理与二分查找算法相一致。二分查找体现了分而治之的重要算法思想。 -- 整理扑克的过程与插入排序算法非常类似。插入排序适合排序小型数据集。 -- 货币找零的步骤本质上是贪心算法，每一步都采取当前看来的最好选择。 +- 查阅字典的原理与二分查找算法相一致。二分查找算法体现了分而治之的重要算法思想。 +- 整理扑克的过程与插入排序算法非常类似。插入排序算法适合排序小型数据集。 +- 货币找零的步骤本质上是贪心算法，每一步都采取当前看来的最好的选择。 - 算法是在有限时间内解决特定问题的一组指令或操作步骤，而数据结构是计算机中组织和存储数据的方式。 - 数据结构与算法紧密相连。数据结构是算法的基石，而算法则是发挥数据结构作用的舞台。 -- 乐高积木对应于数据，积木形状和连接方式代表数据结构，拼装积木的步骤则对应算法。 +- 我们可以将数据结构与算法类比为拼装积木，积木代表数据，积木的形状和连接方式代表数据结构，拼装积木的步骤则对应算法。 diff --git a/chapter_introduction/what_is_dsa.md b/chapter_introduction/what_is_dsa.md index 2e5a70e62..143658191 100644 --- a/chapter_introduction/what_is_dsa.md +++ b/chapter_introduction/what_is_dsa.md @@ -6,7 +6,7 @@ comments: true ## 1.2.1   算法定义 -「算法 Algorithm」是在有限时间内解决特定问题的一组指令或操作步骤。它具有以下特性： +「算法 algorithm」是在有限时间内解决特定问题的一组指令或操作步骤，它具有以下特性： - 问题是明确的，包含清晰的输入和输出定义。 - 具有可行性，能够在有限步骤、时间和内存空间下完成。 @@ -14,7 +14,7 @@ comments: true ## 1.2.2   数据结构定义 -「数据结构 Data Structure」是计算机中组织和存储数据的方式。它的设计目标包括： +「数据结构 data structure」是计算机中组织和存储数据的方式，它的设计目标如下： - 空间占用尽量减少，节省计算机内存。 - 数据操作尽可能快速，涵盖数据访问、添加、删除、更新等。 @@ -27,28 +27,29 @@ comments: true ## 1.2.3   数据结构与算法的关系 -数据结构与算法高度相关、紧密结合，具体表现在： +数据结构与算法高度相关、紧密结合，具体表现在以下几个方面。 - 数据结构是算法的基石。数据结构为算法提供了结构化存储的数据，以及用于操作数据的方法。 -- 算法是数据结构发挥的舞台。数据结构本身仅存储数据信息，通过结合算法才能解决特定问题。 -- 特定算法通常有对应最优的数据结构。算法通常可以基于不同的数据结构进行实现，但最终执行效率可能相差很大。 +- 算法是数据结构发挥作用的舞台。数据结构本身仅存储数据信息，通过结合算法才能解决特定问题。 +- 特定算法通常会有对应最优的数据结构。算法通常可以基于不同的数据结构进行实现，但最终执行效率可能相差很大。 ![数据结构与算法的关系](what_is_dsa.assets/relationship_between_data_structure_and_algorithm.png)

图：数据结构与算法的关系

-数据结构与算法犹如拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。 +数据结构与算法犹如上图所示的拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。 ![拼装积木](what_is_dsa.assets/assembling_blocks.jpg)

图：拼装积木

两者的详细对应关系如下表所示。 +

表：将数据结构与算法类比为积木

-| 数据结构与算法 | 积木 | +| 数据结构与算法 | 拼装积木 | | -------------- | ---------------------------------------- | | 输入数据 | 未拼装的积木 | | 数据结构 | 积木组织形式，包括形状、大小、连接方式等 | diff --git a/chapter_searching/binary_search.md b/chapter_searching/binary_search.md index 9350cd1e2..1d52839f3 100755 --- a/chapter_searching/binary_search.md +++ b/chapter_searching/binary_search.md @@ -104,7 +104,7 @@ comments: true i, j = 0, len(nums) - 1 # 循环，当搜索区间为空时跳出（当 i > j 时为空） while i <= j: - # 理论上 Python 的数字可以无限大（取决于内存大小），无需考虑大数越界问题 + # 理论上 Python 的数字可以无限大（取决于内存大小），无须考虑大数越界问题 m = (i + j) // 2 # 计算中点索引 m if nums[m] < target: i = m + 1 # 此情况说明 target 在区间 [m+1, j] 中 @@ -636,7 +636,7 @@ comments: true 二分查找在时间和空间方面都有较好的性能： - 二分查找的时间效率高。在大数据量下，对数阶的时间复杂度具有显著优势。例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需 $\log_2 2^{20} = 20$ 轮循环。 -- 二分查找无需额外空间。相较于需要借助额外空间的搜索算法（例如哈希查找），二分查找更加节省空间。 +- 二分查找无须额外空间。相较于需要借助额外空间的搜索算法（例如哈希查找），二分查找更加节省空间。 然而，二分查找并非适用于所有情况，原因如下： diff --git a/chapter_searching/binary_search_edge.md b/chapter_searching/binary_search_edge.md index ff4948a86..70e410b33 100644 --- a/chapter_searching/binary_search_edge.md +++ b/chapter_searching/binary_search_edge.md @@ -325,5 +325,5 @@ status: new 代码在此省略，值得注意的有： -- 给定数组不包含小数，这意味着我们无需关心如何处理相等的情况。 +- 给定数组不包含小数，这意味着我们无须关心如何处理相等的情况。 - 因为该方法引入了小数，所以需要将函数中的变量 `target` 改为浮点数类型。 diff --git a/chapter_searching/searching_algorithm_revisited.md b/chapter_searching/searching_algorithm_revisited.md index dad80d4e1..11578a422 100644 --- a/chapter_searching/searching_algorithm_revisited.md +++ b/chapter_searching/searching_algorithm_revisited.md @@ -20,7 +20,7 @@ comments: true - 「线性搜索」适用于数组和链表等线性数据结构。它从数据结构的一端开始，逐个访问元素，直到找到目标元素或到达另一端仍没有找到目标元素为止。 - 「广度优先搜索」和「深度优先搜索」是图和树的两种遍历策略。广度优先搜索从初始节点开始逐层搜索，由近及远地访问各个节点。深度优先搜索是从初始节点开始，沿着一条路径走到头为止，再回溯并尝试其他路径，直到遍历完整个数据结构。 -暴力搜索的优点是简单且通用性好，**无需对数据做预处理和借助额外的数据结构**。 +暴力搜索的优点是简单且通用性好，**无须对数据做预处理和借助额外的数据结构**。 然而，**此类算法的时间复杂度为 $O(n)$** ，其中 $n$ 为元素数量，因此在数据量较大的情况下性能较差。 @@ -68,7 +68,7 @@ comments: true **线性搜索** -- 通用性较好，无需任何数据预处理操作。假如我们仅需查询一次数据，那么其他三种方法的数据预处理的时间比线性搜索的时间还要更长。 +- 通用性较好，无须任何数据预处理操作。假如我们仅需查询一次数据，那么其他三种方法的数据预处理的时间比线性搜索的时间还要更长。 - 适用于体量较小的数据，此情况下时间复杂度对效率影响较小。 - 适用于数据更新频率较高的场景，因为该方法不需要对数据进行任何额外维护。 diff --git a/chapter_searching/summary.md b/chapter_searching/summary.md index 330e94bf5..702f49e7c 100644 --- a/chapter_searching/summary.md +++ b/chapter_searching/summary.md @@ -5,8 +5,8 @@ comments: true # 10.6   小结 - 二分查找依赖于数据的有序性，通过循环逐步缩减一半搜索区间来实现查找。它要求输入数据有序，且仅适用于数组或基于数组实现的数据结构。 -- 暴力搜索通过遍历数据结构来定位数据。线性搜索适用于数组和链表，广度优先搜索和深度优先搜索适用于图和树。此类算法通用性好，无需对数据预处理，但时间复杂度 $O(n)$ 较高。 +- 暴力搜索通过遍历数据结构来定位数据。线性搜索适用于数组和链表，广度优先搜索和深度优先搜索适用于图和树。此类算法通用性好，无须对数据预处理，但时间复杂度 $O(n)$ 较高。 - 哈希查找、树查找和二分查找属于高效搜索方法，可在特定数据结构中快速定位目标元素。此类算法效率高，时间复杂度可达 $O(\log n)$ 甚至 $O(1)$ ，但通常需要借助额外数据结构。 - 实际中，我们需要对数据体量、搜索性能要求、数据查询和更新频率等因素进行具体分析，从而选择合适的搜索方法。 -- 线性搜索适用于小型或频繁更新的数据；二分查找适用于大型、排序的数据；哈希查找适合对查询效率要求较高且无需范围查询的数据；树查找适用于需要维护顺序和支持范围查询的大型动态数据。 +- 线性搜索适用于小型或频繁更新的数据；二分查找适用于大型、排序的数据；哈希查找适合对查询效率要求较高且无须范围查询的数据；树查找适用于需要维护顺序和支持范围查询的大型动态数据。 - 用哈希查找替换线性查找是一种常用的优化运行时间的策略，可将时间复杂度从 $O(n)$ 降低至 $O(1)$ 。 diff --git a/chapter_sorting/bubble_sort.md b/chapter_sorting/bubble_sort.md index 022af52d7..668d9fb79 100755 --- a/chapter_sorting/bubble_sort.md +++ b/chapter_sorting/bubble_sort.md @@ -38,7 +38,7 @@ comments: true 1. 首先，对 $n$ 个元素执行“冒泡”，**将数组的最大元素交换至正确位置**， 2. 接下来，对剩余 $n - 1$ 个元素执行“冒泡”，**将第二大元素交换至正确位置**。 3. 以此类推，经过 $n - 1$ 轮“冒泡”后，**前 $n - 1$ 大的元素都被交换至正确位置**。 -4. 仅剩的一个元素必定是最小元素，无需排序，因此数组排序完成。 +4. 仅剩的一个元素必定是最小元素，无须排序，因此数组排序完成。 ![冒泡排序流程](bubble_sort.assets/bubble_sort_overview.png) diff --git a/chapter_sorting/heap_sort.md b/chapter_sorting/heap_sort.md index c42878094..db3c66013 100644 --- a/chapter_sorting/heap_sort.md +++ b/chapter_sorting/heap_sort.md @@ -80,7 +80,7 @@ comments: true ma = l; if (r < n && nums[r] > nums[ma]) ma = r; - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (ma == i) break; // 交换两节点 @@ -124,7 +124,7 @@ comments: true ma = l; if (r < n && nums[r] > nums[ma]) ma = r; - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (ma == i) { break; } @@ -165,7 +165,7 @@ comments: true ma = l if r < n and nums[r] > nums[ma]: ma = r - # 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + # 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if ma == i: break # 交换两节点 @@ -202,7 +202,7 @@ comments: true if r < n && (*nums)[r] > (*nums)[ma] { ma = r } - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if ma == i { break } @@ -245,7 +245,7 @@ comments: true if (r < n && nums[r] > nums[ma]) { ma = r; } - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (ma === i) { break; } @@ -288,7 +288,7 @@ comments: true if (r < n && nums[r] > nums[ma]) { ma = r; } - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (ma === i) { break; } @@ -329,7 +329,7 @@ comments: true ma = l; if (r < n && nums[r] > nums[ma]) ma = r; - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (ma == i) { break; } @@ -374,7 +374,7 @@ comments: true ma = l; if (r < n && nums[r] > nums[ma]) ma = r; - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (ma == i) break; // 交换两节点 @@ -417,7 +417,7 @@ comments: true if r < n, nums[r] > nums[ma] { ma = r } - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if ma == i { break } @@ -464,7 +464,7 @@ comments: true int ma = i; if (l < n && nums[l] > nums[ma]) ma = l; if (r < n && nums[r] > nums[ma]) ma = r; - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if (ma == i) break; // 交换两节点 int temp = nums[i]; @@ -509,7 +509,7 @@ comments: true if r < n && nums[r] > nums[ma] { ma = r; } - // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 + // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if ma == i { break; } diff --git a/chapter_sorting/insertion_sort.md b/chapter_sorting/insertion_sort.md index bd190fbcf..ab4e94b50 100755 --- a/chapter_sorting/insertion_sort.md +++ b/chapter_sorting/insertion_sort.md @@ -258,7 +258,7 @@ comments: true 插入排序的时间复杂度为 $O(n^2)$ ，而我们即将学习的快速排序的时间复杂度为 $O(n \log n)$ 。尽管插入排序的时间复杂度相比快速排序更高，**但在数据量较小的情况下，插入排序通常更快**。 -这个结论与线性查找和二分查找的适用情况的结论类似。快速排序这类 $O(n \log n)$ 的算法属于基于分治的排序算法，往往包含更多单元计算操作。而在数据量较小时，$n^2$ 和 $n \log n$ 的数值比较接近，复杂度不占主导作用；每轮中的单元计算操作数量起到决定性因素。 +这个结论与线性查找和二分查找的适用情况的结论类似。快速排序这类 $O(n \log n)$ 的算法属于基于分治的排序算法，往往包含更多单元计算操作。而在数据量较小时，$n^2$ 和 $n \log n$ 的数值比较接近，复杂度不占主导作用；每轮中的单元操作数量起到决定性因素。 实际上，许多编程语言（例如 Java）的内置排序函数都采用了插入排序，大致思路为：对于长数组，采用基于分治的排序算法，例如快速排序；对于短数组，直接使用插入排序。 diff --git a/chapter_sorting/merge_sort.md b/chapter_sorting/merge_sort.md index 35e4f905e..12eb69229 100755 --- a/chapter_sorting/merge_sort.md +++ b/chapter_sorting/merge_sort.md @@ -635,7 +635,7 @@ comments: true 归并排序在排序链表时具有显著优势，空间复杂度可以优化至 $O(1)$ ，原因如下： -- 由于链表仅需改变指针就可实现节点的增删操作，因此合并阶段（将两个短有序链表合并为一个长有序链表）无需创建辅助链表。 +- 由于链表仅需改变指针就可实现节点的增删操作，因此合并阶段（将两个短有序链表合并为一个长有序链表）无须创建辅助链表。 - 通过使用“迭代划分”替代“递归划分”，可省去递归使用的栈帧空间。 具体实现细节比较复杂，有兴趣的同学可以查阅相关资料进行学习。 diff --git a/chapter_sorting/selection_sort.md b/chapter_sorting/selection_sort.md index 2f202b043..4437923be 100644 --- a/chapter_sorting/selection_sort.md +++ b/chapter_sorting/selection_sort.md @@ -12,7 +12,7 @@ comments: true 2. 选取区间 $[0, n-1]$ 中的最小元素，将其与索引 $0$ 处元素交换。完成后，数组前 1 个元素已排序。 3. 选取区间 $[1, n-1]$ 中的最小元素，将其与索引 $1$ 处元素交换。完成后，数组前 2 个元素已排序。 4. 以此类推。经过 $n - 1$ 轮选择与交换后，数组前 $n - 1$ 个元素已排序。 -5. 仅剩的一个元素必定是最大元素，无需排序，因此数组排序完成。 +5. 仅剩的一个元素必定是最大元素，无须排序，因此数组排序完成。 === "<1>" ![选择排序步骤](selection_sort.assets/selection_sort_step1.png) diff --git a/chapter_sorting/sorting_algorithm.md b/chapter_sorting/sorting_algorithm.md index e038e5cfe..c028d41cb 100644 --- a/chapter_sorting/sorting_algorithm.md +++ b/chapter_sorting/sorting_algorithm.md @@ -16,7 +16,7 @@ comments: true **运行效率**：我们期望排序算法的时间复杂度尽量低，且总体操作数量较少（即时间复杂度中的常数项降低）。对于大数据量情况，运行效率显得尤为重要。 -**就地性**：顾名思义，「原地排序」通过在原数组上直接操作实现排序，无需借助额外的辅助数组，从而节省内存。通常情况下，原地排序的数据搬运操作较少，运行速度也更快。 +**就地性**：顾名思义，「原地排序」通过在原数组上直接操作实现排序，无须借助额外的辅助数组，从而节省内存。通常情况下，原地排序的数据搬运操作较少，运行速度也更快。 **稳定性**：「稳定排序」在完成排序后，相等元素在数组中的相对顺序不发生改变。稳定排序是优良特性，也是多级排序场景的必要条件。 diff --git a/chapter_stack_and_queue/stack.md b/chapter_stack_and_queue/stack.md index 00169876a..43ef30b5f 100755 --- a/chapter_stack_and_queue/stack.md +++ b/chapter_stack_and_queue/stack.md @@ -1082,7 +1082,7 @@ comments: true

图：基于数组实现栈的入栈出栈操作

-由于入栈的元素可能会源源不断地增加，因此我们可以使用动态数组，这样就无需自行处理数组扩容问题。以下为示例代码。 +由于入栈的元素可能会源源不断地增加，因此我们可以使用动态数组，这样就无须自行处理数组扩容问题。以下为示例代码。 === "Java" diff --git a/chapter_tree/avl_tree.md b/chapter_tree/avl_tree.md index ab6790426..669d77064 100644 --- a/chapter_tree/avl_tree.md +++ b/chapter_tree/avl_tree.md @@ -1139,7 +1139,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉 return leftRotate(node); } } - // 平衡树，无需旋转，直接返回 + // 平衡树，无须旋转，直接返回 return node; } ``` @@ -1173,7 +1173,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉 return leftRotate(node); } } - // 平衡树，无需旋转，直接返回 + // 平衡树，无须旋转，直接返回 return node; } ``` @@ -1203,7 +1203,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉 # 先右旋后左旋 node.right = self.__right_rotate(node.right) return self.__left_rotate(node) - # 平衡树，无需旋转，直接返回 + # 平衡树，无须旋转，直接返回 return node ``` @@ -1237,7 +1237,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉 return t.leftRotate(node) } } - // 平衡树，无需旋转，直接返回 + // 平衡树，无须旋转，直接返回 return node } ``` @@ -1271,7 +1271,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉 return this.#leftRotate(node); } } - // 平衡树，无需旋转，直接返回 + // 平衡树，无须旋转，直接返回 return node; } ``` @@ -1305,7 +1305,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉 return this.leftRotate(node); } } - // 平衡树，无需旋转，直接返回 + // 平衡树，无须旋转，直接返回 return node; } ``` @@ -1339,7 +1339,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉 return leftRotate(node); } } - // 平衡树，无需旋转，直接返回 + // 平衡树，无须旋转，直接返回 return node; } ``` @@ -1373,7 +1373,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉 return leftRotate(node); } } - // 平衡树，无需旋转，直接返回 + // 平衡树，无须旋转，直接返回 return node; } ``` @@ -1407,7 +1407,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉 return leftRotate(node: node) } } - // 平衡树，无需旋转，直接返回 + // 平衡树，无须旋转，直接返回 return node } ``` @@ -1441,7 +1441,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉 return self.leftRotate(node); } } - // 平衡树，无需旋转，直接返回 + // 平衡树，无须旋转，直接返回 return node; } ``` @@ -1475,7 +1475,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉 return leftRotate(node); } } - // 平衡树，无需旋转，直接返回 + // 平衡树，无须旋转，直接返回 return node; } ``` @@ -1513,7 +1513,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉 Self::left_rotate(Some(node)) } } else { - // 平衡树，无需旋转，直接返回 + // 平衡树，无须旋转，直接返回 node } } diff --git a/chapter_tree/binary_search_tree.md b/chapter_tree/binary_search_tree.md index c4ab66627..423207d34 100755 --- a/chapter_tree/binary_search_tree.md +++ b/chapter_tree/binary_search_tree.md @@ -1478,7 +1478,7 @@ comments: true 我们知道，二叉树的中序遍历遵循“左 $\rightarrow$ 根 $\rightarrow$ 右”的遍历顺序，而二叉搜索树满足“左子节点 $<$ 根节点 $<$ 右子节点”的大小关系。因此，在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小节点，从而得出一个重要性质：**二叉搜索树的中序遍历序列是升序的**。 -利用中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需 $O(n)$ 时间，无需额外排序，非常高效。 +利用中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需 $O(n)$ 时间，无须额外排序，非常高效。 ![二叉搜索树的中序遍历序列](binary_search_tree.assets/bst_inorder_traversal.png)