考研 408 · 图核心知识点

2026-08-11T00:00:00+00:00

考研 408 · 图核心知识点</h1>

图是 408 大题最爱：存储 → 遍历 → 生成树 → 最短路 → 拓扑/关键路径。 </blockquote>

1. 图的存储</h2>
邻接矩阵</h3>
1 2 3 4 1 [ 0 1 1 0 ] 2 [ 1 0 1 1 ] 3 [ 1 1 0 1 ] 4 [ 0 1 1 0 ]</code></pre> 无向图对称；有向图按出边填写。判断两点是否相邻 O(1)，求度方便；但空间 O(n²)。 邻接表</h3> 1 → 2 → 3 2 → 1 → 3 → 4 3 → 1 → 2 → 4 4 → 2 → 3</code></pre> 空间 O(n+e)，适合稀疏图；求某点出度方便，判断相邻需扫描。 存储</th> 空间</th> 判断相邻</th> 求所有邻点</th></tr></thead> 邻接矩阵</td> O(n²)</td> O(1)</td> O(n)</td></tr> 邻接表</td> O(n+e)</td> O(degree)</td> O(degree)</td></tr> </tbody></table> 2. 遍历</h2> DFS（深度优先，用栈/递归）</h3> 访问顶点 → 递归访问第一个未访问邻点 → 回溯</code></pre>BFS（广度优先，用队列）</h3> 访问顶点 → 邻点全部入队 → 逐个出队重复</code></pre> 复杂度：邻接表 O(n+e)，邻接矩阵 O(n²)。 BFS 还能求无权图最短路径（边数）、判断连通分量数。 3. 最小生成树 MST</h2> Prim（加点）</h3> 从一个顶点出发，每次选择"连接已选集合与未选集合的最短边"加入集合，直到覆盖全部顶点。 复杂度：邻接矩阵 O(n²)；适合稠密图。</code></pre>Kruskal（加边）</h3> 边按权排序，从小到大选边，用并查集避免成环，选 n−1 条为止。 复杂度：O(e·log e)；适合稀疏图。</code></pre>示例</h3> 1 --2-- 2 | \ | 2 4 3 | \ | 3 --1-- 4 按 Kruskal：先取 3-4(1)、1-2(2)、1-3(2)（跳过 2-4(3)） ⇒ MST 总权 5</code></pre> 4. 最短路径</h2> Dijkstra（单源，非负权）</h3> 维护 dist[]，每次取未确定顶点中 dist 最小者，松弛其邻边。 复杂度：邻接矩阵 O(n²)；堆优化 O((n+e)log n)。 不能处理负权边。</code></pre>Floyd（多源）</h3> 三重循环：d[i][j] = min(d[i][j], d[i][k] + d[k][j]) 复杂度 O(n³)；可处理负权（无负环）。</code></pre>示例（Dijkstra 从 1 出发）</h3> 2 1 ───── 3 | 1 1 | 2 ───── 4 3 dist: 1→1=0, 1→2=1, 1→3=2, 1→4=3（经 3）</code></pre> 5. 拓扑排序（AOV 网）</h2> 无环有向图，顶点表示活动。 反复：选入度为 0 的顶点输出，删除其出边，直到全部输出。 若剩余顶点仍有入度 ⇒ 存在环。 复杂度：邻接表 O(n+e)。</code></pre>示例</h3> 课程依赖：A→C, B→C, C→D 拓扑序之一：A B C D（不唯一）</code></pre> 6. 关键路径（AOE 网）</h2> 顶点 = 事件，边 = 活动（带权=耗时） ve(最早发生) 正向取 max；vl(最迟发生) 逆向取 min 活动最早 e = ve(弧尾)；活动最迟 l = vl(弧头) − 权 e == l 的活动为关键活动，串联成关键路径 关键路径长度 = 工程最短工期</code></pre>示例</h3> v1 ─2─▶ v2 ─3─▶ v4 \ ▲ 4 ────────▶ 3 ve: v1=0, v2=2, v4=5, v3=4 vl: v1=0, v2=2, v4=5, v3=2（逆向） 关键活动：v1→v2(2), v2→v4(3)，关键路径长 5</code></pre> 7. 常考题型</h2> 画邻接矩阵/邻接表；</li> 给图写 DFS/BFS 序列；</li> Prim/Kruskal 过程与总权；</li> Dijkstra/Floyd 逐步表；</li> 拓扑排序与环检测；</li> 求 ve/vl/e/l 与关键路径；</li> 判断有向图强连通、无向图连通分量。</li> </ol> 8. 易错点</h2> Dijkstra 不适用负权，Floyd 可；</li> MST 不含权值相等的唯一性讨论（可能不唯一）；</li> 拓扑排序不唯一；</li> 关键路径可能不止一条；</li> BFS 求最短路只对无权图。</li> </ul> 上一篇：树</a> ｜下一篇：排序</a> </blockquote> 考研 408 · 排序核心知识点 2026-08-11T00:00:00+00:00 考研 408 · 排序核心知识点</h1> 排序是 408 高频选择题 + 偶尔大题：背总表、会手推过程、能判断稳定性。 </blockquote> 1. 总表（必背）</h2> 算法</th> 类别</th> 最好</th> 平均</th> 最坏</th> 空间</th> 稳定</th></tr></thead> 直接插入</td> 插入</td> O(n)</td> O(n²)</td> O(n²)</td> O(1)</td> ✅</td></tr> 希尔</td> 插入</td> O(n^1.3)</td> —</td> O(n²)</td> O(1)</td> ❌</td></tr> 冒泡</td> 交换</td> O(n)</td> O(n²)</td> O(n²)</td> O(1)</td> ✅</td></tr> 快速排序</td> 交换</td> O(n log n)</td> O(n log n)</td> O(n²)</td> O(log n)</td> ❌</td></tr> 简单选择</td> 选择</td> O(n²)</td> O(n²)</td> O(n²)</td> O(1)</td> ❌</td></tr> 堆排序</td> 选择</td> O(n log n)</td> O(n log n)</td> O(n log n)</td> O(1)</td> ❌</td></tr> 归并排序</td> 归并</td> O(n log n)</td> O(n log n)</td> O(n log n)</td> O(n)</td> ✅</td></tr> 基数排序</td> 分配</td> O(d(n+r))</td> O(d(n+r))</td> O(d(n+r))</td> O(r)</td> ✅</td></tr> </tbody></table> 记忆点：稳定的只有直接插入 / 冒泡 / 归并 / 基数；快排最坏 O(n²)；归并空间 O(n)。 2. 插入类</h2> 直接插入</h3> 初始: [3] 1 4 2 第1趟: [1 3] 4 2 第2趟: [1 3 4] 2 第3趟: [1 2 3 4]</code></pre> 思想：把待排元素插入已有序前缀的合适位置。 希尔排序</h3> 按增量 d 分组做直接插入，增量逐步缩小到 1（最后一次就是直接插入）。 例：d=2 时分成奇偶两组分别插入排序。</code></pre> 3. 交换类</h2> 冒泡</h3> 第1趟: 3 1 4 2 → 1 3 2 [4]（4 冒到末尾） 第2趟: 1 3 2 → 1 2 [3] 4 第3趟: 1 [2] 3 4</code></pre> 无交换可提前结束，最好 O(n)。 快速排序（分治）</h3> 选基准（通常首元素）→ 一趟划分：左小右大 → 递归两侧 例 [4 2 5 1 3] 以 4 为基准一趟后：[1 2 3] 4 [5]</code></pre>int partition(int a[], int low, int high) { int pivot = a[low]; while (low < high) { while (low < high && a[high] >= pivot) high--; a[low] = a[high]; while (low < high && a[low] <= pivot) low++; a[high] = a[low]; } a[low] = pivot; return low; }</code></pre> 快排平均 O(n log n)；若每次划分极不平衡（已有序）最坏 O(n²)。 4. 选择类</h2> 简单选择</h3> 每趟选剩余最小元素与当前位置交换： [1] 3 4 2 → 1 [2] 4 3 → 1 2 [3] 4</code></pre> 比较次数固定 n(n−1)/2，与初始状态无关。 堆排序</h3> 建大根堆 → 堆顶与末尾交换 → 下沉调整 [4 3 2 1] 交换 1： [1 3 2] 4 → 下沉 → [3 1 2] 4 → 交换 → [2 1] 3 4 → ...</code></pre>大根堆：parent ≥ children；调整（sift down）O(log n) 建堆 O(n)；排序 O(n log n)</code></pre> 5. 归并排序（二路）</h2> 分：数组二分到底；治：两两有序合并 [4 2 5 1] → [4 2][5 1] → [2 4][1 5] → [1 2 4 5]</code></pre>void merge(int a[], int low, int mid, int high) { // 复制到临时数组，双指针比较归并 } void mergeSort(int a[], int low, int high) { if (low < high) { int mid = (low + high) / 2; mergeSort(a, low, mid); mergeSort(a, mid + 1, high); merge(a, low, mid, high); } }</code></pre> 稳定、O(n log n)、空间 O(n)；适合外部排序基础。 6. 基数排序</h2> 按"位"分配-收集：个位 → 十位 → 百位… 例 [12, 3, 45]： 个位收集：3(03) 12 45 → 十位收集：3 12 45 复杂度 O(d(n+r))，d 位数、r 基数（十进制 10）</code></pre> 7. 408 高频结论</h2> 考点</th> 结论</th></tr></thead> 快排最坏</td> 基本有序时退化 O(n²)</td></tr> 稳定性判断</td> 相邻交换类（冒泡/插入）稳定；跳跃交换不稳定</td></tr> 比较次数与初始无关</td> 简单选择、折半插入、基数</td></tr> 一趟排序后能确定位置</td> 快排基准、选择类每趟定一个</td></tr> 与初始状态有关</td> 插入/冒泡/快排（趟数）；选择/归并/基数无关</td></tr> n 较小 / 基本有序</td> 直接插入最佳</td></tr> </tbody></table> 8. 外部排序（了解）</h2> 归并段（run）→ 败者树多路归并 → 置换选择排序生成更长段 总代价 ≈ 内部归并 + I/O 次数；I/O 次数 = 2×趟数×块数 增加归并路数、减少初始段数可减少 I/O</code></pre> 9. 例题速览</h2> 例 1：[1, 3, 2, 5, 4]</code> 用直接插入排序第 2 趟结果。 第1趟: [1 3] 2 5 4 第2趟: [1 2 3] 5 4</code></pre> 例 2：下列哪个排序是稳定的？直接插入 / 快排 / 堆排 / 希尔。 答案：直接插入</code></pre> 上一篇：图</a> </blockquote> 考研 408 · 字符串核心知识点 2026-08-11T00:00:00+00:00 考研 408 · 字符串核心知识点</h1> 408 中字符串以模式匹配（朴素 / KMP） 为绝对重点，配合字符串存储与基本操作。 </blockquote> 1. 字符串的存储</h2> 顺序存储：char s[MAXLEN]，用 '\0' 或 length 记录长度 堆分配：char* s，长度动态管理 块链存储：链表每个结点存多个字符（块），省指针空间</code></pre> 408 约定：字符数组下标常从 1 开始（s[1..n]</code>），便于 next 数组推导；下标 0 存长度或不用。 2. 朴素模式匹配（BF）</h2> 主串 s</code>（长 n）、模式串 p</code>（长 m）： 从主串每个位置 i 起，与 p 逐位比较； 失配则 i 回退到 i+1，j 回到 1，继续。</code></pre> 时间复杂度：最坏 O(n·m)；平均 O(n+m)。 图示</h3> 主串: a b a b c a b 模式: a b c 第 1 趟: a b a 失配于 c vs a → 主串从第 2 位再来 第 2 趟: a b a 第 3 趟: a b c ✓ 匹配成功，位置 3</code></pre> 3. KMP 算法</h2> 核心思想</h3> 失配时主串不回溯，模式串沿 next 数组滑动，把已匹配前缀的信息利用起来。 int KMP(const char s[], const char p[]) { int i = 1, j = 1; while (i <= s[0] && j <= p[0]) { if (j == 0 || s[i] == p[j]) { i++; j++; } else j = next[j]; } if (j > p[0]) return i - p[0]; // 匹配位置 return 0; }</code></pre>next 数组定义（next[1] = 0）</h3> next[j] = 模式串 p[1..j-1] 中"最长相等前后缀长度 + 1" 失配时 j = next[j] 再比。</code></pre>求解 next（递推）</h3> void getNext(const char p[], int next[]) { int j = 1, k = 0; next[1] = 0; while (j < p[0]) { if (k == 0 || p[j] == p[k]) { j++; k++; next[j] = k; } else { k = next[k]; } } }</code></pre>图示（p = a b a b a a）</h3> j : 1 2 3 4 5 6 7 p : a b a b a a - next: 0 1 1 2 3 4 2 例：j=5 时 p[1..4] = a b a b，最长相等前后缀 "ab" 长 2 ⇒ next[5] = 3</code></pre>nextval（优化 next）</h3> 若 p[j] == p[next[j]]，则 nextval[j] = nextval[next[j]]，进一步跳过相同字符比较。</code></pre> 时间复杂度：O(n+m)；空间 O(m)。 4. 常用题型</h2> 题型</th> 解法要点</th></tr></thead> 求 next / nextval 数组</td> 手算“最长相等前后缀“</td></tr> 主串定位</td> KMP 主循环 + next</td></tr> 循环节问题</td> 周期 = m − next[m]（若整除）</td></tr> 字符串相等判断</td> 长度 + 逐位比较</td></tr> 模式串滑动次数</td> 每趟失配后 j=next[j] 计数</td></tr> </tbody></table> 5. 例题速览</h2> 例 1：主串 ababcabcacbab</code>，模式 abcac</code>，求 next 数组并用 KMP 找首次匹配。 p : a b c a c next: 0 1 1 1 2 比较过程： a b a b c a b c a c a b a b c 失配(c vs a) → j = next[3] = 1 a b c a c 匹配成功，位置 6</code></pre> 例 2：next[7]</code> 语义 = 当第 7 位失配时，模式串从第 next[7]</code> 位继续比较。 6. 易错点</h2> next 数组下标从 1 开始、next[1]=0</code>；</li> 前缀/后缀都是真子串（不含自身）；</li> KMP 主串指针只增不减；</li> 朴素匹配最坏情况如 s=aaaaab, p=aaab</code>。</li> </ul> 下一篇：树</a> </blockquote> 考研 408 · 树核心知识点 2026-08-11T00:00:00+00:00 考研 408 · 树核心知识点</h1> 树是 408 数据结构大题高发区：性质 → 遍历 → BST/AVL → 哈夫曼 → 并查集。 </blockquote> 1. 二叉树基本性质</h2> ① 第 i 层至多 2^(i−1) 个结点 ② 深度为 k 的二叉树至多 2^k − 1 个结点 ③ 叶子数 n₀ = 度为 2 结点数 n₂ + 1 ④ 完全二叉树 n 个结点：深度 = ⌊log₂n⌋ + 1 ⑤ 顺序存储（完全二叉树）：i 的左孩子 2i、右孩子 2i+1、父 ⌊i/2⌋</code></pre>二叉树的形态数</h3> n 个结点的不同二叉树形态数 = 卡特兰数 C(n) = C(2n,n)/(n+1)</code></pre> 2. 遍历</h2> 递归序（先/中/后）</h3> 先序：根 → 左 → 右 DLR 中序：左 → 根 → 右 LDR 后序：左 → 右 → 根 LRD 层序：逐层从左到右</code></pre>图示</h3> 1 / \ 2 3 / \ \ 4 5 6 先序: 1 2 4 5 3 6 中序: 4 2 5 1 3 6 后序: 4 5 2 6 3 1 层序: 1 2 3 4 5 6</code></pre>由遍历序列确定二叉树</h3> 必须知道中序 + （先序或后序之一） 先序/后序确定根，中序划分左右子树 层序 + 中序亦可</code></pre>非递归遍历要点</h3> // 先序非递归：栈 push(root); while (!stack.empty()) { node = pop(); visit(node); if (node->right) push(node->right); if (node->left) push(node->left); } // 层序：队列 enqueue(root); while (!queue.empty()) { node = dequeue(); visit(node); if (node->left) enqueue(node->left); if (node->right) enqueue(node->right); }</code></pre> 3. 线索二叉树</h2> 利用空指针域： ltag = 0 左孩子 / 1 前驱；rtag = 0 右孩子 / 1 后继</code></pre> 中序线索化后，可快速找某结点的中序前驱/后继，遍历不需要栈。 4. 二叉排序树 BST</h2> 左子树 < 根 < 右子树</code></pre>操作</th> 平均复杂度</th></tr></thead> 查找 / 插入 / 删除</td> O(log n)（树高）</td></tr> 最坏（退化为链）</td> O(n)</td></tr> </tbody></table> 删除三种情况：叶子直接删；单孩子提升；双孩子用前驱或后继替换。 5. 平衡二叉树 AVL</h2> 平衡因子 = 左子树高 − 右子树高，绝对值 ≤ 1。 插入后失衡四种调整： LL：右旋 RR：左旋 LR：先左旋再右旋 RL：先右旋再左旋</code></pre>图示（LL 右旋）</h3> 3 2 / 右旋 / \ 2 ─────▶ 1 3 / 1</code></pre> 最小失衡子树调整后，整棵树恢复平衡；AVL 查找/插入/删除均 O(log n)。 6. 红黑树（408 要求掌握性质与插入过程）</h2> ① 结点非红即黑 ② 根是黑色 ③ 叶子（外部空结点）黑色 ④ 红结点的两个孩子必为黑（无连续红） ⑤ 任一结点到其所有后代叶子的路径含相同数目的黑结点（黑高相等）</code></pre> 插入调整：先染红新结点，再按叔结点颜色分情况变色 / 旋转；根始终染黑。 红黑树高度 ≤ 2·log₂(n+1)，保证 O(log n) 平衡查找。 7. 哈夫曼树与编码</h2> 构造</h3> 每次取权值最小的两棵树合并，新根权 = 两者之和，重复至一棵树。</code></pre>性质</h3> WPL = Σ(叶权 × 路径长度) 最小 只有度为 0 和 2 的结点：n 个叶子 ⇒ 2n−1 个结点</code></pre>示例（权 7 5 2 4）</h3> 18 / \ 7 11 / \ 5 6 / \ 2 4 编码（左 0 右 1）： 7 → 0 5 → 10 2 → 110 4 → 111 WPL = 7×1 + 5×2 + 2×3 + 4×3 = 35</code></pre> 哈夫曼编码是最优前缀编码（任一编码不是另一编码的前缀）。 8. 树 / 森林 ↔ 二叉树</h2> 孩子兄弟表示法： 左孩子指针 = 第一个孩子；右孩子指针 = 下一个兄弟 森林转二叉树：各树根依次作为右子树连接</code></pre> 树的先序 = 对应二叉树的先序；树的后序 = 对应二叉树的中序。 9. 并查集</h2> int find(int x) { while (parent[x] != x) x = parent[x]; return x; } void unionSet(int a, int b) { int ra = find(a), rb = find(b); if (ra != rb) parent[ra] = rb; // 可加按秩合并 }</code></pre> 用途：判断连通分量、Kruskal 判环、集合合并。路径压缩 + 按秩合并后近似 O(α(n))。 10. 堆</h2> 大根堆：parent ≥ children；小根堆：parent ≤ children 存储：完全二叉树顺序存储，下标 1 开始</code></pre>操作</th> 复杂度</th></tr></thead> 建堆</td> O(n)</td></tr> 插入 / 删除堆顶</td> O(log n)</td></tr> 堆排序</td> O(n log n)</td></tr> </tbody></table> 11. 常考题型</h2> 由先序+中序还原二叉树并求后序；</li> 完全二叉树结点编号与父子关系；</li> AVL 插入旋转过程；</li> 哈夫曼树构造与 WPL、编码；</li> 树转二叉树后的遍历关系；</li> 并查集查找次数与路径压缩；</li> 判断是否为 BST / AVL / 堆。</li> </ol> 上一篇：字符串</a> ｜下一篇：图</a> </blockquote>

Rocky‘s Blog - 408

考研 408 · 图核心知识点

1. 图的存储</h2>

2. 遍历</h2>

3. 最小生成树 MST</h2>

4. 最短路径</h2>

考研 408 · 排序核心知识点

2. 插入类</h2>

3. 交换类</h2>

4. 选择类</h2>

考研 408 · 字符串核心知识点

3. KMP 算法</h2>

考研 408 · 树核心知识点

2. 遍历</h2>

7. 哈夫曼树与编码</h2>