[Blog][Domain] programb.blog.csdn.net

### 3. **适应性强**- 插入排序对**接近有序的数据表现极好**，时间复杂度趋近于 $ O(n) $。- 冒泡排序即使经过优化，在部分有序情况下也难以达到同样响应速度。### 4. **代码执行效率对比示例**对于相同输入 `[5, 1, 2, 3, 4]`：- **插入排序**：只需将 `5` 向右移动一位，其余元素前移一格，整体移动较少。- **冒泡排序**：需要多次交换才能将 `5` “冒泡”到最后，中间产生大量冗余交换。

拓扑排序结果可能是：[v0, v1, v2, v3, v4] 逆拓扑排序为：[v4, v3, v2, v1, v0]1. 计算 ve： - ve[0]=0 - ve[1]=max(0+5)=5；ve[2]=0+6=6 - ve[3]=5+4=9；ve[4]=max(6+2, 9+0? ...) → 假设 v3→v4 权为0？需明确图结构 （实际中应根据具体边权和连接关系精确计算）2. 设 ve[4]=11 → 则 vl[4]=113. 反向按逆拓扑更新 vl： -

#### 处理方式：1. **报错提示**：在项目管理中应禁止存在环的计划。2. **人工修正依赖关系**：检查并修改错误的前置条件。3. **自动诊断环路径**：可通过 DFS 回溯找出具体环路，辅助用户定位问题。

### ✅ 算法步骤（基于 DFS 的拓扑排序）：1. 对图中每个未被访问的顶点调用 DFS；2. 在 DFS 过程中，先递归访问所有邻接顶点；3. 当该顶点的所有邻接点都处理完成后，将该顶点压入**栈**；4. 所有顶点遍历完成后，栈中元素从顶到底即为**逆向拓扑序列**；5. 弹出栈中所有元素，得到正向拓扑序列。

### 综合效果当同时使用**路径压缩**和**按秩合并**时，并查集的每个操作的平均时间复杂度接近于 **O(α(n))**，其中 α 是阿克曼函数的反函数，对于任何实际规模的输入，α(n) ≤ 5，可视为常数。这使得并查集在 Kruskal 算法、连通性问题等场景中极为高效。

3. **关键点解释**： - 初始时将起点加入堆，代价为 0，其余顶点通过松弛操作逐步更新。 - 每次从堆中取出代价最小的顶点 `u`，若未访问，则将其纳入生成树。 - 遍历 `u` 的所有邻接点 `v`，若 `v` 未被访问，则把边 `(u,v)` 的权重 `w` 作为连接 `v` 到生成树的可能路径，压入堆中。 - 同一顶点可能被多次加入堆（来自不同邻居），但只处理第一次弹出的最小值，其余自动忽略（懒惰删除）。4. **时间复杂度分析**： - 每条边最多入堆一次 →

2. **树的形态差异**： - DFS生成树通常“瘦长”，分支较深，层次较多但宽度较小。 - BFS生成树则“宽短”，呈辐射状，层数较少但每层节点较多。3. **边的类型关注点不同**： - 在DFS中，常用于识别**回边**（指向已访问祖先节点的边），可用于检测环路或判断图是否有向环。 - 在BFS中，更关注**层间边**，适合求解最短路径（无权图中从源点到各点的最短路径）。

### 时间与空间复杂度- **时间复杂度**：O(n)，n 为节点数，每个节点入队出队一次。- **空间复杂度**：O(w)，w 为树的最大宽度（队列中最多存储一层的节点）。-

### ✅ 非递归 DFS 实现步骤：1. 创建一个栈，将起始顶点入栈。2. 创建一个集合记录已访问的顶点。3. 当栈不为空时： - 弹出栈顶顶点； - 如果该顶点未被访问，标记为已访问并输出； - 将其所有未访问的邻接顶点**逆序压入栈**（保证邻接顶点按顺序访问，可选）；

| 路径存在性、连通分量 | ✅ 常用于判断连通性 | ✅ 可用 || 最短路径（无权图） | ❌ 不保证最短 | ✅ 能找到最短路径 || 拓扑排序 | ✅ 常用（基于DFS） | ❌ 不适用 || 走迷宫、回溯问题 | ✅ 天然适合 | ⚠️ 效率低 || 层次遍历、最小步数问题 | ❌ 不适合 | ✅ 理想选择 |

- 使用头插法将新边插入链表前端（效率高）；- 对于无向图，每条边 `(u,v)` 要添加两个方向的表结点；- `LocateVex` 函数用于根据字符查找顶点下标；- 动态分配内存给每个边结点，注意不要内存泄漏（实际应用中应提供销毁函数）；

- 若邻接矩阵是对称的，即对于所有 $ i \neq j $，都有 $ A[i][j] = A[j][i] $，则该图很可能是**无向图**。因为在无向图中，边没有方向，顶点 $ i $ 与 $ j $ 之间的连接是双向的。 - 若邻接矩阵**不对称**，即存在某些位置使得 $ A[i][j] \neq A[j][i] $（例如有 $ A[i][j] = 1 $ 但 $ A[j][i] = 0 $），则说明边具有方向性，该图为**有向图**。

### 🔧 步骤二：将邻接矩阵转置（即边反向），再做一次 DFS- 转置矩阵 $A^T$ 表示原图中所有边的方向反转；- 在转置图上从同一个顶点 $v_0$ 开始 DFS；- 若仍不能访问全部顶点 → 也不是强连通图。

- **森林转二叉树**的过程遵循以下规则： 1. 将森林中的每一棵树独立地转换为对应的二叉树（即保留每个节点的第一个孩子作为左子树，其余兄弟作为该孩子的右链）。 2. 将第一棵树的根节点作为最终二叉树的根。 3. 后续每棵树都作为前一棵树对应二叉树根节点的**右子树**连接起来。例如，第二棵树成为第一棵树根的右子树，第三棵树成为第二棵树在右子树位置上的右子树，依此类推。 这样形成的二叉树，其左子树代表原树的子孙结构，右子树链则表示兄弟关系或不同

### 💡 优点与意义：- 所有树都可以唯一地转换成一个等价的二叉树；- 存储结构统一为二叉链表，便于程序实现；- 可复用二叉树的遍历算法来处理普通树；- 多棵树组成的森林也可类似转换为森林对应的二叉树集合（见下文扩展）。

3. **孩子兄弟表示法（二叉链表表示法）** - 每个节点包含三个部分：数据域、指向“第一个孩子”的指针、指向“下一个兄弟”的指针。 - 结构上等价于二叉树（左子树为第一个孩子，右子树为下一个兄弟），因此可以将任意树或森林转换为二叉树进行处理。 - 特别适用于实现树与二叉树之间的相互转换，便于复用二叉树的遍历、插入、删除等算法。

1. 给定 n 个字符及其出现频率（或权重），每个字符作为叶子节点。2. 构造一个优先队列（最小堆），按权值排序。3. 重复以下操作 (n-1) 次： - 取出权值最小的两个节点 A 和 B； - 创建新节点 C，C 的权值 = A.权值 + B.权值； - 将 A 设为 C 的左孩子，B 为右孩子（或反之）； - 将 C 插入优先队列。4. 最后剩下的节点即为哈夫曼树的根。

1. 初始 5 个叶子：a(0.3), b(0.25), d(0.22), c(0.15), e(0.08)2. 合并 e(0.08) 和 c(0.15) → 新结点1 (0.23)3. 合并 d(0.22) 和 新结点1(0.23) → 新结点2 (0.45)4. 合并 a(0.3) 和 b(0.25) → 新结点3 (0.55)5. 合并 新结点2(0.45) 和 新结点3(0.55) → 根结点 (1.0)最终形成哈夫曼树，根为最后一个生成的结点。

| **排序 + 双指针归并** | 初始按权值排序，之后用两个队列分别保存原始节点和生成的内部节点，利用“单调性”在线性时间内选择最小值 | 高效静态哈夫曼编码 || **数组扫描优化** | 添加标记避免重复查找，或缓存候选列表 | 小规模但频繁调用 |#### ✅ 推荐优化方案：双队列法（高效且常用）```text思路：- Q1：存放初始叶子节点，按权值升序排列。- Q2：存放合并产生的内部节点（按生成顺序，权值自然递增）。- 每次从 Q1 和 Q2 的队首选两个最小的节点进行合并。

✅ **技巧提示**：- 不需要真正“画图”也能算 WPL：记录每个原始权值被合并了多少次 —— 实际上每合并一次，其所在子树的所有叶子路径长度都会增加 1。- 因此，也可以通过**合并次数统计深度**来间接计算。例如：- 权值 2：参与了 3 次合并（第一次成6，第二次成11，第三次成18）→ 深度=3- 权值 4：同理 → 深度=3- 权值 5：参与两次后续合并 → 深度=2- 权值 7：只在最后一次合并 → 深度=1

### 示例说明假设有一棵中序线索化的二叉树，中序序列为：D → B → E → A → F → C → G 调用 `inorder_traverse_threaded(root)` 将按此顺序输出，无需栈，时间复杂度 O(n)，空间复杂度 O(1)。> 注意：前提是树已经完成中序线索化，在建树时通过中序遍历设置 `ltag` 和 `rtag`。

线索化后：- D 的 `rchild` 指向 B（后继），`rtag = 1`- B 的 `lchild` 指向 D（前驱），`ltag = 1`- E 的 `rchild` 指向 A（后继），`rtag = 1`- A 的 `lchild` 指向 E（前驱），`ltag = 1`- C 的前后无更多节点，视情况处理调用 `inorderTraverse(root)` 将输出：`D B E A C`

补充说明中强调：不同遍历方式生成的线性序列反映了不同的逻辑顺序。例如：- 中序遍历对二叉搜索树可得到升序序列；- 层序遍历则揭示了树的层级分布。这些序列中所谓的“前驱”与“后继”关系依赖于具体的遍历规则，并无全局统一性。前序遍历和后序遍历的非递归实现同样基于栈结构，但访问节点的顺序不同，因此入栈策略也有所区别。

- **入栈顺序**：从根开始一路向左，将路径上的所有节点入栈。- **判断访问时机**： - 若当前节点无右子树 → 可直接访问； - 或右子树已经被访问过（`prev == curr->rchild`）→ 表示左右子树均已处理，可访问根；- **否则**：转向右子树继续处理。

- **先序遍历**：顺序为 `根 → 左子树 → 右子树`，所以第一个元素就是当前子树的**根节点**。- **中序遍历**：顺序为 `左子树 → 根 → 右子树`，因此可以在中序序列中找到根的位置，从而划分出左右子树的范围。利用这两个特性，可以**递归构造二叉树**。

| 特点 | 下标从 1 开始 | 下标从 0 开始 ||------|----------------|----------------|| 公式简洁性 | ⭐ 高（2i, 2i+1, i//2） | 较低（2i+1, 2i+2, (i-1)//2） || 教学友好性 | 强 | 一般 || 实际编程使用 | 少（需浪费 arr[0]） | 多（节省空间） || 数学规律性 | 易理解、易记忆 | 需额外推导 |因此，**在理论教学和图示表示中倾向于从下标 1 开始**，以突出结构规律；而在

- **双亲结点**：若 $i > 1$，其双亲编号为 $\left\lfloor \frac{i}{2} \right\rfloor$；当 $i = 1$ 时为根结点，无双亲。- **左孩子结点**：若 $2i \leq n$，左孩子编号为 $2i$；否则不存在左孩子。- **右孩子结点**：若 $2i+1 \leq n$，右孩子编号为 $2i+1$；否则不存在右孩子。

| **定义要求** | 所有层都完全填满 | 前 $ k-1 $ 层满，最后一层左对齐 || **结点数量** | 必须是 $ 2^k - 1 $ | 可以是 $ n $，满足 $ 2^{k-1} \leq n < 2^k $ || **结构特点** | 每个非叶结点都有两个孩子 | 允许某些非叶结点只有一个孩子（只能是左孩子） || **是否一定是完全二叉树** | 是 | 否（例如：只有根和右孩子就不是完全二叉树） || **应用场景** | 较少直接应用 | 堆（Heap）、优先队列常用结构

- **TPC-C** 定义了5种相对简单的事务操作： - 新订单（New-Order） - 支付（Payment） - 订单状态查询（Order-Status） - 发货（Delivery） - 库存水平检查（Stock-Level） 这些事务以短小、高频为特点，侧重高并发下的基本事务处理能力。 - **TPC-E** 则定义了更复杂的 **9种事务类型**，模拟金融信息服务环境，例如： - 交易请求（Trade-Res

- 每一行 $ i $ 最多有3个非零元素，但第1行和第n行只有2个。- 然而，如果我们假设每一行都“贡献了两个完整元素”，然后加上列偏移，就能得到统一公式。- 实际上，这是通过对存储模式的归纳得出的经验公式。- 更本质地看：前 $ i-1 $ 行大约贡献了 $ 2(i-1) $ 个元素（因为平均每行约2个），再加上当前行中第 $ j $ 所处的位置偏移。但精确地说，**该公式来源于对三对角结构中每行非零元素分布的系统编号**。

2. **基本操作** - **取表头 head(LS)**：返回广义表的第一个元素。若第一个元素是子表，则返回该子表。例如，`head((a, b), c)` 返回 `(a, b)`。 - **取表尾 tail(LS)**：返回除去表头后剩余元素组成的**新广义表**。注意，表尾始终是一个表，即使只有一个元素也需加括号。例如，`tail((a, b), c)` 返回 `(c)`，而 `tail(a, b, c)` 返回 `(b, c)`。

**二叉树**是一种特殊的树结构，它满足以下定义： - 二叉树是 $ n $（$ n \geq 0 $）个结点的有限集合，可以为空树（$ n = 0 $）。 - 非空时，每个结点至多有两个子树，分别称为**左子树**和**右子树**。 - 左、右子树是有序的，即区分左右，不能随意交换——这是**有序树**。换句话说，二叉树中每个结点的度最大为 2，且每个结点的左右孩子有明确的位置区分。---

### ✅ 结论：行主序与列主序地址公式之所以不同，根本原因在于**数据在内存中的物理排列顺序不同**：- 行主序按“行”为单位连续存放 → 地址增长依赖于列宽 `n`- 列主序按“列”为单位连续存放 → 地址增长依赖于行高 `m`

1. **内存空间连续**：数组在内存中占用一段连续的空间。当在数组中间或开头插入一个新元素时，必须将该位置及其后的所有元素向后移动一位，以腾出空间；同样，删除一个元素时，需要将后续所有元素向前移动一位，以填补空缺。

KMP 算法提升了朴素匹配的效率（从 O(nm) 到 O(n+m)），而数组作为基础结构支撑了矩阵压缩（如稀疏矩阵的三元组表示）、广义表的存储实现等高级主题。构造 KMP 算法中的 `next` 数组，本质是**对模式串本身进行“自我匹配”**，求出每个位置前缀的最长相等真前后缀（即：最长的、不等于自身的前缀与后缀相等的部分）的长度。`next[j]` 表示当模式串 `P[j]` 匹配失败时，新的匹配起点位置。---

1. **next[0] = -1** 固定。2. 对于每个后续位置 j ≥ 1： - 考察子串 `pattern[0..j]` - 找出它的所有**真前缀**和**真后缀** - 找出其中**最长的相等前后缀** - 记录这个最长前缀的最后一个字符的下标 → 即为 `next[j]`3. 可用递推思想辅助：若已知前面的 next 值，可通过类 KMP 方式模拟构建。

- j=0, k=-1 → 进入 if → j=1, k=0 → next[1]=0- j=1, k=0 → p[1]='b', p[0]='a' → 不等 → k = next[0] = -1- j=1, k=-1 → if 成立 → j=2, k=0 → next[2]=0- j=2, k=0 → p[2]='a' == p[0]='a' → j=3, k=1 → next[3]=1- j=3, k=1 → p[3]='b' == p[1]='b' → j=4, k=2 → next[4]=2

### 核心思想：利用模式串的“最长公共前后缀”进行跳跃当主串 `s[i]` 与模式串 `t[j]` 不匹配时：- 朴素算法会将主串指针 `i` 回退到起始位置的下一个位置，重新从 `j=0` 开始匹配；- KMP算法则认为：如果模式串前缀中存在重复结构（如 `"ABAB"` 中 `"AB"` 是前后缀），就可以利用这个结构，把模式串“滑动”到下一个可能匹配的位置，而主串指针 `i` **不需要回退**，只需调整模式串指针 `j` 到 `next[j-1]` 的位置继续比较。---

设主串 `s = "abcde"`，要将 `t = "xyz"` 插入到位置 `pos = 3` 处：- 前缀：`SubString("abcde", 1, 2) = "ab"`- 插入串：`"xyz"`- 后缀：`SubString("abcde", 3, 3) = "cde"`- 结果：`"ab" + "xyz" + "cde" = "abxyzcde"`### 时间复杂度分析：- 求子串和连接操作通常涉及字符复制，时间复杂度为 O(n + m)，其中 n 是主串长度，m 是插入串长度。

循环队列中的“假溢出”问题是指：尽管队列的实际元素个数未达到最大容量，但由于顺序队列的线性存储结构限制，尾指针已到达数组末尾，导致无法继续插入元素的现象。这种现象是“假”的溢出，因为数组前面可能存在空闲空间。**解决方法：使用循环队列（Circular Queue）**通过将队列的存储空间首尾相连，形成逻辑上的环形结构，使得当 `rear` 或 `front` 指针到达数组末尾时，可以“绕回”到数组开头继续使用空闲空间，从而有效避免假溢出。