简介：军队文职计算机类数据结构与算法知识点总结以Word文档形式呈现，面向备考军队文职计算机岗位的考生，系统梳理数据结构与算法核心考点，帮助快速搭建知识框架。文档覆盖基本概念、线性表、栈与队列、树与二叉树、图、查找与排序七大模块，重点讲解逻辑结构与物理结构、顺序存储与链式存储的适用场景，以及算法正确性、有穷性、确定性、可行性等特性，并对时间复杂度、空间复杂度设计要求作出总结。文中配有顺序表与链表的操作对比、栈和循环队列的进出示意图、二叉树前中后序遍历、图的深度优先与广度优先搜索、常见查找与排序算法等典型示例，便于按章节复习和考前速记。压缩包内共1个Word文档，大小约661KB，内容精炼、结构清晰，无需额外配套材料即可直接使用。已有98人学习浏览，适合需要系统回顾数据结构与算法知识、强化解题思路的军队文职备考生。
1. 军队文职计算机类的数据结构与算法：先搞清楚这份总结真正要解决什么问题
军队文职计算机类岗位的备考资料很多，但数据结构与算法这份知识点总结，恰恰是最容易被低估的一类。很多人一打开目录就背定义，背到图的遍历就停下来了，结果上了考场发现：选择题里复杂度算错、链表题边界判断漏了、算法设计题只写得出思路写不完代码。其实这个科目在计算机类岗位考试中权重不低，但丢分往往不是因为它难，而是复习顺序出了问题——该先掌握的线性表、栈、队列、二叉树、排序还没吃透，就去啃偏门算法。这份总结要解决的就是这么一件事：把“考什么”翻译成“该学什么”，再把“该学什么”翻译成“能落笔写出来的代码”，顺带告诉你哪些地方最容易踩坑。适合两类人：一类是时间紧、想快速建立考点框架的在职考生；另一类是离职备考、需要一份能对着练习的知识提纲的新人。如果你打算按章节把知识点整理成自己的笔记，这篇文章也可以当成文档目录的参考骨架。
2. 把知识清单变成考点地图：线性表、栈、队列怎么选型才不丢分
文职计算机类笔试对数据结构的考察，不会停在“能说出定义”，而是要求你快速判断在什么场景用什么结构、写出核心操作代码。线性表、栈、队列是整套数据结构的地基，也是最容易在选择题和大题开头出现的部分。这一章把它们的选型依据、手写模板和考法一次性讲透。
2.1 线性表：顺序存储与链式存储的取舍，以及笔试里的出题角度
顺序表和链表是线性表的两种实现方式。选择题最喜欢考“在哪个操作上谁更快”：顺序表按位置随机访问是 O(1)，链表要 O(n)；在顺序表头部插入要移动 n 个元素，链表头部插入是 O(1)；链表需要额外存储指针域，顺序表需要预分配连续空间。备考时不要只背结论，要能说清楚为什么——顺序表访问第 i 个元素直接按起始地址加偏移量算，链表必须从头节点走 i 步。这类“为什么”才是选择题里拉开差距的地方。
从选型角度看，顺序表适合“查多改少”的场景，比如存一组定长的配置项，按索引读；链表适合“插入删除频繁”的场景，比如实现 LRU 缓存里的条目移动。很多考生会纠结“考试到底选哪个”，其实题目不会只有一个正确答案，而是问“哪种操作的时间复杂度更低”，所以复习重点是把每个操作在两种实现下的代价背熟。
| 对比项 | 顺序存储 | 链式存储 |
|---|---|---|
| 存储方式 | 连续内存，按位访问 | 节点分散，指针连接 |
| 空间分配 | 预分配，可能浪费 | 按需分配，额外存指针 |
| 按位查找 | O(1) | O(n) |
| 按值查找 | O(n) | O(n) |
| 头部插入删除 | O(n)，需移动元素 | O(1)，改指针即可 |
| 尾部插入删除 | O(1) | O(1)（有尾指针）或 O(n) |
| 适用场景 | 查多改少、大小基本固定 | 插入删除频繁、大小不确定 |
笔试里真正容易丢分的不是这些结论，而是边界。例如“在长度为 n 的顺序表第 i 个位置插入元素，需要移动多少个元素”——答案是 n-i+1 个（假设位置从 1 开始）。如果没画过图，很容易记反。链表题则常栽在“断链”上：修改 next 之前没有保存后继节点。下面这个反转链表模板是高频手写题，建议直接抄进你的知识点总结文档。
def reverse_list(head): prev = None cur = head # 逐个把当前节点的 next 指向前驱，实现反转 while cur: nxt = cur.next # 先保存后继，避免断链 cur.next = prev # 反转指针 prev = cur # 前驱后移 cur = nxt # 当前节点后移 return prev # prev 最终指向新链表头逻辑说明：这个模板的关键是 nxt 在指针修改前保存；如果先执行 cur.next = prev，链表从第一个节点开始就断了，后面的节点全部丢失。循环结束条件用 while cur 而不是 while cur.next，否则链表只有一个节点时游标不会移动。返回值 prev 是反转后的新头节点，调用方接收时不要再用原来的 head。参数说明：head 是头节点引用，传入空链表时 while 循环不进入，直接返回 None，代码天然处理了空表场景。prev 初始化为 None，因为原链表的尾节点反转后 next 必须指向空。这套写法还能扩展到“反转区间链表”等变体，笔试时先把基础模板写对比追求花哨更重要。
除了反转，链表的高频考法还有删除指定节点（只给节点引用时用值覆盖法）、找倒数第 k 个节点（快慢指针）、判断是否有环（快慢指针相遇）。建议在文档里把这三个归成“链表三件套”，每题配一个手写模板，考前快速过一遍。
2.2 栈与队列：两个看似简单的结构为什么年年考
栈和队列在基础结构里最简单，但考法最灵活。栈的应用包括括号匹配、表达式求值、函数调用栈、撤销操作；队列则常见于缓冲区、滑动窗口、图的 BFS。选择题里有一个高频点：出栈序列的合法性判断。比如入栈序列 1,2,3,4，出栈序列 4,3,2,1 合法，但 4,3,1,2 不合法——因为 2 压在 1 上方，1 必须先出。这类题不用背公式，用辅助栈模拟一遍就能判断，但很多人一紧张就忘了这一步。
循环队列是另一道常考题，而且是个经典坑：判队满时留一个元素位不用，把队满条件写成 (rear+1)%capacity == front，这样能避开“塞满时 front==rear 与空队无法区分”的模糊。很多教材会把这个“留一位”的设计写在前面，但考试题目未必给提示，复习时要把这个前提刻在脑子里。栈与队列的代码题常考“用两个栈模拟队列”和“用两个队列模拟栈”，前者更频繁，下面给出模板。
class MyQueue: def __init__(self): self.in_stack = [] # 负责入队 self.out_stack = [] # 负责出队，仅在出队时倒数据 def push(self, x): # 入队永远入 in_stack self.in_stack.append(x) def pop(self): # 如果 out_stack 为空，把 in_stack 全部倒过来 if not self.out_stack: while self.in_stack: self.out_stack.append(self.in_stack.pop()) return self.out_stack.pop() def peek(self): # 先保证 out_stack 有数据，再取栈顶 if not self.out_stack: while self.in_stack: self.out_stack.append(self.in_stack.pop()) return self.out_stack[-1] def empty(self): return not self.in_stack and not self.out_stack逻辑说明：push 只进 in_stack，pop 时如果 out_stack 为空才批量倒数据，整体摊还代价是 O(1)。注意 pop 和 peek 都调用了同一个“搬运”逻辑，二刷时可以抽成一个 move 方法，减少重复。空队列时 pop 会抛异常，笔试手写建议在函数开头判空。参数说明：x 是入队元素，类型不限；in_stack 的栈顶是队尾，out_stack 的栈顶是队头，倒数据后原 in_stack 会被清空。这个模板的易错点是忘记判断 out_stack 是否为空就 pop，导致数据顺序错乱。
建议把“栈与队列”小节整理成三块：特性与应用、手写模板、判断题口诀（后进先出/先进先出、循环队列判空判满条件）。这三块覆盖了选择题和大题的大部分考法。
2.3 经典例题演示与代码模板：最小栈与括号匹配
把前两个小节的经验落到具体题目上。最小栈要求在 O(1) 时间获取栈内最小值，常见做法是维持一个辅助栈，栈顶永远保存“从栈底到当前栈顶的最小值”。这道题既考栈结构，又考空间换时间的思路，是计算机类岗位题库里的常客。
class MinStack: def __init__(self): self.data = [] # 普通栈 self.minv = [] # 辅助栈，栈顶是当前最小值 def push(self, val): self.data.append(val) # 注意：等于 sign 时也要压入，避免重复最小值丢失 if not self.minv or val <= self.minv[-1]: self.minv.append(val) def pop(self): if self.data: if self.data[-1] == self.minv[-1]: self.minv.pop() self.data.pop() def top(self): return self.data[-1] def get_min(self): return self.minv[-1]逻辑说明：关键在 push 和 pop 时同步维护 minv。用 val <= self.minv[-1] 而不是 <，因为存在重复最小值时，pop 一个元素可能导致真正的“次小值”被错误删除。pop 里先比较两个栈顶是否相等，相等才弹 minv，保证辅助栈与主栈状态一致。参数说明：val 是每次压入的整数；辅助栈最坏情况下与主栈同长，空间复杂度 O(n)，但逻辑简单、不容易写边界 bug。如果面试要求 O(1) 空间，可以用“栈内存差值”的技巧，但笔试优先写辅助栈版本。括号匹配则是用栈逐个处理左括号入栈、右括号与栈顶配对，出现不匹配立即返回 False，最后栈为空才是合法字符串。这两题覆盖了“栈的应用”和“O(1) 查询”两种常见考法，建议放进知识点总结的“必背模板”区。
3. 树与图：遍历、搜索和最短路径的高频考点拆解
树与图是数据结构里知识点最密集的部分，也是很多考生复习时最容易半途而废的地方。这一章先解决二叉树的遍历写法，再把图的存储选型和搜索算法讲清楚，最后给出最短路径与最小生成树的适用边界。
3.1 二叉树遍历：递归与迭代的写法转换
二叉树的递归遍历几乎背下来就有分，但大题里常要求“不用递归”，考察显式栈的模拟。前序和中序的迭代模板很相似：中序是“一路向左，弹出时访问，再转向右子树”；前序则是在入栈时就访问节点。层序遍历用队列，每层需要先取当前队列长度，再按层处理，避免把下一层的节点混进当前层。选择题里还常考“根据前序+中序还原二叉树”，原理是前序第一个节点是根，中序里该节点左边是左子树、右边是右子树，递归切分即可。
def inorder(root): result = [] stack = [] cur = root while cur or stack: # 尽量向左走，把路径上的节点都压栈 while cur: stack.append(cur) cur = cur.left # 弹出栈顶，访问，然后转向右子树 cur = stack.pop() result.append(cur.val) cur = cur.right return result逻辑说明：外层 while 条件“cur or stack”很关键，根节点不为空或栈非空都要继续；内层 while 是“左边走到底”，保证弹出顺序满足左→根→右。参数说明：root 是树根节点引用，val 是节点值；空树时 cur 为 None、stack 为空，直接返回空列表。改成前序只需要调整访问时机：入栈时马上把 val 加入 result。层序则用 deque 存储每层节点，每次循环先取当前层长度再遍历。递归版和迭代版建议并排抄在同一页笔记里，对比差异，考前手写一遍迭代版能有效避免考场卡壳。
树的另一个高频考点是平衡二叉树和二叉搜索树的性质：中序遍历二叉搜索树得到有序序列；判断平衡时，左右子树高度差绝对值不超过 1。这些结论不难，但选择题常把它们和“完全二叉树用数组存储时父子下标关系”混在一起考。数组存储那部分记住两个公式：左孩子下标 2i+1，右孩子下标 2i+2（从 0 开始），父节点下标 (i-1)//2，就能在图上推出来。
3.2 图的存储与搜索：邻接矩阵、邻接表、DFS/BFS 的复杂度对比
图论在计算机类岗位笔试里不会下放太深，但邻接矩阵和邻接表的选择经常出现在选择题里。邻接矩阵适合稠密图，查询两点是否连通 O(1)，缺点是空间 O(n^2)，稀疏图浪费严重；邻接表适合稀疏图，遍历某个顶点的所有邻居开销小，但判断两点是否连通需要遍历链表，最坏 O(度)。这个选择会直接影响后续 DFS/BFS 的复杂度分析，所以复习时要先把表记住。
| 对比项 | 邻接矩阵 | 邻接表 |
|---|---|---|
| 存储空间 | O(n^2)，固定开销 | O(n+m)，稀疏图更省 |
| 加边 | O(1) | O(1)（头插法） |
| 判断两点连通 | O(1) | O(度)，最坏 O(n) |
| 遍历某点邻居 | O(n)，即使邻居很少也要扫整行 | O(度)，只扫链表 |
| 适用场景 | 稠密图、需要频繁判断连通性 | 稀疏图、遍历邻居为主 |
图搜索的两种写法则各有侧重。DFS 适合判断连通性、检测环、输出拓扑序；BFS 适合无权图的最短路径、层序问题。手写时注意：用递归写 DFS 要提防深度过大，Python 默认递归深度约 1000，图规模大时应改成显式栈；BFS 的 visited 标记必须在入队时完成，否则同一节点可能被多次入队。
def dfs(graph, start, visited): # graph: 邻接表，字典形式 {节点: [邻居们]} visited.add(start) for nxt in graph.get(start, []): if nxt not in visited: dfs(graph, nxt, visited) def bfs(graph, start): from collections import deque visited = {start} q = deque([start]) while q: node = q.popleft() for nxt in graph.get(node, []): if nxt not in visited: visited.add(nxt) q.append(nxt) return visited逻辑说明：DFS 用 visited 集合防止环路死循环；graph.get(start, []) 在节点不存在时返回空列表，避免 KeyError。BFS 用队列实现“按距离逐层访问”，入队时标记 visited 是必须的，否则同一个邻居会被多个节点重复发现。参数说明：graph 的 key 是节点编号，value 是邻居列表；start 是起点；visited 用 set 保证 O(1) 去重。如果题目要求返回访问顺序而不是集合，把 visited 换成列表并在 add 之后 append 即可。
3.3 最短路径与最小生成树：Dijkstra、Floyd、Prim、Kruskal 的适用边界
这部分在笔试里更重原理和复杂度，而不是完整手写。Dijkstra 适用于单源、非负权图，朴素实现 O(n^2)，堆优化可以到 O((n+m)log n)；Floyd 适用于多源最短路，O(n^3)；Prim 和 Kruskal 都是最小生成树算法，Prim 适合稠密图，Kruskal 需要排序边集合，适合稀疏图，复杂度 O(m log m)。错误率最高的是 Dijkstra 的适用前提：如果图中存在负权边，Dijkstra 会翻车，正确做法是换用 Bellman-Ford 或 SPFA。
| 算法 | 问题 | 前提条件 | 时间复杂度 | 一句话记忆 |
|---|---|---|---|---|
| Dijkstra | 单源最短路 | 边权非负 | O(n^2) / 堆优化 O((n+m)log n) | 贪心取当前最近点 |
| Floyd | 多源最短路 | 可含负权、不能有负环 | O(n^3) | 三重循环枚举中转点 |
| Prim | 最小生成树 | 无向连通图 | O(n^2)，适合稠密图 | 从一个点长出一棵树 |
| Kruskal | 最小生成树 | 无向连通图 | O(m log m)，适合稀疏图 | 按边权排序并查集 |
堆优化 Dijkstra 是很多考生想背又背不全的模板，其实先写朴素版再优化成堆会更容易理解。核心区别只在“每次从堆里取当前距离最小的未访问点”。
import heapq def dijkstra(graph, start): # graph: {节点: [(邻点, 边权), ...]} dist = {node: float('inf') for node in graph} dist[start] = 0 pq = [(0, start)] # (距离, 节点) while pq: d, u = heapq.heappop(pq) if d > dist[u]: continue # 过期记录，跳过，不要重复松弛 for v, w in graph.get(u, []): nd = d + w if nd < dist[v]: dist[v] = nd heapq.heappush(pq, (nd, v)) return dist逻辑说明：小顶堆每次都取当前已知距离最小的节点，跳过过期记录是关键优化——如果堆里某个节点的距离已经大于 dist 中的记录，说明该记录已被更短的路径替换过，不用再处理。更新邻居时只有 nd 更小才入堆，保证每个节点可能被多次入堆但只被成功松弛有限次。参数说明：graph 的边权为非负整数；start 是源点；dist 中 float('inf') 表示不可达；优先队列元素格式是 (距离, 节点)，距离是元组第一关键字。手写时可以先用“每次遍历找最小点”的朴素版理解思路，再改堆版本，避免背代码时把更新逻辑写丢。
4. 排序与查找：背模板前先搞懂稳定性与复杂度边界
排序是整个数据结构里最容易“背了就丢分、懂了才不丢分”的章节。查找部分则集中在二分和哈希。这一章先把排序的复杂度与稳定性讲透，再给快排、堆排、二分的可复用模板。
4.1 八大排序的分类记忆与稳定性判断
先把八大排序按类别分清楚：插入类的直接插入、希尔；交换类的冒泡、快排；选择类的简单选择、堆排；归并排序；基数排序。核心复杂度结论要背牢：平均 O(n log n) 的是快排、堆排、归并；最坏退化成 O(n^2) 的是快排（基准选得差）、直接插入（逆序输入）、简单选择（无论什么输入都是 O(n^2)）；希尔排序复杂度依赖增量序列，笔试一般只考“不稳定”。空间方面，归并需要 O(n) 辅助空间，快排需要递归栈 O(log n) 到 O(n)，其余大多 O(1)。
| 排序算法 | 平均 | 最坏 | 空间 | 稳定性 |
|---|---|---|---|---|
| 直接插入 | O(n^2) | O(n^2) | O(1) | 稳定 |
| 希尔 | 不确定 | 不确定 | O(1) | 不稳定 |
| 冒泡 | O(n^2) | O(n^2) | O(1) | 稳定 |
| 快排 | O(n log n) | O(n^2) | O(log n) | 不稳定 |
| 简单选择 | O(n^2) | O(n^2) | O(1) | 不稳定 |
| 堆排 | O(n log n) | O(n log n) | O(1) | 不稳定 |
| 归并 | O(n log n) | O(n log n) | O(n) | 稳定 |
| 基数 | O(d(n+r)) | O(d(n+r)) | O(n+r) | 稳定 |
稳定性判断有个口诀：不稳定的是“快、选、堆、希”，其余都稳定。这个口诀能快速解决选择题。容易丢分的地方是“堆排序是选择类排序，不稳定”——很多人觉得它和快排都是 O(n log n)，就以为也像归并一样稳定，一选就错。归并的稳定性来自“合并时相等元素优先取左半”，这个细节值得记一句。
4.2 快排与堆排的手写细节：边界条件与基准值选择
快排手写是出现率很高的题，也是二刷时最容易暴露边界问题的题。Lomuto 分区最简单：基准取最后一个元素，i 指向小于区的末尾，j 扫描整个区间，遇到小于基准的元素就与 i 交换，最后把基准换到 i+1 的位置。注意 low 和 high 是闭区间还是开区间，不同写法会让很多人翻车。
def quick_sort(arr, low, high): if low < high: # 分区，返回基准位置 pi = partition(arr, low, high) quick_sort(arr, low, pi - 1) quick_sort(arr, pi + 1, high) def partition(arr, low, high): pivot = arr[high] i = low - 1 # 小于区的最后一个位置 for j in range(low, high): if arr[j] < pivot: i += 1 arr[i], arr[j] = arr[j], arr[i] # 基准归位到 i+1 arr[i + 1], arr[high] = arr[high], arr[i + 1] return i + 1逻辑说明：Lomuto 每次把 high 位置当作基准，返回值 pi 的左侧全小于等于基准，右侧全大于等于基准；递归区间是 [low, pi-1] 和 [pi+1, high]，基准本身不参与后续递归。参数说明：low 和 high 是闭区间边界，调用时必须写 quick_sort(arr, 0, len(arr)-1)，少写 -1 就会越界。如果输入数组基本有序，固定取最后一个元素作基准会导致分区极不平衡，最坏退化 O(n^2)；改成三数取中（low、mid、high 三个位置中取中间值作基准）可以显著降低退化概率，笔试时在 partition 开头加三行即可。如果不要求原地排序，手写归并代替快排更安全，因为归并最坏也是 O(n log n)，只是需要额外空间。堆排序手写重点在建堆和下沉：建堆从最后一个非叶子节点 (n//2 - 1) 开始向前调整，下沉时比较左右孩子选较大值与根交换，循环边界用 while index < n，每次交换后 index 更新为孩子位置。
4.3 查找与哈希：冲突处理策略与装填因子怎么答
查找部分选择题常考二分查找的比较次数和判定树高度；大题常考二分查找代码。二分查找最忌讳边界混乱，推荐左闭右开写法：区间是 [left, right)，循环条件 while left < right，mid 取 left + (right-left)//2，缩小区间时用 right = mid 或 left = mid + 1。这套写法统一后，各种变体（找第一个大于等于 target 的数、找最后一个小于等于 target 的数）都只改一两行。
def lower_bound(nums, target): left, right = 0, len(nums) # 左闭右开区间 [left, right) while left < right: mid = left + (right - left) // 2 if nums[mid] < target: left = mid + 1 # mid 不行，区间右移 else: right = mid # mid 可行，保留 mid return left # 第一个大于等于 target 的下标逻辑说明：当 nums[mid] < target 时，mid 及其左侧都不可能满足条件，所以 left 跳到 mid+1；否则 right 收到 mid，保证区间长度减少且不丢失答案。参数说明：nums 是已排序序列，允许重复元素；target 是待查值；返回的是插入位置，等价于 C++ 的 lower_bound。注意 mid 用 left + (right-left)//2 而不是 (left+right)//2，避免整数溢出，这个细节在面试里也是加分项。
哈希部分常考冲突处理和装填因子。开放定址法包括线性探测、二次探测、再散列；链地址法将冲突元素挂成链表。装填因子 = 表中已有记录数 / 表长，越大冲突概率越高，一般控制在 0.7~0.8 以下。线性探测的“堆积”现象是高频易错点——连续占用会让后续插入探测次数增加，二次探测能缓解但只能探测到表长一半的位置。这些结论建议整理成“哈希必背五条”，考前直接套。
5. 备考中的常见问题与避坑：刷题量上去了分数没上去的原因
这一章专门整理我在复习指导过程中反复看到的真实问题。每一条都是“现象 → 原因 → 解决”的结构，你可以对照自己的复习状态，看看踩了哪几条。
5.1 现象：背熟了算法却不会写代码
很多考生把“看懂了”当成“会写了”。看到快排注释能说出思路，合上笔记却连 partition 里的 i 都忘了初始化。原因很简单：数据结构是写出来的，不是看出来的。解决方式是每学完一个模板，当晚合上文档独立手写一遍，写不出来的地方就是知识盲区。我用过比较有效的办法是“15 分钟手写挑战”：十分钟写主体，五分钟检查边界，不看任何参考，写错就重来。链表反转、二分查找、快排、中序迭代遍历，这四道可以作为最小自测集，能全对再往下推进。
5.2 现象：复杂度分析反复翻车
选择题问“在表尾插入元素，顺序表和链表分别是多少”，有人答成 O(n) 和 O(1)，还有人把“均摊复杂度”和“最坏复杂度”混用。翻车原因是复习时只背结论，不关心结论怎么来的。解决方法是把复杂度推导过程记在文档里：顺序表尾插为什么 O(1)——因为只需在 length 位置赋值并 length+1；链表尾插为什么 O(n)——因为要先遍历到尾节点。递归算法的复杂度建议记一下主定理的三种常见情况：T(n)=aT(n/b)+O(n^d)，当 a=b^d 时结果是 O(n^d log n)，a<b^d 时是 O(n^d)，a>b^d 时是 O(n^{log_b a})。归并、快排相关的选择题基本都能用这个公式快速判断。
5.3 现象：选择题里的概念细节丢分
稳定排序、循环队列判空判满、线索二叉树的“前驱后继”指什么、栈的增长方向，这些细节只占一两分，但错三道就拉开差距。原因是在做真题时遇到细节题只是对答案，不把相关知识点划入总结。建议建一张“易混点清单”，每条写成“定义 + 反例 + 一句话记法”。比如“堆排序不稳定，因为相同关键字可能被调整到堆的不同位置”“循环队列判满画一个 4 格队列就懂，不用背公式”。这张清单考前 30 分钟只看一遍，比临时翻教材有效得多。
5.4 现象：只刷题不总结，题型迁移不了
刷题是必要的，但就题论题很难把分数稳定下来。一个典型表现是：做过“数组中两数之和”，换成“三数之和”就看不懂，因为缺少从“暴力解 → 优化结构 → 双指针”的迁移意识。解决方法是每道错题记录三个字段：考点、错误原因、同型题特征。比如“两数之和”的考点是哈希表补数，“三数之和”是排序加双指针，两道题解法不同，但都要求先想“能不能把一层循环的查找降成 O(1)”。把这个总结过程写进知识点文档，积累 50 道错题的效果比盲目刷 200 道更稳。
5.5 现象：时间分配失衡，大题写不完
计算机类岗位考试里，选择题和大题的分数结构不同，常见问题是在前面的概念题上犹豫太久，最后算法设计题只剩十分钟。原因是平时没做过整套限时训练。建议留出几套完整模拟题，分三轮做：第一轮全部做完看正确率；第二轮只做错题并写明原因；第三轮限时完成，逼自己在不确定时快速标记跳过。算法大题即使写不出完整代码，也要写出核心数据结构、关键步骤和复杂度分析，给阅卷一个“思路正确”的落脚点，这比留白强得多。
6. 把总结文档用起来：一套可执行的复习节奏与自测方法
这份知识点总结最终要落成可以“照着练”的清单，而不是躺在硬盘里的文档。我建议把它拆成三个复习轮次：第一轮按章节顺序过知识点，边看边把每个模板代码手写一遍，目标不是背，而是建立“看到题型 → 想到结构 → 想到模板”的反应链；第二轮按题型倒着走，从真题里的数据结构和算法题反查知识点，把错题涉及的章节标红，标红位置就是下一轮重点；第三轮只翻高亮和易混点清单，每天抽 15 到 20 分钟做一道手写题，保持代码手感。自测时不要用看的方式，要合上文档写输出，然后用“能否在限定时间写对”作为唯一标准。
数据结构与算法的提分逻辑其实不复杂：考点固定、模板固定、易错点固定。真正稀缺的是“把该学的范围收窄”和“把写过的代码反复写对”。我帮几位备考者梳理这类文档时最深的感受是：第一次复习时贪全，把偏门知识点都背了一遍，反而没挤出时间做二叉树层序和快排的手写，最后失分点恰恰在那些基础题上。这个方向真正该投入的精力，不在偏门知识点，而在高频模板的肌肉记忆。如果你也是按章节整理这份资料，建议在文档最前面留一页“优先级清单”，按复习频率排序列出必背算法，每次打开先过这页，再决定今天要不要深入细节。希望帮到你，也希望你复习到最后能体会到那种“翻车越来越少”的正反馈——数据结构与算法这个地方，投入和回报几乎成正比。
本文还有配套的精品资源，点击获取
