Update performance_evaluation.md and time_complexity.md

codes/python/chapter_computational_complexity/time_complexity.py

@@ -97,7 +97,9 @@ def linear_log_recur(n: int) -> int:
     """线性对数阶"""
     if n <= 1:
         return 1
-    count: int = linear_log_recur(n // 2) + linear_log_recur(n // 2)
+    # 一分为二，子问题的规模减小一半
+    count = linear_log_recur(n // 2) + linear_log_recur(n // 2)
+    # 当前子问题包含 n 个操作
     for _ in range(n):
         count += 1
     return count
@@ -120,32 +122,32 @@ if __name__ == "__main__":
     n = 8
     print("输入数据大小 n =", n)
 
-    count: int = constant(n)
+    count = constant(n)
     print("常数阶的操作数量 =", count)
 
-    count: int = linear(n)
+    count = linear(n)
     print("线性阶的操作数量 =", count)
-    count: int = array_traversal([0] * n)
+    count = array_traversal([0] * n)
     print("线性阶（遍历数组）的操作数量 =", count)
 
-    count: int = quadratic(n)
+    count = quadratic(n)
     print("平方阶的操作数量 =", count)
     nums = [i for i in range(n, 0, -1)]  # [n, n-1, ..., 2, 1]
-    count: int = bubble_sort(nums)
+    count = bubble_sort(nums)
     print("平方阶（冒泡排序）的操作数量 =", count)
 
-    count: int = exponential(n)
+    count = exponential(n)
     print("指数阶（循环实现）的操作数量 =", count)
-    count: int = exp_recur(n)
+    count = exp_recur(n)
     print("指数阶（递归实现）的操作数量 =", count)
 
-    count: int = logarithmic(n)
+    count = logarithmic(n)
     print("对数阶（循环实现）的操作数量 =", count)
-    count: int = log_recur(n)
+    count = log_recur(n)
     print("对数阶（递归实现）的操作数量 =", count)
 
-    count: int = linear_log_recur(n)
+    count = linear_log_recur(n)
     print("线性对数阶（递归实现）的操作数量 =", count)
 
-    count: int = factorial_recur(n)
+    count = factorial_recur(n)
     print("阶乘阶（递归实现）的操作数量 =", count)

docs/chapter_computational_complexity/performance_evaluation.md

@@ -7,7 +7,7 @@
 
 也就是说，在能够解决问题的前提下，算法效率已成为衡量算法优劣的主要评价指标，它包括以下两个维度。
 
-- **时间效率**：算法运行速度的快慢。
+- **时间效率**：算法运行时间的长短。
 - **空间效率**：算法占用内存空间的大小。
 
 简而言之，**我们的目标是设计“既快又省”的数据结构与算法**。而有效地评估算法效率至关重要，因为只有这样，我们才能将各种算法进行对比，进而指导算法设计与优化过程。
@@ -18,7 +18,7 @@
 
 假设我们现在有算法 `A` 和算法 `B` ，它们都能解决同一问题，现在需要对比这两个算法的效率。最直接的方法是找一台计算机，运行这两个算法，并监控记录它们的运行时间和内存占用情况。这种评估方式能够反映真实情况，但也存在较大的局限性。
 
-一方面，**难以排除测试环境的干扰因素**。硬件配置会影响算法的性能。比如在某台计算机中，算法 `A` 的运行时间比算法 `B` 短；但在另一台配置不同的计算机中，可能得到相反的测试结果。这意味着我们需要在各种机器上进行测试，统计平均效率，而这是不现实的。
+一方面，**难以排除测试环境的干扰因素**。硬件配置会影响算法的性能表现。比如一个算法的并行度较高，那么它就更适合在多核 CPU 上运行，一个算法的内存操作密集，那么它在高性能内存上的表现就会更好。也就是说，算法在不同的机器上的测试结果可能是不一致的。这意味着我们需要在各种机器上进行测试，统计平均效率，而这是不现实的。
 
 另一方面，**展开完整测试非常耗费资源**。随着输入数据量的变化，算法会表现出不同的效率。例如，在输入数据量较小时，算法 `A` 的运行时间比算法 `B` 短；而在输入数据量较大时，测试结果可能恰恰相反。因此，为了得到有说服力的结论，我们需要测试各种规模的输入数据，而这需要耗费大量的计算资源。
 
@@ -32,8 +32,9 @@
 - “随着输入数据大小的增加”意味着复杂度反映了算法运行效率与输入数据体量之间的关系。
 - “时间和空间的增长趋势”表示复杂度分析关注的不是运行时间或占用空间的具体值，而是时间或空间增长的“快慢”。
 
-**复杂度分析克服了实际测试方法的弊端**，体现在以下两个方面。
+**复杂度分析克服了实际测试方法的弊端**，体现在以下几个方面。
 
+- 它无需实际运行代码，更加绿色节能。
 - 它独立于测试环境，分析结果适用于所有运行平台。
 - 它可以体现不同数据量下的算法效率，尤其是在大数据量下的算法性能。
 

docs/chapter_computational_complexity/time_complexity.md

@@ -534,7 +534,7 @@ $$
 
 - **时间复杂度能够有效评估算法效率**。例如，算法 `B` 的运行时间呈线性增长，在 $n > 1$ 时比算法 `A` 更慢，在 $n > 1000000$ 时比算法 `C` 更慢。事实上，只要输入数据大小 $n$ 足够大，复杂度为“常数阶”的算法一定优于“线性阶”的算法，这正是时间增长趋势的含义。
 - **时间复杂度的推算方法更简便**。显然，运行平台和计算操作类型都与算法运行时间的增长趋势无关。因此在时间复杂度分析中，我们可以简单地将所有计算操作的执行时间视为相同的“单位时间”，从而将“计算操作运行时间统计”简化为“计算操作数量统计”，这样一来估算难度就大大降低了。
-- **时间复杂度也存在一定的局限性**。例如，尽管算法 `A` 和 `C` 的时间复杂度相同，但实际运行时间差别很大。同样，尽管算法 `B` 的时间复杂度比 `C` 高，但在输入数据大小 $n$ 较小时，算法 `B` 明显优于算法 `C` 。在这些情况下，我们很难仅凭时间复杂度判断算法效率的高低。当然，尽管存在上述问题，复杂度分析仍然是评判算法效率最有效且常用的方法。
+- **时间复杂度也存在一定的局限性**。例如，尽管算法 `A` 和 `C` 的时间复杂度相同，但实际运行时间差别很大。同样，尽管算法 `B` 的时间复杂度比 `C` 高，但在输入数据大小 $n$ 较小时，算法 `B` 明显优于算法 `C` 。对于此类情况，我们时常难以仅凭时间复杂度判断算法效率的高低。当然，尽管存在上述问题，复杂度分析仍然是评判算法效率最有效且常用的方法。
 
 ## 函数渐近上界