企业官网建设流程全解析

数据结构这门课在408里的地位不用多说，45分左右的分值，属于性价比最高的科目之一。它不像计组那样需要背大量硬件细节，也不像操作系统那样概念琐碎，更不像计算机网络那样知识点零散。数据结构的核心是“抽象+逻辑”，把常见的数据组织方式和算法思路吃透，配合一定量的代码练习，就能拿到大部分分数。

“数据结构大观2”这个系列的定位，就是在考前把408数据结构的所有核心知识点用一张图、一条主线串起来。这篇文章会把知识地图拆开，从线性表一路走到排序，把每一章考什么、怎么考、容易错在哪全部理一遍。适合两类人：第一类是刚开始复习408，想快速建立知识框架的同学；第二类是已经刷过一轮题，但总觉得知识点是散的、想系统串联的同学。

先说明本文的用法：不代替教材，不代替刷题。它的作用是帮你把王道、严蔚敏教材里分散的考点压缩成一份“考前检索目录”，复习的时候遇到模糊的点，回来对照这篇按图索骥。下面直接进入知识地图。

1. 知识地图速览：408数据结构考什么

先给一张总体视图。408数据结构一共八块内容，每一块对应的题型和重要程度差别很大：

从题型分布看，选择题覆盖全部章节，后面的大题集中在图的应用、查找和排序的比较、以及线性表和树的代码题。所以复习顺序建议是：先理解线性结构，再掌握树的递归思维，然后进入图的各种算法，最后把查找和排序当成“算法比较”来学。这种顺序符合知识依赖关系，也能让每一章的新概念都有前几章的支撑。

一图流的核心思路是：数据结构不是八块孤立的考点，而是同一个问题在不同条件下的演化。同样是存取数据，按顺序排是线性表，限定操作位置就成了栈，加个先进先出约束就变成队列，加上父子关系就形成树，再加上多对多关联就变成图。建议学完每一章后，自己画一张类似的演化图，这会比死记硬背有效得多。

2. 适用场景与复习边界

这篇知识地图适合在什么阶段使用？

第一，基础理解阶段。刚开始复习时，你可能看完王道视频课觉得自己懂了，但合上书不知道讲了什么。这时用本文的章节框架做回顾测试，每个小标题先自己复述，再看正文补漏，能快速筛查盲点。

第二，强化刷题阶段。刷题中遇到错误率高的知识点，比如KMP的next数组、AVL旋转、B树插入、快排复杂度计算，直接回到对应章节看归纳，比重新翻整章教材效率高。

第三，冲刺回顾阶段。考前两周，只看目录结构，尝试把每个章节下的考点默写出来，写不出来的就是薄弱点。

边界也要说清楚。408数据结构的难点不完全在知识记忆，而在于两个能力：一是把抽象数据结构转化成可运行的代码，二是把算法思路应用到具体题目场景中。这篇文章解决的是知识组织和易错点提示，不负责替你完成代码训练。如果你想最后一道算法设计题拿满分，光看文章不够，必须动手在纸上写代码。

此外，复习时注意区分“408要求”和“科研/工作面试要求”。408数据结构偏重原理和经典算法，不会让你实现红黑树的完整删除，也不会让你手写B+树的大段代码。像红黑树、跳表这类内容，408只要求概念层理解，而公司面试八股文则可能要求手写。如果你是考研为主，别在红黑树细节上钻牛角尖；如果你同时准备面试，可以在408基础之外单独补充。

3. 线性表：顺序存储与链式存储

线性表是数据结构的地基，408直接考察的分数不算最多，但后面树、图都会用到线性表思想，算法设计题也经常拿链表开刀。

3.1 顺序表

顺序表用一段连续的内存空间存储元素，随机访问是O(1)，插入和删除需要移动元素，平均移动n/2次，时间复杂度O(n)。这三个结论必须条件反射式记下来。

常考操作是插入、删除、查找。插入时要判断表是否已满，删除时要判断表是否为空，移动元素时注意从后往前还是从前往后。代码写错最典型的原因就是移动方向反了。

#define MaxSize 50 typedef struct { int data[MaxSize]; int length; } SqList; // 在第 i 个位置插入元素 e bool ListInsert(SqList &L, int i, int e) { if (i < 1 || i > L.length + 1) return false; if (L.length >= MaxSize) return false; for (int j = L.length; j >= i; j--) { L.data[j] = L.data[j - 1]; // 从后往前移动 } L.data[i - 1] = e; L.length++; return true; }

408并不要求你写出完全可编译的完整程序，但核心逻辑必须正确。这里要特别注意：位置i到底是逻辑位置还是数组下标，题目一般会说清楚，默认是逻辑位置从1开始，数组下标从0开始。

3.2 链表

链表分为单链表、双链表、循环链表、静态链表。408选择填空常考这几个点：头结点的作用、查找第i个节点的时间复杂度、删除节点的操作顺序、双链表和循环链表的边界条件。

头结点是一个容易被忽视但反复考察的设计。带头结点的单链表，头指针永远不为空，插入删除逻辑统一，空表和非空表的处理一致。有些同学自己写代码时不带头结点，考试画图就容易乱，建议默认都带头结点写，除非题目明确说不带头。

单链表插入和删除的核心是抓住前驱节点。删除节点p需要找到前驱，遍历O(n)；如果题目给的是“只给节点p，要求O(1)删除”，可以用“偷梁换柱”法：把p的后继值赋给p，再删除后继。这个技巧在算法题里出现过多次。

// 删除单链表中第一个值为 x 的节点 bool DeleteNode(LinkList &L, int x) { LNode *p = L; while (p->next != NULL && p->next->data != x) { p = p->next; } if (p->next == NULL) return false; LNode *q = p->next; p->next = q->next; free(q); return true; }

双链表的插入和删除必须同时维护前驱指针和后继指针，常见错误是只注意一个方向，导致链表断裂。循环链表判断是否遍历完的条件从“p == NULL”变成“p == 头结点”，这个变化在约瑟夫环问题里特别关键。

3.3 线性表考点串联

顺序表和链表的对比是选择题常客：随机存取选顺序表，频繁插入删除选链表；顺序表空间连续、局部性好，链表空间不连续、需要额外指针域。哈希表解决冲突时也用到线性探测，队列的循环存储也是线性表思想的变体，复习时要有意识地把这些横向关联起来。

算法设计题里，链表类题目的常用套路是：快慢指针求中间节点、双指针合并有序链表、头插法逆置链表、标记法删除重复节点。这些套路一共就十几种，刷题时遇到就归纳，后面会越做越顺。

4. 栈、队列与递归

栈和队列都是操作受限的线性表。它们不新增加数据结构，而是限定操作方式，这让它们在具体场景中表现出很强的规律性。

4.1 栈：后进先出

栈的常考维度有三个：进出栈序列是否合法、栈的应用场景、链表/数组两种实现方式。

进出栈序列问题，核心是“元素出栈时，栈内的元素一定是按入栈顺序排列的”。题目给出一个入栈序列1,2,3，问哪个出栈序列合法，用穷举或者用卡特兰数都能算。n个元素依次入栈，出栈序列总数是卡特兰数 C(2n,n)/(n+1)，选择填空偶尔考。

栈的典型应用包括：括号匹配、表达式求值、递归、进制转换、迷宫求解。408对表达式求值的考察频率很高，中缀转后缀、后缀表达式求值，建议把这两种转换规则手推熟，考场上画栈的变化过程得分效率很高。

// 用顺序栈实现括号匹配 bool isMatch(char str[], int length) { char stack[MaxSize]; int top = -1; for (int i = 0; i < length; i++) { if (str[i] == '(' || str[i] == '[' || str[i] == '{') { stack[++top] = str[i]; } else { if (top == -1) return false; char ch = stack[top--]; if (str[i] == ')' && ch != '(') return false; if (str[i] == ']' && ch != '[') return false; if (str[i] == '}' && ch != '{') return false; } } return top == -1; }

4.2 队列：先进先出

循环队列是考察重点。为了区分队空和队满，常见做法是牺牲一个存储单元，队空条件front == rear，队满条件(rear+1) % MaxSize == front。很多同学记反，其实只要记住队满时队列里最多只能放MaxSize-1个元素就够了。

另一个常考点是链队和循环队列各适合什么场景。链队没有长度限制但需要额外指针；循环队列固定空间、存取O(1)，适合任务队列、缓冲区这类场景。树的层次遍历、图的广度优先遍历都直接用队列，这两个地方用熟了，队列的理解自然就到位。

4.3 栈、队列与递归

递归的本质就是函数调用栈。递归函数每次调用都压入一个栈帧，返回时弹出。因此，经典递归问题都可以用栈改写成非递归，408不要求必写非递归，但要求理解递归转栈的思想。树的前序/中序/后序遍历，用递归很简单，用栈写稍复杂；层序遍历用队列写，思路是“访问一个节点，就把它的左右孩子入队”。

复习到这里，建议做一个串联练习：用栈实现中缀转后缀，再用队列模拟打印任务调度。一个“后进先出”一个“先进先出”，配合使用能理解很多操作系统里的调度逻辑，虽然那是OS科目的事，但数据结构的模型是先决条件。

5. 串与KMP算法

串这块内容分值不高，选择题考最多的是朴素模式匹配和KMP的next数组计算。

朴素匹配从主串每个位置开始，依次比较模式串，最坏时间复杂度O(n*m)，n为主串长度、m为模式串长度。KMP优化的核心是：匹配失败时，模式串不回头到开头，而是跳到next[j]指定的位置。

next数组怎么求，是很多人的痛点。严谨定义是：next[j]等于模式串前j-1个字符组成的子串中，最长相等前后缀的长度加1，next[1]=0。但如果直接用这个定义手算，很容易算错。更推荐的方法是掌握“递推法”：已知next[j]=k，比较p[j]和p[k]，相等则next[j+1]=k+1，不相等则让k=next[k]，继续比较。

// 求模式串 T 的 next 数组 void getNext(char T[], int next[]) { int i = 1, j = 0; next[1] = 0; while (i < T[0]) { // T[0] 保存串长 if (j == 0 || T[i] == T[j]) { ++i; ++j; next[i] = j; } else { j = next[j]; } } }

nextval数组是为了解决KMP的冗余匹配问题。nextval的求法是：如果T[i] == T[next[i]]，则nextval[i] = nextval[next[i]]，否则nextval[i] = next[i]。考试中如果题目要求用“优化后的KMP”匹配，就要用nextval。

这部分题目不难，但计算量大，容易因为粗心失分。建议找十道next数组计算题反复练，直到能在三分钟内算出一组完整的next和nextval值。

6. 树与二叉树

树是408数据结构的分水岭。选择题稳定出好几道，大题也经常在这里面出算法题。理解和掌握的关键在于递归思维。

6.1 二叉树基础性质

二叉树的核心性质里，这几个常考：第i层最多有2^(i-1)个节点；深度为k的二叉树最多有2^k-1个节点；叶子节点数n0与度为2的节点数n2满足n0=n2+1；n个节点的完全二叉树深度为⌊log2(n)⌋+1。

完全二叉树的性质很重要，比如：编号为i的节点，左孩子编号2i，右孩子编号2i+1，父节点编号⌊i/2⌋。这个性质可以直接用数组存储完全二叉树，堆排序就是基于这个存储方式。

6.2 二叉树的遍历与线索化

前序、中序、后序、层序，四种遍历必须能写出递归代码、非递归代码（前中后序用栈、层序用队列）和手动模拟结果。409的大题如果出树，大概率会结合遍历出题，比如“根据前序和中序重建二叉树”“求二叉树的高度”“判断两棵二叉树是否相似”。

前序+中序可以唯一确定一棵二叉树，后序+中序也可以，前序+后序不能唯一确定。这个结论选择题直接考。

线索二叉树是让空指针域指向前驱或后继，从而优化遍历。线索化的过程就是遍历一遍二叉树，过程中记录pre指针，把空指针改成线索。考试常考“哪个指针域被改成线索”“第一个和最后一个遍历序列中的节点有没有前驱/后继”。

// 求二叉树高度（后序遍历的递归写法） int getHeight(BiTree T) { if (T == NULL) return 0; int leftH = getHeight(T->lchild); int rightH = getHeight(T->rchild); return (leftH > rightH ? leftH : rightH) + 1; }

6.3 树、森林与哈夫曼树

树转二叉树、森林转二叉树，规则要记清楚：左孩子右兄弟。选择题会给一棵树，问你它转成二叉树后某个节点的右指针指向哪里。练几道题就能掌握。

哈夫曼树是带权路径长度WPL最小的二叉树。构造规则：每次选两个权值最小的节点合并，新节点的权值等于两者之和，重复直到只剩一个节点。常考点是：哈夫曼树中没有度为1的节点，n个叶子节点构造哈夫曼树后总节点数为2n-1，所以n个叶子节点的哈夫曼树有n-1个非叶子节点。哈夫曼编码是前缀编码，没有任何一个编码是另一个编码的前缀。

6.4 并查集

并查集在408里这两年考得越来越频繁。它是一个树形结构，支持两个操作：Find找根、Union合并两个集合。核心优化是路径压缩和按秩合并。路径压缩让find操作几乎变成常数时间，Union时把矮树合并到高树上，防止树退化成链表。

408对并查集的考察目前主要是概念和简单应用，比如判断无向图有几个连通分量，或者判断图中两个顶点是否连通。代码要求不高，但知道数组实现方式对理解很有帮助。

int father[MAXN]; // father[i] 表示 i 的父节点 int find(int x) { if (father[x] != x) father[x] = find(father[x]); // 路径压缩 return father[x]; } void unionSet(int a, int b) { int fa = find(a), fb = find(b); if (fa != fb) father[fa] = fb; // 简单合并，可再按秩优化 }

7. 图：算法密集区

图的章节是408大题和第二道大题常见的来源，算法数量多、逻辑链条长，需要系统性整理。

7.1 图的存储方式

邻接矩阵、邻接表、十字链表、邻接多重表，408主要考前两种。邻接矩阵用二维数组，O(n^2)空间，判断两点是否相邻O(1)，但遍历所有边要O(n^2)。邻接表用链表存边，空间O(n+e)，适合稀疏图，但判断两点是否相邻需要遍历链表。

选择题喜欢考“对稠密图、稀疏图分别选哪种存储”。稠密图选邻接矩阵，稀疏图选邻接表，这是一个很直接的结论。十字链表用于有向图，邻接多重表用于无向图，了解概念即可。

7.2 图的遍历

DFS用栈或递归，BFS用队列。给定一个图，要能写出DFS遍历序列和BFS遍历序列，注意起点不同、邻接点排列顺序不同都会影响结果。

还要会把DFS和BFS用在具体问题上：BFS能求无权图的单源最短路径，DFS能判断图中是否有环、求连通分量数、拓扑排序。从“遍历”到“应用”的转化是408大题的高频考法。

7.3 最小生成树

Prim算法和Kruskal算法是常考对比。

Prim从任意顶点出发，每次找连接“已选集合”和“未选集合”的最短边，适合稠密图，时间复杂度O(n^2)，与边数无关。Kruskal每次选一条权值最小的边，只要不形成环就加入，适合稀疏图，时间复杂度O(e log e)。

选择题经常问“给一个图，写出Prim或Kruskal的生成边顺序”。重点考察“Kruskal加入边的顺序”和“Prim每一步加入的顶点”。手算时要画清楚，避免边选重复。

7.4 最短路径

Dijkstra、Floyd、还有无权图的BFS最短路径，三种方法按图类型区分。

Dijkstra解决单源非负权值最短路径，核心是贪心，每次选当前dist最小的未访问顶点，更新邻居的dist。它不能处理负权边，这个在选择题常考。Floyd用动态规划，可以处理图中所有顶点对的最短路径，允许负权边但不允许负权回路，时间复杂度O(n^3)。

大题每年都有可能出现Dijkstra的模拟，考场上要会完整写出dist数组和path数组的变化过程，不要只写出最后结果，过程分也很重要。

7.5 拓扑排序与关键路径

拓扑排序是判断有向图是否有环的手段，AOV网的顶点代表活动。入度为0的顶点出队，删除关联边，重复直到队列为空。若有顶点始终无法出队，说明有环。

关键路径基于AOE网，边代表活动，顶点代表事件。求关键路径的步骤是：先求事件最早发生时间ve（按拓扑序正向求max），再求事件最迟发生时间vl（按逆拓扑序反向求min），ve等于vl的顶点是关键路径上的顶点。边活动最早e和边活动最迟l也按类似方法求，e==l的边是关键活动。关键路径可能不止一条，掌握这个概念很重要。

这一块大题容易出，因为它结合了拓扑排序、动态规划和图的三要素，综合性很强。建议找两到三道真题用表格手算一遍。

8. 查找：从二分到散列

查找章节的考点相对独立，但难度一点都不低。B树、AVL树、散列冲突处理都是选择题热点。

8.1 顺序查找与折半查找

顺序查找平均比较次数(n+1)/2，成功和不成功的比较次数差别不大，适合顺序表或链表。折半查找要求顺序表并且有序，不能用链表，因为链表无法O(1)随机访问中间元素。折半查找的时间复杂度是O(log n)，它的判定树是一棵平衡二叉树。

折半查找手算时要会画判定树，能回答某个关键字的比较次数、查找成功的平均查找长度。判定树的构建跟平衡二叉树构建很接近，学起来可以互相印证。

8.2 BST与AVL

二叉排序树（BST）的中序遍历是有序序列，这个结论是很多题目的前提。插入时从根节点往下比较，小于走左、大于走右，找到空位置插入。删除分三种情况：叶子直接删；只有一棵子树用子树顶替；有两棵子树用中序前驱或后继替换再删除。

BST最坏情况下退化成单链表，查找O(n)，所以有了平衡二叉树AVL。AVL要求每个节点左右子树高度差不超过1。插入后失去平衡有四种情况：LL、RR、LR、RL，分别用右单旋、左单旋、先左后右、先右后左调整。记住“调整的是从插入节点往上找，第一个不平衡节点开始的子树”，考场上画旋转过程就能拿下。

红黑树在408里只要求概念了解，不要求手写。知道它是近似平衡、查找复杂度O(log n)、常用于Linux内核和Java TreeMap即可，不要在红黑树细节上花太多时间。

8.3 B树与B+树

B树是m叉查找树，每个节点最多m棵子树、最多m-1个关键字，所有叶节点在同一层，关键字有序。B树的插入会导致分裂，分裂时中间关键字上升到父节点；删除可能涉及合并。选择题会考查B树的每个节点最少几个关键字的公式：除根节点外，任意节点至少有⌈m/2⌉-1个关键字。

B+树和B树的区别在于：B+树的非叶节点不保存数据记录，只作为索引；所有数据都在叶节点，叶节点之间用指针链接。B+树更适合数据库索引，因为扫库时顺序读叶子链表即可，不需要遍历整棵树。这个对比在选择题里反复出现。

8.4 散列查找

散列最核心的是冲突处理方法。开放定址法（线性探测、二次探测、再散列）和拉链法是常考的对象。线性探测法会把冲突元素放到下一个空位，容易产生聚集现象；二次探测按1、-1、4、-4...探测，能缓解聚集但可能找不到空位。拉链法把同义词挂在链表上，处理简单、删除方便。

散列表的ASL计算是固定考法。给定散列函数和冲突处理方式，要求计算查找成功和查找失败的平均查找长度。这里有两个坑：查找失败的长度计算要算到“空位置”为止，不同教材对空的定义可能不同；装填因子α = 表中记录数/表长，α越大冲突越多，ASL越大。

9. 排序：复杂度、稳定性与手算

排序章节最大的难点不是代码，而是横向比较。八大排序必须要能背出这张表：

9.1 插入类排序

直接插入排序适合“基本有序”或“元素较少”的序列，每一趟把一个元素插入到前面有序序列的适当位置，一趟结束前面多一个有序元素，整体有序需要n-1趟。希尔排序是插入排序的改进，按增量分组做直接插入，增量递减到1。关键是最后一个增量必须是1，否则结果不一定有序。

9.2 交换类排序

冒泡排序每一趟把最大值“冒”到末尾，提前通过标志位判断有序后可以提前结束。快速排序是平均性能最好的内排序之一，选枢轴、划分、递归排序左右两侧。快排最坏情况发生在序列已经有序时，复杂度降到O(n^2)，因为每次划分只分出一个元素。这是选择题最爱挖坑的点。

快速排序手算时，每一趟划分结束后要标出枢轴元素的最终位置。408大题会让手动模拟快排的partition过程，写清楚low和high指针的移动顺序比直接给结果更稳妥。

9.3 选择类排序

简单选择排序每一趟选择最小元素与当前位置交换，比较次数与初始序列顺序无关，固定为n(n-1)/2，但移动次数少。堆排序需要先建堆，大根堆还是小根堆取决于升序还是降序。堆排序常与完全二叉树存储结合出题，比如“给定序列，写出建堆后的数组”。

手写堆排序时，筛选法调整（sift down）是核心。从最后一个非叶子节点开始，逐个向下调整；输出堆顶后，用最后一个元素补位，再向下调整。这个过程比代码本身更常出现在大题里，一定要练熟。

9.4 归并与基数

归并排序是稳定的O(n log n)，但需要O(n)额外空间。二路归并每次把两个有序段合并，适合外部排序和链表排序，链表归并不需要额外数组空间。

基数排序不是基于比较的排序，而是按位分配收集。最低位优先（LSD）从个位开始分配，收集后进入十位，再收集。基数排序的时间复杂度跟关键字长度d和基数r相关，平均和最坏都是O(d(n+r))，空间O(r)。它是稳定的，但只适用于整数或能分解成多关键字的序列。

10. 一图流串联：数据结构各章间的内在逻辑

现在把前八章的知识点横向串起来，你会看到一条清晰的主线。

线性表是基础容器：顺序表适合随机访问，链表适合动态插入。栈和队列是对线性表做了操作限制，解决的是“谁先被处理”的问题。树解决的是层次关系和数据查找效率问题，二叉树因为存储简单、递归清晰，成为各种高级结构的基础。图解决的是多对多关系问题，所有图的算法本质上都在遍历或搜索：最小生成树是“贪心式遍历”，最短路径是“动态规划式遍历”，拓扑排序是“依赖关系下的线性化”。

查找和排序则是算法思维的综合运用。二分查找依赖有序序列，而有序序列可以通过排序得到，这就是“排序为查找服务”的第一层联系。BST、AVL、B树本质上是动态维护有序序列的树形结构，散列则是用空间换时间的“位置计算式查找”。

如果给这个知识体系画一张图，应该是一棵树的形状：根节点是“数据组织+算法设计”，左子树是“线性结构”（线性表、栈、队列、串），右子树是“非线性结构”（树、图），果实是“查找和排序”这两个应用。

掌握了这张图，你会发现所有新知识都在重复几个基本操作：插入、删除、查找、遍历、排序。40多个数据结构考点，最后都可以归纳到这五个操作在不同结构上的不同实现。这就是“一图流横扫”的真正含义。

11. 复习节奏与常见误判排查

很多同学复习数据结构最大的问题不是知识点不会，而是不知道自己哪里不会。下面给一份易错点排查清单，每一条都可以当成自测题：

时间安排上，建议把数据结构复习分成三轮。第一轮（约3-4周）以教材和王道视频为主，每章学完画知识框架图，读完文章后先用目录自测。第二轮（约3-4周）刷王道课后选择题和历年408真题，把错题按章节归类，对照本文的排查表定位薄弱点。第三轮（考前2-3周）专攻大题，重点练树和图的应用题、排序比较题、链表代码题，同时用目录做“秒复述”自测，要求看到“B树”能在一分钟内说出定义、区别、插入删除特点。

12. 最佳实践与学习建议

给正在复习408的同学几条可落地的建议。

第一，用自己的话说清概念。每学完一个数据结构，尝试用三句话向不熟悉的人解释它是什么、解决什么问题、典型应用是什么。如果你说不清“栈和队列的区别”，说明还没真正理解，回去重新过一遍。

第二，一道题做三遍。第一遍独立完成，第二遍对照标准答案找差距，第三遍不看答案完整复现。这个办法对选择题和大题都适用，对算法设计题尤其有效。408的最后一道算法设计题通常不难，但需要手熟，考场时间有限，写得越快越稳。

第三，把经典算法代码默写下来。线性表插入删除、链表逆置、二叉树遍历、快排、归并、堆排序、Dijkstra，这些不要求逐字母一致，但核心结构必须能白板写出来。建议每天抽半小时默写两段，边写边注释，让肌肉记忆帮你降低考场紧张。

第四，重视错题本而不是笔记本身。很多人花大量时间抄笔记，但抄完不看，意义不大。错题本只需要记录三样东西：题目编号、错在哪一步、对应哪个考点。翻本子时先看考点，再判断自己是否掌握。

第五，关注408与工程实践的连接点。比如Redis里的跳跃表、字典和整数集合，本质上是数据结构的工程实现；文件系统索引用B+树，数据库索引也用它；操作系统的进程调度队列就是典型的优先级队列。这些延伸理解不直接加分，但能帮助你建立“数据结构是解决实际问题的基础设施”这一认知，反过来加深对408考点的记忆。

第六，远离“只看不练”的陷阱。数据结构是一门应用学科，看视频、看文章只能帮你建立认知，不能帮你解题。每天至少保证30分钟手写代码或手算模拟，比连续看三小时视频有用得多。

13. 总结与下一步

408数据结构的知识量在四门课里不算最大，但它的抽象性和算法性决定了不能用纯背诵的方式复习。本文用“一图流”的方式把线性表、栈队列、串、树、图、查找、排序七个模块串成一条主线，整张知识地图的核心就是五个操作：插入、删除、查找、遍历、排序。每个数据结构都是这五个操作在不同约束下的变体，每类算法都是对“如何高效执行这些操作”的回答。

下一步要做的事：

第一，用本文目录做一次自测，标出无法流利复述的章节。 第二，整理自己最近错得最多的三种题型，回到对应章节重做基础例题。 第三，从今天开始坚持每天手写一两段核心算法代码，优先选择链表的插入删除、二叉树的三种递归遍历、排序里的快排和归并、图里的DFS和BFS、Dijkstra。 第四，临近考试时，把各章重要公式和复杂度整理成一页纸，考前反复翻看。

数据结构复习到最后，拼的不是记忆力，而是“遇到问题能快速联想到哪个数据结构、哪个算法”的建模能力。这篇文章已经把从章节到考点的通路铺好了，剩下的就看你愿不愿意上路去练。建议先收藏，复习到某一章模糊时回来对照，比翻整本教材省时间得多。