专升本数据结构备考：线性表、链表、树图与排序的代码与避坑全攻略-平芜编程栈

简介：这份数据结构复习资料专为专升本考生设计，内容系统覆盖数组、链表、栈、队列、二叉树、堆、图、散列表等核心结构，以及排序与查找算法的应用。资源以“数据结构1800例题与答案”为主体，共包含三十四个文件，其中二十三个为htm网页格式的题目分页或答案解析，另有十一个doc文档试卷，整体压缩包约一点零九MB，轻量易下载，适合在手机或电脑上随时刷题对照。截至目前已有五百零八人学习下载，是备考中后期集中突破选择题、填空题与综合题的实用题库。通过大量典型例题与详细答案的反复练习，考生不仅能够熟悉各类数据结构的定义、操作特性和适用场景，还能掌握时间空间复杂度分析、排序算法比较、查找策略选择等高频考点，并逐步建立从理论到代码实现的解题思路，有效提升专升本考试的应试能力与编程基本功。

1. 专升本数据结构：决定你专业课能不能过线的核心资源

没做过专升本数据结构真题的人，很难理解这门课有多“不讲道理”：概念题能考到 malloc 返回值的类型，编程题直接让你 15 分钟手写单链表反转，代码写错一个指针就整段废掉。很多人在这门课上栽跟头，不是因为不努力，而是资料太碎——教材、习题、代码、实验报告各是各的，学完还是一张白纸。这份专升本数据结构资源把严蔚敏 C 语言版的知识点、王道 408 的考点以及常见期末题型整合成一条完整链路，覆盖线性表、栈、队列、树、图、八大排序，每一块都拆成“概念梳理 + 手写代码 + 易错点”三段。适合正在备考专升本、准备 408 数据结构第一轮，或者期末复习想快速搭起体系的工科生。你不需要再花一周去搜零散笔记，按这份资源的章节顺序走，就能把考点一条条过完，编程题也能从“看懂”变成“写得出来”。

2. 线性表与链表：先从顺序表和单链表扫清第一道坎

2.1 选型逻辑：顺序表和链表的边界，决定你代码对不对

专升本考纲里，线性表是第一个大题区。你要先解决的不是怎么背代码，而是搞清楚顺序表和链表各自的应用边界，因为考试常考“哪种结构更适合什么场景”这种概念题，答错直接丢 5 分。

顺序表用一段连续内存存元素，按下标访问是 O(1)，但插入和删除平均要移动一半元素，是 O(n)。链表每个节点单独分配内存，用指针串起来，已知位置时插入删除只要改指针指向，是 O(1)，但查找一个元素必须从头遍历，是 O(n)。这是最基础的结论，但考试喜欢换角度问：频繁插入删除、元素个数不确定、需要动态扩容就选链表；元素个数固定、需要快速按下标访问就选顺序表。答题时把“随机访问”和“插入删除”两个复杂度都写出来，再落一句结论，基本就是满分。

还有一个常被忽略的点是空间开销。顺序表多分配时要预留容量，可能浪费尾部空间；链表每个节点多一个指针域，C 语言里 64 位系统指针占 8 字节，节点多了开销不小。所以有些题目会问“存储密度”，顺序表更接近 1，链表低于 1。这个点在 408 和专升本里都出现过，答题顺带提一句存储密度和内存碎片，比只写复杂度更容易拿全分。

我把常见判断整理成一张表，考前可以当速查卡用：

判断维度	顺序表	链表
随机访问 a[i]	O(1)，按下标直接算地址	O(n)，必须从头走
头部插入/删除	O(n)，元素整体后移	O(1)，改 head 指针
已知节点后插入	O(n)，先移动再插入	O(1)，改两个指针
空间分配	可能预留过多，扩容麻烦	节点随用随分，无扩容问题
存储密度	接近 1	每个节点多一个指针域
适用场景	查找多、按下标访问多	插入删除多、数据量不确定

考试里还有一种结合题：用链表实现栈和队列。栈用链头做栈顶，入栈就是头插，出栈就是删第一个节点；队列用尾指针做入队，头指针做出队。这类题在专升本编程题里出现过不止一次，代码和单链表操作几乎是同一套，把下面的四个核心函数练熟，这类题就是送分。

2.2 单链表四个核心操作的手写模板

编程题是专升本数据结构的大头，很多学校直接考“创建链表 + 逆序输出”这类题。单链表必须能手写的基础操作有四件：建表（头插法/尾插法）、按值删除、反转、合并两个有序链表。给一段可以直接抄的模板，我用的是 C 语言，和严蔚敏教材的写法保持一致：

#include <stdio.h> #include <stdlib.h> typedef struct LNode { int data; struct LNode *next; } LNode, *LinkList; // 头插法：插入后链表的顺序和输入相反 LinkList createByHead(int arr[], int n) { LinkList head = (LNode*)malloc(sizeof(LNode)); head->next = NULL; for (int i = 0; i < n; i++) { LNode *s = (LNode*)malloc(sizeof(LNode)); s->data = arr[i]; s->next = head->next; // 新节点指向原第一个节点 head->next = s; // head 指向新节点 } return head; } // 尾插法：保持输入顺序，用尾指针 r 标记最后一个节点 LinkList createByTail(int arr[], int n) { LinkList head = (LNode*)malloc(sizeof(LNode)); LNode *r = head; // r 始终指向尾节点 for (int i = 0; i < n; i++) { LNode *s = (LNode*)malloc(sizeof(LNode)); s->data = arr[i]; r->next = s; r = s; // 更新尾指针 } r->next = NULL; // 最后收尾 return head; } // 按值删除：删除第一个值为 val 的节点，需要保留前驱 pre int deleteByValue(LinkList head, int val) { LNode *pre = head, *p = head->next; while (p != NULL && p->data != val) { pre = p; p = p->next; } if (p == NULL) return -1; // 没找到 pre->next = p->next; // 前驱直接跨过被删节点 free(p); return 0; }

逻辑说明：头插法每次把新节点插在 head 后面，所以最后得到的是逆序链表；尾插法多维护一个 r 指针指向最后节点，保证顺序不变。删除操作必须保留前驱 pre，因为单链表只能往后走，拿不到 node->prev。三个函数有一个共同点：都要处理“链表为空”和“没找到”的边界，deleteByValue 里 while 循环条件同时判断 p != NULL，就是为了防止访问空指针的 data 字段。

参数说明：createByHead 和 createByTail 的 arr 是待插入数组，n 是元素个数，返回带头结点的链表头指针。deleteByValue 的 val 是目标值，返回 0 表示删除成功，-1 表示没找到。注意三个函数都假设传入的是带头结点的链表，这符合绝大多数教材和专升本题目的默认约定。

接着是反转和合并，这两个是专升本编程题的高频考点：

// 三指针反转：pre 指向已反转部分的前一个，p 指向当前节点，q 指向下一个节点 LinkList reverseList(LinkList head) { LNode *pre = NULL, *p = head->next, *q; while (p != NULL) { q = p->next; // 先存下一个节点，否则断链后找不到 p->next = pre; // 当前节点的 next 掉头 pre = p; // pre 前移 p = q; // p 前移 } head->next = pre; // 末尾接上新链头 return head; } // 合并两个递增有序链表，结果仍递增 LinkList mergeList(LinkList A, LinkList B) { LNode *pa = A->next, *pb = B->next; LinkList C = (LNode*)malloc(sizeof(LNode)); LNode *tail = C; while (pa != NULL && pb != NULL) { if (pa->data <= pb->data) { tail->next = pa; pa = pa->next; } else { tail->next = pb; pb = pb->next; } tail = tail->next; } tail->next = (pa != NULL) ? pa : pb; // 剩余整段直接接上 return C; }

逻辑说明：反转用三个指针 pre、p、q，核心是每次先把 p->next 存到 q，再把 p->next 指向前一个节点，最后三个指针一起后移。合并两个有序链表时，比较 pa 和 pb 的 data，谁小接谁，最后一定有一个链表先走完，把剩余那段整个接上去就行，不需要逐个再比。

参数说明：reverseList 接收带头结点的链表头指针，反转的是头结点之后的节点，head 本身不变，最后 head->next 指向新链头。mergeList 接收两个带头结点的递增链表头指针，返回新链表 C 的头指针，C 不额外分配节点数据空间，只是复用 A、B 的节点，这个细节写注释里能加分。

想判断自己是不是真会了，有个土办法：把以上函数抄一遍之后合上代码，在白纸上从头默写。默写到“反转时为什么要先存 q”这一步卡住，说明你对“链会断”这件事还没有形成肌肉记忆，回到代码再看一遍。专升本考试编程题基本都是从这四个操作变体出来的，比如“删除链表中所有值为 x 的节点”“合并后逆序输出”，万变不离其宗。

2.3 头结点与指针传递的三个隐蔽约定

带头结点的链表和无头结点是两个世界。头结点 data 字段不存数据，作用有两个：一是统一“空链表”和“非空链表”的操作逻辑，让插入删除不必单独处理首节点；二是避免链表为空时头指针为 NULL 导致的各种判空。严蔚敏教材和专升本考试默认带头结点，你答题前如果题目没明说，建议先写“带头结点”，再在注释里标一句，阅卷老师会认为你考虑周全。

第二个约定是函数参数。如果要在函数里新建链表并返回新头，应该用返回值方式 LinkList createByHead(...)；如果只是修改头结点之后的节点，传 LinkList head 就够了，因为 head 指向的节点还在。但有个经典错误：void deleteFirst(LinkList head) 想删除第一个节点，当链表只有一个节点时，函数内部 free 掉这个节点后 head 变成野指针，而主调函数里的 head 还是那个地址，再访问就崩了。正确做法是传二级指针 void deleteFirst(LinkList *head)，或者用返回值带回新头。这个点考试不一定直接考，但写代码时用错，运行起来就会出“玄学”崩溃。

第三个约定是 malloc 之后必须判空。C 语言里 malloc 失败会返回 NULL，很多同学不写 if (s == NULL) return NULL;。理论课不扣分，但有的学校评分标准里有“健壮性”一项，判空写了不扣分，不写可能扣 1 到 2 分。哪怕时间紧张，至少在主函数里写一次判空，代码看起来也更完整。这三个约定在高分模板里几乎每个都见到，它们决定了代码能不能跑，以及跑的时候会不会崩得莫名其妙。

3. 树、图与排序：算法大题的重灾区

3.1 二叉树遍历：递归与非递归的互通

二叉树是专升本必考的重灾区。递归遍历代码很短，但考试喜欢让你写“非递归”版本，因为递归本质用系统栈，考不到你对栈的理解。记住一个结论：递归遍历改成非递归，就是自己用栈模拟函数调用栈。

先看递归版本，前序和中序只在访问时机上差一行：

typedef struct BiTNode { int data; struct BiTNode *lchild, *rchild; } BiTNode, *BiTree; void preOrder(BiTree T) { if (T != NULL) { visit(T); // 前序：先访问根 preOrder(T->lchild); preOrder(T->rchild); } } void inOrder(BiTree T) { if (T != NULL) { inOrder(T->lchild); visit(T); // 中序：左中右 inOrder(T->rchild); } }

前序非递归的核心思路：遇到一个节点，先访问它，然后把它的右子树和左子树依次入栈——注意，正确的是先压右再压左，因为栈是后进先出，要让左子树先出栈。下面给能直接背的版本：

void preOrderIter(BiTree T) { if (T == NULL) return; BiTNode *stack[100]; // 用数组模拟栈 int top = -1; stack[++top] = T; // 根先入栈 while (top >= 0) { BiTNode *p = stack[top--]; visit(p); if (p->rchild != NULL) stack[++top] = p->rchild; // 右子树先入栈 if (p->lchild != NULL) stack[++top] = p->lchild; // 左子树后入栈 } }

逻辑说明：初始化一个空栈，根节点入栈。每次弹出一个节点访问，然后把它的右孩子和左孩子按“右先左后”的顺序入栈，保证下次弹出的是左孩子，实现“根-左-右”的访问顺序。考试里栈容量可以假设足够大，专升本不考动态栈扩容。

参数说明：T 是二叉树根节点指针；stack 数组充当栈，top 是栈顶下标；visit(p) 是你需要实现的访问函数。一个很实用的推导：后序遍历“左-右-根”正好是前序“根-左-右”的镜像，你可以在前序代码里把左右入栈顺序对调，输出再反转，就是后序结果。这个方法笔试时能省不少时间，前提是你记得把输出反转，不然就翻车了。

中序非递归就多一个“先一路走到最左”的步骤，逻辑是：从根开始，不断把左孩子入栈，直到没有左孩子；弹出栈顶访问，再转向右子树。这个“左到底再回头”的模式，在后续写线索二叉树和树的遍历时都通用。建议你把这个模板抄到手写笔记里，每题对照着写，比死背代码可靠。

3.2 图的存储与最短路径的拿分点

图在专升本里占分比树低，但必考。第一类考点是存储结构对比：邻接矩阵是二维数组，判断任意两个顶点是否有边是 O(1)，但空间复杂度 O(n²)，适合顶点少边多的稠密图；邻接表每个顶点挂一条链表，空间 O(n+e)，适合稀疏图，但判断两个顶点是否有边要遍历链表。考题常问“求某个顶点的度”，无向图邻接矩阵里数对应行的非零元素个数，邻接表数链表长度；有向图还要区分出度和入度，出度数链表长度，入度要遍历所有顶点的链表才能统计——这是很多人丢分的点，后面避坑章节我会专门讲。

第二类考点是最短路径。专升本考 Dijkstra 比较多，要求你手工模拟出每一轮的 dist 数组变化，有的学校还要求写伪代码。手工模拟的关键是记住三步：每次从未确定最短路径的顶点里挑 dist 最小的；把这个顶点标记为已确定；用这个顶点更新它所有邻接顶点的 dist。真题里最坑的变体是“边权为负”，Dijkstra 直接失效，正确答案要指出它不能用、要用 Bellman-Ford。如果你只背了步骤没理解“为什么负权不行”，这题就死了。

给一段简化版 Dijkstra 核心代码：

#define INF 0x3f3f3f3f // n 个顶点，edges 是邻接矩阵，start 是源点 void dijkstra(int n, int edges[][MAX], int start, int dist[]) { int visited[MAX] = {0}; // visited[i] = 1 表示已确定最短路径 for (int i = 0; i < n; i++) dist[i] = edges[start][i]; dist[start] = 0; visited[start] = 1; for (int k = 0; k < n - 1; k++) { int u = -1, minD = INF; for (int i = 0; i < n; i++) { if (!visited[i] && dist[i] < minD) { // 找未确定中最小 minD = dist[i]; u = i; } } if (u == -1) break; // 剩余顶点不可达 visited[u] = 1; for (int v = 0; v < n; v++) { if (!visited[v] && edges[u][v] < INF && dist[u] + edges[u][v] < dist[v]) { dist[v] = dist[u] + edges[u][v]; // 松弛更新 } } } }

逻辑说明：dist 初始化为源点到各顶点的直接边权，没有边就是 INF。每轮选一个未确认且 dist 最小的顶点 u，标记后用它去“松弛”其他顶点——大白话就是“经过 u 到 v 会不会比现在直接到 v 更短”。因为负边权会让“已经确认的最小值”到后面还能被更短的路径改小，所以 Dijkstra 对负权失效。

参数说明：edges 是邻接矩阵，松弛条件里判断 edges[u][v] < INF 是为了防止对无边的情况做无意义更新。visited 数组控制“每轮确认一个顶点”的节奏，手工模拟题里对着它一行行写步骤就行。MAX 是矩阵最大维数，不同学校的题面会给出具体值，答题时沿用题面常量即可。

3.3 八大排序横向对比：一张表和一段快排

排序是数据结构里知识点最密的一块，也是 408 和专升本都密集出题的区域。你需要一张表把八种排序钉死在脑子里：

排序算法	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
直接插入	O(n²)	O(n²)	O(1)	稳定
希尔排序	O(n^1.3) 左右	O(n²)	O(1)	不稳定
冒泡排序	O(n²)	O(n²)	O(1)	稳定
快速排序	O(n log n)	O(n²)	O(log n)	不稳定
简单选择	O(n²)	O(n²)	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(r)	稳定

记忆不用口诀，但有一句话很好用：“快选堆”都不稳定，其余稳定。快排最坏退化到 O(n²)，发生在初始序列基本有序或每次划分极不均衡时；归并空间 O(n) 因为要临时数组；基数排序的关键字有 d 位，每位的取值是 r 个。考试如果问“哪几种排序的移动次数和序列初始状态关系最大”，答案是快排，因为某个元素可能被反复移动跨越很远——这个坑很多人不知道。

快排必须能手写，专升本甚至有的学校会把它当成单独的大题：

// 一趟划分：以 a[low] 为枢轴，小的放左，大的放右 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; } void quickSort(int a[], int low, int high) { if (low < high) { int p = partition(a, low, high); // p 是枢轴最终位置 quickSort(a, low, p - 1); // 递归排序左半 quickSort(a, p + 1, high); // 递归排序右半 } }

逻辑说明：partition 每次把第一个元素当枢轴，从右边找比枢轴小的填空位，从左边找比枢轴大的填空位，最终 low 和 high 相遇的位置就是枢轴落点。递归边界是 low >= high。要特别注意 while 里比较用的是 >= 和 <=，不是 > 和 <，否则相等的元素会频繁交换，序列全是重复元素时快排会退化到 O(n²)——这是我实测踩过的坑。

参数说明：a 是待排序数组，low、high 是本次划分的区间端点。枢轴选 a[low] 是严蔚敏教材默认写法，408 真题里有用三数取中优化枢轴的变体，专升本如果问到，说“随机或取中能改善退化情况”即可。

整个排序模块的复习顺序我建议是：先背复杂度表背到条件反射，再手写快排和归并两个 O(n log n) 的，最后用冒泡和直接插入去理解“谁在交换、谁在移动”。排序代码不需要八种全背，但概念题要全会，这是性价比较高的策略。

4. 常见问题与避坑：最容易翻车的五个现场

4.1 野指针：free 之后继续访问

现象：deleteByValue 删除节点后，主程序里继续打印这个节点的 data，有时输出诡异数字，有时直接段错误；在 Visual Studio 里报“触发了一个断点”。

原因：free(p) 只是把 p 指向的内存还给系统，p 的值没变，仍然指向一块已被释放的区域，这叫野指针。系统可能已经把这块内存重新分配给别人，再读就是未定义行为。

解决：删除节点后立刻 p = NULL。写代码时养成两个习惯：malloc 后判空，free 后置空。考试里阅卷老师不一定会运行，但 free 之后没有任何处理，有经验的老师一眼就能看出隐患，扣分没得商量。

4.2 递归出口缺失导致栈溢出

现象：中序非递归写完后运行正常，递归版本一旦树超过几层就崩，弹窗显示 stack overflow。

原因：递归版本没有写“空树返回”的出口，或者把 return 写成了递归调用。比如 void inOrder(BiTree T) { if (T->lchild) ... } 这种写法，在 T 为 NULL 时访问 T->lchild 直接崩。

解决：递归函数第一行永远是 if (T == NULL) return。如果发现一个递归函数在无限调用自己，第一件事加出口再加断言。专升本不考深奥递归，所有树遍历递归都只有“空树返回”和“左右子树分别递归”两条路，先写出口再写逻辑，就不会栈溢出。

4.3 复杂度凭感觉判断

现象：判断循环次数时只数外层 for，看到一个双层循环就写 O(n²)，实际上内层循环次数是 log n，正确答案是 O(n log n)。

原因：复杂度计算要数“基本操作的执行次数”，不是数循环嵌套层数。很多同学把“两层循环”直接等同于 O(n²)，忽略内层步长变化。

解决：用一个自查模板——找到循环里执行最频繁的那条语句，数清它在最坏情况下执行几次。比如 for (i = 1; i <= n; i *= 2) 内层执行 log₂n 次，再嵌套一个 n 次的外层，就是 O(n log n)。专升本复杂度题不超过这个难度，平时做题时每次写完顺手在括号里写依据，坚持两周就不怕了。

4.4 稳定性与排序算法的绑定记混

现象：单选题问“下列哪个排序算法是稳定的”，选项里同时出现堆排序和归并排序，选了堆排序，丢 2 分。

原因：把“快选堆不稳定”记成了“快堆选不稳定”，或者把“选择”和“插入”搞混了。

解决：用拆字法。“选择”排序每次“选”一个极值扔出去，被选中的元素可能跳过相同值的另一个元素，所以不稳定；“插入”是相邻比较逐步挪动，相同值不会越过彼此，所以稳定。归并稳定是因为合并时两个子序列用 <= 比较，相等时取左半边的，相同值也能保持相对顺序。考前把“稳定 = 相邻比较；远距离跳越 = 不稳定”这个原则写在自己的速查卡上，比死记列表可靠。

4.5 图的入度计算漏掉所有顶点

现象：给一个有向图让你求每个顶点的入度，用了邻接表，只数了每个顶点自己链表的长度，得出“入度等于出度”的错误结论。

原因：有向图邻接表存的是“出边”，一个顶点的链表里都是它指向的顶点。要求入度只能反过来统计“谁指向我”，必须遍历所有顶点的链表。

解决：把邻接表理解成“出边表”。求入度时，对每个顶点 v，遍历所有顶点的链表，数链表里出现 v 的次数。考试模拟这种题时，拿一张纸画邻接表，每看到一个 v 就手动加一，养成“统计对象是 v 而不是当前链表头”的习惯，这个坑就不会再踩。

5. 备考落地：教材、王道 408 与真题的配合路径

5.1 教材选型：严蔚敏 C 语言版 + 王道 408 的配合方式

专升本复习的第一个常见错误是“只看一门资料”。严蔚敏《数据结构（C 语言版）》是很多省份专升本的指定教材，知识点全、符号正统，但例题偏理论、代码风格偏老。王道 408 的《数据结构》是考研系列的，优势在考点归纳直接、真题密度高，尤其“408 数据结构代码必背”那一批总结，对专升本同样适用——因为专升本很多题就是从考研题改编过来的。

我的建议是：主线用严蔚敏，刷题用王道。具体顺序是——第一轮：一章严蔚敏教材 + 对应王道小节的选择题；第二轮：重做王道标记过的错题 + 刷目标院校近五年真题；第三轮：只过真题中的编程题，用白纸手写。专升本的考纲一般比 408 少，比如“跳表、B 树细节、KMP 证明”这些多半不考，但“B 树的插入删除”“KMP 求 next 数组”有的省份又确实出现过。所以拿到本省考纲后，先拿荧光笔在严蔚敏目录上划掉不考章节，这一步能省一周时间。

5.2 三轮复习法与每轮的产出物

第一轮大概 6 周，按章节同步学概念和代码。要求每一章的代码当天在白纸上默写一遍，比如学完单链表，当天晚上把建表、删除、反转各默写一遍。默写不是为了背题，是为了让你在考场上看到“逆序输出链表”时能直接写出来，不需要现场想。

第二轮大概 4 周，以刷题为主。把王道每章后面的题做一遍，错题分三类：概念错、代码错、粗心错。概念错回教材看原话；代码错自己写注释复盘；粗心错的标一个“下次审题先画数据流”。这一轮的产出物是一份自己的易错清单，大概 3 到 5 页 A4，后面第三轮只看它。

第三轮大概 2 周，做真题模拟。按考试时间做套题，编程题限时 15 分钟，概念题限时 1 分钟一题。做完立刻对答案，重点不是对错，而是找出“概念题虽然对了但不确定”的题——这些才是真正要补的。三轮时间可以根据自己基础压缩，但第三轮不能省，因为考试状态只有真限时才能练出来。

5.3 编程题答题模板与考场时间分配

专升本编程题分三种：实现类（建表、遍历、反转）、结果输出类（给一棵树写出遍历序列）、算法设计类（求二叉树深度、判断链表是否有环）。答题时用固定模板：先写函数头注释，说明入参和返回值；再写核心逻辑；最后写边界处理。哪怕时间不够，也要把函数头写出来，有的老师按点给分，函数签名有分、核心循环有分、边界有分。

考场时间分配我一般建议：选择填空 20 分钟，判断题 10 分钟，简答题 30 分钟，编程题（通常 2 到 3 道）45 分钟，剩下 15 分钟检查。最常见的翻车是概念题耗时过长——“这个排序稳定不稳定”纠结了五分钟。应对方法是：遇到不确定的先标记跳过，最后回头，把自己练过的判断原则默写在草稿纸上再选。

6. 进阶：白纸默写三遍法，把代码焊成肌肉记忆

资源里所有代码都抄过一遍之后，你面临一个真问题：抄会了不等于会写。我自己当年就翻车在这一点上——资料看了三遍，代码每行都懂，一上考场写层序遍历，手放在纸上，第一个循环的初始化就卡住了。后来我总结了一个验证方法，叫“白纸默写三遍法”，这份资源里每个核心函数都适用。

第一遍：读完题目后立刻合上资料，在白纸上写。允许卡壳，卡壳时在边上画一个“#”标记。写完自查，把这遍代码作为“第一次版本”存档。第二遍：隔 24 小时，把第一遍的版本盖住，重新写。这一遍的目的不是和标准答案比对，而是检验第一次卡壳的地方补上没有。第三遍：隔一周，这次限时，比如快排 8 分钟写完，单链表反转 5 分钟写完。三遍都能在限定时间内完整写完且自测无误，才算通过。

用这个标准去卡资源里的每个函数，你会发现一个有意思的现象：有些函数一遍就过，有些函数三遍都卡同一个地方。卡点就是你的弱项，记到易错清单里。考前最后两天，别人在翻书，你只需要翻这份“卡点清单”。

验证轮次	时间间隔	要求	通过标准
第一遍	学完当天	合书默写	能写完，卡壳处标记
第二遍	24 小时后	盖住第一遍	卡壳处能补齐
第三遍	一周后	限时默写	限时内完成且逻辑自测通过