图：空间复杂度的常见类型
+图：常见的空间复杂度类型
!!! 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 的时间增长趋势
+图：算法 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$ 的倍数。 + 图：函数的渐近上界
-也就是说，计算渐近上界就是寻找一个函数 $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$ 趋于无穷大时，这些常数变得无足轻重。 -表：多项式时间复杂度示例
+ +表：不同操作数量对应的时间复杂度
图：时间复杂度的常见类型
+图：常见的时间复杂度类型
!!! 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 @@ $$ } ``` - +下图对比了常数阶、线性阶和平方阶三种时间复杂度。 -图：常数阶、线性阶、平方阶的时间复杂度
+ -以「冒泡排序」为例，外层循环执行 $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 @@ $$ } ``` +下图展示了细胞分裂的过程。 + 图：指数阶的时间复杂度
-在实际算法中，指数阶常出现于递归函数。例如以下代码，其递归地一分为二，经过 $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}$ 个数字。 -下表列举了各种基本数据类型的占用空间、取值范围和默认值。此表格无需硬背，大致理解即可，需要时可以通过查表来回忆。 +下表列举了各种基本数据类型的占用空间、取值范围和默认值。此表格无须硬背，大致理解即可，需要时可以通过查表来回忆。表：基本数据类型的占用空间和取值范围
图：查字典步骤
-查阅字典这个小学生必备技能，实际上就是著名的「二分查找」。从数据结构的角度，我们可以把字典视为一个已排序的「数组」；从算法的角度，我们可以将上述查字典的一系列操作看作是「二分查找」算法。 +查阅字典这个小学生必备技能，实际上就是著名的二分查找算法。从数据结构的角度，我们可以把字典视为一个已排序的「数组」；从算法的角度，我们可以将上述查字典的一系列操作看作是「二分查找」。 -**例二：整理扑克**。我们在打牌时，每局都需要整理扑克牌，使其从小到大排列，实现流程如下： +**例二：整理扑克**。我们在打牌时，每局都需要整理扑克牌，使其从小到大排列，实现流程如下图所示。 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 数据结构与算法的关系 -数据结构与算法高度相关、紧密结合，具体表现在： +数据结构与算法高度相关、紧密结合，具体表现在以下几个方面。 - 数据结构是算法的基石。数据结构为算法提供了结构化存储的数据，以及用于操作数据的方法。 -- 算法是数据结构发挥的舞台。数据结构本身仅存储数据信息，通过结合算法才能解决特定问题。 -- 特定算法通常有对应最优的数据结构。算法通常可以基于不同的数据结构进行实现，但最终执行效率可能相差很大。 +- 算法是数据结构发挥作用的舞台。数据结构本身仅存储数据信息，通过结合算法才能解决特定问题。 +- 特定算法通常会有对应最优的数据结构。算法通常可以基于不同的数据结构进行实现，但最终执行效率可能相差很大。 图：数据结构与算法的关系
-数据结构与算法犹如拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。 +数据结构与算法犹如上图所示的拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。 图：拼装积木
两者的详细对应关系如下表所示。 +表：将数据结构与算法类比为积木
图：基于数组实现栈的入栈出栈操作
-由于入栈的元素可能会源源不断地增加，因此我们可以使用动态数组，这样就无需自行处理数组扩容问题。以下为示例代码。 +由于入栈的元素可能会源源不断地增加，因此我们可以使用动态数组，这样就无须自行处理数组扩容问题。以下为示例代码。 === "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)$ 时间，无须额外排序，非常高效。 