Table. 数组与链表特点对比
+ +
+
+| | 数组 | 链表 |
+| ------------ | ------------------------ | ------------ |
+| 存储方式 | 连续内存空间 | 离散内存空间 |
+| 数据结构长度 | 长度不可变 | 长度可变 |
+| 内存使用率 | 占用内存少、缓存局部性好 | 占用内存多 |
+| 优势操作 | 随机访问 | 插入、删除 |
+
+
+
+!!! tip
+
+ 「缓存局部性（Cache locality）」涉及到了计算机操作系统，在本书不做展开介绍，建议有兴趣的同学 Google / Baidu 一下。
+
+Table. 数组与链表操作时间复杂度
+ +
+
+| 操作 | 数组 | 链表 |
+| ------- | ------ | ------ |
+| 访问元素 | $O(1)$ | $O(N)$ |
+| 添加元素 | $O(N)$ | $O(1)$ |
+| 删除元素 | $O(N)$ | $O(1)$ |
+
+
diff --git a/build/chapter_computational_complexity/performance_evaluation.md b/build/chapter_computational_complexity/performance_evaluation.md
new file mode 100644
index 000000000..6c236c864
--- /dev/null
+++ b/build/chapter_computational_complexity/performance_evaluation.md
@@ -0,0 +1,43 @@
+---
+comments: true
+---
+
+# 2.1. 算法效率评估
+
+## 2.1.1. 算法评价维度
+
+在开始学习算法之前，我们首先要想清楚算法的设计目标是什么，或者说，如何来评判算法的好与坏。整体上看，我们设计算法时追求两个层面的目标。
+
+1. **找到问题解法**。算法需要能够在规定的输入范围下，可靠地求得问题的正确解。
+2. **寻求最优解法**。同一个问题可能存在多种解法，而我们希望算法效率尽可能的高。
+
+换言之，在可以解决问题的前提下，算法效率则是主要评价维度，包括：
+
+- **时间效率**，即算法的运行速度的快慢。
+- **空间效率**，即算法占用的内存空间大小。
+
+数据结构与算法追求“运行速度快、占用内存少”，而如何去评价算法效率则是非常重要的问题，因为只有知道如何评价算法，才能去做算法之间的对比分析，以及优化算法设计。
+
+## 2.1.2. 效率评估方法
+
+### 实际测试
+
+假设我们现在有算法 A 和 算法 B ，都能够解决同一问题，现在需要对比两个算法之间的效率。我们能够想到的最直接的方式，就是找一台计算机，把两个算法都完整跑一遍，并监控记录运行时间和内存占用情况。这种评估方式能够反映真实情况，但是也存在很大的硬伤。
+
+**难以排除测试环境的干扰因素**。硬件配置会影响到算法的性能表现。例如，在某台计算机中，算法 A 比算法 B 运行时间更短；但换到另一台配置不同的计算机中，可能会得到相反的测试结果。这意味着我们需要在各种机器上展开测试，而这是不现实的。
+
+**展开完整测试非常耗费资源**。随着输入数据量的大小变化，算法会呈现出不同的效率表现。比如，有可能输入数据量较小时，算法 A 运行时间短于算法 B ，而在输入数据量较大时，测试结果截然相反。因此，若想要达到具有说服力的对比结果，那么需要输入各种体量数据，这样的测试需要占用大量计算资源。
+
+### 理论估算
+
+既然实际测试具有很大的局限性，那么我们是否可以仅通过一些计算，就获知算法的效率水平呢？答案是肯定的，我们将此估算方法称为「复杂度分析 Complexity Analysis」或「渐近复杂度分析 Asymptotic Complexity Analysis」。
+
+**复杂度分析评估随着输入数据量的增长，算法的运行时间和占用空间的增长趋势**。根据时间和空间两方面，复杂度可分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。
+
+**复杂度分析克服了实际测试方法的弊端**。一是独立于测试环境，分析结果适用于所有运行平台。二是可以体现不同数据量下的算法效率，尤其是可以反映大数据量下的算法性能。
+
+## 2.1.3. 复杂度分析重要性
+
+复杂度分析给出一把评价算法效率的“标尺”，告诉我们执行某个算法需要多少时间和空间资源，也让我们可以开展不同算法之间的效率对比。
+
+计算复杂度是个数学概念，对于初学者可能比较抽象，学习难度相对较高。从这个角度出发，其并不适合作为第一章内容。但是，当我们讨论某个数据结构或者算法的特点时，难以避免需要分析它的运行速度和空间使用情况。**因此，在展开学习数据结构与算法之前，建议读者先对计算复杂度建立起初步的了解，并且能够完成简单案例的复杂度分析**。
diff --git a/build/chapter_computational_complexity/space_complexity.md b/build/chapter_computational_complexity/space_complexity.md
new file mode 100755
index 000000000..61a217f6e
--- /dev/null
+++ b/build/chapter_computational_complexity/space_complexity.md
@@ -0,0 +1,1512 @@
+---
+comments: true
+---
+
+# 2.3. 空间复杂度
+
+「空间复杂度 Space Complexity」统计 **算法使用内存空间随着数据量变大时的增长趋势**。这个概念与时间复杂度很类似。
+
+## 2.3.1. 算法相关空间
+
+算法运行中，使用的内存空间主要有以下几种：
+
+- 「输入空间」用于存储算法的输入数据；
+- 「暂存空间」用于存储算法运行中的变量、对象、函数上下文等数据；
+- 「输出空间」用于存储算法的输出数据；
+
+!!! tip
+
+ 通常情况下，空间复杂度统计范围是「暂存空间」+「输出空间」。
+
+暂存空间可分为三个部分：
+
+- 「暂存数据」用于保存算法运行中的各种 **常量、变量、对象** 等。
+- 「栈帧空间」用于保存调用函数的上下文数据。系统每次调用函数都会在栈的顶部创建一个栈帧，函数返回时，栈帧空间会被释放。
+- 「指令空间」用于保存编译后的程序指令，**在实际统计中一般忽略不计**。
+
+
+
+Fig. 算法使用的相关空间
+ +=== "Java" + + ```java title="" + /* 类 */ + class Node { + int val; + Node next; + Node(int x) { val = x; } + } + + /* 函数 */ + int function() { + // do something... + return 0; + } + + int algorithm(int n) { // 输入数据 + final int a = 0; // 暂存数据（常量） + int b = 0; // 暂存数据（变量） + Node node = new Node(0); // 暂存数据（对象） + int c = function(); // 栈帧空间（调用函数） + return a + b + c; // 输出数据 + } + ``` + +=== "C++" + + ```cpp title="" + /* 结构体 */ + struct Node { + int val; + Node *next; + Node(int x) : val(x), next(nullptr) {} + }; + + /* 函数 */ + int func() { + // do something... + return 0; + } + + int algorithm(int n) { // 输入数据 + const int a = 0; // 暂存数据（常量） + int b = 0; // 暂存数据（变量） + Node* node = new Node(0); // 暂存数据（对象） + int c = func(); // 栈帧空间（调用函数） + return a + b + c; // 输出数据 + } + ``` + +=== "Python" + + ```python title="" + """ 类 """ + class Node: + def __init__(self, x): + self.val = x # 结点值 + self.next = None # 指向下一结点的指针（引用） + + """ 函数 """ + def function(): + # do something... + return 0 + + def algorithm(n): # 输入数据 + b = 0 # 暂存数据（变量） + node = Node(0) # 暂存数据（对象） + c = function() # 栈帧空间（调用函数） + return a + b + c # 输出数据 + ``` + +=== "Go" + + ```go title="" + /* 结构体 */ + type node struct { + val int + next *node + } + + /* 创建 node 结构体 */ + func newNode(val int) *node { + return &node{val: val} + } + + /* 函数 */ + func function() int { + // do something... + return 0 + } + + func algorithm(n int) int { // 输入数据 + const a = 0 // 暂存数据（常量） + b := 0 // 暂存数据（变量） + newNode(0) // 暂存数据（对象） + c := function() // 栈帧空间（调用函数） + return a + b + c // 输出数据 + } + ``` + +=== "JavaScript" + + ```js title="" + /* 类 */ + class Node { + val; + next; + constructor(val) { + this.val = val === undefined ? 0 : val; // 结点值 + this.next = null; // 指向下一结点的引用 + } + } + + /* 函数 */ + function constFunc() { + // do something + return 0; + } + + function algorithm(n) { // 输入数据 + const a = 0; // 暂存数据（常量） + const b = 0; // 暂存数据（变量） + const node = new Node(0); // 暂存数据（对象） + const c = constFunc(); // 栈帧空间（调用函数） + return a + b + c; // 输出数据 + } + ``` + +=== "TypeScript" + + ```typescript title="" + /* 类 */ + class Node { + val: number; + next: Node | null; + constructor(val?: number) { + this.val = val === undefined ? 0 : val; // 结点值 + this.next = null; // 指向下一结点的引用 + } + } + + /* 函数 */ + function constFunc(): number { + // do something + return 0; + } + + function algorithm(n: number): number { // 输入数据 + const a = 0; // 暂存数据（常量） + const b = 0; // 暂存数据（变量） + const node = new Node(0); // 暂存数据（对象） + const c = constFunc(); // 栈帧空间（调用函数） + return a + b + c; // 输出数据 + } + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + /* 类 */ + class Node + { + int val; + Node next; + Node(int x) { val = x; } + } + + /* 函数 */ + int function() + { + // do something... + return 0; + } + + int algorithm(int n) // 输入数据 + { + int a = 0; // 暂存数据（常量） + int b = 0; // 暂存数据（变量） + Node node = new Node(0); // 暂存数据（对象） + int c = function(); // 栈帧空间（调用函数） + return a + b + c; // 输出数据 + } + ``` + +=== "Swift" + + ```swift title="" + /* 类 */ + class Node { + var val: Int + var next: Node? + + init(x: Int) { + val = x + } + } + + /* 函数 */ + func function() -> Int { + // do something... + return 0 + } + + func algorithm(n: Int) -> Int { // 输入数据 + let a = 0 // 暂存数据（常量） + var b = 0 // 暂存数据（变量） + let node = Node(x: 0) // 暂存数据（对象） + let c = function() // 栈帧空间（调用函数） + return a + b + c // 输出数据 + } + ``` + +=== "Zig" + + ```zig title="" + + ``` + +## 2.3.2. 推算方法 + +空间复杂度的推算方法和时间复杂度总体类似，只是从统计“计算操作数量”变为统计“使用空间大小”。与时间复杂度不同的是，**我们一般只关注「最差空间复杂度」**。这是因为内存空间是一个硬性要求，我们必须保证在所有输入数据下都有足够的内存空间预留。 + +**最差空间复杂度中的“最差”有两层含义**，分别为输入数据的最差分布、算法运行中的最差时间点。 + +- **以最差输入数据为准**。当 $n < 10$ 时，空间复杂度为 $O(1)$ ；但是当 $n > 10$ 时，初始化的数组 `nums` 使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ； +- **以算法运行过程中的峰值内存为准**。程序在执行最后一行之前，使用 $O(1)$ 空间；当初始化数组 `nums` 时，程序使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ； + +=== "Java" + + ```java title="" + void algorithm(int n) { + int a = 0; // O(1) + int[] b = new int[10000]; // O(1) + if (n > 10) + int[] nums = new int[n]; // O(n) + } + ``` + +=== "C++" + + ```cpp title="" + void algorithm(int n) { + int a = 0; // O(1) + vectorFig. 空间复杂度的常见类型
+ +!!! tip + + 部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果遇到看不懂的地方无需担心，可以在学习完后面章节后再来复习，现阶段先聚焦在理解空间复杂度含义和推算方法上。 + +### 常数阶 $O(1)$ + +常数阶常见于数量与输入数据大小 $n$ 无关的常量、变量、对象。 + +需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，即不会累积占用空间，空间复杂度仍为 $O(1)$ 。 + +=== "Java" + + ```java title="space_complexity.java" + /* 常数阶 */ + void constant(int n) { + // 常量、变量、对象占用 O(1) 空间 + final int a = 0; + int b = 0; + int[] nums = new int[10000]; + ListNode node = new ListNode(0); + // 循环中的变量占用 O(1) 空间 + for (int i = 0; i < n; i++) { + int c = 0; + } + // 循环中的函数占用 O(1) 空间 + for (int i = 0; i < n; i++) { + function(); + } + } + ``` + +=== "C++" + + ```cpp title="space_complexity.cpp" + /* 常数阶 */ + void constant(int n) { + // 常量、变量、对象占用 O(1) 空间 + const int a = 0; + int b = 0; + vectorFig. 递归函数产生的线性阶空间复杂度
+ +### 平方阶 $O(n^2)$ + +平方阶常见于元素数量与 $n$ 成平方关系的矩阵、图。 + +=== "Java" + + ```java title="space_complexity.java" + /* 平方阶 */ + void quadratic(int n) { + // 矩阵占用 O(n^2) 空间 + int [][]numMatrix = new int[n][n]; + // 二维列表占用 O(n^2) 空间 + ListFig. 递归函数产生的平方阶空间复杂度
+ +### 指数阶 $O(2^n)$ + +指数阶常见于二叉树。高度为 $n$ 的「满二叉树」的结点数量为 $2^n - 1$ ，使用 $O(2^n)$ 空间。 + +=== "Java" + + ```java title="space_complexity.java" + /* 指数阶（建立满二叉树） */ + TreeNode buildTree(int n) { + if (n == 0) return null; + TreeNode root = new TreeNode(0); + root.left = buildTree(n - 1); + root.right = buildTree(n - 1); + return root; + } + ``` + +=== "C++" + + ```cpp title="space_complexity.cpp" + /* 指数阶（建立满二叉树） */ + TreeNode* buildTree(int n) { + if (n == 0) return nullptr; + TreeNode* root = new TreeNode(0); + root->left = buildTree(n - 1); + root->right = buildTree(n - 1); + return root; + } + ``` + +=== "Python" + + ```python title="space_complexity.py" + """ 指数阶（建立满二叉树） """ + def build_tree(n): + if n == 0: return None + root = TreeNode(0) + root.left = build_tree(n - 1) + root.right = build_tree(n - 1) + return root + ``` + +=== "Go" + + ```go title="space_complexity.go" + /* 指数阶（建立满二叉树） */ + func buildTree(n int) *treeNode { + if n == 0 { + return nil + } + root := newTreeNode(0) + root.left = buildTree(n - 1) + root.right = buildTree(n - 1) + return root + } + ``` + +=== "JavaScript" + + ```js title="space_complexity.js" + /* 指数阶（建立满二叉树） */ + function buildTree(n) { + if (n === 0) return null; + const root = new TreeNode(0); + root.left = buildTree(n - 1); + root.right = buildTree(n - 1); + return root; + } + ``` + +=== "TypeScript" + + ```typescript title="space_complexity.ts" + /* 指数阶（建立满二叉树） */ + function buildTree(n: number): TreeNode | null { + if (n === 0) return null; + const root = new TreeNode(0); + root.left = buildTree(n - 1); + root.right = buildTree(n - 1); + return root; + } + ``` + +=== "C" + + ```c title="space_complexity.c" + + ``` + +=== "C#" + + ```csharp title="space_complexity.cs" + /* 指数阶（建立满二叉树） */ + TreeNode? buildTree(int n) + { + if (n == 0) return null; + TreeNode root = new TreeNode(0); + root.left = buildTree(n - 1); + root.right = buildTree(n - 1); + return root; + } + ``` + +=== "Swift" + + ```swift title="space_complexity.swift" + /* 指数阶（建立满二叉树） */ + func buildTree(n: Int) -> TreeNode? { + if n == 0 { + return nil + } + let root = TreeNode(x: 0) + root.left = buildTree(n: n - 1) + root.right = buildTree(n: n - 1) + return root + } + ``` + +=== "Zig" + + ```zig title="space_complexity.zig" + // 指数阶（建立满二叉树） + fn buildTree(mem_allocator: std.mem.Allocator, n: i32) !?*inc.TreeNode(i32) { + if (n == 0) return null; + const root = try mem_allocator.create(inc.TreeNode(i32)); + root.init(0); + root.left = try buildTree(mem_allocator, n - 1); + root.right = try buildTree(mem_allocator, n - 1); + return root; + } + ``` + + + +Fig. 满二叉树下的指数阶空间复杂度
+ +### 对数阶 $O(\log n)$ + +对数阶常见于分治算法、数据类型转换等。 + +例如「归并排序」，长度为 $n$ 的数组可以形成高度为 $\log n$ 的递归树，因此空间复杂度为 $O(\log n)$ 。 + +再例如「数字转化为字符串」，输入任意正整数 $n$ ，它的位数为 $\log_{10} n$ ，即对应字符串长度为 $\log_{10} n$ ，因此空间复杂度为 $O(\log_{10} n) = O(\log n)$ 。 diff --git a/build/chapter_computational_complexity/space_time_tradeoff.md b/build/chapter_computational_complexity/space_time_tradeoff.md new file mode 100755 index 000000000..07eea2e1a --- /dev/null +++ b/build/chapter_computational_complexity/space_time_tradeoff.md @@ -0,0 +1,386 @@ +--- +comments: true +--- + +# 2.4. 权衡时间与空间 + +理想情况下，我们希望算法的时间复杂度和空间复杂度都能够达到最优，而实际上，同时优化时间复杂度和空间复杂度是非常困难的。 + +**降低时间复杂度，往往是以提升空间复杂度为代价的，反之亦然**。我们把牺牲内存空间来提升算法运行速度的思路称为「以空间换时间」；反之，称之为「以时间换空间」。选择哪种思路取决于我们更看重哪个方面。 + +大多数情况下，时间都是比空间更宝贵的，只要空间复杂度不要太离谱、能接受就行，**因此以空间换时间最为常用**。 + +## 2.4.1. 示例题目 * + +以 LeetCode 全站第一题 [两数之和](https://leetcode.cn/problems/two-sum/) 为例。 + +!!! question "两数之和" + + 给定一个整数数组 `nums` 和一个整数目标值 `target` ，请你在该数组中找出“和”为目标值 `target` 的那两个整数，并返回它们的数组下标。 + + 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 + + 你可以按任意顺序返回答案。 + +「暴力枚举」和「辅助哈希表」分别为 **空间最优** 和 **时间最优** 的两种解法。本着时间比空间更宝贵的原则，后者是本题的最佳解法。 + +### 方法一：暴力枚举 + +时间复杂度 $O(N^2)$ ，空间复杂度 $O(1)$ ，属于「时间换空间」。 + +虽然仅使用常数大小的额外空间，但运行速度过慢。 + +=== "Java" + + ```java title="leetcode_two_sum.java" + class SolutionBruteForce { + public int[] twoSum(int[] nums, int target) { + int size = nums.length; + // 两层循环，时间复杂度 O(n^2) + for (int i = 0; i < size - 1; i++) { + for (int j = i + 1; j < size; j++) { + if (nums[i] + nums[j] == target) + return new int[] { i, j }; + } + } + return new int[0]; + } + } + ``` + +=== "C++" + + ```cpp title="leetcode_two_sum.cpp" + class SolutionBruteForce { + public: + vectorFig. 算法 A, B, C 的时间增长趋势
+ +相比直接统计算法运行时间，时间复杂度分析的做法有什么好处呢？以及有什么不足？ + +**时间复杂度可以有效评估算法效率**。算法 `B` 运行时间的增长是线性的，在 $n > 1$ 时慢于算法 `A` ，在 $n > 1000000$ 时慢于算法 `C` 。实质上，只要输入数据大小 $n$ 足够大，复杂度为「常数阶」的算法一定优于「线性阶」的算法，这也正是时间增长趋势的含义。 + +**时间复杂度的推算方法更加简便**。在时间复杂度分析中，我们可以将统计「计算操作的运行时间」简化为统计「计算操作的数量」，这是因为，无论是运行平台还是计算操作类型，都与算法运行时间的增长趋势无关。因而，我们可以简单地将所有计算操作的执行时间统一看作是相同的“单位时间”，这样的简化做法大大降低了估算难度。 + +**时间复杂度也存在一定的局限性**。比如，虽然算法 `A` 和 `C` 的时间复杂度相同，但是实际的运行时间有非常大的差别。再比如，虽然算法 `B` 比 `C` 的时间复杂度要更高，但在输入数据大小 $n$ 比较小时，算法 `B` 是要明显优于算法 `C` 的。对于以上情况，我们很难仅凭时间复杂度来判定算法效率高低。然而，即使存在这些问题，计算复杂度仍然是评判算法效率的最有效且常用的方法。 + +## 2.2.3. 函数渐近上界 + +设算法「计算操作数量」为 $T(n)$ ，其是一个关于输入数据大小 $n$ 的函数。例如，以下算法的操作数量为 + +$$ +T(n) = 3 + 2n +$$ + +=== "Java" + + ```java title="" + void algorithm(int n) { + int a = 1; // +1 + a = a + 1; // +1 + a = a * 2; // +1 + // 循环 n 次 + for (int i = 0; i < n; i++) { // +1（每轮都执行 i ++） + System.out.println(0); // +1 + } + } + ``` + +=== "C++" + + ```cpp title="" + void algorithm(int n) { + int a = 1; // +1 + a = a + 1; // +1 + a = a * 2; // +1 + // 循环 n 次 + for (int i = 0; i < n; i++) { // +1（每轮都执行 i ++） + cout << 0 << endl; // +1 + } + } + ``` + +=== "Python" + + ```python title="" + def algorithm(n): + a = 1 # +1 + a = a + 1 # +1 + a = a * 2 # +1 + # 循环 n 次 + for i in range(n): # +1 + print(0) # +1 + ``` + +=== "Go" + + ```go title="" + func algorithm(n int) { + a := 1 // +1 + a = a + 1 // +1 + a = a * 2 // +1 + // 循环 n 次 + for i := 0; i < n; i++ { // +1 + fmt.Println(a) // +1 + } + } + ``` + +=== "JavaScript" + + ```js title="" + function algorithm(n){ + var a = 1; // +1 + a += 1; // +1 + a *= 2; // +1 + // 循环 n 次 + for(let i = 0; i < n; i++){ // +1（每轮都执行 i ++） + console.log(0); // +1 + } + + } + ``` + +=== "TypeScript" + + ```typescript title="" + function algorithm(n: number): void{ + var a: number = 1; // +1 + a += 1; // +1 + a *= 2; // +1 + // 循环 n 次 + for(let i = 0; i < n; i++){ // +1（每轮都执行 i ++） + console.log(0); // +1 + } + + } + ``` + +=== "C" + + ```c title="" + void algorithm(int n) { + int a = 1; // +1 + a = a + 1; // +1 + a = a * 2; // +1 + // 循环 n 次 + for (int i = 0; i < n; i++) { // +1（每轮都执行 i ++） + printf("%d", 0); // +1 + } + } + ``` + +=== "C#" + + ```csharp title="" + void algorithm(int n) { + int a = 1; // +1 + a = a + 1; // +1 + a = a * 2; // +1 + // 循环 n 次 + for (int i = 0; i < n; i++) { // +1（每轮都执行 i ++） + Console.WriteLine(0); // +1 + } + } + ``` + +=== "Swift" + + ```swift title="" + func algorithm(n: Int) { + var a = 1 // +1 + a = a + 1 // +1 + a = a * 2 // +1 + // 循环 n 次 + for _ in 0 ..< n { // +1 + print(0) // +1 + } + } + ``` + +=== "Zig" + + ```zig title="" + + ``` + +$T(n)$ 是个一次函数，说明时间增长趋势是线性的，因此易得时间复杂度是线性阶。 + +我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号被称为「大 $O$ 记号 Big-$O$ Notation」，代表函数 $T(n)$ 的「渐近上界 asymptotic upper bound」。 + +我们要推算时间复杂度，本质上是在计算「操作数量函数 $T(n)$ 」的渐近上界。下面我们先来看看函数渐近上界的数学定义。 + +!!! abstract "函数渐近上界" + + 若存在正实数 $c$ 和实数 $n_0$ ，使得对于所有的 $n > n_0$ ，均有 + $$ + T(n) \leq c \cdot f(n) + $$ + 则可认为 $f(n)$ 给出了 $T(n)$ 的一个渐近上界，记为 + $$ + T(n) = O(f(n)) + $$ + + + +Fig. 函数的渐近上界
+ +本质上看，计算渐近上界就是在找一个函数 $f(n)$ ，**使得在 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别（仅相差一个常数项 $c$ 的倍数）**。 + +!!! tip + + 渐近上界的数学味儿有点重，如果你感觉没有完全理解，无需担心，因为在实际使用中我们只需要会推算即可，数学意义可以慢慢领悟。 + +## 2.2.4. 推算方法 + +推算出 $f(n)$ 后，我们就得到时间复杂度 $O(f(n))$ 。那么，如何来确定渐近上界 $f(n)$ 呢？总体分为两步，首先「统计操作数量」，然后「判断渐近上界」。 + +### 1) 统计操作数量 + +对着代码，从上到下一行一行地计数即可。然而，**由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数偷懒技巧： + +1. **跳过数量与 $n$ 无关的操作**。因为他们都是 $T(n)$ 中的常数项，对时间复杂度不产生影响。 +2. **省略所有系数**。例如，循环 $2n$ 次、$5n + 1$ 次、……，都可以化简记为 $n$ 次，因为 $n$ 前面的系数对时间复杂度也不产生影响。 +3. **循环嵌套时使用乘法**。总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用上述 `1.` 和 `2.` 技巧。 + +根据以下示例，使用上述技巧前、后的统计结果分别为 + +$$ +\begin{aligned} +T(n) & = 2n(n + 1) + (5n + 1) + 2 & \text{完整统计 (-.-|||)} \newline +& = 2n^2 + 7n + 3 \newline +T(n) & = n^2 + n & \text{偷懒统计 (o.O)} +\end{aligned} +$$ + +最终，两者都能推出相同的时间复杂度结果，即 $O(n^2)$ 。 + +=== "Java" + + ```java title="" + void algorithm(int n) { + int a = 1; // +0（技巧 1） + a = a + n; // +0（技巧 1） + // +n（技巧 2） + for (int i = 0; i < 5 * n + 1; i++) { + System.out.println(0); + } + // +n*n（技巧 3） + for (int i = 0; i < 2 * n; i++) { + for (int j = 0; j < n + 1; j++) { + System.out.println(0); + } + } + } + ``` + +=== "C++" + + ```cpp title="" + void algorithm(int n) { + int a = 1; // +0（技巧 1） + a = a + n; // +0（技巧 1） + // +n（技巧 2） + for (int i = 0; i < 5 * n + 1; i++) { + cout << 0 << endl; + } + // +n*n（技巧 3） + for (int i = 0; i < 2 * n; i++) { + for (int j = 0; j < n + 1; j++) { + cout << 0 << endl; + } + } + } + ``` + +=== "Python" + + ```python title="" + def algorithm(n): + a = 1 # +0（技巧 1） + a = a + n # +0（技巧 1） + # +n（技巧 2） + for i in range(5 * n + 1): + print(0) + # +n*n（技巧 3） + for i in range(2 * n): + for j in range(n + 1): + print(0) + ``` + +=== "Go" + + ```go title="" + func algorithm(n int) { + a := 1 // +0（技巧 1） + a = a + n // +0（技巧 1） + // +n（技巧 2） + for i := 0; i < 5 * n + 1; i++ { + fmt.Println(0) + } + // +n*n（技巧 3） + for i := 0; i < 2 * n; i++ { + for j := 0; j < n + 1; j++ { + fmt.Println(0) + } + } + } + ``` + +=== "JavaScript" + + ```js title="" + function algorithm(n) { + let a = 1; // +0（技巧 1） + a = a + n; // +0（技巧 1） + // +n（技巧 2） + for (let i = 0; i < 5 * n + 1; i++) { + console.log(0); + } + // +n*n（技巧 3） + for (let i = 0; i < 2 * n; i++) { + for (let j = 0; j < n + 1; j++) { + console.log(0); + } + } + } + ``` + +=== "TypeScript" + + ```typescript title="" + function algorithm(n: number): void { + let a = 1; // +0（技巧 1） + a = a + n; // +0（技巧 1） + // +n（技巧 2） + for (let i = 0; i < 5 * n + 1; i++) { + console.log(0); + } + // +n*n（技巧 3） + for (let i = 0; i < 2 * n; i++) { + for (let j = 0; j < n + 1; j++) { + console.log(0); + } + } + } + ``` + +=== "C" + + ```c title="" + void algorithm(int n) { + int a = 1; // +0（技巧 1） + a = a + n; // +0（技巧 1） + // +n（技巧 2） + for (int i = 0; i < 5 * n + 1; i++) { + printf("%d", 0); + } + // +n*n（技巧 3） + for (int i = 0; i < 2 * n; i++) { + for (int j = 0; j < n + 1; j++) { + printf("%d", 0); + } + } + } + ``` + +=== "C#" + + ```csharp title="" + void algorithm(int n) + { + int a = 1; // +0（技巧 1） + a = a + n; // +0（技巧 1） + // +n（技巧 2） + for (int i = 0; i < 5 * n + 1; i++) + { + Console.WriteLine(0); + } + // +n*n（技巧 3） + for (int i = 0; i < 2 * n; i++) + { + for (int j = 0; j < n + 1; j++) + { + Console.WriteLine(0); + } + } + } + ``` + +=== "Swift" + + ```swift title="" + func algorithm(n: Int) { + var a = 1 // +0（技巧 1） + a = a + n // +0（技巧 1） + // +n（技巧 2） + for _ in 0 ..< (5 * n + 1) { + print(0) + } + // +n*n（技巧 3） + for _ in 0 ..< (2 * n) { + for _ in 0 ..< (n + 1) { + print(0) + } + } + } + ``` + +=== "Zig" + + ```zig title="" + + ``` + +### 2) 判断渐近上界 + +**时间复杂度由多项式 $T(n)$ 中最高阶的项来决定**。这是因为在 $n$ 趋于无穷大时，最高阶的项将处于主导作用，其它项的影响都可以被忽略。 + +以下表格给出了一些例子，其中有一些夸张的值，是想要向大家强调 **系数无法撼动阶数** 这一结论。在 $n$ 趋于无穷大时，这些常数都是“浮云”。 + +
+
+| 操作数量 $T(n)$ | 时间复杂度 $O(f(n))$ |
+| ---------------------- | -------------------- |
+| $100000$ | $O(1)$ |
+| $3n + 2$ | $O(n)$ |
+| $2n^2 + 3n + 2$ | $O(n^2)$ |
+| $n^3 + 10000n^2$ | $O(n^3)$ |
+| $2^n + 10000n^{10000}$ | $O(2^n)$ |
+
+
+
+## 2.2.5. 常见类型
+
+设输入数据大小为 $n$ ，常见的时间复杂度类型有（从低到高排列）
+
+$$
+\begin{aligned}
+O(1) < O(\log n) < O(n) < O(n \log n) < O(n^2) < O(2^n) < O(n!) \newline
+\text{常数阶} < \text{对数阶} < \text{线性阶} < \text{线性对数阶} < \text{平方阶} < \text{指数阶} < \text{阶乘阶}
+\end{aligned}
+$$
+
+
+
+Fig. 时间复杂度的常见类型
+ +!!! tip + + 部分示例代码需要一些前置知识，包括数组、递归算法等。如果遇到看不懂的地方无需担心，可以在学习完后面章节后再来复习，现阶段先聚焦在理解时间复杂度含义和推算方法上。 + +### 常数阶 $O(1)$ + +常数阶的操作数量与输入数据大小 $n$ 无关，即不随着 $n$ 的变化而变化。 + +对于以下算法，无论操作数量 `size` 有多大，只要与数据大小 $n$ 无关，时间复杂度就仍为 $O(1)$ 。 + +=== "Java" + + ```java title="time_complexity.java" + /* 常数阶 */ + int constant(int n) { + int count = 0; + int size = 100000; + for (int i = 0; i < size; i++) + count++; + return count; + } + ``` + +=== "C++" + + ```cpp title="time_complexity.cpp" + /* 常数阶 */ + int constant(int n) { + int count = 0; + int size = 100000; + for (int i = 0; i < size; i++) + count++; + return count; + } + ``` + +=== "Python" + + ```python title="time_complexity.py" + """ 常数阶 """ + def constant(n): + count = 0 + size = 100000 + for _ in range(size): + count += 1 + return count + ``` + +=== "Go" + + ```go title="time_complexity.go" + /* 常数阶 */ + func constant(n int) int { + count := 0 + size := 100000 + for i := 0; i < size; i++ { + count ++ + } + return count + } + ``` + +=== "JavaScript" + + ```js title="time_complexity.js" + /* 常数阶 */ + function constant(n) { + let count = 0; + const size = 100000; + for (let i = 0; i < size; i++) count++; + return count; + } + ``` + +=== "TypeScript" + + ```typescript title="time_complexity.ts" + /* 常数阶 */ + function constant(n: number): number { + let count = 0; + const size = 100000; + for (let i = 0; i < size; i++) count++; + return count; + } + ``` + +=== "C" + + ```c title="time_complexity.c" + /* 常数阶 */ + int constant(int n) { + int count = 0; + int size = 100000; + int i = 0; + for (int i = 0; i < size; i++) { + count ++; + } + return count; + } + ``` + +=== "C#" + + ```csharp title="time_complexity.cs" + /* 常数阶 */ + int constant(int n) + { + int count = 0; + int size = 100000; + for (int i = 0; i < size; i++) + count++; + return count; + } + ``` + +=== "Swift" + + ```swift title="time_complexity.swift" + /* 常数阶 */ + func constant(n: Int) -> Int { + var count = 0 + let size = 100000 + for _ in 0 ..< size { + count += 1 + } + return count + } + ``` + +=== "Zig" + + ```zig title="time_complexity.zig" + // 常数阶 + fn constant(n: i32) i32 { + _ = n; + var count: i32 = 0; + const size: i32 = 100_000; + var i: i32 = 0; + while(iFig. 常数阶、线性阶、平方阶的时间复杂度
+ +以「冒泡排序」为例，外层循环 $n - 1$ 次，内层循环 $n-1, n-2, \cdots, 2, 1$ 次，平均为 $\frac{n}{2}$ 次，因此时间复杂度为 $O(n^2)$ 。 + +$$ +O((n - 1) \frac{n}{2}) = O(n^2) +$$ + +=== "Java" + + ```java title="time_complexity.java" + /* 平方阶（冒泡排序） */ + int bubbleSort(int[] nums) { + int count = 0; // 计数器 + // 外循环：待排序元素数量为 n-1, n-2, ..., 1 + for (int i = nums.length - 1; i > 0; i--) { + // 内循环：冒泡操作 + for (int j = 0; j < i; j++) { + if (nums[j] > nums[j + 1]) { + // 交换 nums[j] 与 nums[j + 1] + int tmp = nums[j]; + nums[j] = nums[j + 1]; + nums[j + 1] = tmp; + count += 3; // 元素交换包含 3 个单元操作 + } + } + } + return count; + } + ``` + +=== "C++" + + ```cpp title="time_complexity.cpp" + /* 平方阶（冒泡排序） */ + int bubbleSort(vectorFig. 指数阶的时间复杂度
+ +在实际算法中，指数阶常出现于递归函数。例如以下代码，不断地一分为二，分裂 $n$ 次后停止。 + +=== "Java" + + ```java title="time_complexity.java" + /* 指数阶（递归实现） */ + int expRecur(int n) { + if (n == 1) return 1; + return expRecur(n - 1) + expRecur(n - 1) + 1; + } + ``` + +=== "C++" + + ```cpp title="time_complexity.cpp" + /* 指数阶（递归实现） */ + int expRecur(int n) { + if (n == 1) return 1; + return expRecur(n - 1) + expRecur(n - 1) + 1; + } + ``` + +=== "Python" + + ```python title="time_complexity.py" + """ 指数阶（递归实现）""" + def exp_recur(n): + if n == 1: return 1 + return exp_recur(n - 1) + exp_recur(n - 1) + 1 + ``` + +=== "Go" + + ```go title="time_complexity.go" + /* 指数阶（递归实现）*/ + func expRecur(n int) int { + if n == 1 { + return 1 + } + return expRecur(n-1) + expRecur(n-1) + 1 + } + ``` + +=== "JavaScript" + + ```js title="time_complexity.js" + /* 指数阶（递归实现） */ + function expRecur(n) { + if (n == 1) return 1; + return expRecur(n - 1) + expRecur(n - 1) + 1; + } + ``` + +=== "TypeScript" + + ```typescript title="time_complexity.ts" + /* 指数阶（递归实现） */ + function expRecur(n: number): number { + if (n == 1) return 1; + return expRecur(n - 1) + expRecur(n - 1) + 1; + } + + ``` + +=== "C" + + ```c title="time_complexity.c" + /* 指数阶（递归实现） */ + int expRecur(int n) { + if (n == 1) return 1; + return expRecur(n - 1) + expRecur(n - 1) + 1; + } + ``` + +=== "C#" + + ```csharp title="time_complexity.cs" + /* 指数阶（递归实现） */ + int expRecur(int n) + { + if (n == 1) return 1; + return expRecur(n - 1) + expRecur(n - 1) + 1; + } + ``` + +=== "Swift" + + ```swift title="time_complexity.swift" + /* 指数阶（递归实现） */ + func expRecur(n: Int) -> Int { + if n == 1 { + return 1 + } + return expRecur(n: n - 1) + expRecur(n: n - 1) + 1 + } + ``` + +=== "Zig" + + ```zig title="time_complexity.zig" + // 指数阶（递归实现） + fn expRecur(n: i32) i32{ + if (n == 1) return 1; + return expRecur(n - 1) + expRecur(n - 1) + 1; + } + ``` + +### 对数阶 $O(\log n)$ + +对数阶与指数阶正好相反，后者反映“每轮增加到两倍的情况”，而前者反映“每轮缩减到一半的情况”。对数阶仅次于常数阶，时间增长得很慢，是理想的时间复杂度。 + +对数阶常出现于「二分查找」和「分治算法」中，体现“一分为多”、“化繁为简”的算法思想。 + +设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。 + +=== "Java" + + ```java title="time_complexity.java" + /* 对数阶（循环实现） */ + int logarithmic(float n) { + int count = 0; + while (n > 1) { + n = n / 2; + count++; + } + return count; + } + ``` + +=== "C++" + + ```cpp title="time_complexity.cpp" + /* 对数阶（循环实现） */ + int logarithmic(float n) { + int count = 0; + while (n > 1) { + n = n / 2; + count++; + } + return count; + } + ``` + +=== "Python" + + ```python title="time_complexity.py" + """ 对数阶（循环实现）""" + def logarithmic(n): + count = 0 + while n > 1: + n = n / 2 + count += 1 + return count + ``` + +=== "Go" + + ```go title="time_complexity.go" + /* 对数阶（循环实现）*/ + func logarithmic(n float64) int { + count := 0 + for n > 1 { + n = n / 2 + count++ + } + return count + } + ``` + +=== "JavaScript" + + ```js title="time_complexity.js" + /* 对数阶（循环实现） */ + function logarithmic(n) { + let count = 0; + while (n > 1) { + n = n / 2; + count++; + } + return count; + } + ``` + +=== "TypeScript" + + ```typescript title="time_complexity.ts" + /* 对数阶（循环实现） */ + function logarithmic(n: number): number { + let count = 0; + while (n > 1) { + n = n / 2; + count++; + } + return count; + } + ``` + +=== "C" + + ```c title="time_complexity.c" + /* 对数阶（循环实现） */ + int logarithmic(float n) { + int count = 0; + while (n > 1) { + n = n / 2; + count++; + } + return count; + } + ``` + +=== "C#" + + ```csharp title="time_complexity.cs" + /* 对数阶（循环实现） */ + int logarithmic(float n) + { + int count = 0; + while (n > 1) + { + n = n / 2; + count++; + } + return count; + } + ``` + +=== "Swift" + + ```swift title="time_complexity.swift" + /* 对数阶（循环实现） */ + func logarithmic(n: Int) -> Int { + var count = 0 + var n = n + while n > 1 { + n = n / 2 + count += 1 + } + return count + } + ``` + +=== "Zig" + + ```zig title="time_complexity.zig" + // 对数阶（循环实现） + fn logarithmic(n: f32) i32 + { + var count: i32 = 0; + var n_var = n; + while (n_var > 1) + { + n_var = n_var / 2; + count +=1; + } + return count; + } + ``` + + + +Fig. 对数阶的时间复杂度
+ +与指数阶类似，对数阶也常出现于递归函数。以下代码形成了一个高度为 $\log_2 n$ 的递归树。 + +=== "Java" + + ```java title="time_complexity.java" + /* 对数阶（递归实现） */ + int logRecur(float n) { + if (n <= 1) return 0; + return logRecur(n / 2) + 1; + } + ``` + +=== "C++" + + ```cpp title="time_complexity.cpp" + /* 对数阶（递归实现） */ + int logRecur(float n) { + if (n <= 1) return 0; + return logRecur(n / 2) + 1; + } + ``` + +=== "Python" + + ```python title="time_complexity.py" + """ 对数阶（递归实现）""" + def log_recur(n): + if n <= 1: return 0 + return log_recur(n / 2) + 1 + ``` + +=== "Go" + + ```go title="time_complexity.go" + /* 对数阶（递归实现）*/ + func logRecur(n float64) int { + if n <= 1 { + return 0 + } + return logRecur(n/2) + 1 + } + ``` + +=== "JavaScript" + + ```js title="time_complexity.js" + /* 对数阶（递归实现） */ + function logRecur(n) { + if (n <= 1) return 0; + return logRecur(n / 2) + 1; + } + ``` + +=== "TypeScript" + + ```typescript title="time_complexity.ts" + /* 对数阶（递归实现） */ + function logRecur(n: number): number { + if (n <= 1) return 0; + return logRecur(n / 2) + 1; + } + ``` + +=== "C" + + ```c title="time_complexity.c" + /* 对数阶（递归实现） */ + int logRecur(float n) { + if (n <= 1) return 0; + return logRecur(n / 2) + 1; + } + ``` + +=== "C#" + + ```csharp title="time_complexity.cs" + /* 对数阶（递归实现） */ + int logRecur(float n) + { + if (n <= 1) return 0; + return logRecur(n / 2) + 1; + } + ``` + +=== "Swift" + + ```swift title="time_complexity.swift" + /* 对数阶（递归实现） */ + func logRecur(n: Int) -> Int { + if n <= 1 { + return 0 + } + return logRecur(n: n / 2) + 1 + } + ``` + +=== "Zig" + + ```zig title="time_complexity.zig" + // 对数阶（递归实现） + fn logRecur(n: f32) i32 + { + if (n <= 1) return 0; + return logRecur(n / 2) + 1; + } + ``` + +### 线性对数阶 $O(n \log n)$ + +线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。 + +主流排序算法的时间复杂度都是 $O(n \log n )$ ，例如快速排序、归并排序、堆排序等。 + +=== "Java" + + ```java title="time_complexity.java" + /* 线性对数阶 */ + int linearLogRecur(float n) { + if (n <= 1) return 1; + int count = linearLogRecur(n / 2) + + linearLogRecur(n / 2); + for (int i = 0; i < n; i++) { + count++; + } + return count; + } + ``` + +=== "C++" + + ```cpp title="time_complexity.cpp" + /* 线性对数阶 */ + int linearLogRecur(float n) { + if (n <= 1) return 1; + int count = linearLogRecur(n / 2) + + linearLogRecur(n / 2); + for (int i = 0; i < n; i++) { + count++; + } + return count; + } + ``` + +=== "Python" + + ```python title="time_complexity.py" + """ 线性对数阶 """ + def linear_log_recur(n): + if n <= 1: return 1 + count = linear_log_recur(n // 2) + \ + linear_log_recur(n // 2) + for _ in range(n): + count += 1 + return count + ``` + +=== "Go" + + ```go title="time_complexity.go" + /* 线性对数阶 */ + func linearLogRecur(n float64) int { + if n <= 1 { + return 1 + } + count := linearLogRecur(n/2) + + linearLogRecur(n/2) + for i := 0.0; i < n; i++ { + count++ + } + return count + } + ``` + +=== "JavaScript" + + ```js title="time_complexity.js" + /* 线性对数阶 */ + function linearLogRecur(n) { + if (n <= 1) return 1; + let count = linearLogRecur(n / 2) + linearLogRecur(n / 2); + for (let i = 0; i < n; i++) { + count++; + } + return count; + } + ``` + +=== "TypeScript" + + ```typescript title="time_complexity.ts" + /* 线性对数阶 */ + function linearLogRecur(n: number): number { + if (n <= 1) return 1; + let count = linearLogRecur(n / 2) + linearLogRecur(n / 2); + for (let i = 0; i < n; i++) { + count++; + } + return count; + } + ``` + +=== "C" + + ```c title="time_complexity.c" + /* 线性对数阶 */ + int linearLogRecur(float n) { + if (n <= 1) return 1; + int count = linearLogRecur(n / 2) + + linearLogRecur(n / 2); + for (int i = 0; i < n; i++) { + count ++; + } + return count; + } + ``` + +=== "C#" + + ```csharp title="time_complexity.cs" + /* 线性对数阶 */ + int linearLogRecur(float n) + { + if (n <= 1) return 1; + int count = linearLogRecur(n / 2) + + linearLogRecur(n / 2); + for (int i = 0; i < n; i++) + { + count++; + } + return count; + } + ``` + +=== "Swift" + + ```swift title="time_complexity.swift" + /* 线性对数阶 */ + func linearLogRecur(n: Double) -> Int { + if n <= 1 { + return 1 + } + var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2) + for _ in 0 ..< Int(n) { + count += 1 + } + return count + } + ``` + +=== "Zig" + + ```zig title="time_complexity.zig" + // 线性对数阶 + fn linearLogRecur(n: f32) i32 + { + if (n <= 1) return 1; + var count: i32 = linearLogRecur(n / 2) + + linearLogRecur(n / 2); + var i: f32 = 0; + while (i < n) : (i += 1) { + count += 1; + } + return count; + } + ``` + + + +Fig. 线性对数阶的时间复杂度
+ +### 阶乘阶 $O(n!)$ + +阶乘阶对应数学上的「全排列」。即给定 $n$ 个互不重复的元素，求其所有可能的排列方案，则方案数量为 + +$$ +n! = n \times (n - 1) \times (n - 2) \times \cdots \times 2 \times 1 +$$ + +阶乘常使用递归实现。例如以下代码，第一层分裂出 $n$ 个，第二层分裂出 $n - 1$ 个，…… ，直至到第 $n$ 层时终止分裂。 + +=== "Java" + + ```java title="time_complexity.java" + /* 阶乘阶（递归实现） */ + int factorialRecur(int n) { + if (n == 0) return 1; + int count = 0; + // 从 1 个分裂出 n 个 + for (int i = 0; i < n; i++) { + count += factorialRecur(n - 1); + } + return count; + } + ``` + +=== "C++" + + ```cpp title="time_complexity.cpp" + /* 阶乘阶（递归实现） */ + int factorialRecur(int n) { + if (n == 0) return 1; + int count = 0; + // 从 1 个分裂出 n 个 + for (int i = 0; i < n; i++) { + count += factorialRecur(n - 1); + } + return count; + } + ``` + +=== "Python" + + ```python title="time_complexity.py" + """ 阶乘阶（递归实现）""" + def factorial_recur(n): + if n == 0: return 1 + count = 0 + # 从 1 个分裂出 n 个 + for _ in range(n): + count += factorial_recur(n - 1) + return count + ``` + +=== "Go" + + ```go title="time_complexity.go" + /* 阶乘阶（递归实现） */ + func factorialRecur(n int) int { + if n == 0 { + return 1 + } + count := 0 + // 从 1 个分裂出 n 个 + for i := 0; i < n; i++ { + count += factorialRecur(n - 1) + } + return count + } + ``` + +=== "JavaScript" + + ```js title="time_complexity.js" + /* 阶乘阶（递归实现） */ + function factorialRecur(n) { + if (n == 0) return 1; + let count = 0; + // 从 1 个分裂出 n 个 + for (let i = 0; i < n; i++) { + count += factorialRecur(n - 1); + } + return count; + } + ``` + +=== "TypeScript" + + ```typescript title="time_complexity.ts" + /* 阶乘阶（递归实现） */ + function factorialRecur(n: number): number { + if (n == 0) return 1; + let count = 0; + // 从 1 个分裂出 n 个 + for (let i = 0; i < n; i++) { + count += factorialRecur(n - 1); + } + return count; + } + ``` + +=== "C" + + ```c title="time_complexity.c" + /* 阶乘阶（递归实现） */ + int factorialRecur(int n) { + if (n == 0) return 1; + int count = 0; + for (int i = 0; i < n; i++) { + count += factorialRecur(n - 1); + } + return count; + } + ``` + +=== "C#" + + ```csharp title="time_complexity.cs" + /* 阶乘阶（递归实现） */ + int factorialRecur(int n) + { + if (n == 0) return 1; + int count = 0; + // 从 1 个分裂出 n 个 + for (int i = 0; i < n; i++) + { + count += factorialRecur(n - 1); + } + return count; + } + ``` + +=== "Swift" + + ```swift title="time_complexity.swift" + /* 阶乘阶（递归实现） */ + func factorialRecur(n: Int) -> Int { + if n == 0 { + return 1 + } + var count = 0 + // 从 1 个分裂出 n 个 + for _ in 0 ..< n { + count += factorialRecur(n: n - 1) + } + return count + } + ``` + +=== "Zig" + + ```zig title="time_complexity.zig" + // 阶乘阶（递归实现） + fn factorialRecur(n: i32) i32 { + if (n == 0) return 1; + var count: i32 = 0; + var i: i32 = 0; + // 从 1 个分裂出 n 个 + while (i < n) : (i += 1) { + count += factorialRecur(n - 1); + } + return count; + } + ``` + + + +Fig. 阶乘阶的时间复杂度
+ +## 2.2.6. 最差、最佳、平均时间复杂度 + +**某些算法的时间复杂度不是恒定的，而是与输入数据的分布有关**。举一个例子，输入一个长度为 $n$ 数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的；算法的任务是返回元素 $1$ 的索引。我们可以得出以下结论： + +- 当 `nums = [?, ?, ..., 1]`，即当末尾元素是 $1$ 时，则需完整遍历数组，此时达到 **最差时间复杂度 $O(n)$** ； +- 当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，此时达到 **最佳时间复杂度 $\Omega(1)$** ； + +「函数渐近上界」使用大 $O$ 记号表示，代表「最差时间复杂度」。与之对应，「函数渐近下界」用 $\Omega$ 记号（Omega Notation）来表示，代表「最佳时间复杂度」。 + +=== "Java" + + ```java title="worst_best_time_complexity.java" + public class worst_best_time_complexity { + /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */ + int[] randomNumbers(int n) { + Integer[] nums = new Integer[n]; + // 生成数组 nums = { 1, 2, 3, ..., n } + for (int i = 0; i < n; i++) { + nums[i] = i + 1; + } + // 随机打乱数组元素 + Collections.shuffle(Arrays.asList(nums)); + // Integer[] -> int[] + int[] res = new int[n]; + for (int i = 0; i < n; i++) { + res[i] = nums[i]; + } + return res; + } + + /* 查找数组 nums 中数字 1 所在索引 */ + int findOne(int[] nums) { + for (int i = 0; i < nums.length; i++) { + // 当元素 1 在数组头部时，达到最佳时间复杂度 O(1) + // 当元素 1 在数组尾部时，达到最差时间复杂度 O(n) + if (nums[i] == 1) + return i; + } + return -1; + } + } + ``` + +=== "C++" + + ```cpp title="worst_best_time_complexity.cpp" + /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */ + vectorFig. 线性与非线性数据结构
+ +## 3.2.2. 物理结构：连续与离散 + +!!! note + + 若感到阅读困难，建议先看完下个章节「数组与链表」，再回过头来理解物理结构的含义。 + +**「物理结构」反映了数据在计算机内存中的存储方式**。从本质上看，分别是 **数组的连续空间存储** 和 **链表的离散空间存储**。物理结构从底层上决定了数据的访问、更新、增删等操作方法，在时间效率和空间效率方面呈现出此消彼长的特性。 + + + +Fig. 连续空间存储与离散空间存储
+ +**所有数据结构都是基于数组、或链表、或两者组合实现的**。例如栈和队列，既可以使用数组实现、也可以使用链表实现，而例如哈希表，其实现同时包含了数组和链表。 + +- **基于数组可实现**：栈、队列、哈希表、树、堆、图、矩阵、张量（维度 $\geq 3$ 的数组）等； +- **基于链表可实现**：栈、队列、哈希表、树、堆、图等； + +基于数组实现的数据结构也被称为「静态数据结构」，这意味着该数据结构在在被初始化后，长度不可变。相反地，基于链表实现的数据结构被称为「动态数据结构」，该数据结构在被初始化后，我们也可以在程序运行中修改其长度。 + +!!! tip + + 数组与链表是其他所有数据结构的“底层积木”，建议读者一定要多花些时间了解。 diff --git a/build/chapter_data_structure/data_and_memory.md b/build/chapter_data_structure/data_and_memory.md new file mode 100644 index 000000000..c10980616 --- /dev/null +++ b/build/chapter_data_structure/data_and_memory.md @@ -0,0 +1,149 @@ +--- +comments: true +--- + +# 3.1. 数据与内存 + +## 3.1.1. 基本数据类型 + +谈到计算机中的数据，我们能够想到文本、图片、视频、语音、3D 模型等等，这些数据虽然组织形式不同，但是有一个共同点，即都是由各种基本数据类型构成的。 + +**「基本数据类型」是 CPU 可以直接进行运算的类型，在算法中直接被使用。** + +- 「整数」根据不同的长度分为 byte, short, int, long ，根据算法需求选用，即在满足取值范围的情况下尽量减小内存空间占用； +- 「浮点数」代表小数，根据长度分为 float, double ，同样根据算法的实际需求选用； +- 「字符」在计算机中是以字符集的形式保存的，char 的值实际上是数字，代表字符集中的编号，计算机通过字符集查表来完成编号到字符的转换。占用空间与具体编程语言有关，通常为 2 bytes 或 1 byte ； +- 「布尔」代表逻辑中的 “是” 与 “否” ，其占用空间需要具体根据编程语言确定，通常为 1 byte 或 1 bit ； + +!!! note "字节与比特" + + 1 字节 (byte) = 8 比特 (bit) ， 1 比特即最基本的 1 个二进制位 + +Table. Java 的基本数据类型
+ +
+
+| 类别 | 符号 | 占用空间 | 取值范围 | 默认值 |
+| ------ | ----------- | ----------------- | ---------------------------------------------- | -------------- |
+| 整数 | byte | 1 byte | $-2^7$ ~ $2^7 - 1$ ( $-128$ ~ $127$ ) | $0$ |
+| | short | 2 bytes | $-2^{15}$ ~ $2^{15} - 1$ | $0$ |
+| | **int** | 4 bytes | $-2^{31}$ ~ $2^{31} - 1$ | $0$ |
+| | long | 8 bytes | $-2^{63}$ ~ $2^{63} - 1$ | $0$ |
+| 浮点数 | **float** | 4 bytes | $-3.4 \times 10^{38}$ ~ $3.4 \times 10^{38}$ | $0.0$ f |
+| | double | 8 bytes | $-1.7 \times 10^{308}$ ~ $1.7 \times 10^{308}$ | $0.0$ |
+| 字符 | **char** | 2 bytes / 1 byte | $0$ ~ $2^{16} - 1$ | $0$ |
+| 布尔 | **boolean(bool)** | 1 byte / 1 bit | $\text{true}$ 或 $\text{false}$ | $\text{false}$ |
+
+
+
+!!! tip
+
+ 以上表格中，加粗项在「算法题」中最为常用。此表格无需硬背，大致理解即可，需要时可以通过查表来回忆。
+
+**「基本数据类型」与「数据结构」之间的联系与区别**
+
+我们知道，数据结构是在计算机中 **组织与存储数据的方式**，它的主语是“结构”，而不是“数据”。比如，我们想要表示“一排数字”，自然应该使用「数组」这个数据结构。数组的存储方式使之可以表示数字的相邻关系、先后关系等一系列我们需要的信息，但至于其中存储的是整数 int ，还是小数 float ，或是字符 char ，**则与所谓的数据的结构无关了**。
+
+=== "Java"
+
+ ```java title=""
+ /* 使用多种「基本数据类型」来初始化「数组」 */
+ int[] numbers = new int[5];
+ float[] decimals = new float[5];
+ char[] characters = new char[5];
+ boolean[] booleans = new boolean[5];
+ ```
+
+=== "C++"
+
+ ```cpp title=""
+ /* 使用多种「基本数据类型」来初始化「数组」 */
+ int numbers[5];
+ float decimals[5];
+ char characters[5];
+ bool booleans[5];
+ ```
+
+=== "Python"
+
+ ```python title=""
+ """ Python 的 list 可以自由存储各种基本数据类型和对象 """
+ list = [0, 0.0, 'a', False]
+ ```
+
+=== "Go"
+
+ ```go title=""
+ // 使用多种「基本数据类型」来初始化「数组」
+ var numbers = [5]int{}
+ var decimals = [5]float64{}
+ var characters = [5]byte{}
+ var booleans = [5]bool{}
+ ```
+
+=== "JavaScript"
+
+ ```js title=""
+ /* JavaScript 的数组可以自由存储各种基本数据类型和对象 */
+ const array = [0, 0.0, 'a', false];
+ ```
+
+=== "TypeScript"
+
+ ```typescript title=""
+ /* 使用多种「基本数据类型」来初始化「数组」 */
+ const numbers: number[] = [];
+ const characters: string[] = [];
+ const booleans: boolean[] = [];
+ ```
+
+=== "C"
+
+ ```c title=""
+ /* 使用多种「基本数据类型」来初始化「数组」 */
+ int numbers[10];
+ float decimals[10];
+ char characters[10];
+ bool booleans[10];
+
+ ```
+
+=== "C#"
+
+ ```csharp title=""
+ /* 使用多种「基本数据类型」来初始化「数组」 */
+ int[] numbers = new int[5];
+ float[] decimals = new float[5];
+ char[] characters = new char[5];
+ bool[] booleans = new bool[5];
+ ```
+
+=== "Swift"
+
+ ```swift title=""
+ /* 使用多种「基本数据类型」来初始化「数组」 */
+ let numbers = Array(repeating: Int(), count: 5)
+ let decimals = Array(repeating: Double(), count: 5)
+ let characters = Array(repeating: Character("a"), count: 5)
+ let booleans = Array(repeating: Bool(), count: 5)
+ ```
+
+=== "Zig"
+
+ ```zig title=""
+
+ ```
+
+## 3.1.2. 计算机内存
+
+在计算机中，内存和硬盘是两种主要的存储硬件设备。「硬盘」主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。「内存」用于运行程序时暂存数据，速度较快，但容量较小（通常为 GB 级别）。
+
+**算法运行中，相关数据都被存储在内存中**。下图展示了一个计算机内存条，其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格，其中每个单元格都可以存储 1 byte 的数据，在算法运行时，所有数据都被存储在这些单元格中。
+
+**系统通过「内存地址 Memory Location」来访问目标内存位置的数据**。计算机根据特定规则给表格中每个单元格编号，保证每块内存空间都有独立的内存地址。自此，程序便通过这些地址，访问内存中的数据。
+
+
+
+Fig. 内存条、内存空间、内存地址
+ +**内存资源是设计数据结构与算法的重要考虑因素**。内存是所有程序的公共资源，当内存被某程序占用时，不能被其它程序同时使用。我们需要根据剩余内存资源的情况来设计算法。例如，若剩余内存空间有限，则要求算法占用的峰值内存不能超过系统剩余内存；若运行的程序很多、缺少大块连续的内存空间，则要求选取的数据结构必须能够存储在离散的内存空间内。 diff --git a/build/chapter_data_structure/summary.md b/build/chapter_data_structure/summary.md new file mode 100644 index 000000000..5340746a3 --- /dev/null +++ b/build/chapter_data_structure/summary.md @@ -0,0 +1,11 @@ +--- +comments: true +--- + +# 3.3. 小结 + +- 整数 byte, short, int, long 、浮点数 float, double 、字符 char 、布尔 boolean 是计算机中的基本数据类型，占用空间的大小决定了它们的取值范围。 +- 在程序运行时，数据存储在计算机的内存中。内存中每块空间都有独立的内存地址，程序是通过内存地址来访问数据的。 +- 数据结构主要可以从逻辑结构和物理结构两个角度进行分类。逻辑结构反映了数据中元素之间的逻辑关系，物理结构反映了数据在计算机内存中的存储形式。 +- 常见的逻辑结构有线性、树状、网状等。我们一般根据逻辑结构将数据结构分为线性（数组、链表、栈、队列）和非线性（树、图、堆）两种。根据实现方式的不同，哈希表可能是线性或非线性。 +- 物理结构主要有两种，分别是连续空间存储（数组）和离散空间存储（链表），所有的数据结构都是由数组、或链表、或两者组合实现的。 diff --git a/build/chapter_graph/graph.md b/build/chapter_graph/graph.md new file mode 100644 index 000000000..5f8d861e5 --- /dev/null +++ b/build/chapter_graph/graph.md @@ -0,0 +1,87 @@ +--- +comments: true +--- + +# 9.1. 图 + +「图 Graph」是一种非线性数据结构，由「顶点 Vertex」和「边 Edge」组成。我们可将图 $G$ 抽象地表示为一组顶点 $V$ 和一组边 $E$ 的集合。例如，以下表示一个包含 5 个顶点和 7 条边的图 + +$$ +\begin{aligned} +V & = \{ 1, 2, 3, 4, 5 \} \newline +E & = \{ (1,2), (1,3), (1,5), (2,3), (2,4), (2,5), (4,5) \} \newline +G & = \{ V, E \} \newline +\end{aligned} +$$ + + + +那么，图与其他数据结构的关系是什么？如果我们把「顶点」看作结点，把「边」看作连接各个结点的指针，则可将「图」看成一种从「链表」拓展而来的数据结构。**相比线性关系（链表）和分治关系（树），网络关系（图）的自由度更高，也从而更为复杂**。 + +## 9.1.1. 图常见类型 + +根据边是否有方向，分为「无向图 Undirected Graph」和「有向图 Directed Graph」。 + +- 在无向图中，边表示两结点之间“双向”的连接关系，例如微信或 QQ 中的“好友关系”； +- 在有向图中，边是有方向的，即 $A \rightarrow B$ 和 $A \leftarrow B$ 两个方向的边是相互独立的，例如微博或抖音上的“关注”与“被关注”关系； + + + +根据所有顶点是否连通，分为「连通图 Connected Graph」和「非连通图 Disconnected Graph」。 + +- 对于连通图，从某个结点出发，可以到达其余任意结点； +- 对于非连通图，从某个结点出发，至少有一个结点无法到达； + + + +我们可以给边添加“权重”变量，得到「有权图 Weighted Graph」。例如，在王者荣耀等游戏中，系统会根据共同游戏时间来计算玩家之间的“亲密度”，这种亲密度网络就可以使用有权图来表示。 + + + +## 9.1.2. 图常用术语 + +- 「邻接 Adjacency」：当两顶点之间有边相连时，称此两顶点“邻接”。 +- 「路径 Path」：从顶点 A 到顶点 B 走过的边构成的序列，被称为从 A 到 B 的“路径”。 +- 「度 Degree」表示一个顶点具有多少条边。对于有向图，「入度 In-Degree」表示有多少条边指向该顶点，「出度 Out-Degree」表示有多少条边从该顶点指出。 + +## 9.1.3. 图的表示 + +图的常用表示方法有「邻接矩阵」和「邻接表」。以下使用「无向图」来举例。 + +### 邻接矩阵 + +设图的顶点数量为 $n$ ，「邻接矩阵 Adjacency Matrix」使用一个 $n \times n$ 大小的矩阵来表示图，每一行（列）代表一个顶点，矩阵元素代表边，使用 $1$ 或 $0$ 来表示两个顶点之间有边或无边。 + + + +邻接矩阵具有以下性质： + +- 顶点不能与自身相连，因而邻接矩阵主对角线元素没有意义。 +- 「无向图」两个方向的边等价，此时邻接矩阵关于主对角线对称。 +- 将邻接矩阵的元素从 $1$ , $0$ 替换为权重，则能够表示「有权图」。 + +使用邻接矩阵表示图时，我们可以直接通过访问矩阵元素来获取边，因此增删查操作的效率很高，时间复杂度均为 $O(1)$ 。然而，矩阵的空间复杂度为 $O(n^2)$ ，内存占用较大。 + +### 邻接表 + +「邻接表 Adjacency List」使用 $n$ 个链表来表示图，链表结点表示顶点。第 $i$ 条链表对应顶点 $i$ ，其中存储了所有与该顶点相连的顶点。 + + + +邻接表仅存储存在的边，而边的总数往往远小于 $n^2$ ，因此更加节省空间。但是，因为在邻接表中需要通过遍历链表来查找边，所以其时间效率不如邻接矩阵。 + +观察上图发现，**邻接表结构与哈希表「链地址法」非常相似，因此我们也可以用类似方法来优化效率**。比如，当链表较长时，可以把链表转化为「AVL 树」，从而将时间效率从 $O(n)$ 优化至 $O(\log n)$ ，还可以通过中序遍历获取有序序列；还可以将链表转化为 HashSet（即哈希表），将时间复杂度降低至 $O(1)$ ，。 + +## 9.1.4. 图常见应用 + +现实中的许多系统都可以使用图来建模，对应的待求解问题也可以被约化为图计算问题。 + +
+
+| | 顶点 | 边 | 图计算问题 |
+| -------- | ---- | -------------------- | ------------ |
+| 社交网络 | 用户 | 好友关系 | 潜在好友推荐 |
+| 地铁线路 | 站点 | 站点间的连通性 | 最短路线推荐 |
+| 太阳系 | 星体 | 星体间的万有引力作用 | 行星轨道计算 |
+
+
diff --git a/build/chapter_graph/graph_operations.md b/build/chapter_graph/graph_operations.md
new file mode 100644
index 000000000..4b86d4d39
--- /dev/null
+++ b/build/chapter_graph/graph_operations.md
@@ -0,0 +1,662 @@
+---
+comments: true
+---
+
+# 9.2. 图基础操作
+
+图的基础操作分为对「边」的操作和对「顶点」的操作，在「邻接矩阵」和「邻接表」这两种表示下的实现方式不同。
+
+## 9.2.1. 基于邻接矩阵的实现
+
+设图的顶点总数为 $n$ ，则有：
+
+- **添加或删除边**：直接在邻接矩阵中修改指定边的对应元素即可，使用 $O(1)$ 时间。而由于是无向图，因此需要同时更新两个方向的边。
+- **添加顶点**：在邻接矩阵的尾部添加一行一列，并全部填 $0$ 即可，使用 $O(n)$ 时间。
+- **删除顶点**：在邻接矩阵中删除一行一列。当删除首行首列时达到最差情况，需要将 $(n-1)^2$ 个元素“向左上移动”，从而使用 $O(n^2)$ 时间。
+- **初始化**：传入 $n$ 个顶点，初始化长度为 $n$ 的顶点列表 `vertices` ，使用 $O(n)$ 时间；初始化 $n \times n$ 大小的邻接矩阵 `adjMat` ，使用 $O(n^2)$ 时间。
+
+=== "初始化邻接矩阵"
+ 
+
+=== "添加边"
+ 
+
+=== "删除边"
+ 
+
+=== "添加顶点"
+ 
+
+=== "删除顶点"
+ 
+
+以下是基于邻接矩阵表示图的实现代码。
+
+=== "Java"
+
+ ```java title="graph_adjacency_matrix.java"
+ /* 基于邻接矩阵实现的无向图类 */
+ class GraphAdjMat {
+ List
+
+| | 邻接矩阵 | 邻接表（链表） | 邻接表（哈希表） |
+| ------------ | -------- | -------------- | ---------------- |
+| 判断是否邻接 | $O(1)$ | $O(m)$ | $O(1)$ |
+| 添加边 | $O(1)$ | $O(1)$ | $O(1)$ |
+| 删除边 | $O(1)$ | $O(m)$ | $O(1)$ |
+| 添加顶点 | $O(n)$ | $O(1)$ | $O(1)$ |
+| 删除顶点 | $O(n^2)$ | $O(n + m)$ | $O(n)$ |
+| 内存空间占用 | $O(n^2)$ | $O(n + m)$ | $O(n + m)$ |
+
+
+
+观察上表，貌似邻接表（哈希表）的时间与空间效率最优。但实际上，在邻接矩阵中操作边的效率更高，只需要一次数组访问或赋值操作即可。总结以上，**邻接矩阵体现“以空间换时间”，邻接表体现“以时间换空间”**。
diff --git a/build/chapter_hashing/hash_collision.md b/build/chapter_hashing/hash_collision.md
new file mode 100644
index 000000000..269254c6c
--- /dev/null
+++ b/build/chapter_hashing/hash_collision.md
@@ -0,0 +1,81 @@
+---
+comments: true
+---
+
+# 6.2. 哈希冲突
+
+理想情况下，哈希函数应该为每个输入产生唯一的输出，使得 key 和 value 一一对应。而实际上，往往存在向哈希函数输入不同的 key 而产生相同输出的情况，这种情况被称为「哈希冲突 Hash Collision」。哈希冲突会导致查询结果错误，从而严重影响哈希表的可用性。
+
+那么，为什么会出现哈希冲突呢？本质上看，**由于哈希函数的输入空间往往远大于输出空间**，因此不可避免地会出现多个输入产生相同输出的情况，即为哈希冲突。比如，输入空间是全体整数，输出空间是一个固定大小的桶（数组）的索引范围，那么必定会有多个整数同时映射到一个桶索引。
+
+为了缓解哈希冲突，一方面，我们可以通过「哈希表扩容」来减小冲突概率。极端情况下，当输入空间和输出空间大小相等时，哈希表就等价于数组了，可谓“大力出奇迹”。
+
+另一方面，**考虑通过优化数据结构以缓解哈希冲突**，常见的方法有「链式地址」和「开放寻址」。
+
+## 6.2.1. 哈希表扩容
+
+「负载因子 Load Factor」定义为 **哈希表中元素数量除以桶槽数量（即数组大小）**，代表哈希冲突的严重程度。
+
+**负载因子常用作哈希表扩容的触发条件**。比如在 Java 中，当负载因子 $> 0.75$ 时则触发扩容，将 HashMap 大小扩充至原先的 $2$ 倍。
+
+与数组扩容类似，**哈希表扩容操作的开销很大**，因为需要将所有键值对从原哈希表依次移动至新哈希表。
+
+## 6.2.2. 链式地址
+
+在原始哈希表中，桶内的每个地址只能存储一个元素（即键值对）。**考虑将单个元素转化成一个链表，将所有冲突元素都存储在一个链表中**。
+
+
+
+链式地址下，哈希表操作方法为：
+
+- **查询元素**：先将 key 输入到哈希函数得到桶内索引，即可访问链表头结点，再通过遍历链表查找对应 value 。
+- **添加元素**：先通过哈希函数访问链表头部，再将结点（即键值对）添加到链表头部即可。
+- **删除元素**：同样先根据哈希函数结果访问链表头部，再遍历链表查找对应结点，删除之即可。
+
+链式地址虽然解决了哈希冲突问题，但仍存在局限性，包括：
+
+- **占用空间变大**，因为链表或二叉树包含结点指针，相比于数组更加耗费内存空间；
+- **查询效率降低**，因为需要线性遍历链表来查找对应元素；
+
+为了缓解时间效率问题，**可以把「链表」转化为「AVL 树」或「红黑树」**，将查询操作的时间复杂度优化至 $O(\log n)$ 。
+
+## 6.2.3. 开放寻址
+
+「开放寻址」不引入额外数据结构，而是通过“多次探测”来解决哈希冲突。根据探测方法的不同，主要分为 **线性探测、平方探测、多次哈希**。
+
+### 线性探测
+
+「线性探测」使用固定步长的线性查找来解决哈希冲突。
+
+**插入元素**：如果出现哈希冲突，则从冲突位置向后线性遍历（步长一般取 1 ），直到找到一个空位，则将元素插入到该空位中。
+
+**查找元素**：若出现哈希冲突，则使用相同步长执行线性查找，会遇到两种情况：
+
+1. 找到对应元素，返回 value 即可；
+2. 若遇到空位，则说明查找键值对不在哈希表中；
+
+
+
+线性探测存在以下缺陷：
+
+- **不能直接删除元素**。删除元素会导致桶内出现一个空位，在查找其他元素时，该空位有可能导致程序认为元素不存在（即上述第 `2.` 种情况）。因此需要借助一个标志位来标记删除元素。
+- **容易产生聚集**。桶内被占用的连续位置越长，这些连续位置发生哈希冲突的可能性越大，从而进一步促进这一位置的“聚堆生长”，最终导致增删查改操作效率的劣化。
+
+### 多次哈希
+
+顾名思义，「多次哈希」的思路是使用多个哈希函数 $f_1(x)$ , $f_2(x)$ , $f_3(x)$ , $\cdots$ 进行探测。
+
+**插入元素**：若哈希函数 $f_1(x)$ 出现冲突，则尝试 $f_2(x)$ ，以此类推……直到找到空位后插入元素。
+
+**查找元素**：以相同的哈希函数顺序查找，存在两种情况：
+
+1. 找到目标元素，则返回之；
+2. 到空位或已尝试所有哈希函数，说明哈希表中无此元素；
+
+相比于「线性探测」，「多次哈希」方法更不容易产生聚集，代价是多个哈希函数增加了额外计算量。
+
+!!! note "工业界方案"
+
+ Java 采用「链式地址」。在 JDK 1.8 之后，HashMap 内数组长度大于 64 时，长度大于 8 的链表会被转化为「红黑树」，以提升查找性能。
+
+ Python 采用「开放寻址」。字典 dict 使用伪随机数进行探测。
diff --git a/build/chapter_hashing/hash_map.md b/build/chapter_hashing/hash_map.md
new file mode 100755
index 000000000..40913ec14
--- /dev/null
+++ b/build/chapter_hashing/hash_map.md
@@ -0,0 +1,887 @@
+---
+comments: true
+---
+
+# 6.1. 哈希表
+
+哈希表通过建立「键 key」和「值 value」之间的映射，实现高效的元素查找。具体地，输入一个 key ，在哈希表中查询并获取 value ，时间复杂度为 $O(1)$ 。
+
+例如，给定一个包含 $n$ 个学生的数据库，每个学生有“姓名 `name` ”和“学号 `id` ”两项数据，希望实现一个查询功能：**输入一个学号，返回对应的姓名**，则可以使用哈希表实现。
+
+
+
+Fig. 哈希表抽象表示
+ +## 6.1.1. 哈希表效率 + +除了哈希表之外，还可以使用以下数据结构来实现上述查询功能： + +1. **无序数组**：每个元素为 `[学号, 姓名]` ； +2. **有序数组**：将 `1.` 中的数组按照学号从小到大排序； +3. **链表**：每个结点的值为 `[学号, 姓名]` ； +4. **二叉搜索树**：每个结点的值为 `[学号, 姓名]` ，根据学号大小来构建树； + +使用上述方法，各项操作的时间复杂度如下表所示（在此不做赘述，详解可见 [二叉搜索树章节](https://www.hello-algo.com/chapter_tree/binary_search_tree/#_6)）。无论是查找元素、还是增删元素，哈希表的时间复杂度都是 $O(1)$ ，全面胜出！ + +
+
+| | 无序数组 | 有序数组 | 链表 | 二叉搜索树 | 哈希表 |
+| -------- | -------- | ----------- | ------ | ----------- | ------ |
+| 查找元素 | $O(n)$ | $O(\log n)$ | $O(n)$ | $O(\log n)$ | $O(1)$ |
+| 插入元素 | $O(1)$ | $O(n)$ | $O(1)$ | $O(\log n)$ | $O(1)$ |
+| 删除元素 | $O(n)$ | $O(n)$ | $O(n)$ | $O(\log n)$ | $O(1)$ |
+
+
+
+## 6.1.2. 哈希表常用操作
+
+哈希表的基本操作包括 **初始化、查询操作、添加与删除键值对**。
+
+=== "Java"
+
+ ```java title="hash_map.java"
+ /* 初始化哈希表 */
+ MapFig. 哈希函数
+ +=== "Java" + + ```java title="array_hash_map.java" + /* 键值对 int->String */ + class Entry { + public int key; // 键 + public String val; // 值 + public Entry(int key, String val) { + this.key = key; + this.val = val; + } + } + + /* 基于数组简易实现的哈希表 */ + class ArrayHashMap { + private ListFig. 哈希冲突
+ +综上所述，一个优秀的「哈希函数」应该具备以下特性： + +- 尽量少地发生哈希冲突； +- 时间复杂度 $O(1)$ ，计算尽可能高效； +- 空间使用率高，即“键值对占用空间 / 哈希表总占用空间”尽可能大； diff --git a/build/chapter_hashing/summary.md b/build/chapter_hashing/summary.md new file mode 100644 index 000000000..a66b041a3 --- /dev/null +++ b/build/chapter_hashing/summary.md @@ -0,0 +1,5 @@ +--- +comments: true +--- + +# 6.3. 小结 diff --git a/build/chapter_heap/heap.md b/build/chapter_heap/heap.md new file mode 100644 index 000000000..79c1ded80 --- /dev/null +++ b/build/chapter_heap/heap.md @@ -0,0 +1,1040 @@ +--- +comments: true +--- + +# 8.1. 堆 + +「堆 Heap」是一棵限定条件下的「完全二叉树」。根据成立条件，堆主要分为两种类型： + +- 「大顶堆 Max Heap」，任意结点的值 $\geq$ 其子结点的值； +- 「小顶堆 Min Heap」，任意结点的值 $\leq$ 其子结点的值； + + + +## 8.1.1. 堆术语与性质 + +- 由于堆是完全二叉树，因此最底层结点靠左填充，其它层结点皆被填满。 +- 二叉树中的根结点对应「堆顶」，底层最靠右结点对应「堆底」。 +- 对于大顶堆 / 小顶堆，其堆顶元素（即根结点）的值最大 / 最小。 + +## 8.1.2. 堆常用操作 + +值得说明的是，多数编程语言提供的是「优先队列 Priority Queue」，其是一种抽象数据结构，**定义为具有出队优先级的队列**。 + +而恰好，**堆的定义与优先队列的操作逻辑完全吻合**，大顶堆就是一个元素从大到小出队的优先队列。从使用角度看，我们可以将「优先队列」和「堆」理解为等价的数据结构。因此，本文与代码对两者不做特别区分，统一使用「堆」来命名。 + +堆的常用操作见下表（方法命名以 Java 为例）。 + +Table. 堆的常用操作
+ +
+
+| 方法 | 描述 | 时间复杂度 |
+| --------- | ----------------------------------------- | ----------- |
+| add() | 元素入堆 | $O(\log n)$ |
+| poll() | 堆顶元素出堆 | $O(\log n)$ |
+| peek() | 访问堆顶元素（大 / 小顶堆分别为最大 / 小值） | $O(1)$ |
+| size() | 获取堆的元素数量 | $O(1)$ |
+| isEmpty() | 判断堆是否为空 | $O(1)$ |
+
+
+
+我们可以直接使用编程语言提供的堆类（或优先队列类）。
+
+!!! tip
+
+ 类似于排序中“从小到大排列”和“从大到小排列”，“大顶堆”和“小顶堆”可仅通过修改 Comparator 来互相转换。
+
+=== "Java"
+
+ ```java title="heap.java"
+ /* 初始化堆 */
+ // 初始化小顶堆
+ QueueFig. 数据结构与算法的关系
+ +如果将「LEGO 乐高」类比到「数据结构与算法」，那么可以得到下表所示的对应关系。 + +
+
+| 数据结构与算法 | LEGO 乐高 |
+| -------------- | ---------------------------------------- |
+| 输入数据 | 未拼装的积木 |
+| 数据结构 | 积木组织形式，包括形状、大小、连接方式等 |
+| 算法 | 把积木拼成目标形态的一系列操作步骤 |
+| 输出数据 | 积木模型 |
+
+
+
+!!! tip "约定俗成的简称"
+
+ 在实际讨论中，我们通常会将「数据结构与算法」直接简称为「算法」。例如，我们熟称的 LeetCode 算法题目，实际上同时考察了数据结构和算法两部分知识。
diff --git a/build/chapter_preface/about_the_book.md b/build/chapter_preface/about_the_book.md
new file mode 100644
index 000000000..12e5b7e93
--- /dev/null
+++ b/build/chapter_preface/about_the_book.md
@@ -0,0 +1,265 @@
+---
+comments: true
+---
+
+# 0.1. 关于本书
+
+五年前发生的一件事，成为了我职业生涯的重要转折点。当时的我在交大读研，对互联网求职一无所知，但仍然硬着头皮申请了 Microsoft 软件工程师实习。面试官让我在白板上写出“快速排序”代码，我畏畏缩缩地写了一个“冒泡排序”，并且还写错了` (ToT) ` 。从面试官的表情上，我看到了一个大大的 "GG" 。
+
+此次失利倒逼我开始刷算法题。我采用“扫雷游戏”式的学习方法，两眼一抹黑刷题，扫到不会的“雷”就通过查资料把它“排掉”，配合周期性总结，逐渐形成了数据结构与算法的知识图景。幸运地，我在秋招斩获了多家大厂的 Offer 。
+
+回想自己当初在“扫雷式”刷题中被炸的满头包的痛苦，思考良久，我意识到一本“前期刷题必看”的读物可以使算法小白少走许多弯路。写作意愿滚滚袭来，那就动笔吧：
+
+Hello，算法！
+ +## 0.1.1. 读者对象 + +!!! success "前置条件" + + 您需要至少具备任一语言的编程基础，能够阅读和编写简单代码。 + +如果您是 **算法初学者**，完全没有接触过算法，或者已经有少量刷题，对数据结构与算法有朦胧的理解，在会与不会之间反复横跳，那么这本书就是为您而写！本书能够带来： + +- 了解刷题所需的 **数据结构**，包括常用操作、优势和劣势、典型应用、实现方法等。 +- 学习各类 **算法**，介绍算法的设计思想、运行效率、优势劣势、实现方法等。 +- 可一键运行的 **配套代码**，包含详细注释，帮助你通过实践加深理解。 + +如果您是 **算法熟练工**，已经积累一定刷题量，接触过大多数题型，那么本书内容对你来说可能稍显基础，但仍能够带来以下价值： + +- 本书篇幅不长，可以帮助你提纲挈领地回顾算法知识。 +- 书中包含许多对比性、总结性的算法内容，可以帮助你梳理算法知识体系。 +- 源代码实现了各种经典数据结构和算法，可以作为“刷题工具库”来使用。 + +如果您是 **算法大佬**，请受我膜拜！希望您可以抽时间提出意见建议，或者[一起参与创作](https://www.hello-algo.com/chapter_preface/contribution/)，帮助各位同学获取更好的学习内容，感谢！ + +## 0.1.2. 内容结构 + +本书主要内容分为复杂度分析、数据结构、算法三个部分。 + + + +Fig. 知识点思维导图
+ +### 复杂度分析 + +首先介绍数据结构与算法的评价维度、算法效率的评估方法，引出了计算复杂度概念。 + +接下来，从 **函数渐近上界** 入手，分别介绍了 **时间复杂度** 和 **空间复杂度**，包括推算方法、常见类型、示例等。同时，剖析了 **最差、最佳、平均** 时间复杂度的联系与区别。 + +### 数据结构 + +首先介绍了常用的 **基本数据类型** 、以及它们是如何在内存中存储的。 + +接下来，介绍了两种 **数据结构分类方法**，包括逻辑结构与物理结构。 + +后续展开介绍了 **数组、链表、栈、队列、散列表、树、堆、图** 等数据结构，关心以下内容： + +- 基本定义：数据结构的设计来源、存在意义； +- 主要特点：在各项数据操作中的优势、劣势； +- 常用操作：例如访问、更新、插入、删除、遍历、搜索等； +- 常见类型：在算法题或工程实际中，经常碰到的数据结构类型； +- 典型应用：此数据结构经常搭配哪些算法使用； +- 实现方法：对于重要的数据结构，将给出完整的实现示例； + +### 算法 + +包括 **查找算法、排序算法、搜索与回溯、动态规划、分治算法**，内容包括： + +- 基本定义：算法的设计思想； +- 主要特点：使用前置条件、优势和劣势； +- 算法效率：最差和平均时间复杂度、空间复杂度； +- 实现方法：完整的算法实现，以及优化措施； +- 示例题目：结合例题加深理解； + +## 0.1.3. 配套代码 + +完整代码托管在 [GitHub 仓库](https://github.com/krahets/hello-algo) ，皆可一键运行。 + +!!! tip "前置工作" + + 1. [编程环境安装](https://www.hello-algo.com/chapter_preface/installation/) ，若有请跳过 + 2. 代码下载与使用方法请见 [如何使用本书](https://www.hello-algo.com/chapter_preface/suggestions/#_4) + +## 0.1.4. 风格约定 + +- 标题后标注 * 符号的是选读章节，如果你的时间有限，可以先跳过这些章节。 +- 文章中的重要名词会用「」符号标注，例如「数组 Array」。名词混淆会导致不必要的歧义，因此最好可以记住这类名词（包括中文和英文），以便后续阅读文献时使用。 +- 重点内容、总起句、总结句会被 **加粗**，此类文字值得特别关注。 +- 专有名词和有特指含义的词句会使用 “ ” 标注，以避免歧义。 +- 在工程应用中，每种语言都有注释规范；而本书放弃了一部分的注释规范性，以换取更加紧凑的内容排版。注释主要分为三种类型：标题注释、内容注释、多行注释。 + +=== "Java" + + ```java title="" + /* 标题注释，用于标注函数、类、测试样例等 */ + + // 内容注释，用于详解代码 + + /** + * 多行 + * 注释 + */ + ``` + +=== "C++" + + ```cpp title="" + /* 标题注释，用于标注函数、类、测试样例等 */ + + // 内容注释，用于详解代码 + + /** + * 多行 + * 注释 + */ + ``` + +=== "Python" + + ```python title="" + """ 标题注释，用于标注函数、类、测试样例等 """ + + # 内容注释，用于详解代码 + + """ + 多行 + 注释 + """ + ``` + +=== "Go" + + ```go title="" + /* 标题注释，用于标注函数、类、测试样例等 */ + + // 内容注释，用于详解代码 + + /** + * 多行 + * 注释 + */ + ``` + +=== "JavaScript" + + ```js title="" + /* 标题注释，用于标注函数、类、测试样例等 */ + + // 内容注释，用于详解代码 + + /** + * 多行 + * 注释 + */ + ``` + +=== "TypeScript" + + ```typescript title="" + /* 标题注释，用于标注函数、类、测试样例等 */ + + // 内容注释，用于详解代码 + + /** + * 多行 + * 注释 + */ + ``` + +=== "C" + + ```c title="" + /* 标题注释，用于标注函数、类、测试样例等 */ + + // 内容注释，用于详解代码 + + /** + * 多行 + * 注释 + */ + ``` + +=== "C#" + + ```csharp title="" + /* 标题注释，用于标注函数、类、测试样例等 */ + + // 内容注释，用于详解代码 + + /** + * 多行 + * 注释 + */ + ``` + +=== "Swift" + + ```swift title="" + /* 标题注释，用于标注函数、类、测试样例等 */ + + // 内容注释，用于详解代码 + + /** + * 多行 + * 注释 + */ + ``` + +=== "Zig" + + ```zig title="" + // 标题注释，用于标注函数、类、测试样例等 + + // 内容注释，用于详解代码 + + // 多行 + // 注释 + ``` + +## 0.1.5. 本书特点 * + +??? abstract "默认折叠，可以跳过" + + **以实践为主**。我们知道，学习英语期间光啃书本是远远不够的，需要多听、多说、多写，在实践中培养语感、积累经验。编程语言也是一门语言，因此学习方法也应是类似的，需要多看优秀代码、多敲键盘、多思考代码逻辑。 + + 本书的理论部分占少量篇幅，主要分为两类：一是基础且必要的概念知识，以培养读者对于算法的感性认识；二是重要的分类、对比或总结，这是为了帮助你站在更高视角俯瞰各个知识点，形成连点成面的效果。 + + 实践部分主要由示例和代码组成。代码配有简要注释，复杂示例会尽可能地使用视觉化的形式呈现。我强烈建议读者对照着代码自己敲一遍，如果时间有限，也至少逐行读、复制并运行一遍，配合着讲解将代码吃透。 + + **视觉化学习**。信息时代以来，视觉化的脚步从未停止。媒体形式经历了文字短信、图文 Email 、动图、短（长）视频、交互式 Web 、3D 游戏等演变过程，信息的视觉化程度越来越高、愈加符合人类感官、信息传播效率大大提升。科技界也在向视觉化迈进，iPhone 就是一个典型例子，其相对于传统手机是高度视觉化的，包含精心设计的字体、主题配色、交互动画等。 + + 近两年，短视频成为最受欢迎的信息媒介，可以在短时间内将高密度的信息“灌”给我们，有着极其舒适的观看体验。阅读则不然，读者与书本之间天然存在一种“疏离感”，我们看书会累、会走神、会停下来想其他事、会划下喜欢的句子、会思考某一片段的含义，这种疏离感给了读者与书本之间对话的可能，拓宽了想象空间。 + + 本书作为一本入门教材，希望可以保有书本的“慢节奏”，但也会避免与读者产生过多“疏离感”，而是努力将知识完整清晰地推送到你聪明的小脑袋瓜中。我将采用视觉化的方式（例如配图、动画），尽我可能清晰易懂地讲解复杂概念和抽象示例。 + + **内容精简化**。大多数的经典教科书，会把每个主题都讲的很透彻。虽然透彻性正是其获得读者青睐的原因，但对于想要快速入门的初学者来说，这些教材的实用性不足。本书会避免引入非必要的概念、名词、定义等，也避免展开不必要的理论分析，毕竟这不是一本真正意义上的教材，主要任务是尽快地带领读者入门。 + + 引入一些生活案例或趣味内容，非常适合作为知识点的引子或者解释的补充，但当融入过多额外元素时，内容会稍显冗长，也许反而使读者容易迷失、抓不住重点，这也是本书需要避免的。 + + 敲代码如同写字，“美”是统一的追求。本书力求美观的代码，保证规范的变量命名、统一的空格与换行、对齐的缩进、整齐的注释等。 + +## 0.1.6. 致谢 + +本书的成书过程中，我获得了许多人的帮助，包括但不限于： + +- 感谢我的女朋友泡泡担任本书的首位读者，从算法小白的视角为本书的写作提出了许多建议，使这本书更加适合算法初学者来阅读。 +- 感谢腾宝、琦宝、飞宝为本书起了个响当当的名字，好听又有梗，直接唤起我最初敲下第一行代码 "Hello, World!" 的回忆。 +- 感谢我的导师李博，在小酌畅谈时您告诉我“觉得适合、想做就去做”，坚定了我写这本书的决心。 +- 感谢苏潼为本书设计了封面和 LOGO ，我有些强迫症，前后多次修改，谢谢你的耐心。 +- 感谢 @squidfunk ，包括 [Material-for-MkDocs](https://github.com/squidfunk/mkdocs-material/tree/master) 顶级开源项目以及给出的写作排版建议。 + +在写作过程中，我阅读了许多与数据结构与算法的书籍材料，学习到了许多知识，感谢前辈们的精彩创作。 + +感谢父母，你们一贯的支持与鼓励给了我自由度来做这些有趣的事。 + +## 0.1.7. 作者简介 + +{: .center} + +Krahets
+ +大厂高级算法工程师、算法爱好者
+ +力扣（LeetCode）全网阅读量最高博主
+分享近百道算法题解，累积回复数千读者的评论问题
+创作 LeetBook《图解算法数据结构》，已免费售出 22 万本
diff --git a/build/chapter_preface/contribution.md b/build/chapter_preface/contribution.md new file mode 100644 index 000000000..073c3f5f4 --- /dev/null +++ b/build/chapter_preface/contribution.md @@ -0,0 +1,65 @@ +--- +comments: true +--- + +# 0.4. 一起参与创作 + +!!! success "开源的魅力" + + 纸质书籍的两次印刷的间隔时间往往需要数年，内容更新非常不方便。但在本开源 HTML 书中，内容更迭的时间被缩短至数日甚至几个小时。 + +由于作者水平有限，书中内容难免疏漏谬误，请您谅解。此外，期待您可以一同参与本书的创作。如果发现笔误、无效链接、内容缺失、文字歧义、解释不清晰、行文结构不合理等问题，烦请您修正内容，以帮助其他读者获取更优质的学习内容。所有 [撰稿人](https://github.com/krahets/hello-algo/graphs/contributors) 将被展示在仓库主页，以感谢您对开源社区的无私奉献。 + +## 0.4.1. 修改文字与代码 + +每个页面的右上角都有一个「编辑」按钮，你可以按照以下步骤修改文章： + +1. 点击编辑按钮，如果遇到提示“需要 Fork 此仓库”，请通过； +2. 修改 Markdown 源文件内容； +3. 在页面底部填写更改说明，然后单击“Propose file change”按钮； +4. 页面跳转后，点击“Create pull request”按钮发起拉取请求即可，我会第一时间查看处理并及时更新内容。 + + + +## 0.4.2. 修改图片与动画 + +书中的配图无法直接修改，需要通过以下途径提出修改意见： + +1. 新建一个 Issue ，将需要修改的图片复制或截图，粘贴在面板中； +2. 描述图片问题，应如何修改； +3. 提交 Issue 即可，我会第一时间重新画图并替换图片。 + +## 0.4.3. 创作新内容 + +如果您想要创作新内容，例如 **重写章节、新增章节、修改代码、翻译代码至其他编程语言** 等，那么需要实施 Pull Request 工作流程： + +1. 登录 GitHub ，并 Fork [本仓库](https://github.com/krahets/hello-algo) 至个人账号； +2. 进入 Fork 仓库网页，使用 `git clone` 克隆该仓库至本地； +3. 在本地进行内容创作（建议通过运行测试来验证代码正确性）； +4. 将本地更改 Commit ，并 Push 至远程仓库； +5. 刷新仓库网页，点击“Create pull request”按钮发起拉取请求（Pull Request）即可； + +非常欢迎您和我一同来创作本书！ + +## 0.4.4. 本地部署 hello-algo + +### Docker + +请确保 Docker 已经安装并启动，并根据如下命令离线部署。 + +稍等片刻，即可使用浏览器打开 `http://localhost:8000` 访问本项目。 + +```bash +git clone https://github.com/krahets/hello-algo.git +cd hello-algo + +docker-compose up -d +``` + +使用如下命令即可删除部署。 + +```bash +docker-compose down +``` + +（TODO：教学视频） diff --git a/build/chapter_preface/installation.md b/build/chapter_preface/installation.md new file mode 100644 index 000000000..adab95b21 --- /dev/null +++ b/build/chapter_preface/installation.md @@ -0,0 +1,52 @@ +--- +comments: true +--- + +# 0.3. 编程环境安装 + +（TODO 视频教程） + +## 0.3.1. 安装 VSCode + +本书推荐使用开源轻量的 VSCode 作为本地 IDE ，下载并安装 [VSCode](https://code.visualstudio.com/) 。 + +## 0.3.2. Java 环境 + +1. 下载并安装 [OpenJDK](https://jdk.java.net/18/)（版本需满足 > JDK 9）。 +2. 在 VSCode 的插件市场中搜索 `java` ，安装 Java Extension Pack 。 + +## 0.3.3. C/C++ 环境 + +1. Windows 系统需要安装 [MinGW](https://sourceforge.net/projects/mingw-w64/files/) （[配置教程](https://glj0.netlify.app/d-%E8%BD%AF%E4%BB%B6%E6%8A%80%E8%83%BD/windows%20%E4%B8%8B%E4%BD%BF%E7%94%A8%20vscode%20+%20mingw%20%E5%AE%8C%E6%88%90%E7%AE%80%E5%8D%95%20c%20%E6%88%96%20cpp%20%E4%BB%A3%E7%A0%81%E7%9A%84%E8%BF%90%E8%A1%8C%E4%B8%8E%E8%B0%83%E8%AF%95/)），MacOS 自带 Clang 无需安装。 +2. 在 VSCode 的插件市场中搜索 `c++` ，安装 C/C++ Extension Pack 。 + +## 0.3.4. Python 环境 + +1. 下载并安装 [Miniconda3](https://docs.conda.io/en/latest/miniconda.html) 。 +2. 在 VSCode 的插件市场中搜索 `python` ，安装 Python Extension Pack 。 + +## 0.3.5. Go 环境 + +1. 下载并安装 [go](https://go.dev/dl/) 。 +2. 在 VSCode 的插件市场中搜索 `go` ，安装 Go 。 +3. 快捷键 `Ctrl + Shift + P` 呼出命令栏，输入 go ，选择 `Go: Install/Update Tools` ，全部勾选并安装即可。 + +## 0.3.6. JavaScript 环境 + +1. 下载并安装 [node.js](https://nodejs.org/en/) 。 +2. 在 VSCode 的插件市场中搜索 `javascript` ，安装 JavaScript (ES6) code snippets 。 + +## 0.3.7. C# 环境 + +1. 下载并安装 [.Net 6.0](https://dotnet.microsoft.com/en-us/download) ； +2. 在 VSCode 的插件市场中搜索 `c#` ，安装 c# 。 + +## 0.3.8. Swift 环境 + +1. 下载并安装 [Swift](https://www.swift.org/download/)； +2. 在 VSCode 的插件市场中搜索 `swift`，安装 [Swift for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=sswg.swift-lang)。 + +## 0.3.9. 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/build/chapter_preface/suggestions.md b/build/chapter_preface/suggestions.md new file mode 100644 index 000000000..7907db787 --- /dev/null +++ b/build/chapter_preface/suggestions.md @@ -0,0 +1,63 @@ +--- +comments: true +--- + +# 0.2. 如何使用本书 + +## 0.2.1. 图文搭配学 + +视频和图片相比于文字的信息密度和结构化程度更高，更容易让人理解。在本书中，重点和难点知识会主要以动画、图解的形式呈现，而文字的作用则是作为动画和图的解释与补充。 + +在阅读本书的过程中，若发现某段内容提供了动画或图解，**建议你以图为主线**，将文字内容（一般在图的上方）对齐到图中内容，综合来理解。 + + + +## 0.2.2. 代码实践学 + +!!! tip "前置工作" + + 如果没有本地编程环境，可以参照下节 [编程环境安装](https://www.hello-algo.com/chapter_preface/installation/) 。 + +### 下载代码仓 + +如果已经安装 [Git](https://git-scm.com/downloads) ，可以通过命令行来克隆代码仓。 + +```shell +git clone https://github.com/krahets/hello-algo.git +``` + +当然，你也可以点击“Download ZIP”直接下载代码压缩包，解压即可。 + + + +### 运行源代码 + +本书提供配套 Java, C++, Python 代码仓（后续可能拓展支持语言）。书中的代码栏上若标有 `*.java` , `*.cpp` , `*.py` ，则可在仓库 codes 文件夹中找到对应的 **代码源文件**。 + + + +这些源文件中包含详细注释，配有测试样例，可以直接运行，帮助你省去不必要的调试时间，可以将精力集中在学习内容上。 + + + +!!! tip "代码学习建议" + + 若学习时间紧张，**请至少将所有代码通读并运行一遍**。若时间允许，**强烈建议对照着代码自己敲一遍**，逐渐锻炼肌肉记忆。相比于读代码，写代码的过程往往能带来新的收获。 + +## 0.2.3. 提问讨论学 + +阅读本书时，请不要“惯着”那些弄不明白的知识点。如果有任何疑惑，**可以在评论区留下你的问题**，小伙伴们和我都会给予解答（您一般 3 天内会得到回复）。 + +同时，也希望你可以多花时间逛逛评论区。一方面，可以看看大家遇到了什么问题，反过来查漏补缺，这往往可以引起更加深度的思考。另一方面，也希望你可以慷慨地解答小伙伴们的问题、分享自己的见解，大家一起加油与进步！ + + + +## 0.2.4. 算法学习“三步走” + +**第一阶段，算法入门，也正是本书的定位**。熟悉各种数据结构的特点、用法，学习各种算法的工作原理、用途、效率等。 + +**第二阶段，刷算法题**。可以先从热门题单开刷，推荐 [剑指 Offer](https://leetcode.cn/problem-list/xb9nqhhg/)、[LeetCode 热题 HOT 100](https://leetcode.cn/problem-list/2cktkvj/) ，先积累至少 100 道题量，熟悉大多数的算法问题。刚开始刷题时，“遗忘”是最大的困扰点，但这是很正常的，请不要担心。学习中有一种概念叫“周期性回顾”，同一道题隔段时间做一次，当做了三遍以上，往往就能牢记于心了。 + +**第三阶段，搭建知识体系**。在学习方面，可以阅读算法专栏文章、解题框架、算法教材，不断地丰富知识体系。在刷题方面，可以开始采用进阶刷题方案，例如按专题分类、一题多解、一解多题等，刷题方案在社区中可以找到一些讲解，在此不做赘述。 + + diff --git a/build/chapter_reference/index.md b/build/chapter_reference/index.md new file mode 100644 index 000000000..fcc5da56f --- /dev/null +++ b/build/chapter_reference/index.md @@ -0,0 +1,17 @@ +# 参考文献 + +[1] Thomas H. Cormen, et al. Introduction to Algorithms (3rd Edition). + +[2] Aditya Bhargava. Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People (1st Edition). + +[3] 程杰. 大话数据结构. + +[4] 王争. 数据结构与算法之美. + +[5] 严蔚敏. 数据结构（ C 语言版）. + +[6] 邓俊辉. 数据结构（ C++ 语言版，第三版）. + +[7] 马克·艾伦·维斯著，陈越译. 数据结构与算法分析：Java语言描述（第三版）. + +[8] Gayle Laakmann McDowell. Cracking the Coding Interview: 189 Programming Questions and Solutions (6th Edition). diff --git a/build/chapter_searching/binary_search.md b/build/chapter_searching/binary_search.md new file mode 100755 index 000000000..9ac254cec --- /dev/null +++ b/build/chapter_searching/binary_search.md @@ -0,0 +1,555 @@ +--- +comments: true +--- + +# 10.2. 二分查找 + +「二分查找 Binary Search」利用数据的有序性，通过每轮缩小一半搜索区间来查找目标元素。 + +使用二分查找有两个前置条件： + +- **要求输入数据是有序的**，这样才能通过判断大小关系来排除一半的搜索区间； +- **二分查找仅适用于数组**，而在链表中使用效率很低，因为其在循环中需要跳跃式（非连续地）访问元素。 + +## 10.2.1. 算法实现 + +给定一个长度为 $n$ 的排序数组 `nums` ，元素从小到大排列。数组的索引取值范围为 + +$$ +0, 1, 2, \cdots, n-1 +$$ + +使用「区间」来表示这个取值范围的方法主要有两种： + +1. **双闭区间 $[0, n-1]$** ，即两个边界都包含自身；此方法下，区间 $[0, 0]$ 仍包含一个元素； +2. **左闭右开 $[0, n)$** ，即左边界包含自身、右边界不包含自身；此方法下，区间 $[0, 0)$ 为空； + +### “双闭区间”实现 + +首先，我们先采用“双闭区间”的表示，在数组 `nums` 中查找目标元素 `target` 的对应索引。 + +=== "Step 1" +  + +=== "Step 2" +  + +=== "Step 3" +  + +=== "Step 4" +  + +=== "Step 5" +  + +=== "Step 6" +  + +=== "Step 7" +  + +二分查找“双闭区间”表示下的代码如下所示。 + +=== "Java" + + ```java title="binary_search.java" + /* 二分查找（双闭区间） */ + int binarySearch(int[] nums, int target) { + // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素 + int i = 0, j = nums.length - 1; + // 循环，当搜索区间为空时跳出（当 i > j 时为空） + while (i <= j) { + int m = (i + j) / 2; // 计算中点索引 m + if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中 + i = m + 1; + else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中 + j = m - 1; + else // 找到目标元素，返回其索引 + return m; + } + // 未找到目标元素，返回 -1 + return -1; + } + ``` + +=== "C++" + + ```cpp title="binary_search.cpp" + /* 二分查找（双闭区间） */ + int binarySearch(vector
+
+| 表示方法 | 初始化指针 | 缩小区间 | 循环终止条件 |
+| ------------------- | ------------------- | ------------------------- | ------------ |
+| 双闭区间 $[0, n-1]$ | $i = 0$ , $j = n-1$ | $i = m + 1$ , $j = m - 1$ | $i > j$ |
+| 左闭右开 $[0, n)$ | $i = 0$ , $j = n$ | $i = m + 1$ , $j = m$ | $i = j$ |
+
+
+
+观察发现，在“双闭区间”表示中，由于对左右两边界的定义是相同的，因此缩小区间的 $i$ , $j$ 处理方法也是对称的，这样更不容易出错。综上所述，**建议你采用“双闭区间”的写法。**
+
+### 大数越界处理
+
+当数组长度很大时，加法 $i + j$ 的结果有可能会超出 `int` 类型的取值范围。在此情况下，我们需要换一种计算中点的写法。
+
+=== "Java"
+
+ ```java title=""
+ // (i + j) 有可能超出 int 的取值范围
+ int m = (i + j) / 2;
+ // 更换为此写法则不会越界
+ int m = i + (j - i) / 2;
+ ```
+
+=== "C++"
+
+ ```cpp title=""
+ // (i + j) 有可能超出 int 的取值范围
+ int m = (i + j) / 2;
+ // 更换为此写法则不会越界
+ int m = i + (j - i) / 2;
+ ```
+
+=== "Python"
+
+ ```py title=""
+ # Python 中的数字理论上可以无限大（取决于内存大小）
+ # 因此无需考虑大数越界问题
+ ```
+
+=== "Go"
+
+ ```go title=""
+ // (i + j) 有可能超出 int 的取值范围
+ m := (i + j) / 2
+ // 更换为此写法则不会越界
+ m := i + (j - i) / 2
+ ```
+
+=== "JavaScript"
+
+ ```js title=""
+ // (i + j) 有可能超出 int 的取值范围
+ let m = parseInt((i + j) / 2);
+ // 更换为此写法则不会越界
+ let m = parseInt(i + (j - i) / 2);
+ ```
+
+=== "TypeScript"
+
+ ```typescript title=""
+ // (i + j) 有可能超出 Number 的取值范围
+ let m = Math.floor((i + j) / 2);
+ // 更换为此写法则不会越界
+ let m = Math.floor(i + (j - i) / 2);
+ ```
+
+=== "C"
+
+ ```c title=""
+
+ ```
+
+=== "C#"
+
+ ```csharp title=""
+ // (i + j) 有可能超出 int 的取值范围
+ int m = (i + j) / 2;
+ // 更换为此写法则不会越界
+ int m = i + (j - i) / 2;
+ ```
+
+=== "Swift"
+
+ ```swift title=""
+ // (i + j) 有可能超出 int 的取值范围
+ let m = (i + j) / 2
+ // 更换为此写法则不会越界
+ let m = i + (j - 1) / 2
+ ```
+
+=== "Zig"
+
+ ```zig title=""
+
+ ```
+
+## 10.2.2. 复杂度分析
+
+**时间复杂度 $O(\log n)$** ：其中 $n$ 为数组或链表长度；每轮排除一半的区间，因此循环轮数为 $\log_2 n$ ，使用 $O(\log n)$ 时间。
+
+**空间复杂度 $O(1)$** ：指针 `i` , `j` 使用常数大小空间。
+
+## 10.2.3. 优点与缺点
+
+二分查找效率很高，体现在：
+
+- **二分查找时间复杂度低**。对数阶在数据量很大时具有巨大优势，例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需要 $\log_2 2^{20} = 20$ 轮循环。
+- **二分查找不需要额外空间**。相对于借助额外数据结构来实现查找的算法来说，其更加节约空间使用。
+
+但并不意味着所有情况下都应使用二分查找，这是因为：
+
+- **二分查找仅适用于有序数据**。如果输入数据是无序的，为了使用二分查找而专门执行数据排序，那么是得不偿失的，因为排序算法的时间复杂度一般为 $O(n \log n)$ ，比线性查找和二分查找都更差。再例如，对于频繁插入元素的场景，为了保持数组的有序性，需要将元素插入到特定位置，时间复杂度为 $O(n)$ ，也是非常昂贵的。
+- **二分查找仅适用于数组**。由于在二分查找中，访问索引是 “非连续” 的，因此链表或者基于链表实现的数据结构都无法使用。
+- **在小数据量下，线性查找的性能更好**。在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，在数据量 $n$ 较小时，线性查找反而比二分查找更快。
diff --git a/build/chapter_searching/hashing_search.md b/build/chapter_searching/hashing_search.md
new file mode 100755
index 000000000..157e67a2e
--- /dev/null
+++ b/build/chapter_searching/hashing_search.md
@@ -0,0 +1,251 @@
+---
+comments: true
+---
+
+# 10.3. 哈希查找
+
+!!! question
+
+ 在数据量很大时，「线性查找」太慢；而「二分查找」要求数据必须是有序的，并且只能在数组中应用。那么是否有方法可以同时避免上述缺点呢？答案是肯定的，此方法被称为「哈希查找」。
+
+「哈希查找 Hash Searching」借助一个哈希表来存储需要的「键值对 Key Value Pair」，我们可以在 $O(1)$ 时间下实现“键 $\rightarrow$ 值”映射查找，体现着“以空间换时间”的算法思想。
+
+## 10.3.1. 算法实现
+
+如果我们想要给定数组中的一个目标元素 `target` ，获取该元素的索引，那么可以借助一个哈希表实现查找。
+
+
+
+=== "Java"
+
+ ```java title="hashing_search.java"
+ /* 哈希查找（数组） */
+ int hashingSearchArray(MapTable. 三种查找方法对比
+ +
+
+| | 线性查找 | 二分查找 | 哈希查找 |
+| ------------------------------------- | ------------------------ | ----------------------------- | ------------------------ |
+| 适用数据结构 | 数组、链表 | 数组 | 数组、链表 |
+| 输入数据要求 | 无 | 有序 | 无 |
+| 平均时间复杂度查找 / 插入 / 删除 | $O(n)$ / $O(1)$ / $O(n)$ | $O(\log n)$ / $O(n)$ / $O(n)$ | $O(1)$ / $O(1)$ / $O(1)$ |
+| 最差时间复杂度查找 / 插入 / 删除 | $O(n)$ / $O(1)$ / $O(n)$ | $O(\log n)$ / $O(n)$ / $O(n)$ | $O(n)$ / $O(n)$ / $O(n)$ |
+| 空间复杂度 | $O(1)$ | $O(1)$ | $O(n)$ |
+
+
diff --git a/build/chapter_sorting/bubble_sort.md b/build/chapter_sorting/bubble_sort.md
new file mode 100755
index 000000000..e23edcaab
--- /dev/null
+++ b/build/chapter_sorting/bubble_sort.md
@@ -0,0 +1,465 @@
+---
+comments: true
+---
+
+# 11.2. 冒泡排序
+
+「冒泡排序 Bubble Sort」是一种最基础的排序算法，非常适合作为第一个学习的排序算法。顾名思义，「冒泡」是该算法的核心操作。
+
+!!! question "为什么叫“冒泡”"
+
+ 在水中，越大的泡泡浮力越大，所以最大的泡泡会最先浮到水面。
+
+「冒泡」操作则是在模拟上述过程，具体做法为：从数组最左端开始向右遍历，依次对比相邻元素大小，若 **左元素 > 右元素** 则将它俩交换，最终可将最大元素移动至数组最右端。
+
+完成此次冒泡操作后，**数组最大元素已在正确位置，接下来只需排序剩余 $n - 1$ 个元素**。
+
+=== "Step 1"
+ 
+
+=== "Step 2"
+ 
+
+=== "Step 3"
+ 
+
+=== "Step 4"
+ 
+
+=== "Step 5"
+ 
+
+=== "Step 6"
+ 
+
+=== "Step 7"
+ 
+
+Fig. 冒泡操作
+ +## 11.2.1. 算法流程 + +1. 设数组长度为 $n$ ，完成第一轮「冒泡」后，数组最大元素已在正确位置，接下来只需排序剩余 $n - 1$ 个元素。 +2. 同理，对剩余 $n - 1$ 个元素执行「冒泡」，可将第二大元素交换至正确位置，因而待排序元素只剩 $n - 2$ 个。 +3. 以此类推…… **循环 $n - 1$ 轮「冒泡」，即可完成整个数组的排序**。 + + + +Fig. 冒泡排序流程
+ +=== "Java" + + ```java title="bubble_sort.java" + /* 冒泡排序 */ + void bubbleSort(int[] nums) { + // 外循环：待排序元素数量为 n-1, n-2, ..., 1 + for (int i = nums.length - 1; i > 0; i--) { + // 内循环：冒泡操作 + for (int j = 0; j < i; j++) { + if (nums[j] > nums[j + 1]) { + // 交换 nums[j] 与 nums[j + 1] + int tmp = nums[j]; + nums[j] = nums[j + 1]; + nums[j + 1] = tmp; + } + } + } + } + ``` + +=== "C++" + + ```cpp title="bubble_sort.cpp" + /* 冒泡排序 */ + void bubbleSort(vectorFig. 插入操作
+ +## 11.3.1. 算法流程 + +1. 第 1 轮先选取数组的 **第 2 个元素** 为 `base` ，执行「插入操作」后，**数组前 2 个元素已完成排序**。 +2. 第 2 轮选取 **第 3 个元素** 为 `base` ，执行「插入操作」后，**数组前 3 个元素已完成排序**。 +3. 以此类推……最后一轮选取 **数组尾元素** 为 `base` ，执行「插入操作」后，**所有元素已完成排序**。 + + + +Fig. 插入排序流程
+ +=== "Java" + + ```java title="insertion_sort.java" + /* 插入排序 */ + void insertionSort(int[] nums) { + // 外循环：base = nums[1], nums[2], ..., nums[n-1] + for (int i = 1; i < nums.length; i++) { + int base = nums[i], j = i - 1; + // 内循环：将 base 插入到左边的正确位置 + while (j >= 0 && nums[j] > base) { + nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位 + j--; + } + nums[j + 1] = base; // 2. 将 base 赋值到正确位置 + } + } + ``` + +=== "C++" + + ```cpp title="insertion_sort.cpp" + /* 插入排序 */ + void insertionSort(vectorFig. 排序中的不同元素类型和判断规则
+ +## 11.1.1. 评价维度 + +排序算法主要可根据 **稳定性 、就地性 、自适应性 、比较类** 来分类。 + +### 稳定性 + +- 「稳定排序」在完成排序后，**不改变** 相等元素在数组中的相对顺序。 +- 「非稳定排序」在完成排序后，相等元素在数组中的相对位置 **可能被改变**。 + +假设我们有一个存储学生信息的表格，第 1, 2 列分别是姓名和年龄。那么在以下示例中，「非稳定排序」会导致输入数据的有序性丢失。因此「稳定排序」是很好的特性，**在多级排序中是必须的**。 + +```shell + # 输入数据是按照姓名排序好的 + # (name, age) + ('A', 19) + ('B', 18) + ('C', 21) + ('D', 19) + ('E', 23) + + # 假设使用非稳定排序算法按年龄排序列表， + # 结果中 ('D', 19) 和 ('A', 19) 的相对位置改变， + # 输入数据按姓名排序的性质丢失 + ('B', 18) + ('D', 19) + ('A', 19) + ('C', 21) + ('E', 23) +``` + +### 就地性 + +- 「原地排序」无需辅助数据，不使用额外空间； +- 「非原地排序」需要借助辅助数据，使用额外空间； + +「原地排序」不使用额外空间，可以节约内存；并且一般情况下，由于数据操作减少，原地排序的运行效率也更高。 + +### 自适应性 + +- 「自适应排序」的时间复杂度受输入数据影响，即最佳 / 最差 / 平均时间复杂度不相等。 +- 「非自适应排序」的时间复杂度恒定，与输入数据无关。 + +我们希望 **最差 = 平均**，即不希望排序算法的运行效率在某些输入数据下发生劣化。 + +### 比较类 + +- 「比较类排序」基于元素之间的比较算子（小于、相等、大于）来决定元素的相对顺序。 +- 「非比较类排序」不基于元素之间的比较算子来决定元素的相对顺序。 + +「比较类排序」的时间复杂度最优为 $O(n \log n)$ ；而「非比较类排序」可以达到 $O(n)$ 的时间复杂度，但通用性较差。 + +## 11.1.2. 理想排序算法 + +- **运行快**，即时间复杂度低； +- **稳定排序**，即排序后相等元素的相对位置不变化； +- **原地排序**，即运行中不使用额外的辅助空间； +- **正向自适应性**，即算法的运行效率不会在某些输入数据下发生劣化； + +然而，**没有排序算法同时具备以上所有特性**。排序算法的选型使用取决于具体的列表类型、列表长度、元素分布等因素。 diff --git a/build/chapter_sorting/merge_sort.md b/build/chapter_sorting/merge_sort.md new file mode 100755 index 000000000..cf2854917 --- /dev/null +++ b/build/chapter_sorting/merge_sort.md @@ -0,0 +1,475 @@ +--- +comments: true +--- + +# 11.5. 归并排序 + +「归并排序 Merge Sort」是算法中“分治思想”的典型体现，其有「划分」和「合并」两个阶段： + +1. **划分阶段**：通过递归不断 **将数组从中点位置划分开**，将长数组的排序问题转化为短数组的排序问题； +2. **合并阶段**：划分到子数组长度为 1 时，开始向上合并，不断将 **左、右两个短排序数组** 合并为 **一个长排序数组**，直至合并至原数组时完成排序； + + + +Fig. 归并排序两阶段：划分与合并
+ +## 11.5.1. 算法流程 + +**「递归划分」** 从顶至底递归地 **将数组从中点切为两个子数组**，直至长度为 1 ； + +1. 计算数组中点 `mid` ，递归划分左子数组（区间 `[left, mid]` ）和右子数组（区间 `[mid + 1, right]` ）； +2. 递归执行 `1.` 步骤，直至子数组区间长度为 1 时，终止递归划分； + +**「回溯合并」** 从底至顶地将左子数组和右子数组合并为一个 **有序数组** ； + +需要注意，由于从长度为 1 的子数组开始合并，所以 **每个子数组都是有序的**。因此，合并任务本质是要 **将两个有序子数组合并为一个有序数组**。 + +=== "Step1" +  + +=== "Step2" +  + +=== "Step3" +  + +=== "Step4" +  + +=== "Step5" +  + +=== "Step6" +  + +=== "Step7" +  + +=== "Step8" +  + +=== "Step9" +  + +=== "Step10" +  + +观察发现，归并排序的递归顺序就是二叉树的「后序遍历」。 + +- **后序遍历**：先递归左子树、再递归右子树、最后处理根结点。 +- **归并排序**：先递归左子树、再递归右子树、最后处理合并。 + +=== "Java" + + ```java title="merge_sort.java" + /** + * 合并左子数组和右子数组 + * 左子数组区间 [left, mid] + * 右子数组区间 [mid + 1, right] + */ + void merge(int[] nums, int left, int mid, int right) { + // 初始化辅助数组 + int[] tmp = Arrays.copyOfRange(nums, left, right + 1); + // 左子数组的起始索引和结束索引 + int leftStart = left - left, leftEnd = mid - left; + // 右子数组的起始索引和结束索引 + int rightStart = mid + 1 - left, rightEnd = right - left; + // i, j 分别指向左子数组、右子数组的首元素 + int i = leftStart, j = rightStart; + // 通过覆盖原数组 nums 来合并左子数组和右子数组 + for (int k = left; k <= right; k++) { + // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++ + if (i > leftEnd) + nums[k] = tmp[j++]; + // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++ + else if (j > rightEnd || tmp[i] <= tmp[j]) + nums[k] = tmp[i++]; + // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++ + else + nums[k] = tmp[j++]; + } + } + + /* 归并排序 */ + void mergeSort(int[] nums, int left, int right) { + // 终止条件 + if (left >= right) return; // 当子数组长度为 1 时终止递归 + // 递归划分 + int mid = (left + right) / 2; // 计算数组中点 + mergeSort(nums, left, mid); // 递归左子数组 + mergeSort(nums, mid + 1, right); // 递归右子数组 + // 回溯合并 + merge(nums, left, mid, right); + } + ``` + +=== "C++" + + ```cpp title="merge_sort.cpp" + /** + * 合并左子数组和右子数组 + * 左子数组区间 [left, mid] + * 右子数组区间 [mid + 1, right] + */ + void merge(vectorFig. 哨兵划分
+ +=== "Java" + + ``` java title="quick_sort.java" + /* 元素交换 */ + void swap(int[] nums, int i, int j) { + int tmp = nums[i]; + nums[i] = nums[j]; + nums[j] = tmp; + } + + /* 哨兵划分 */ + int partition(int[] nums, int left, int right) { + // 以 nums[left] 作为基准数 + int i = left, j = right; + while (i < j) { + while (i < j && nums[j] >= nums[left]) + j--; // 从右向左找首个小于基准数的元素 + while (i < j && nums[i] <= nums[left]) + i++; // 从左向右找首个大于基准数的元素 + swap(nums, i, j); // 交换这两个元素 + } + swap(nums, i, left); // 将基准数交换至两子数组的分界线 + return i; // 返回基准数的索引 + } + ``` + +=== "C++" + + ```cpp title="quick_sort.cpp" + /* 元素交换 */ + void swap(vectorFig. 快速排序流程
+ +=== "Java" + + ```java title="quick_sort.java" + /* 快速排序 */ + void quickSort(int[] nums, int left, int right) { + // 子数组长度为 1 时终止递归 + if (left >= right) + return; + // 哨兵划分 + int pivot = partition(nums, left, right); + // 递归左子数组、右子数组 + quickSort(nums, left, pivot - 1); + quickSort(nums, pivot + 1, right); + } + ``` + +=== "C++" + + ```cpp title="quick_sort.cpp" + /* 快速排序 */ + void quickSort(vectorFig. 双向队列的操作
+ +## 5.3.1. 双向队列常用操作 + +双向队列的常用操作见下表，方法名需根据特定语言来确定。 + +Table. 双向队列的常用操作
+ +
+
+| 方法名 | 描述 | 时间复杂度 |
+| ------------ | ---------------- | ---------- |
+| pushFirst() | 将元素添加至队首 | $O(1)$ |
+| pushLast() | 将元素添加至队尾 | $O(1)$ |
+| pollFirst() | 删除队首元素 | $O(1)$ |
+| pollLast() | 删除队尾元素 | $O(1)$ |
+| peekFirst() | 访问队首元素 | $O(1)$ |
+| peekLast() | 访问队尾元素 | $O(1)$ |
+| size() | 获取队列的长度 | $O(1)$ |
+| isEmpty() | 判断队列是否为空 | $O(1)$ |
+
+
+
+相同地，我们可以直接使用编程语言实现好的双向队列类。
+
+=== "Java"
+
+ ```java title="deque.java"
+ /* 初始化双向队列 */
+ DequeFig. 队列的先入先出特性
+ +## 5.2.1. 队列常用操作 + +队列的常用操作见下表，方法名需根据特定语言来确定。 + +Table. 队列的常用操作
+ +
+
+| 方法名 | 描述 | 时间复杂度 |
+| --------- | -------------------------- | -------- |
+| push() | 元素入队，即将元素添加至队尾 | $O(1)$ |
+| poll() | 队首元素出队 | $O(1)$ |
+| front() | 访问队首元素 | $O(1)$ |
+| size() | 获取队列的长度 | $O(1)$ |
+| isEmpty() | 判断队列是否为空 | $O(1)$ |
+
+
+
+我们可以直接使用编程语言实现好的队列类。
+
+=== "Java"
+
+ ```java title="queue.java"
+ /* 初始化队列 */
+ QueueFig. 栈的先入后出特性
+ +## 5.1.1. 栈常用操作 + +栈的常用操作见下表（方法命名以 Java 为例）。 + +Table. 栈的常用操作
+ +
+
+| 方法 | 描述 | 时间复杂度 |
+| --------- | ---------------------- | ---------- |
+| push() | 元素入栈（添加至栈顶） | $O(1)$ |
+| pop() | 栈顶元素出栈 | $O(1)$ |
+| peek() | 访问栈顶元素 | $O(1)$ |
+| size() | 获取栈的长度 | $O(1)$ |
+| isEmpty() | 判断栈是否为空 | $O(1)$ |
+
+
+
+我们可以直接使用编程语言实现好的栈类。 某些语言并未专门提供栈类，但我们可以直接把该语言的「数组」或「链表」看作栈来使用，并通过“脑补”来屏蔽无关操作。
+
+=== "Java"
+
+ ```java title="stack.java"
+ /* 初始化栈 */
+ // 在 Java 中，推荐将 ArrayList 当作栈来使用
+ List
+
+| 失衡结点的平衡因子 | 子结点的平衡因子 | 应采用的旋转方法 |
+| ------------------ | ---------------- | ---------------- |
+| $>0$ （即左偏树） | $\geq 0$ | 右旋 |
+| $>0$ （即左偏树） | $<0$ | 先左旋后右旋 |
+| $<0$ （即右偏树） | $\leq 0$ | 左旋 |
+| $<0$ （即右偏树） | $>0$ | 先右旋后左旋 |
+
+
+
+为方便使用，我们将旋转操作封装成一个函数。至此，**我们可以使用此函数来旋转各种失衡情况，使失衡结点重新恢复平衡**。
+
+=== "Java"
+
+ ```java title="avl_tree.java"
+ /* 执行旋转操作，使该子树重新恢复平衡 */
+ TreeNode rotate(TreeNode node) {
+ // 获取结点 node 的平衡因子
+ int balanceFactor = balanceFactor(node);
+ // 左偏树
+ if (balanceFactor > 1) {
+ if (balanceFactor(node.left) >= 0) {
+ // 右旋
+ return rightRotate(node);
+ } else {
+ // 先左旋后右旋
+ node.left = leftRotate(node.left);
+ return rightRotate(node);
+ }
+ }
+ // 右偏树
+ if (balanceFactor < -1) {
+ if (balanceFactor(node.right) <= 0) {
+ // 左旋
+ return leftRotate(node);
+ } else {
+ // 先右旋后左旋
+ node.right = rightRotate(node.right);
+ return leftRotate(node);
+ }
+ }
+ // 平衡树，无需旋转，直接返回
+ return node;
+ }
+ ```
+
+=== "C++"
+
+ ```cpp title="avl_tree.cpp"
+ /* 执行旋转操作，使该子树重新恢复平衡 */
+ TreeNode* rotate(TreeNode* node) {
+ // 获取结点 node 的平衡因子
+ int _balanceFactor = balanceFactor(node);
+ // 左偏树
+ if (_balanceFactor > 1) {
+ if (balanceFactor(node->left) >= 0) {
+ // 右旋
+ return rightRotate(node);
+ } else {
+ // 先左旋后右旋
+ node->left = leftRotate(node->left);
+ return rightRotate(node);
+ }
+ }
+ // 右偏树
+ if (_balanceFactor < -1) {
+ if (balanceFactor(node->right) <= 0) {
+ // 左旋
+ return leftRotate(node);
+ } else {
+ // 先右旋后左旋
+ node->right = rightRotate(node->right);
+ return leftRotate(node);
+ }
+ }
+ // 平衡树，无需旋转，直接返回
+ return node;
+ }
+ ```
+
+=== "Python"
+
+ ```python title="avl_tree.py"
+ """ 执行旋转操作，使该子树重新恢复平衡 """
+ def __rotate(self, node: Optional[TreeNode]) -> TreeNode:
+ # 获取结点 node 的平衡因子
+ balance_factor = self.balance_factor(node)
+ # 左偏树
+ if balance_factor > 1:
+ if self.balance_factor(node.left) >= 0:
+ # 右旋
+ return self.__right_rotate(node)
+ else:
+ # 先左旋后右旋
+ node.left = self.__left_rotate(node.left)
+ return self.__right_rotate(node)
+ # 右偏树
+ elif balance_factor < -1:
+ if self.balance_factor(node.right) <= 0:
+ # 左旋
+ return self.__left_rotate(node)
+ else:
+ # 先右旋后左旋
+ node.right = self.__right_rotate(node.right)
+ return self.__left_rotate(node)
+ # 平衡树，无需旋转，直接返回
+ return node
+ ```
+
+=== "Go"
+
+ ```go title="avl_tree.go"
+ /* 执行旋转操作，使该子树重新恢复平衡 */
+ func rotate(node *TreeNode) *TreeNode {
+ // 获取结点 node 的平衡因子
+ // Go 推荐短变量，这里 bf 指代 balanceFactor
+ bf := balanceFactor(node)
+ // 左偏树
+ if bf > 1 {
+ if balanceFactor(node.Left) >= 0 {
+ // 右旋
+ return rightRotate(node)
+ } else {
+ // 先左旋后右旋
+ node.Left = leftRotate(node.Left)
+ return rightRotate(node)
+ }
+ }
+ // 右偏树
+ if bf < -1 {
+ if balanceFactor(node.Right) <= 0 {
+ // 左旋
+ return leftRotate(node)
+ } else {
+ // 先右旋后左旋
+ node.Right = rightRotate(node.Right)
+ return leftRotate(node)
+ }
+ }
+ // 平衡树，无需旋转，直接返回
+ return node
+ }
+ ```
+
+=== "JavaScript"
+
+ ```js title="avl_tree.js"
+ /* 执行旋转操作，使该子树重新恢复平衡 */
+ rotate(node) {
+ // 获取结点 node 的平衡因子
+ let balanceFactor = this.balanceFactor(node);
+ // 左偏树
+ if (balanceFactor > 1) {
+ if (this.balanceFactor(node.left) >= 0) {
+ // 右旋
+ return this.rightRotate(node);
+ } else {
+ // 先左旋后右旋
+ node.left = this.leftRotate(node.left);
+ return this.rightRotate(node);
+ }
+ }
+ // 右偏树
+ if (balanceFactor < -1) {
+ if (this.balanceFactor(node.right) <= 0) {
+ // 左旋
+ return this.leftRotate(node);
+ } else {
+ // 先右旋后左旋
+ node.right = this.rightRotate(node.right);
+ return this.leftRotate(node);
+ }
+ }
+ // 平衡树，无需旋转，直接返回
+ return node;
+ }
+ ```
+
+=== "TypeScript"
+
+ ```typescript title="avl_tree.ts"
+
+ ```
+
+=== "C"
+
+ ```c title="avl_tree.c"
+
+ ```
+
+=== "C#"
+
+ ```csharp title="avl_tree.cs"
+ /* 执行旋转操作，使该子树重新恢复平衡 */
+ TreeNode? rotate(TreeNode? node)
+ {
+ // 获取结点 node 的平衡因子
+ int balanceFactorInt = balanceFactor(node);
+ // 左偏树
+ if (balanceFactorInt > 1)
+ {
+ if (balanceFactor(node.left) >= 0)
+ {
+ // 右旋
+ return rightRotate(node);
+ }
+ else
+ {
+ // 先左旋后右旋
+ node.left = leftRotate(node?.left);
+ return rightRotate(node);
+ }
+ }
+ // 右偏树
+ if (balanceFactorInt < -1)
+ {
+ if (balanceFactor(node.right) <= 0)
+ {
+ // 左旋
+ return leftRotate(node);
+ }
+ else
+ {
+ // 先右旋后左旋
+ node.right = rightRotate(node?.right);
+ return leftRotate(node);
+ }
+ }
+ // 平衡树，无需旋转，直接返回
+ return node;
+ }
+ ```
+
+=== "Swift"
+
+ ```swift title="avl_tree.swift"
+ /* 执行旋转操作，使该子树重新恢复平衡 */
+ func rotate(node: TreeNode?) -> TreeNode? {
+ // 获取结点 node 的平衡因子
+ let balanceFactor = balanceFactor(node: node)
+ // 左偏树
+ if balanceFactor > 1 {
+ if self.balanceFactor(node: node?.left) >= 0 {
+ // 右旋
+ return rightRotate(node: node)
+ } else {
+ // 先左旋后右旋
+ node?.left = leftRotate(node: node?.left)
+ return rightRotate(node: node)
+ }
+ }
+ // 右偏树
+ if balanceFactor < -1 {
+ if self.balanceFactor(node: node?.right) <= 0 {
+ // 左旋
+ return leftRotate(node: node)
+ } else {
+ // 先右旋后左旋
+ node?.right = rightRotate(node: node?.right)
+ return leftRotate(node: node)
+ }
+ }
+ // 平衡树，无需旋转，直接返回
+ return node
+ }
+ ```
+
+=== "Zig"
+
+ ```zig title="avl_tree.zig"
+
+ ```
+
+## 7.4.3. AVL 树常用操作
+
+### 插入结点
+
+「AVL 树」的结点插入操作与「二叉搜索树」主体类似。不同的是，在插入结点后，从该结点到根结点的路径上会出现一系列「失衡结点」。所以，**我们需要从该结点开始，从底至顶地执行旋转操作，使所有失衡结点恢复平衡**。
+
+=== "Java"
+
+ ```java title="avl_tree.java"
+ /* 插入结点 */
+ TreeNode insert(int val) {
+ root = insertHelper(root, val);
+ return root;
+ }
+
+ /* 递归插入结点（辅助函数） */
+ TreeNode insertHelper(TreeNode node, int val) {
+ if (node == null) return new TreeNode(val);
+ /* 1. 查找插入位置，并插入结点 */
+ if (val < node.val)
+ node.left = insertHelper(node.left, val);
+ else if (val > node.val)
+ node.right = insertHelper(node.right, val);
+ else
+ return node; // 重复结点不插入，直接返回
+ updateHeight(node); // 更新结点高度
+ /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+ node = rotate(node);
+ // 返回子树的根节点
+ return node;
+ }
+ ```
+
+=== "C++"
+
+ ```cpp title="avl_tree.cpp"
+ /* 插入结点 */
+ TreeNode* insert(int val) {
+ root = insertHelper(root, val);
+ return root;
+ }
+
+ /* 递归插入结点（辅助函数） */
+ TreeNode* insertHelper(TreeNode* node, int val) {
+ if (node == nullptr) return new TreeNode(val);
+ /* 1. 查找插入位置，并插入结点 */
+ if (val < node->val)
+ node->left = insertHelper(node->left, val);
+ else if (val > node->val)
+ node->right = insertHelper(node->right, val);
+ else
+ return node; // 重复结点不插入，直接返回
+ updateHeight(node); // 更新结点高度
+ /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+ node = rotate(node);
+ // 返回子树的根节点
+ return node;
+ }
+ ```
+
+=== "Python"
+
+ ```python title="avl_tree.py"
+ """ 插入结点 """
+ def insert(self, val) -> TreeNode:
+ self.root = self.__insert_helper(self.root, val)
+ return self.root
+
+ """ 递归插入结点（辅助函数）"""
+ def __insert_helper(self, node: Optional[TreeNode], val: int) -> TreeNode:
+ if node is None:
+ return TreeNode(val)
+ # 1. 查找插入位置，并插入结点
+ if val < node.val:
+ node.left = self.__insert_helper(node.left, val)
+ elif val > node.val:
+ node.right = self.__insert_helper(node.right, val)
+ else:
+ # 重复结点不插入，直接返回
+ return node
+ # 更新结点高度
+ self.__update_height(node)
+ # 2. 执行旋转操作，使该子树重新恢复平衡
+ return self.__rotate(node)
+ ```
+
+=== "Go"
+
+ ```go title="avl_tree.go"
+ /* 插入结点 */
+ func (t *avlTree) insert(val int) *TreeNode {
+ t.root = insertHelper(t.root, val)
+ return t.root
+ }
+ /* 递归插入结点（辅助函数） */
+ func insertHelper(node *TreeNode, val int) *TreeNode {
+ if node == nil {
+ return NewTreeNode(val)
+ }
+ /* 1. 查找插入位置，并插入结点 */
+ if val < node.Val {
+ node.Left = insertHelper(node.Left, val)
+ } else if val > node.Val {
+ node.Right = insertHelper(node.Right, val)
+ } else {
+ // 重复结点不插入，直接返回
+ return node
+ }
+ // 更新结点高度
+ updateHeight(node)
+ /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+ node = rotate(node)
+ // 返回子树的根节点
+ return node
+ }
+ ```
+
+=== "JavaScript"
+
+ ```js title="avl_tree.js"
+ /* 插入结点 */
+ insert(val) {
+ this.root = this.insertHelper(this.root, val);
+ return this.root;
+ }
+
+ /* 递归插入结点（辅助函数） */
+ insertHelper(node, val) {
+ if (node === null) return new TreeNode(val);
+ /* 1. 查找插入位置，并插入结点 */
+ if (val < node.val) node.left = this.insertHelper(node.left, val);
+ else if (val > node.val) node.right = this.insertHelper(node.right, val);
+ else return node; // 重复结点不插入，直接返回
+ this.updateHeight(node); // 更新结点高度
+ /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+ node = this.rotate(node);
+ // 返回子树的根节点
+ return node;
+ }
+ ```
+
+=== "TypeScript"
+
+ ```typescript title="avl_tree.ts"
+
+ ```
+
+=== "C"
+
+ ```c title="avl_tree.c"
+
+
+
+ ```
+
+=== "C#"
+
+ ```csharp title="avl_tree.cs"
+ /* 插入结点 */
+ public TreeNode? insert(int val)
+ {
+ root = insertHelper(root, val);
+ return root;
+ }
+
+ /* 递归插入结点（辅助函数） */
+ private TreeNode? insertHelper(TreeNode? node, int val)
+ {
+ if (node == null) return new TreeNode(val);
+ /* 1. 查找插入位置，并插入结点 */
+ if (val < node.val)
+ node.left = insertHelper(node.left, val);
+ else if (val > node.val)
+ node.right = insertHelper(node.right, val);
+ else
+ return node; // 重复结点不插入，直接返回
+ updateHeight(node); // 更新结点高度
+ /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+ node = rotate(node);
+ // 返回子树的根节点
+ return node;
+ }
+ ```
+
+=== "Swift"
+
+ ```swift title="avl_tree.swift"
+ /* 插入结点 */
+ @discardableResult
+ func insert(val: Int) -> TreeNode? {
+ root = insertHelper(node: root, val: val)
+ return root
+ }
+
+ /* 递归插入结点（辅助函数） */
+ func insertHelper(node: TreeNode?, val: Int) -> TreeNode? {
+ var node = node
+ if node == nil {
+ return TreeNode(x: val)
+ }
+ /* 1. 查找插入位置，并插入结点 */
+ if val < node!.val {
+ node?.left = insertHelper(node: node?.left, val: val)
+ } else if val > node!.val {
+ node?.right = insertHelper(node: node?.right, val: val)
+ } else {
+ return node // 重复结点不插入，直接返回
+ }
+ updateHeight(node: node) // 更新结点高度
+ /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+ node = rotate(node: node)
+ // 返回子树的根节点
+ return node
+ }
+ ```
+
+=== "Zig"
+
+ ```zig title="avl_tree.zig"
+
+ ```
+
+### 删除结点
+
+「AVL 树」删除结点操作与「二叉搜索树」删除结点操作总体相同。类似地，**在删除结点后，也需要从底至顶地执行旋转操作，使所有失衡结点恢复平衡**。
+
+=== "Java"
+
+ ```java title="avl_tree.java"
+ /* 删除结点 */
+ TreeNode remove(int val) {
+ root = removeHelper(root, val);
+ return root;
+ }
+
+ /* 递归删除结点（辅助函数） */
+ TreeNode removeHelper(TreeNode node, int val) {
+ if (node == null) return null;
+ /* 1. 查找结点，并删除之 */
+ if (val < node.val)
+ node.left = removeHelper(node.left, val);
+ else if (val > node.val)
+ node.right = removeHelper(node.right, val);
+ else {
+ if (node.left == null || node.right == null) {
+ TreeNode child = node.left != null ? node.left : node.right;
+ // 子结点数量 = 0 ，直接删除 node 并返回
+ if (child == null)
+ return null;
+ // 子结点数量 = 1 ，直接删除 node
+ else
+ node = child;
+ } else {
+ // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+ TreeNode temp = getInOrderNext(node.right);
+ node.right = removeHelper(node.right, temp.val);
+ node.val = temp.val;
+ }
+ }
+ updateHeight(node); // 更新结点高度
+ /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+ node = rotate(node);
+ // 返回子树的根节点
+ return node;
+ }
+ ```
+
+=== "C++"
+
+ ```cpp title="avl_tree.cpp"
+ /* 删除结点 */
+ TreeNode* remove(int val) {
+ root = removeHelper(root, val);
+ return root;
+ }
+
+ /* 递归删除结点（辅助函数） */
+ TreeNode* removeHelper(TreeNode* node, int val) {
+ if (node == nullptr) return nullptr;
+ /* 1. 查找结点，并删除之 */
+ if (val < node->val)
+ node->left = removeHelper(node->left, val);
+ else if (val > node->val)
+ node->right = removeHelper(node->right, val);
+ else {
+ if (node->left == nullptr || node->right == nullptr) {
+ TreeNode* child = node->left != nullptr ? node->left : node->right;
+ // 子结点数量 = 0 ，直接删除 node 并返回
+ if (child == nullptr) {
+ delete node;
+ return nullptr;
+ }
+ // 子结点数量 = 1 ，直接删除 node
+ else {
+ delete node;
+ node = child;
+ }
+ } else {
+ // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+ TreeNode* temp = getInOrderNext(node->right);
+ node->right = removeHelper(node->right, temp->val);
+ node->val = temp->val;
+ }
+ }
+ updateHeight(node); // 更新结点高度
+ /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+ node = rotate(node);
+ // 返回子树的根节点
+ return node;
+ }
+ ```
+
+=== "Python"
+
+ ```python title="avl_tree.py"
+ """ 删除结点 """
+ def remove(self, val: int):
+ root = self.__remove_helper(self.root, val)
+ return root
+
+ """ 递归删除结点（辅助函数） """
+ def __remove_helper(self, node: Optional[TreeNode], val: int) -> Optional[TreeNode]:
+ if node is None:
+ return None
+ # 1. 查找结点，并删除之
+ if val < node.val:
+ node.left = self.__remove_helper(node.left, val)
+ elif val > node.val:
+ node.right = self.__remove_helper(node.right, val)
+ else:
+ if node.left is None or node.right is None:
+ child = node.left or node.right
+ # 子结点数量 = 0 ，直接删除 node 并返回
+ if child is None:
+ return None
+ # 子结点数量 = 1 ，直接删除 node
+ else:
+ node = child
+ else: # 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+ temp = self.__get_inorder_next(node.right)
+ node.right = self.__remove_helper(node.right, temp.val)
+ node.val = temp.val
+ # 更新结点高度
+ self.__update_height(node)
+ # 2. 执行旋转操作，使该子树重新恢复平衡
+ return self.__rotate(node)
+ ```
+
+=== "Go"
+
+ ```go title="avl_tree.go"
+ /* 删除结点 */
+ func (t *avlTree) remove(val int) *TreeNode {
+ root := removeHelper(t.root, val)
+ return root
+ }
+
+ /* 递归删除结点（辅助函数） */
+ func removeHelper(node *TreeNode, val int) *TreeNode {
+ if node == nil {
+ return nil
+ }
+ /* 1. 查找结点，并删除之 */
+ if val < node.Val {
+ node.Left = removeHelper(node.Left, val)
+ } else if val > node.Val {
+ node.Right = removeHelper(node.Right, val)
+ } else {
+ if node.Left == nil || node.Right == nil {
+ child := node.Left
+ if node.Right != nil {
+ child = node.Right
+ }
+ // 子结点数量 = 0 ，直接删除 node 并返回
+ if child == nil {
+ return nil
+ } else {
+ // 子结点数量 = 1 ，直接删除 node
+ node = child
+ }
+ } else {
+ // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+ temp := getInOrderNext(node.Right)
+ node.Right = removeHelper(node.Right, temp.Val)
+ node.Val = temp.Val
+ }
+ }
+ // 更新结点高度
+ updateHeight(node)
+ /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+ node = rotate(node)
+ // 返回子树的根节点
+ return node
+ }
+ ```
+
+=== "JavaScript"
+
+ ```js title="avl_tree.js"
+ /* 删除结点 */
+ remove(val) {
+ this.root = this.removeHelper(this.root, val);
+ return this.root;
+ }
+
+ /* 递归删除结点（辅助函数） */
+ removeHelper(node, val) {
+ if (node === null) return null;
+ /* 1. 查找结点，并删除之 */
+ if (val < node.val) node.left = this.removeHelper(node.left, val);
+ else if (val > node.val) node.right = this.removeHelper(node.right, val);
+ else {
+ if (node.left === null || node.right === null) {
+ let child = node.left !== null ? node.left : node.right;
+ // 子结点数量 = 0 ，直接删除 node 并返回
+ if (child === null) return null;
+ // 子结点数量 = 1 ，直接删除 node
+ else node = child;
+ } else {
+ // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+ let temp = this.getInOrderNext(node.right);
+ node.right = this.removeHelper(node.right, temp.val);
+ node.val = temp.val;
+ }
+ }
+ this.updateHeight(node); // 更新结点高度
+ /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+ node = this.rotate(node);
+ // 返回子树的根节点
+ return node;
+ }
+ ```
+
+=== "TypeScript"
+
+ ```typescript title="avl_tree.ts"
+
+ ```
+
+=== "C"
+
+ ```c title="avl_tree.c"
+
+ ```
+
+=== "C#"
+
+ ```csharp title="avl_tree.cs"
+ /* 删除结点 */
+ public TreeNode? remove(int val)
+ {
+ root = removeHelper(root, val);
+ return root;
+ }
+
+ /* 递归删除结点（辅助函数） */
+ private TreeNode? removeHelper(TreeNode? node, int val)
+ {
+ if (node == null) return null;
+ /* 1. 查找结点，并删除之 */
+ if (val < node.val)
+ node.left = removeHelper(node.left, val);
+ else if (val > node.val)
+ node.right = removeHelper(node.right, val);
+ else
+ {
+ if (node.left == null || node.right == null)
+ {
+ TreeNode? child = node.left != null ? node.left : node.right;
+ // 子结点数量 = 0 ，直接删除 node 并返回
+ if (child == null)
+ return null;
+ // 子结点数量 = 1 ，直接删除 node
+ else
+ node = child;
+ }
+ else
+ {
+ // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+ TreeNode? temp = getInOrderNext(node.right);
+ node.right = removeHelper(node.right, temp.val);
+ node.val = temp.val;
+ }
+ }
+ updateHeight(node); // 更新结点高度
+ /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+ node = rotate(node);
+ // 返回子树的根节点
+ return node;
+ }
+ ```
+
+=== "Swift"
+
+ ```swift title="avl_tree.swift"
+ /* 删除结点 */
+ @discardableResult
+ func remove(val: Int) -> TreeNode? {
+ root = removeHelper(node: root, val: val)
+ return root
+ }
+
+ /* 递归删除结点（辅助函数） */
+ func removeHelper(node: TreeNode?, val: Int) -> TreeNode? {
+ var node = node
+ if node == nil {
+ return nil
+ }
+ /* 1. 查找结点，并删除之 */
+ if val < node!.val {
+ node?.left = removeHelper(node: node?.left, val: val)
+ } else if val > node!.val {
+ node?.right = removeHelper(node: node?.right, val: val)
+ } else {
+ if node?.left == nil || node?.right == nil {
+ let child = node?.left != nil ? node?.left : node?.right
+ // 子结点数量 = 0 ，直接删除 node 并返回
+ if child == nil {
+ return nil
+ }
+ // 子结点数量 = 1 ，直接删除 node
+ else {
+ node = child
+ }
+ } else {
+ // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+ let temp = getInOrderNext(node: node?.right)
+ node?.right = removeHelper(node: node?.right, val: temp!.val)
+ node?.val = temp!.val
+ }
+ }
+ updateHeight(node: node) // 更新结点高度
+ /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+ node = rotate(node: node)
+ // 返回子树的根节点
+ return node
+ }
+ ```
+
+=== "Zig"
+
+ ```zig title="avl_tree.zig"
+
+ ```
+
+### 查找结点
+
+「AVL 树」的结点查找操作与「二叉搜索树」一致，在此不再赘述。
+
+## 7.4.4. AVL 树典型应用
+
+- 组织存储大型数据，适用于高频查找、低频增删场景；
+- 用于建立数据库中的索引系统；
+
+!!! question "为什么红黑树比 AVL 树更受欢迎？"
+
+ 红黑树的平衡条件相对宽松，因此在红黑树中插入与删除结点所需的旋转操作相对更少，结点增删操作相比 AVL 树的效率更高。
diff --git a/build/chapter_tree/binary_search_tree.md b/build/chapter_tree/binary_search_tree.md
new file mode 100755
index 000000000..df69cecc2
--- /dev/null
+++ b/build/chapter_tree/binary_search_tree.md
@@ -0,0 +1,1083 @@
+---
+comments: true
+---
+
+# 7.3. 二叉搜索树
+
+「二叉搜索树 Binary Search Tree」满足以下条件：
+
+1. 对于根结点，左子树中所有结点的值 $<$ 根结点的值 $<$ 右子树中所有结点的值；
+2. 任意结点的左子树和右子树也是二叉搜索树，即也满足条件 `1.` ；
+
+
+
+## 7.3.1. 二叉搜索树的操作
+
+### 查找结点
+
+给定目标结点值 `num` ，可以根据二叉搜索树的性质来查找。我们声明一个结点 `cur` ，从二叉树的根结点 `root` 出发，循环比较结点值 `cur.val` 和 `num` 之间的大小关系
+
+- 若 `cur.val < num` ，说明目标结点在 `cur` 的右子树中，因此执行 `cur = cur.right` ；
+- 若 `cur.val > num` ，说明目标结点在 `cur` 的左子树中，因此执行 `cur = cur.left` ；
+- 若 `cur.val = num` ，说明找到目标结点，跳出循环并返回该结点即可；
+
+=== "Step 1"
+ 
+
+=== "Step 2"
+ 
+
+=== "Step 3"
+ 
+
+=== "Step 4"
+ 
+
+二叉搜索树的查找操作和二分查找算法如出一辙，也是在每轮排除一半情况。循环次数最多为二叉树的高度，当二叉树平衡时，使用 $O(\log n)$ 时间。
+
+=== "Java"
+
+ ```java title="binary_search_tree.java"
+ /* 查找结点 */
+ 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;
+ }
+ ```
+
+=== "C++"
+
+ ```cpp title="binary_search_tree.cpp"
+ /* 查找结点 */
+ TreeNode* search(int num) {
+ TreeNode* cur = root;
+ // 循环查找，越过叶结点后跳出
+ while (cur != nullptr) {
+ // 目标结点在 cur 的右子树中
+ if (cur->val < num) cur = cur->right;
+ // 目标结点在 cur 的左子树中
+ else if (cur->val > num) cur = cur->left;
+ // 找到目标结点，跳出循环
+ else break;
+ }
+ // 返回目标结点
+ return cur;
+ }
+ ```
+
+=== "Python"
+
+ ```python title="binary_search_tree.py"
+ """ 查找结点 """
+ def search(self, num: int) -> Optional[TreeNode]:
+ cur = self.root
+ # 循环查找，越过叶结点后跳出
+ while cur is not None:
+ # 目标结点在 cur 的右子树中
+ if cur.val < num:
+ cur = cur.right
+ # 目标结点在 cur 的左子树中
+ elif cur.val > num:
+ cur = cur.left
+ # 找到目标结点，跳出循环
+ else:
+ break
+ return cur
+ ```
+
+=== "Go"
+
+ ```go title="binary_search_tree.go"
+ /* 查找结点 */
+ func (bst *binarySearchTree) search(num int) *TreeNode {
+ node := bst.root
+ // 循环查找，越过叶结点后跳出
+ for node != nil {
+ if node.Val < num {
+ // 目标结点在 cur 的右子树中
+ node = node.Right
+ } else if node.Val > num {
+ // 目标结点在 cur 的左子树中
+ node = node.Left
+ } else {
+ // 找到目标结点，跳出循环
+ break
+ }
+ }
+ // 返回目标结点
+ return node
+ }
+ ```
+
+=== "JavaScript"
+
+ ```js title="binary_search_tree.js"
+ /* 查找结点 */
+ function search(num) {
+ let 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;
+ }
+ ```
+
+=== "TypeScript"
+
+ ```typescript title="binary_search_tree.ts"
+ /* 查找结点 */
+ function search(num: number): TreeNode | null {
+ let cur = root;
+ // 循环查找，越过叶结点后跳出
+ while (cur !== null) {
+ if (cur.val < num) {
+ cur = cur.right; // 目标结点在 cur 的右子树中
+ } else if (cur.val > num) {
+ cur = cur.left; // 目标结点在 cur 的左子树中
+ } else {
+ break; // 找到目标结点，跳出循环
+ }
+ }
+ // 返回目标结点
+ return cur;
+ }
+ ```
+
+=== "C"
+
+ ```c title="binary_search_tree.c"
+
+ ```
+
+=== "C#"
+
+ ```csharp title="binary_search_tree.cs"
+ /* 查找结点 */
+ 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;
+ }
+ ```
+
+=== "Swift"
+
+ ```swift title="binary_search_tree.swift"
+ /* 查找结点 */
+ func search(num: Int) -> TreeNode? {
+ var cur = root
+ // 循环查找，越过叶结点后跳出
+ while cur != nil {
+ // 目标结点在 cur 的右子树中
+ if cur!.val < num {
+ cur = cur?.right
+ }
+ // 目标结点在 cur 的左子树中
+ else if cur!.val > num {
+ cur = cur?.left
+ }
+ // 找到目标结点，跳出循环
+ else {
+ break
+ }
+ }
+ // 返回目标结点
+ return cur
+ }
+ ```
+
+=== "Zig"
+
+ ```zig title="binary_search_tree.zig"
+
+ ```
+
+### 插入结点
+
+给定一个待插入元素 `num` ，为了保持二叉搜索树“左子树 < 根结点 < 右子树”的性质，插入操作分为两步：
+
+1. **查找插入位置**：与查找操作类似，我们从根结点出发，根据当前结点值和 `num` 的大小关系循环向下搜索，直到越过叶结点（遍历到 $\text{null}$ ）时跳出循环；
+2. **在该位置插入结点**：初始化结点 `num` ，将该结点放到 $\text{null}$ 的位置 ；
+
+二叉搜索树不允许存在重复结点，否则将会违背其定义。因此若待插入结点在树中已经存在，则不执行插入，直接返回即可。
+
+
+
+=== "Java"
+
+ ```java title="binary_search_tree.java"
+ /* 插入结点 */
+ TreeNode insert(int num) {
+ // 若树为空，直接提前返回
+ if (root == null) return null;
+ TreeNode cur = root, pre = null;
+ // 循环查找，越过叶结点后跳出
+ while (cur != null) {
+ // 找到重复结点，直接返回
+ if (cur.val == num) return null;
+ pre = cur;
+ // 插入位置在 cur 的右子树中
+ if (cur.val < num) cur = cur.right;
+ // 插入位置在 cur 的左子树中
+ else cur = cur.left;
+ }
+ // 插入结点 val
+ TreeNode node = new TreeNode(num);
+ if (pre.val < num) pre.right = node;
+ else pre.left = node;
+ return node;
+ }
+ ```
+
+=== "C++"
+
+ ```cpp title="binary_search_tree.cpp"
+ /* 插入结点 */
+ TreeNode* insert(int num) {
+ // 若树为空，直接提前返回
+ if (root == nullptr) return nullptr;
+ TreeNode *cur = root, *pre = nullptr;
+ // 循环查找，越过叶结点后跳出
+ while (cur != nullptr) {
+ // 找到重复结点，直接返回
+ if (cur->val == num) return nullptr;
+ pre = cur;
+ // 插入位置在 cur 的右子树中
+ if (cur->val < num) cur = cur->right;
+ // 插入位置在 cur 的左子树中
+ else cur = cur->left;
+ }
+ // 插入结点 val
+ TreeNode* node = new TreeNode(num);
+ if (pre->val < num) pre->right = node;
+ else pre->left = node;
+ return node;
+ }
+ ```
+
+=== "Python"
+
+ ```python title="binary_search_tree.py"
+ """ 插入结点 """
+ def insert(self, num: int) -> Optional[TreeNode]:
+ root = self.root
+ # 若树为空，直接提前返回
+ if root is None:
+ return None
+
+ # 循环查找，越过叶结点后跳出
+ cur, pre = root, None
+ while cur is not None:
+ # 找到重复结点，直接返回
+ if cur.val == num:
+ return None
+ pre = cur
+ # 插入位置在 cur 的右子树中
+ if cur.val < num:
+ cur = cur.right
+ # 插入位置在 cur 的左子树中
+ else:
+ cur = cur.left
+
+ # 插入结点 val
+ node = TreeNode(num)
+ if pre.val < num:
+ pre.right = node
+ else:
+ pre.left = node
+ return node
+ ```
+
+=== "Go"
+
+ ```go title="binary_search_tree.go"
+ /* 插入结点 */
+ func (bst *binarySearchTree) insert(num int) *TreeNode {
+ cur := bst.root
+ // 若树为空，直接提前返回
+ if cur == nil {
+ return nil
+ }
+ // 待插入结点之前的结点位置
+ var pre *TreeNode = nil
+ // 循环查找，越过叶结点后跳出
+ for cur != nil {
+ if cur.Val == num {
+ return nil
+ }
+ pre = cur
+ if cur.Val < num {
+ cur = cur.Right
+ } else {
+ cur = cur.Left
+ }
+ }
+ // 插入结点
+ node := NewTreeNode(num)
+ if pre.Val < num {
+ pre.Right = node
+ } else {
+ pre.Left = node
+ }
+ return cur
+ }
+ ```
+
+=== "JavaScript"
+
+ ```js title="binary_search_tree.js"
+ /* 插入结点 */
+ function insert(num) {
+ // 若树为空，直接提前返回
+ if (root === null) return null;
+ let cur = root, pre = null;
+ // 循环查找，越过叶结点后跳出
+ while (cur !== null) {
+ // 找到重复结点，直接返回
+ if (cur.val === num) return null;
+ pre = cur;
+ // 插入位置在 cur 的右子树中
+ if (cur.val < num) cur = cur.right;
+ // 插入位置在 cur 的左子树中
+ else cur = cur.left;
+ }
+ // 插入结点 val
+ let node = new Tree.TreeNode(num);
+ if (pre.val < num) pre.right = node;
+ else pre.left = node;
+ return node;
+ }
+ ```
+
+=== "TypeScript"
+
+ ```typescript title="binary_search_tree.ts"
+ /* 插入结点 */
+ function insert(num: number): TreeNode | null {
+ // 若树为空，直接提前返回
+ if (root === null) {
+ return null;
+ }
+ let cur = root,
+ pre: TreeNode | null = null;
+ // 循环查找，越过叶结点后跳出
+ while (cur !== null) {
+ if (cur.val === num) {
+ return null; // 找到重复结点，直接返回
+ }
+ pre = cur;
+ if (cur.val < num) {
+ cur = cur.right as TreeNode; // 插入位置在 cur 的右子树中
+ } else {
+ cur = cur.left as TreeNode; // 插入位置在 cur 的左子树中
+ }
+ }
+ // 插入结点 val
+ let node = new TreeNode(num);
+ if (pre!.val < num) {
+ pre!.right = node;
+ } else {
+ pre!.left = node;
+ }
+ return node;
+ }
+ ```
+
+=== "C"
+
+ ```c title="binary_search_tree.c"
+
+ ```
+
+=== "C#"
+
+ ```csharp title="binary_search_tree.cs"
+ /* 插入结点 */
+ TreeNode? insert(int num)
+ {
+ // 若树为空，直接提前返回
+ if (root == null) return null;
+ TreeNode? cur = root, pre = null;
+ // 循环查找，越过叶结点后跳出
+ while (cur != null)
+ {
+ // 找到重复结点，直接返回
+ if (cur.val == num) return null;
+ pre = cur;
+ // 插入位置在 cur 的右子树中
+ if (cur.val < num) cur = cur.right;
+ // 插入位置在 cur 的左子树中
+ else cur = cur.left;
+ }
+
+ // 插入结点 val
+ TreeNode node = new TreeNode(num);
+ if (pre != null)
+ {
+ if (pre.val < num) pre.right = node;
+ else pre.left = node;
+ }
+ return node;
+ }
+ ```
+
+=== "Swift"
+
+ ```swift title="binary_search_tree.swift"
+ /* 插入结点 */
+ func insert(num: Int) -> TreeNode? {
+ // 若树为空，直接提前返回
+ if root == nil {
+ return nil
+ }
+ var cur = root
+ var pre: TreeNode?
+ // 循环查找，越过叶结点后跳出
+ while cur != nil {
+ // 找到重复结点，直接返回
+ if cur!.val == num {
+ return nil
+ }
+ pre = cur
+ // 插入位置在 cur 的右子树中
+ if cur!.val < num {
+ cur = cur?.right
+ }
+ // 插入位置在 cur 的左子树中
+ else {
+ cur = cur?.left
+ }
+ }
+ // 插入结点 val
+ let node = TreeNode(x: num)
+ if pre!.val < num {
+ pre?.right = node
+ } else {
+ pre?.left = node
+ }
+ return node
+ }
+ ```
+
+=== "Zig"
+
+ ```zig title="binary_search_tree.zig"
+
+ ```
+
+为了插入结点，需要借助 **辅助结点 `pre`** 保存上一轮循环的结点，这样在遍历到 $\text{null}$ 时，我们也可以获取到其父结点，从而完成结点插入操作。
+
+与查找结点相同，插入结点使用 $O(\log n)$ 时间。
+
+### 删除结点
+
+与插入结点一样，我们需要在删除操作后维持二叉搜索树的“左子树 < 根结点 < 右子树”的性质。首先，我们需要在二叉树中执行查找操作，获取待删除结点。接下来，根据待删除结点的子结点数量，删除操作需要分为三种情况：
+
+**当待删除结点的子结点数量 $= 0$ 时**，表明待删除结点是叶结点，直接删除即可。
+
+
+
+**当待删除结点的子结点数量 $= 1$ 时**，将待删除结点替换为其子结点即可。
+
+
+
+**当待删除结点的子结点数量 $= 2$ 时**，删除操作分为三步：
+
+1. 找到待删除结点在 **中序遍历序列** 中的下一个结点，记为 `nex` ；
+2. 在树中递归删除结点 `nex` ；
+3. 使用 `nex` 替换待删除结点；
+
+=== "Step 1"
+ 
+
+=== "Step 2"
+ 
+
+=== "Step 3"
+ 
+
+=== "Step 4"
+ 
+
+删除结点操作也使用 $O(\log n)$ 时间，其中查找待删除结点 $O(\log n)$ ，获取中序遍历后继结点 $O(\log n)$ 。
+
+=== "Java"
+
+ ```java title="binary_search_tree.java"
+ /* 删除结点 */
+ TreeNode remove(int num) {
+ // 若树为空，直接提前返回
+ if (root == null) return null;
+ TreeNode cur = root, 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 null;
+ // 子结点数量 = 0 or 1
+ if (cur.left == null || cur.right == null) {
+ // 当子结点数量 = 0 / 1 时， child = null / 该子结点
+ TreeNode child = cur.left != null ? cur.left : cur.right;
+ // 删除结点 cur
+ if (pre.left == cur) pre.left = child;
+ else pre.right = child;
+ // 释放内存
+ delete cur;
+ }
+ // 子结点数量 = 2
+ else {
+ // 获取中序遍历中 cur 的下一个结点
+ TreeNode nex = getInOrderNext(cur.right);
+ int tmp = nex.val;
+ // 递归删除结点 nex
+ remove(nex.val);
+ // 将 nex 的值复制给 cur
+ cur.val = tmp;
+ }
+ return cur;
+ }
+
+ /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+ public TreeNode getInOrderNext(TreeNode root) {
+ if (root == null) return root;
+ // 循环访问左子结点，直到叶结点时为最小结点，跳出
+ while (root.left != null) {
+ root = root.left;
+ }
+ return root;
+ }
+ ```
+
+=== "C++"
+
+ ```cpp title="binary_search_tree.cpp"
+ /* 删除结点 */
+ TreeNode* remove(int num) {
+ // 若树为空，直接提前返回
+ if (root == nullptr) return nullptr;
+ TreeNode *cur = root, *pre = nullptr;
+ // 循环查找，越过叶结点后跳出
+ while (cur != nullptr) {
+ // 找到待删除结点，跳出循环
+ if (cur->val == num) break;
+ pre = cur;
+ // 待删除结点在 cur 的右子树中
+ if (cur->val < num) cur = cur->right;
+ // 待删除结点在 cur 的左子树中
+ else cur = cur->left;
+ }
+ // 若无待删除结点，则直接返回
+ if (cur == nullptr) return nullptr;
+ // 子结点数量 = 0 or 1
+ if (cur->left == nullptr || cur->right == nullptr) {
+ // 当子结点数量 = 0 / 1 时， child = nullptr / 该子结点
+ TreeNode* child = cur->left != nullptr ? cur->left : cur->right;
+ // 删除结点 cur
+ if (pre->left == cur) pre->left = child;
+ else pre->right = child;
+ }
+ // 子结点数量 = 2
+ else {
+ // 获取中序遍历中 cur 的下一个结点
+ TreeNode* nex = getInOrderNext(cur->right);
+ int tmp = nex->val;
+ // 递归删除结点 nex
+ remove(nex->val);
+ // 将 nex 的值复制给 cur
+ cur->val = tmp;
+ }
+ return cur;
+ }
+
+ /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+ TreeNode* getInOrderNext(TreeNode* root) {
+ if (root == nullptr) return root;
+ // 循环访问左子结点，直到叶结点时为最小结点，跳出
+ while (root->left != nullptr) {
+ root = root->left;
+ }
+ return root;
+ }
+ ```
+
+=== "Python"
+
+ ```python title="binary_search_tree.py"
+ """ 删除结点 """
+ def remove(self, num: int) -> Optional[TreeNode]:
+ root = self.root
+ # 若树为空，直接提前返回
+ if root is None:
+ return None
+
+ # 循环查找，越过叶结点后跳出
+ cur, pre = root, None
+ while cur is not None:
+ # 找到待删除结点，跳出循环
+ if cur.val == num:
+ break
+ pre = cur
+ if cur.val < num: # 待删除结点在 cur 的右子树中
+ cur = cur.right
+ else: # 待删除结点在 cur 的左子树中
+ cur = cur.left
+ # 若无待删除结点，则直接返回
+ if cur is None:
+ return None
+
+ # 子结点数量 = 0 or 1
+ if cur.left is None or cur.right is None:
+ # 当子结点数量 = 0 / 1 时， child = null / 该子结点
+ child = cur.left or cur.right
+ # 删除结点 cur
+ if pre.left == cur:
+ pre.left = child
+ else:
+ pre.right = child
+ # 子结点数量 = 2
+ else:
+ # 获取中序遍历中 cur 的下一个结点
+ nex = self.get_inorder_next(cur.right)
+ tmp = nex.val
+ # 递归删除结点 nex
+ self.remove(nex.val)
+ # 将 nex 的值复制给 cur
+ cur.val = tmp
+ return cur
+
+ """ 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） """
+ def get_inorder_next(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+ if root is None:
+ return root
+ # 循环访问左子结点，直到叶结点时为最小结点，跳出
+ while root.left is not None:
+ root = root.left
+ return root
+ ```
+
+=== "Go"
+
+ ```go title="binary_search_tree.go"
+ /* 删除结点 */
+ func (bst *binarySearchTree) remove(num int) *TreeNode {
+ cur := bst.root
+ // 若树为空，直接提前返回
+ if cur == nil {
+ return nil
+ }
+ // 待删除结点之前的结点位置
+ var pre *TreeNode = nil
+ // 循环查找，越过叶结点后跳出
+ for cur != nil {
+ if cur.Val == num {
+ break
+ }
+ pre = cur
+ if cur.Val < num {
+ // 待删除结点在右子树中
+ cur = cur.Right
+ } else {
+ // 待删除结点在左子树中
+ cur = cur.Left
+ }
+ }
+ // 若无待删除结点，则直接返回
+ if cur == nil {
+ return nil
+ }
+ // 子结点数为 0 或 1
+ if cur.Left == nil || cur.Right == nil {
+ var child *TreeNode = nil
+ // 取出待删除结点的子结点
+ if cur.Left != nil {
+ child = cur.Left
+ } else {
+ child = cur.Right
+ }
+ // 将子结点替换为待删除结点
+ if pre.Left == cur {
+ pre.Left = child
+ } else {
+ pre.Right = child
+ }
+ // 子结点数为 2
+ } else {
+ // 获取中序遍历中待删除结点 cur 的下一个结点
+ next := bst.getInOrderNext(cur)
+ temp := next.Val
+ // 递归删除结点 next
+ bst.remove(next.Val)
+ // 将 next 的值复制给 cur
+ cur.Val = temp
+ }
+ return cur
+ }
+
+ /* 获取中序遍历的下一个结点（仅适用于 root 有左子结点的情况） */
+ func (bst *binarySearchTree) getInOrderNext(node *TreeNode) *TreeNode {
+ if node == nil {
+ return node
+ }
+ // 循环访问左子结点，直到叶结点时为最小结点，跳出
+ for node.Left != nil {
+ node = node.Left
+ }
+ return node
+ }
+ ```
+
+=== "JavaScript"
+
+ ```js title="binary_search_tree.js"
+ /* 删除结点 */
+ function remove(num) {
+ // 若树为空，直接提前返回
+ if (root === null) return null;
+ let cur = root, 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 null;
+ // 子结点数量 = 0 or 1
+ if (cur.left === null || cur.right === null) {
+ // 当子结点数量 = 0 / 1 时， child = null / 该子结点
+ let child = cur.left !== null ? cur.left : cur.right;
+ // 删除结点 cur
+ if (pre.left === cur) pre.left = child;
+ else pre.right = child;
+ }
+ // 子结点数量 = 2
+ else {
+ // 获取中序遍历中 cur 的下一个结点
+ let nex = getInOrderNext(cur.right);
+ let tmp = nex.val;
+ // 递归删除结点 nex
+ remove(nex.val);
+ // 将 nex 的值复制给 cur
+ cur.val = tmp;
+ }
+ return cur;
+ }
+
+ /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+ function getInOrderNext(root) {
+ if (root === null) return root;
+ // 循环访问左子结点，直到叶结点时为最小结点，跳出
+ while (root.left !== null) {
+ root = root.left;
+ }
+ return root;
+ }
+ ```
+
+=== "TypeScript"
+
+ ```typescript title="binary_search_tree.ts"
+ /* 删除结点 */
+ function remove(num: number): TreeNode | null {
+ // 若树为空，直接提前返回
+ if (root === null) {
+ return null;
+ }
+ let cur = root,
+ pre: TreeNode | null = null;
+ // 循环查找，越过叶结点后跳出
+ while (cur !== null) {
+ // 找到待删除结点，跳出循环
+ if (cur.val === num) {
+ break;
+ }
+ pre = cur;
+ if (cur.val < num) {
+ cur = cur.right as TreeNode; // 待删除结点在 cur 的右子树中
+ } else {
+ cur = cur.left as TreeNode; // 待删除结点在 cur 的左子树中
+ }
+ }
+ // 若无待删除结点，则直接返回
+ if (cur === null) {
+ return null;
+ }
+ // 子结点数量 = 0 or 1
+ if (cur.left === null || cur.right === null) {
+ // 当子结点数量 = 0 / 1 时， child = null / 该子结点
+ let child = cur.left !== null ? cur.left : cur.right;
+ // 删除结点 cur
+ if (pre!.left === cur) {
+ pre!.left = child;
+ } else {
+ pre!.right = child;
+ }
+ }
+ // 子结点数量 = 2
+ else {
+ // 获取中序遍历中 cur 的下一个结点
+ let next = getInOrderNext(cur.right);
+ let tmp = next!.val;
+ // 递归删除结点 nex
+ remove(next!.val);
+ // 将 nex 的值复制给 cur
+ cur.val = tmp;
+ }
+ return cur;
+ }
+
+ /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+ function getInOrderNext(root: TreeNode | null): TreeNode | null {
+ if (root === null) {
+ return null;
+ }
+ // 循环访问左子结点，直到叶结点时为最小结点，跳出
+ while (root.left !== null) {
+ root = root.left;
+ }
+ return root;
+ }
+ ```
+
+=== "C"
+
+ ```c title="binary_search_tree.c"
+
+ ```
+
+=== "C#"
+
+ ```csharp title="binary_search_tree.cs"
+ /* 删除结点 */
+ TreeNode? remove(int num)
+ {
+ // 若树为空，直接提前返回
+ if (root == null) return null;
+ TreeNode? cur = root, 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 || pre == null) return null;
+ // 子结点数量 = 0 or 1
+ if (cur.left == null || cur.right == null)
+ {
+ // 当子结点数量 = 0 / 1 时， child = null / 该子结点
+ TreeNode? child = cur.left != null ? cur.left : cur.right;
+ // 删除结点 cur
+ if (pre.left == cur)
+ {
+ pre.left = child;
+ }
+ else
+ {
+ pre.right = child;
+ }
+ }
+ // 子结点数量 = 2
+ else
+ {
+ // 获取中序遍历中 cur 的下一个结点
+ TreeNode? nex = getInOrderNext(cur.right);
+ if (nex != null)
+ {
+ int tmp = nex.val;
+ // 递归删除结点 nex
+ remove(nex.val);
+ // 将 nex 的值复制给 cur
+ cur.val = tmp;
+ }
+ }
+ return cur;
+ }
+
+ /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+ private TreeNode? getInOrderNext(TreeNode? root)
+ {
+ if (root == null) return root;
+ // 循环访问左子结点，直到叶结点时为最小结点，跳出
+ while (root.left != null)
+ {
+ root = root.left;
+ }
+ return root;
+ }
+ ```
+
+=== "Swift"
+
+ ```swift title="binary_search_tree.swift"
+ /* 删除结点 */
+ @discardableResult
+ func remove(num: Int) -> TreeNode? {
+ // 若树为空，直接提前返回
+ if root == nil {
+ return nil
+ }
+ var cur = root
+ var pre: TreeNode?
+ // 循环查找，越过叶结点后跳出
+ while cur != nil {
+ // 找到待删除结点，跳出循环
+ if cur!.val == num {
+ break
+ }
+ pre = cur
+ // 待删除结点在 cur 的右子树中
+ if cur!.val < num {
+ cur = cur?.right
+ }
+ // 待删除结点在 cur 的左子树中
+ else {
+ cur = cur?.left
+ }
+ }
+ // 若无待删除结点，则直接返回
+ if cur == nil {
+ return nil
+ }
+ // 子结点数量 = 0 or 1
+ if cur?.left == nil || cur?.right == nil {
+ // 当子结点数量 = 0 / 1 时， child = null / 该子结点
+ let child = cur?.left != nil ? cur?.left : cur?.right
+ // 删除结点 cur
+ if pre?.left === cur {
+ pre?.left = child
+ } else {
+ pre?.right = child
+ }
+ }
+ // 子结点数量 = 2
+ else {
+ // 获取中序遍历中 cur 的下一个结点
+ let nex = getInOrderNext(root: cur?.right)
+ let tmp = nex!.val
+ // 递归删除结点 nex
+ remove(num: nex!.val)
+ // 将 nex 的值复制给 cur
+ cur?.val = tmp
+ }
+ return cur
+ }
+
+ /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+ func getInOrderNext(root: TreeNode?) -> TreeNode? {
+ var root = root
+ if root == nil {
+ return root
+ }
+ // 循环访问左子结点，直到叶结点时为最小结点，跳出
+ while root?.left != nil {
+ root = root?.left
+ }
+ return root
+ }
+ ```
+
+=== "Zig"
+
+ ```zig title="binary_search_tree.zig"
+
+ ```
+
+### 排序
+
+我们知道，「中序遍历」遵循“左 $\rightarrow$ 根 $\rightarrow$ 右”的遍历优先级，而二叉搜索树遵循“左子结点 $<$ 根结点 $<$ 右子结点”的大小关系。因此，在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小结点，从而得出一条重要性质：**二叉搜索树的中序遍历序列是升序的**。
+
+借助中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需 $O(n)$ 时间，而无需额外排序，非常高效。
+
+
+
+## 7.3.2. 二叉搜索树的效率
+
+假设给定 $n$ 个数字，最常用的存储方式是「数组」，那么对于这串乱序的数字，常见操作的效率为：
+
+- **查找元素**：由于数组是无序的，因此需要遍历数组来确定，使用 $O(n)$ 时间；
+- **插入元素**：只需将元素添加至数组尾部即可，使用 $O(1)$ 时间；
+- **删除元素**：先查找元素，使用 $O(n)$ 时间，再在数组中删除该元素，使用 $O(n)$ 时间；
+- **获取最小 / 最大元素**：需要遍历数组来确定，使用 $O(n)$ 时间；
+
+为了得到先验信息，我们也可以预先将数组元素进行排序，得到一个「排序数组」，此时操作效率为：
+
+- **查找元素**：由于数组已排序，可以使用二分查找，平均使用 $O(\log n)$ 时间；
+- **插入元素**：先查找插入位置，使用 $O(\log n)$ 时间，再插入到指定位置，使用 $O(n)$ 时间；
+- **删除元素**：先查找元素，使用 $O(\log n)$ 时间，再在数组中删除该元素，使用 $O(n)$ 时间；
+- **获取最小 / 最大元素**：数组头部和尾部元素即是最小和最大元素，使用 $O(1)$ 时间；
+
+观察发现，无序数组和有序数组中的各项操作的时间复杂度是“偏科”的，即有的快有的慢；**而二叉搜索树的各项操作的时间复杂度都是对数阶，在数据量 $n$ 很大时有巨大优势**。
+
+
+
+| | 无序数组 | 有序数组 | 二叉搜索树 |
+| ------------------- | -------- | ----------- | ----------- |
+| 查找指定元素 | $O(n)$ | $O(\log n)$ | $O(\log n)$ |
+| 插入元素 | $O(1)$ | $O(n)$ | $O(\log n)$ |
+| 删除元素 | $O(n)$ | $O(n)$ | $O(\log n)$ |
+| 获取最小 / 最大元素 | $O(n)$ | $O(1)$ | $O(\log n)$ |
+
+
+
+## 7.3.3. 二叉搜索树的退化
+
+理想情况下，我们希望二叉搜索树的是“左右平衡”的（详见「平衡二叉树」章节），此时可以在 $\log n$ 轮循环内查找任意结点。
+
+如果我们动态地在二叉搜索树中插入与删除结点，**则可能导致二叉树退化为链表**，此时各种操作的时间复杂度也退化之 $O(n)$ 。
+
+!!! note
+
+ 在实际应用中，如何保持二叉搜索树的平衡，也是一个需要重要考虑的问题。
+
+
+
+## 7.3.4. 二叉搜索树常见应用
+
+- 系统中的多级索引，高效查找、插入、删除操作。
+- 各种搜索算法的底层数据结构。
+- 存储数据流，保持其已排序。
diff --git a/build/chapter_tree/binary_tree.md b/build/chapter_tree/binary_tree.md
new file mode 100644
index 000000000..2e876d539
--- /dev/null
+++ b/build/chapter_tree/binary_tree.md
@@ -0,0 +1,578 @@
+---
+comments: true
+---
+
+# 7.1. 二叉树
+
+「二叉树 Binary Tree」是一种非线性数据结构，代表着祖先与后代之间的派生关系，体现着“一分为二”的分治逻辑。类似于链表，二叉树也是以结点为单位存储的，结点包含「值」和两个「指针」。
+
+=== "Java"
+
+ ```java title=""
+ /* 链表结点类 */
+ class TreeNode {
+ int val; // 结点值
+ TreeNode left; // 左子结点指针
+ TreeNode right; // 右子结点指针
+ TreeNode(int x) { val = x; }
+ }
+ ```
+
+=== "C++"
+
+ ```cpp title=""
+ /* 链表结点结构体 */
+ struct TreeNode {
+ int val; // 结点值
+ TreeNode *left; // 左子结点指针
+ TreeNode *right; // 右子结点指针
+ TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ };
+ ```
+
+=== "Python"
+
+ ```python title=""
+ """ 链表结点类 """
+ class TreeNode:
+ def __init__(self, val=None, left=None, right=None):
+ self.val = val # 结点值
+ self.left = left # 左子结点指针
+ self.right = right # 右子结点指针
+ ```
+
+=== "Go"
+
+ ```go title=""
+ /* 链表结点类 */
+ type TreeNode struct {
+ Val int
+ Left *TreeNode
+ Right *TreeNode
+ }
+ /* 结点初始化方法 */
+ func NewTreeNode(v int) *TreeNode {
+ return &TreeNode{
+ Left: nil,
+ Right: nil,
+ Val: v,
+ }
+ }
+ ```
+
+=== "JavaScript"
+
+ ```js title=""
+ /* 链表结点类 */
+ function TreeNode(val, left, right) {
+ this.val = (val === undefined ? 0 : val); // 结点值
+ this.left = (left === undefined ? null : left); // 左子结点指针
+ this.right = (right === undefined ? null : right); // 右子结点指针
+ }
+ ```
+
+=== "TypeScript"
+
+ ```typescript title=""
+ /* 链表结点类 */
+ class TreeNode {
+ val: number;
+ left: TreeNode | null;
+ right: TreeNode | null;
+
+ 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; // 右子结点指针
+ }
+ }
+ ```
+
+=== "C"
+
+ ```c title=""
+
+ ```
+
+=== "C#"
+
+ ```csharp title=""
+ /* 链表结点类 */
+ class TreeNode {
+ int val; // 结点值
+ TreeNode? left; // 左子结点指针
+ TreeNode? right; // 右子结点指针
+ TreeNode(int x) { val = x; }
+ }
+ ```
+
+=== "Swift"
+
+ ```swift title=""
+ /* 链表结点类 */
+ class TreeNode {
+ var val: Int // 结点值
+ var left: TreeNode? // 左子结点指针
+ var right: TreeNode? // 右子结点指针
+
+ init(x: Int) {
+ val = x
+ }
+ }
+ ```
+
+=== "Zig"
+
+ ```zig title=""
+
+ ```
+
+结点的两个指针分别指向「左子结点 Left Child Node」和「右子结点 Right Child Node」，并且称该结点为两个子结点的「父结点 Parent Node」。给定二叉树某结点，将左子结点以下的树称为该结点的「左子树 Left Subtree」，右子树同理。
+
+除了叶结点外，每个结点都有子结点和子树。例如，若将下图的「结点 2」看作父结点，那么其左子结点和右子结点分别为「结点 4」和「结点 5」，左子树和右子树分别为「结点 4 及其以下结点形成的树」和「结点 5 及其以下结点形成的树」。
+
+
+
+Fig. 子结点与子树
+ +## 7.1.1. 二叉树常见术语 + +二叉树的术语较多，建议尽量理解并记住。后续可能遗忘，可以在需要使用时回来查看确认。 + +- 「根结点 Root Node」：二叉树最顶层的结点，其没有父结点； +- 「叶结点 Leaf Node」：没有子结点的结点，其两个指针都指向 $\text{null}$ ； +- 结点所处「层 Level」：从顶至底依次增加，根结点所处层为 1 ； +- 结点「度 Degree」：结点的子结点数量。二叉树中，度的范围是 0, 1, 2 ； +- 「边 Edge」：连接两个结点的边，即结点指针； +- 二叉树「高度」：二叉树中根结点到最远叶结点走过边的数量； +- 结点「深度 Depth」 ：根结点到该结点走过边的数量； +- 结点「高度 Height」：最远叶结点到该结点走过边的数量； + + + +Fig. 二叉树的常见术语
+ +!!! tip "高度与深度的定义" + + 值得注意，我们通常将「高度」和「深度」定义为“走过边的数量”，而有些题目或教材会将其定义为“走过结点的数量”，此时高度或深度都需要 + 1 。 + +## 7.1.2. 二叉树基本操作 + +**初始化二叉树**。与链表类似，先初始化结点，再构建引用指向（即指针）。 + +=== "Java" + + ```java title="binary_tree.java" + // 初始化结点 + TreeNode n1 = new TreeNode(1); + TreeNode n2 = new TreeNode(2); + TreeNode n3 = new TreeNode(3); + TreeNode n4 = new TreeNode(4); + TreeNode n5 = new TreeNode(5); + // 构建引用指向（即指针） + n1.left = n2; + n1.right = n3; + n2.left = n4; + n2.right = n5; + ``` + +=== "C++" + + ```cpp title="binary_tree.cpp" + /* 初始化二叉树 */ + // 初始化结点 + TreeNode* n1 = new TreeNode(1); + TreeNode* n2 = new TreeNode(2); + TreeNode* n3 = new TreeNode(3); + TreeNode* n4 = new TreeNode(4); + TreeNode* n5 = new TreeNode(5); + // 构建引用指向（即指针） + n1->left = n2; + n1->right = n3; + n2->left = n4; + n2->right = n5; + ``` + +=== "Python" + + ```python title="binary_tree.py" + """ 初始化二叉树 """ + # 初始化节点 + n1 = TreeNode(val=1) + n2 = TreeNode(val=2) + n3 = TreeNode(val=3) + n4 = TreeNode(val=4) + n5 = TreeNode(val=5) + # 构建引用指向（即指针） + n1.left = n2 + n1.right = n3 + n2.left = n4 + n2.right = n5 + ``` + +=== "Go" + + ```go title="binary_tree.go" + /* 初始化二叉树 */ + // 初始化结点 + n1 := NewTreeNode(1) + n2 := NewTreeNode(2) + n3 := NewTreeNode(3) + n4 := NewTreeNode(4) + n5 := NewTreeNode(5) + // 构建引用指向（即指针） + n1.Left = n2 + n1.Right = n3 + n2.Left = n4 + n2.Right = n5 + ``` + +=== "JavaScript" + + ```js title="binary_tree.js" + /* 初始化二叉树 */ + // 初始化结点 + let n1 = new TreeNode(1), + n2 = new TreeNode(2), + n3 = new TreeNode(3), + n4 = new TreeNode(4), + n5 = new TreeNode(5); + // 构建引用指向（即指针） + n1.left = n2; + n1.right = n3; + n2.left = n4; + n2.right = n5; + ``` + +=== "TypeScript" + + ```typescript title="binary_tree.ts" + /* 初始化二叉树 */ + // 初始化结点 + let n1 = new TreeNode(1), + n2 = new TreeNode(2), + n3 = new TreeNode(3), + n4 = new TreeNode(4), + n5 = new TreeNode(5); + // 构建引用指向（即指针） + n1.left = n2; + n1.right = n3; + n2.left = n4; + n2.right = n5; + ``` + +=== "C" + + ```c title="binary_tree.c" + + ``` + +=== "C#" + + ```csharp title="binary_tree.cs" + /* 初始化二叉树 */ + // 初始化结点 + TreeNode n1 = new TreeNode(1); + TreeNode n2 = new TreeNode(2); + TreeNode n3 = new TreeNode(3); + TreeNode n4 = new TreeNode(4); + TreeNode n5 = new TreeNode(5); + // 构建引用指向（即指针） + n1.left = n2; + n1.right = n3; + n2.left = n4; + n2.right = n5; + ``` + +=== "Swift" + + ```swift title="binary_tree.swift" + // 初始化结点 + let n1 = TreeNode(x: 1) + let n2 = TreeNode(x: 2) + let n3 = TreeNode(x: 3) + let n4 = TreeNode(x: 4) + let n5 = TreeNode(x: 5) + // 构建引用指向（即指针） + n1.left = n2 + n1.right = n3 + n2.left = n4 + n2.right = n5 + ``` + +=== "Zig" + + ```zig title="binary_tree.zig" + + ``` + +**插入与删除结点**。与链表类似，插入与删除结点都可以通过修改指针实现。 + + + +Fig. 在二叉树中插入与删除结点
+ +=== "Java" + + ```java title="binary_tree.java" + TreeNode P = new TreeNode(0); + // 在 n1 -> n2 中间插入结点 P + n1.left = P; + P.left = n2; + // 删除结点 P + n1.left = n2; + ``` + +=== "C++" + + ```cpp title="binary_tree.cpp" + /* 插入与删除结点 */ + TreeNode* P = new TreeNode(0); + // 在 n1 -> n2 中间插入结点 P + n1->left = P; + P->left = n2; + // 删除结点 P + n1->left = n2; + ``` + +=== "Python" + + ```python title="binary_tree.py" + """ 插入与删除结点 """ + p = TreeNode(0) + # 在 n1 -> n2 中间插入结点 P + n1.left = p + p.left = n2 + # 删除节点 P + n1.left = n2 + ``` + +=== "Go" + + ```go title="binary_tree.go" + /* 插入与删除结点 */ + // 在 n1 -> n2 中间插入结点 P + p := NewTreeNode(0) + n1.Left = p + p.Left = n2 + // 删除结点 P + n1.Left = n2 + ``` + +=== "JavaScript" + + ```js title="binary_tree.js" + /* 插入与删除结点 */ + let P = new TreeNode(0); + // 在 n1 -> n2 中间插入结点 P + n1.left = P; + P.left = n2; + // 删除结点 P + n1.left = n2; + ``` + +=== "TypeScript" + + ```typescript title="binary_tree.ts" + /* 插入与删除结点 */ + const P = new TreeNode(0); + // 在 n1 -> n2 中间插入结点 P + n1.left = P; + P.left = n2; + // 删除结点 P + n1.left = n2; + ``` + +=== "C" + + ```c title="binary_tree.c" + + ``` + +=== "C#" + + ```csharp title="binary_tree.cs" + /* 插入与删除结点 */ + TreeNode P = new TreeNode(0); + // 在 n1 -> n2 中间插入结点 P + n1.left = P; + P.left = n2; + // 删除结点 P + n1.left = n2; + ``` + +=== "Swift" + + ```swift title="binary_tree.swift" + let P = TreeNode(x: 0) + // 在 n1 -> n2 中间插入结点 P + n1.left = P + P.left = n2 + // 删除结点 P + n1.left = n2 + ``` + +=== "Zig" + + ```zig title="binary_tree.zig" + + ``` + +!!! note + + 插入结点会改变二叉树的原有逻辑结构，删除结点往往意味着删除了该结点的所有子树。因此，二叉树中的插入与删除一般都是由一套操作配合完成的，这样才能实现有意义的操作。 + +## 7.1.3. 常见二叉树类型 + +### 完美二叉树 + +「完美二叉树 Perfect Binary Tree」的所有层的结点都被完全填满。在完美二叉树中，所有结点的度 = 2 ；若树高度 $= h$ ，则结点总数 $= 2^{h+1} - 1$ ，呈标准的指数级关系，反映着自然界中常见的细胞分裂。 + +!!! tip + + 在中文社区中，完美二叉树常被称为「满二叉树」，请注意与完满二叉树区分。 + + + +### 完全二叉树 + +「完全二叉树 Complete Binary Tree」只有最底层的结点未被填满，且最底层结点尽量靠左填充。 + +**完全二叉树非常适合用数组来表示**。如果按照层序遍历序列的顺序来存储，那么空结点 `null` 一定全部出现在序列的尾部，因此我们就可以不用存储这些 null 了。 + + + +### 完满二叉树 + +「完满二叉树 Full Binary Tree」除了叶结点之外，其余所有结点都有两个子结点。 + + + +### 平衡二叉树 + +「平衡二叉树 Balanced Binary Tree」中任意结点的左子树和右子树的高度之差的绝对值 $\leq 1$ 。 + + + +## 7.1.4. 二叉树的退化 + +当二叉树的每层的结点都被填满时，达到「完美二叉树」；而当所有结点都偏向一边时，二叉树退化为「链表」。 + +- 完美二叉树是一个二叉树的“最佳状态”，可以完全发挥出二叉树“分治”的优势； +- 链表则是另一个极端，各项操作都变为线性操作，时间复杂度退化至 $O(n)$ ； + + + +Fig. 二叉树的最佳和最差结构
+ +如下表所示，在最佳和最差结构下，二叉树的叶结点数量、结点总数、高度等达到极大或极小值。 + +
+
+| | 完美二叉树 | 链表 |
+| ----------------------------- | ---------- | ---------- |
+| 第 $i$ 层的结点数量 | $2^{i-1}$ | $1$ |
+| 树的高度为 $h$ 时的叶结点数量 | $2^h$ | $1$ |
+| 树的高度为 $h$ 时的结点总数 | $2^{h+1} - 1$ | $h + 1$ |
+| 树的结点总数为 $n$ 时的高度 | $\log_2 (n+1) - 1$ | $n - 1$ |
+
+
+
+## 7.1.5. 二叉树表示方式 *
+
+我们一般使用二叉树的「链表表示」，即存储单位为结点 `TreeNode` ，结点之间通过指针（引用）相连接。本文前述示例代码展示了二叉树在链表表示下的各项基本操作。
+
+那能否可以用「数组表示」二叉树呢？答案是肯定的。先来分析一个简单案例，给定一个「完美二叉树」，将结点按照层序遍历的顺序编号（从 0 开始），那么可以推导得出父结点索引与子结点索引之间的「映射公式」：**设结点的索引为 $i$ ，则该结点的左子结点索引为 $2i + 1$ 、右子结点索引为 $2i + 2$** 。
+
+**本质上，映射公式的作用就是链表中的指针**。对于层序遍历序列中的任意结点，我们都可以使用映射公式来访问子结点。因此，可以直接使用层序遍历序列（即数组）来表示完美二叉树。
+
+
+
+然而，完美二叉树只是个例，二叉树中间层往往存在许多空结点（即 `null` ），而层序遍历序列并不包含这些空结点，并且我们无法单凭序列来猜测空结点的数量和分布位置，**即理论上存在许多种二叉树都符合该层序遍历序列**。显然，这种情况无法使用数组来存储二叉树。
+
+
+
+为了解决此问题，考虑按照完美二叉树的形式来表示所有二叉树，**即在序列中使用特殊符号来显式地表示“空位”**。如下图所示，这样处理后，序列（数组）就可以唯一表示二叉树了。
+
+=== "Java"
+
+ ```java title=""
+ /* 二叉树的数组表示 */
+ // 使用 int 的包装类 Integer ，就可以使用 null 来标记空位
+ Integer[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };
+ ```
+
+=== "C++"
+
+ ```cpp title=""
+ /* 二叉树的数组表示 */
+ // 为了符合数据类型为 int ，使用 int 最大值标记空位
+ // 该方法的使用前提是没有结点的值 = INT_MAX
+ vectorFig. 二叉树的层序遍历
+ +广度优先遍历一般借助「队列」来实现。队列的规则是“先进先出”，广度优先遍历的规则是 ”一层层平推“ ，两者背后的思想是一致的。 + +=== "Java" + + ```java title="binary_tree_bfs.java" + /* 层序遍历 */ + ListFig. 二叉树的前 / 中 / 后序遍历
+ +
+
+| 位置 | 含义 | 此处访问结点时对应 |
+| ---------- | ------------------------------------ | ----------------------------- |
+| 橙色圆圈处 | 刚进入此结点，即将访问该结点的左子树 | 前序遍历 Pre-Order Traversal |
+| 蓝色圆圈处 | 已访问完左子树，即将访问右子树 | 中序遍历 In-Order Traversal |
+| 紫色圆圈处 | 已访问完左子树和右子树，即将返回 | 后序遍历 Post-Order Traversal |
+
+
+
+=== "Java"
+
+ ```java title="binary_tree_dfs.java"
+ /* 前序遍历 */
+ void preOrder(TreeNode root) {
+ if (root == null) return;
+ // 访问优先级：根结点 -> 左子树 -> 右子树
+ list.add(root.val);
+ preOrder(root.left);
+ preOrder(root.right);
+ }
+
+ /* 中序遍历 */
+ void inOrder(TreeNode root) {
+ if (root == null) return;
+ // 访问优先级：左子树 -> 根结点 -> 右子树
+ inOrder(root.left);
+ list.add(root.val);
+ inOrder(root.right);
+ }
+
+ /* 后序遍历 */
+ void postOrder(TreeNode root) {
+ if (root == null) return;
+ // 访问优先级：左子树 -> 右子树 -> 根结点
+ postOrder(root.left);
+ postOrder(root.right);
+ list.add(root.val);
+ }
+ ```
+
+=== "C++"
+
+ ```cpp title="binary_tree_dfs.cpp"
+ /* 前序遍历 */
+ void preOrder(TreeNode* root) {
+ if (root == nullptr) return;
+ // 访问优先级：根结点 -> 左子树 -> 右子树
+ vec.push_back(root->val);
+ preOrder(root->left);
+ preOrder(root->right);
+ }
+
+ /* 中序遍历 */
+ void inOrder(TreeNode* root) {
+ if (root == nullptr) return;
+ // 访问优先级：左子树 -> 根结点 -> 右子树
+ inOrder(root->left);
+ vec.push_back(root->val);
+ inOrder(root->right);
+ }
+
+ /* 后序遍历 */
+ void postOrder(TreeNode* root) {
+ if (root == nullptr) return;
+ // 访问优先级：左子树 -> 右子树 -> 根结点
+ postOrder(root->left);
+ postOrder(root->right);
+ vec.push_back(root->val);
+ }
+ ```
+
+=== "Python"
+
+ ```python title="binary_tree_dfs.py"
+ """ 前序遍历 """
+ def pre_order(root: Optional[TreeNode]):
+ if root is None:
+ return
+ # 访问优先级：根结点 -> 左子树 -> 右子树
+ res.append(root.val)
+ pre_order(root=root.left)
+ pre_order(root=root.right)
+
+ """ 中序遍历 """
+ def in_order(root: Optional[TreeNode]):
+ if root is None:
+ return
+ # 访问优先级：左子树 -> 根结点 -> 右子树
+ in_order(root=root.left)
+ res.append(root.val)
+ in_order(root=root.right)
+
+ """ 后序遍历 """
+ def post_order(root: Optional[TreeNode]):
+ if root is None:
+ return
+ # 访问优先级：左子树 -> 右子树 -> 根结点
+ post_order(root=root.left)
+ post_order(root=root.right)
+ res.append(root.val)
+ ```
+
+=== "Go"
+
+ ```go title="binary_tree_dfs.go"
+ /* 前序遍历 */
+ func preOrder(node *TreeNode) {
+ if node == nil {
+ return
+ }
+ // 访问优先级：根结点 -> 左子树 -> 右子树
+ nums = append(nums, node.Val)
+ preOrder(node.Left)
+ preOrder(node.Right)
+ }
+
+ /* 中序遍历 */
+ func inOrder(node *TreeNode) {
+ if node == nil {
+ return
+ }
+ // 访问优先级：左子树 -> 根结点 -> 右子树
+ inOrder(node.Left)
+ nums = append(nums, node.Val)
+ inOrder(node.Right)
+ }
+
+ /* 后序遍历 */
+ func postOrder(node *TreeNode) {
+ if node == nil {
+ return
+ }
+ // 访问优先级：左子树 -> 右子树 -> 根结点
+ postOrder(node.Left)
+ postOrder(node.Right)
+ nums = append(nums, node.Val)
+ }
+ ```
+
+=== "JavaScript"
+
+ ```js title="binary_tree_dfs.js"
+ /* 前序遍历 */
+ function preOrder(root){
+ if (root === null) return;
+ // 访问优先级：根结点 -> 左子树 -> 右子树
+ list.push(root.val);
+ preOrder(root.left);
+ preOrder(root.right);
+ }
+
+ /* 中序遍历 */
+ function inOrder(root) {
+ if (root === null) return;
+ // 访问优先级：左子树 -> 根结点 -> 右子树
+ inOrder(root.left);
+ list.push(root.val);
+ inOrder(root.right);
+ }
+
+ /* 后序遍历 */
+ function postOrder(root) {
+ if (root === null) return;
+ // 访问优先级：左子树 -> 右子树 -> 根结点
+ postOrder(root.left);
+ postOrder(root.right);
+ list.push(root.val);
+ }
+ ```
+
+=== "TypeScript"
+
+ ```typescript title="binary_tree_dfs.ts"
+ /* 前序遍历 */
+ function preOrder(root: TreeNode | null): void {
+ if (root === null) {
+ return;
+ }
+ // 访问优先级：根结点 -> 左子树 -> 右子树
+ list.push(root.val);
+ preOrder(root.left);
+ preOrder(root.right);
+ }
+
+ /* 中序遍历 */
+ function inOrder(root: TreeNode | null): void {
+ if (root === null) {
+ return;
+ }
+ // 访问优先级：左子树 -> 根结点 -> 右子树
+ inOrder(root.left);
+ list.push(root.val);
+ inOrder(root.right);
+ }
+
+ /* 后序遍历 */
+ function postOrder(root: TreeNode | null): void {
+ if (root === null) {
+ return;
+ }
+ // 访问优先级：左子树 -> 右子树 -> 根结点
+ postOrder(root.left);
+ postOrder(root.right);
+ list.push(root.val);
+ }
+ ```
+
+=== "C"
+
+ ```c title="binary_tree_dfs.c"
+
+ ```
+
+=== "C#"
+
+ ```csharp title="binary_tree_dfs.cs"
+ /* 前序遍历 */
+ void preOrder(TreeNode? root)
+ {
+ if (root == null) return;
+ // 访问优先级：根结点 -> 左子树 -> 右子树
+ list.Add(root.val);
+ preOrder(root.left);
+ preOrder(root.right);
+ }
+
+ /* 中序遍历 */
+ void inOrder(TreeNode? root)
+ {
+ if (root == null) return;
+ // 访问优先级：左子树 -> 根结点 -> 右子树
+ inOrder(root.left);
+ list.Add(root.val);
+ inOrder(root.right);
+ }
+
+ /* 后序遍历 */
+ void postOrder(TreeNode? root)
+ {
+ if (root == null) return;
+ // 访问优先级：左子树 -> 右子树 -> 根结点
+ postOrder(root.left);
+ postOrder(root.right);
+ list.Add(root.val);
+ }
+ ```
+
+=== "Swift"
+
+ ```swift title="binary_tree_dfs.swift"
+ /* 前序遍历 */
+ func preOrder(root: TreeNode?) {
+ guard let root = root else {
+ return
+ }
+ // 访问优先级：根结点 -> 左子树 -> 右子树
+ list.append(root.val)
+ preOrder(root: root.left)
+ preOrder(root: root.right)
+ }
+
+ /* 中序遍历 */
+ func inOrder(root: TreeNode?) {
+ guard let root = root else {
+ return
+ }
+ // 访问优先级：左子树 -> 根结点 -> 右子树
+ inOrder(root: root.left)
+ list.append(root.val)
+ inOrder(root: root.right)
+ }
+
+ /* 后序遍历 */
+ func postOrder(root: TreeNode?) {
+ guard let root = root else {
+ return
+ }
+ // 访问优先级：左子树 -> 右子树 -> 根结点
+ postOrder(root: root.left)
+ postOrder(root: root.right)
+ list.append(root.val)
+ }
+ ```
+
+=== "Zig"
+
+ ```zig title="binary_tree_dfs.zig"
+
+ ```
+
+!!! note
+
+ 使用循环一样可以实现前、中、后序遍历，但代码相对繁琐，有兴趣的同学可以自行实现。
diff --git a/build/chapter_tree/summary.md b/build/chapter_tree/summary.md
new file mode 100644
index 000000000..8566eaa8e
--- /dev/null
+++ b/build/chapter_tree/summary.md
@@ -0,0 +1,18 @@
+---
+comments: true
+---
+
+# 7.5. 小结
+
+- 二叉树是一种非线性数据结构，代表着“一分为二”的分治逻辑。二叉树的结点包含「值」和两个「指针」，分别指向左子结点和右子结点。
+- 选定二叉树中某结点，将其左（右）子结点以下形成的树称为左（右）子树。
+- 二叉树的术语较多，包括根结点、叶结点、层、度、边、高度、深度等。
+- 二叉树的初始化、结点插入、结点删除操作与链表的操作方法类似。
+- 常见的二叉树类型包括完美二叉树、完全二叉树、完满二叉树、平衡二叉树。完美二叉树是理想状态，链表则是退化后的最差状态。
+- 二叉树可以使用数组表示，具体做法是将结点值和空位按照层序遍历的顺序排列，并基于父结点和子结点之间的索引映射公式实现指针。
+
+- 二叉树层序遍历是一种广度优先搜索，体现着“一圈一圈向外”的层进式遍历方式，通常借助队列来实现。
+- 前序、中序、后序遍历是深度优先搜索，体现着“走到头、再回头继续”的回溯遍历方式，通常使用递归实现。
+- 二叉搜索树是一种高效的元素查找数据结构，查找、插入、删除操作的时间复杂度皆为 $O(\log n)$ 。二叉搜索树退化为链表后，各项时间复杂度劣化至 $O(n)$ ，因此如何避免退化是非常重要的课题。
+- AVL 树又称平衡二叉搜索树，其通过旋转操作，使得在不断插入与删除结点后，仍然可以保持二叉树的平衡（不退化）。
+- AVL 树的旋转操作分为右旋、左旋、先右旋后左旋、先左旋后右旋。在插入或删除结点后，AVL 树会从底至顶地执行旋转操作，使树恢复平衡。
diff --git a/build/index.md b/build/index.md
new file mode 100644
index 000000000..0ab257690
--- /dev/null
+++ b/build/index.md
@@ -0,0 +1,77 @@
+---
+comments: true
+hide:
+ - footer
+---
+
+=== " "
+
+
+ { align=left width=350 }
+
+
+
+---
+
+《 Hello，算法 》
+动画图解、能运行、可提问的数据结构与算法快速入门教程
+[](https://github.com/krahets/hello-algo)
+[@Krahets](https://leetcode.cn/u/jyd/)
+「清晰动画讲解」
+ +动画诠释重点，平滑学习曲线电脑、平板、手机全终端阅读
+ + + +!!! quote "" + +"A picture is worth a thousand words."
+“一图胜千言”
+ +--- + +「代码实践导向」
+ +提供经典算法的清晰实现与测试代码多种语言，详细注释，皆可一键运行
+ + + +!!! quote "" + +"Talk is cheap. Show me the code."
+“少吹牛，看代码”
+ +--- + +「可讨论与提问」
+ +作者一般 72h 内回复评论问题与小伙伴们一起讨论学习进步
+ + + +!!! quote "" + +“追风赶月莫停留，平芜尽处是春山”
+一起加油！
+ +--- + +推荐语
+ +!!! quote + + “一本通俗易懂的数据结构与算法入门书，引导读者手脑并用地学习，强烈推荐算法初学者阅读。” + + **—— 邓俊辉，清华大学计算机系教授** + +致谢
+ +感谢本开源书的每一位撰稿人，是他们的无私奉献让这本书变得更好，他们是： + +
+
+
+
+