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

build

Browse Source
This commit is contained in:
krahets
2023-08-17 05:12:05 +08:00
parent f0826da7f6
commit 97c532b228
67 changed files with 1481 additions and 1066 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
chapter_computational_complexity/performance_evaluation.md
View File

@@ -11,10 +11,10 @@ comments: true
因此在能够解决问题的前提下，算法效率成为主要的评价维度，包括：
- **时间效率**，即算法运行速度的快慢。
- **空间效率**，即算法占用内存空间的大小。
- **时间效率**：算法运行速度的快慢。
- **空间效率**：算法占用内存空间的大小。
简而言之，**我们的目标是设计“既快又省”的数据结构与算法**。而有效地评估算法效率至关重要，因为只有了解评价标准，我们才能对比分析各种算法，从而指导算法设计与优化过程。
简而言之，**我们的目标是设计“既快又省”的数据结构与算法**。而有效地评估算法效率至关重要，因为只有这样我们才能将各种算法进行对比，从而指导算法设计与优化过程。
效率评估方法主要分为两种：实际测试和理论估算。
@@ -32,11 +32,11 @@ comments: true
**复杂度分析评估的是算法运行效率随着输入数据量增多时的增长趋势**。这个定义有些拗口，我们可以将其分为三个重点来理解：
- “算法运行效率”可分为运行时间和占用空间两部分，与之对应地，复杂度可分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。
- “随着输入数据量增多时”表示复杂度与输入数据量有关，反映了算法运行效率与输入数据量之间的关系。
- “增长趋势”表示复杂度分析关注的是算法时间与空间的增长趋势，而非具体的运行时间或占用空间。
1. “算法运行效率”可分为运行时间和占用空间两部分，与之对应地，复杂度可分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。
2. “随着输入数据量增多时”意味着复杂度反映了算法运行效率与输入数据量之间的关系。
3. “增长趋势”表示复杂度分析关注的是算法时间与空间的增长趋势，而非具体的运行时间或占用空间。
**复杂度分析克服了实际测试方法的弊端**。首先，它独立于测试环境，因此分析结果适用于所有运行平台。其次，它可以体现不同数据量下的算法效率，尤其是在大数据量下的算法性能。
**复杂度分析克服了实际测试方法的弊端**。首先，它独立于测试环境，分析结果适用于所有运行平台。其次，它可以体现不同数据量下的算法效率，尤其是在大数据量下的算法性能。
如果你对复杂度分析的概念仍感到困惑，无需担心，我们会在后续章节详细介绍。

15
chapter_computational_complexity/space_complexity.md
View File

@@ -26,7 +26,7 @@ comments: true
![算法使用的相关空间](space_complexity.assets/space_types.png)
<p align="center"> Fig. 算法使用的相关空间 </p>
<p align="center"> 图：算法使用的相关空间 </p>
=== "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 @@ $$
![空间复杂度的常见类型](space_complexity.assets/space_complexity_common_types.png)
<p align="center"> Fig. 空间复杂度的常见类型 </p>
<p align="center"> 图：空间复杂度的常见类型 </p>
!!! tip
@@ -967,8 +967,8 @@ $$
// 常量、变量、对象占用 O(1) 空间
final int a = 0;
int b = 0;
List<int> nums = List.filled(10000, 0);
ListNode node = ListNode(0);
// 循环中的变量占用 O(1) 空间
for (var i = 0; i < n; i++) {
int c = 0;
@@ -1417,7 +1417,7 @@ $$
![递归函数产生的线性阶空间复杂度](space_complexity.assets/space_complexity_recursive_linear.png)
<p align="center"> Fig. 递归函数产生的线性阶空间复杂度 </p>
<p align="center"> 图：递归函数产生的线性阶空间复杂度 </p>
### 平方阶 $O(n^2)$
@@ -1605,7 +1605,6 @@ $$
List<List<int>> numMatrix = List.generate(n, (_) => List.filled(n, 0));
// 二维列表占用 O(n^2) 空间
List<List<int>> numList = [];
for (var i = 0; i < n; i++) {
List<int> tmp = [];
for (int j = 0; j < n; j++) {
@@ -1797,7 +1796,7 @@ $$
![递归函数产生的平方阶空间复杂度](space_complexity.assets/space_complexity_recursive_quadratic.png)
<p align="center"> Fig. 递归函数产生的平方阶空间复杂度 </p>
<p align="center"> 图：递归函数产生的平方阶空间复杂度 </p>
### 指数阶 $O(2^n)$
@@ -1969,7 +1968,7 @@ $$
![满二叉树产生的指数阶空间复杂度](space_complexity.assets/space_complexity_exponential.png)
<p align="center"> Fig. 满二叉树产生的指数阶空间复杂度 </p>
<p align="center"> 图：满二叉树产生的指数阶空间复杂度 </p>
### 对数阶 $O(\log n)$

16
chapter_computational_complexity/time_complexity.md
View File

@@ -436,7 +436,7 @@ $$
![算法 A, B, C 的时间增长趋势](time_complexity.assets/time_complexity_simple_example.png)
<p align="center"> Fig. 算法 A, B, C 的时间增长趋势 </p>
<p align="center"> 图：算法 A, B, C 的时间增长趋势 </p>
相较于直接统计算法运行时间，时间复杂度分析有哪些特点呢？
@@ -634,7 +634,7 @@ $T(n)$ 是一次函数，说明时间的增长趋势是线性的，因此其时
![函数的渐近上界](time_complexity.assets/asymptotic_upper_bound.png)
<p align="center"> Fig. 函数的渐近上界 </p>
<p align="center"> 图：函数的渐近上界 </p>
也就是说，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。
@@ -906,7 +906,7 @@ $$
![时间复杂度的常见类型](time_complexity.assets/time_complexity_common_types.png)
<p align="center"> Fig. 时间复杂度的常见类型 </p>
<p align="center"> 图：时间复杂度的常见类型 </p>
!!! tip
@@ -1600,7 +1600,7 @@ $$
![常数阶、线性阶、平方阶的时间复杂度](time_complexity.assets/time_complexity_constant_linear_quadratic.png)
<p align="center"> Fig. 常数阶、线性阶、平方阶的时间复杂度 </p>
<p align="center"> 图：常数阶、线性阶、平方阶的时间复杂度 </p>
以「冒泡排序」为例，外层循环执行 $n - 1$ 次，内层循环执行 $n-1, n-2, \cdots, 2, 1$ 次，平均为 $\frac{n}{2}$ 次，因此时间复杂度为 $O(n^2)$ 。
@@ -2110,7 +2110,7 @@ $$
![指数阶的时间复杂度](time_complexity.assets/time_complexity_exponential.png)
<p align="center"> Fig. 指数阶的时间复杂度 </p>
<p align="center"> 图：指数阶的时间复杂度 </p>
在实际算法中，指数阶常出现于递归函数。例如以下代码，其递归地一分为二，经过 $n$ 次分裂后停止。
@@ -2420,7 +2420,7 @@ $$
![对数阶的时间复杂度](time_complexity.assets/time_complexity_logarithmic.png)
<p align="center"> Fig. 对数阶的时间复杂度 </p>
<p align="center"> 图：对数阶的时间复杂度 </p>
与指数阶类似，对数阶也常出现于递归函数。以下代码形成了一个高度为 $\log_2 n$ 的递归树。
@@ -2745,7 +2745,7 @@ $$
![线性对数阶的时间复杂度](time_complexity.assets/time_complexity_logarithmic_linear.png)
<p align="center"> Fig. 线性对数阶的时间复杂度 </p>
<p align="center"> 图：线性对数阶的时间复杂度 </p>
### 阶乘阶 $O(n!)$
@@ -2947,7 +2947,7 @@ $$
![阶乘阶的时间复杂度](time_complexity.assets/time_complexity_factorial.png)
<p align="center"> Fig. 阶乘阶的时间复杂度 </p>
<p align="center"> 图：阶乘阶的时间复杂度 </p>
请注意，因为 $n! > 2^n$ ，所以阶乘阶比指数阶增长地更快，在 $n$ 较大时也是不可接受的。