企业官网建设流程全解析

简介：青岛大学王卓教授编著的《数据结构与算法基础》配套学习资源包，适合高校计算机专业学生、考研复习者及自学者系统学习核心数据结构。资源按绪论、线性表、栈和队列、串、树和二叉树、图、查找、排序共八章组织，循序渐进覆盖各知识模块。包内共80个文件，以43张PNG原理示意图为主，另有24个C++算法实现示例、9个Markdown章节笔记、2个说明文档和2个头文件，压缩包仅8.16MB，便于本地查阅。图示内容具体到平衡二叉树LL/LR/RR/RL四种旋转调整、顺序表与链表比较、串的next[j]计算、图的存储结构对比，以及各类查找和排序方法效率对比等易混淆重点；C++示例则对应各章算法设计题目，可直接编译运行。已有115人学习，适合期末复习、考研专业课备考或日常自学的查漏补缺。

1. 数据结构与算法基础（青岛大学-王卓）.zip：为什么自学者绕不开这套课

很多人第一次学数据结构，不是死在二叉树，而是死在链表上。翻开严蔚敏的《数据结构（C语言版）》，线性表那一章读得明明白白，合上书想写一个链表反转，却连 next 指针该指向哪里都理不清。这时候，很多人会把“数据结构与算法基础（青岛大学-王卓）.zip”这套资源找出来。它是一套以青岛大学王卓老师主讲的课程视频为核心的资料包，章节沿着严蔚敏教材走，被热心网友整理成 zip 压缩包流传，成了考研党的入门常备。

这套课的价值，在于把“看书看不懂”的抽象概念，用黑板推演和 C 代码逐步讲透。指针、递归、KMP、图遍历这些劝退点，在王卓的课里都有手把手的推导过程。它不是用来替代教材，而是用来填补“从概念到代码”的中间断层。适合三类人：准备 408 考研、期末临时抱佛脚、以及刷算法题之前想补数据结构的从业者。

后面我会从课程结构、代码复现、常见翻车、刷题节奏四个方面，把这套资源的用法拆开讲清楚。你不需要把每一条都说服，只要跟着其中一条路走一遍，就能感受到它和单纯看视频的差别。

2. 先清点课程的骨架：从线性表到排序，把学习顺序调成“能落地”的模式

拿到 zip 之后不要急着解压从头看到尾。先弄明白课程讲什么，再决定用自己的顺序学。王卓的《数据结构与算法基础》基本按严蔚敏《数据结构（C 语言版）》的章节来，数据结构这门课谈的是数据的逻辑结构、存储结构以及操作集合，课程主线就是线性结构、树形结构、图结构和排序查找算法。

对初学者来说，视频资源容易造成“我全懂了”的错觉。为了防止这种错觉，建议每章结束前关闭视频，自己写一段提纲讲给自己听。能讲出来，才算真正过了一遍。下面我会把课程内容和学习顺序拆成三块：章节对应关系、视频课件配合方式、两种学习路线。

2.1 课程内容与严蔚敏教材的对应关系

常见的大块有：绪论（复杂度分析）、线性表（顺序表与链表）、栈和队列、串（重点在 KMP 算法）、数组与广义表、树与二叉树（遍历、哈夫曼树）、图（遍历、最小生成树、最短路径）、查找（二分查找、BST、哈希）、排序（插入、交换、选择、归并）。具体对应关系可以看这张表：

很多人分不清“数据结构”和“数据类型”的区别。数据结构是数据元素之间的关系，比如线性关系、层次关系；数据类型是编程语言层面的一组值和操作集。这个区别在课程绪论里讲过，但容易忽略，408 选择题偶尔会考。还有“逻辑结构”与“存储结构”的关系：线性表是逻辑结构，顺序表是它的顺序存储实现，链表是它的链式存储实现，同一个逻辑结构可以有多种存储方式。这些概念不搞清楚，后面树的“二叉链表存储”和图里的“邻接表存储”都会学成一笔糊涂账。

课程名字里带着“算法”，但主要内容还是以数据结构为骨架的经典算法。贪心、动态规划、回溯这类独立的算法设计技巧，在这套课里只是顺带提及，不是主线。如果你是为了 408 里的算法大题，学完这套课之后还要另外补算法设计专题。

2.2 视频和课件怎么配合：先看推导再抄代码

我一般建议三遍法。第一遍用 1.5 到 2 倍速完整听一遍，只求听懂每章的“为什么”：为什么链表插入要改指针，为什么快排要递归。第二遍停下来，跟着老师在黑板上手写推导，尤其是 KMP 的 next 数组、二叉树遍历、图的最小生成树，这一步是理解的关键。第三遍才是上机，把课上的伪代码或老师手写代码，用 C 语言自己实现一遍。

具体操作可以这样拆：

• 解压 zip 后，按章节名给视频重命名，例如 01 线性表、02 栈和队列，避免播放器按文件名首字母排序打乱课程顺序。
• 每看完一章，用 A4 纸写一张“一页纸笔记”：逻辑结构、存储结构、核心操作、复杂度、易错点。这张纸就是后面复习的索引。
• 课件里若有代码片段，先抄在纸上，不要复制粘贴。抄写的过程会逼你注意到分号、下标这些细节。

zip 包里有时文件编码是 GBK，在 macOS 解压会乱码，这是常见坑，后面避坑章再说。这里的重点是：资源本身是静态材料，只有配合你的笔记和上机，才算被真正用起来。只看视频不下手，大概率一周后就忘光了。

2.3 两种学习顺序：按章节推进 vs 按专题横向打通

零基础自学者适合按章节顺序走，因为课程设计有递进关系。线性表是栈队列的基础，树是图的基础，查找排序依赖前面掌握的代码能力。顺序推进不容易造成知识点缺口。但如果你已经有基础，只是为了应付考试或快速复习，横向专题会更高效。

横向专题的组织推荐这么做：

• 线性表专题：顺序表、单链表、双链表、循环链表，把增删改查的实现放一起对比，你就能看出指针操作的同构性。
• 递归专题：斐波那契、二叉树遍历、快排、归并，集中体会递归的三要素：终止条件、递归方程、返回值。
• 排序专题：插入排序、冒泡排序、快速排序、堆排序、归并排序，五个算法横向对比，重点记稳定性、时间复杂度和适用数据量。
• 查找专题：顺序查找、二分查找、BST 查找、哈希查找，体会“预排序”带来的复杂度变化。

专题法非常适合在后半程做“数据结构期末复习”或者“408 数据结构考研知识点归纳”时用。你不需要把所有视频重新看一遍，只需把涉及该专题的片段调出来，对照着表格过一遍。记得在笔记里留一栏标注“这个算法在哪个视频里讲过”，以后出问题能快速定位。

另外，不少人在学图结构时，觉得邻接矩阵比邻接表好理解，就忽略邻接表。但王卓课上反复强调，邻接表是稀疏图的标准存储方式，408 也喜欢在这上面出代码题。如果你跳过邻接表，后面 Kruskal、Prim、Dijkstra 这些算法在稀疏图上的复杂度分析就没法做。类似这种“看似简单实则必考”的点，在每章结束时要自己列一个考点清单，对照着视频确认没有遗漏。

3. 把课上的算法变成能跑通的 C 代码：链表、KMP、排序的最小复现

视频听懂不等于会写。这里选三个最典型、面试和考研都爱考的代码片段，用 C 语言最小实现跑通。它们都直接对应课程里的黑板书内容，也是很多人第一次翻车的地方。下面的代码我尽量保持和课上的思路一致，但去掉了环境依赖，只保留核心函数。

3.1 单链表反转：指针操作的“第一次翻车”

单链表反转是线性表章节的经典代码题。很多人跟着视频看觉得简单，自己写就把链表断开了。常见做法是用三个指针迭代：pre 指向已反转节点头，cur 指向当前节点，next 暂存 cur 的下一个节点。

#include <stdio.h> #include <stdlib.h> typedef struct ListNode { int val; struct ListNode *next; } ListNode; // 迭代反转单链表，返回新头节点 ListNode* reverseList(ListNode *head) { ListNode *pre = NULL; // 已反转部分的前一个节点 ListNode *cur = head; // 当前要反转的节点 ListNode *next = NULL; // 防止断链的暂存节点 while (cur != NULL) { next = cur->next; // 先保存下一个节点 cur->next = pre; // 改变当前节点的next指向 pre = cur; // pre后移 cur = next; // cur后移 } return pre; // pre最终指向原链表的尾节点，即新链表的头 }

逻辑说明：这个循环里最重要的一行是next = cur->next，它必须在改变cur->next之前执行。很多人直接写cur->next = pre，然后找不到原链表的下一个节点，导致循环走不下去。这个思想在后面的双向链表、树的反转类问题里反复出现。

参数说明：传入空链表时，cur == NULL，循环不执行，直接返回NULL，所以不用单独加判空，但为了代码可读性可以在函数开头加一句if (head == NULL || head->next == NULL) return head;。如果链表有环，这个迭代版本会变成死循环，正式代码里需要先跑快慢指针判环。另外注意，这里假设节点用malloc分配，测试完记得用free逐个释放，避免内存泄漏。

3.2 KMP 算法的 next 数组：手算和代码差一位的玄学

KMP 是串章节的重头戏，也是课程里公认最劝退的一节。问题几乎总是集中在 next 数组上：手算用公式能算出“最长相等前后缀长度”，但写成代码时下标从 0 还是从 1，结果完全不一样。下面给出以 0 为起始下标的版本，配合主串搜索函数。

#include <stdio.h> #include <string.h> // 计算next数组，下标从0开始，next[i]表示i+1失配时应回退的位置 void getNext(const char *p, int *next) { int len = (int)strlen(p); int i = 0, j = -1; next[0] = -1; // 约定next[0]为-1，便于统一处理 while (i < len - 1) { if (j == -1 || p[i] == p[j]) { i++; j++; next[i] = j; } else { j = next[j]; // 回退 } } } // 返回模式串p在主串s中的起始下标，找不到返回-1 int strStr(const char *s, const char *p) { int n = (int)strlen(s), m = (int)strlen(p); if (m == 0) return 0; int next[m]; getNext(p, next); int i = 0, j = 0; while (i < n && j < m) { if (j == -1 || s[i] == p[j]) { i++; j++; } else { j = next[j]; } } return j == m ? i - j : -1; }

逻辑说明：getNext里最难理解的是j = next[j]这一行。它表示前缀和后缀匹配失败时，把已经匹配的前缀长度j回退到它的最长公共前后缀长度。这个过程和 KMP 主串匹配是对称的，很多视频里会用“自己匹配自己”来概括。

参数说明：这个版本下标从 0 开始，next[0] = -1，对应的手算公式是“最长相等前后缀长度减一”。如果你习惯严蔚敏教材里下标从 1 开始，next[1] = 0，那next[i]的值会比这个版本大 1。写代码前必须先把下标约定写死在注释里，否则两个版本混用，失配时跳几次就越界。用模式串"ABABC"手算，这个版本的next是[-1, 0, 0, 1, 2]，你可以自己推一遍，再拿去和网上的 KMP 例子对照。

3.3 快速排序与归并排序：边界条件决定成败

排序章节是课程后半程的重点。视频里会把插入、冒泡、快排、堆排、归并都讲一遍，其中快排和归并是递归思想的两大代表，也是手撕代码时翻车最频繁的两个。

// 快速排序：取最左元素为枢轴，递归分治 void quickSort(int arr[], int low, int high) { if (low >= high) return; // 递归终止条件 int pivot = arr[low]; // 枢轴 int i = low, j = high; while (i < j) { // 从右往左找比枢轴小的元素 while (i < j && arr[j] >= pivot) j--; if (i < j) arr[i++] = arr[j]; // 从左往右找比枢轴大的元素 while (i < j && arr[i] <= pivot) i++; if (i < j) arr[j--] = arr[i]; } arr[i] = pivot; // 枢轴落位 quickSort(arr, low, i - 1); // 左区间 quickSort(arr, i + 1, high); // 右区间 }

逻辑说明：快排的坑主要在边界。while (i < j && arr[j] >= pivot)必须取>=，否则等于枢轴的元素会左右来回交换，导致死循环。递归出口low >= high而不是low == high，因为当区间只有一个元素时，low和high相等，函数应立即返回。

参数说明：这个版本以最左元素为枢轴，对基本有序的数组会退化成 O(n²)，所以实际工程常用随机选枢轴或三数取中。408 考试通常不要求实现随机化，但复杂度分析题里会明确指出“枢轴取中间值”的前提。常见排序的稳定性也要记住：快排不稳定，归并稳定，堆排不稳定。

归并排序的稳定版实现：

// 归并排序：递归分治后合并两个有序区间 void merge(int arr[], int temp[], int left, int mid, int right) { int i = left, j = mid + 1, k = left; while (i <= mid && j <= right) { if (arr[i] <= arr[j]) temp[k++] = arr[i++]; else temp[k++] = arr[j++]; } while (i <= mid) temp[k++] = arr[i++]; while (j <= right) temp[k++] = arr[j++]; for (i = left; i <= right; i++) arr[i] = temp[i]; } void mergeSort(int arr[], int temp[], int left, int right) { if (left >= right) return; int mid = left + (right - left) / 2; mergeSort(arr, temp, left, mid); mergeSort(arr, temp, mid + 1, right); merge(arr, temp, left, mid, right); }

逻辑说明：归并排序的空间复杂度是 O(n)，因为每一层递归都需要临时数组。这里的temp在调用前一次性分配，避免递归里重复malloc。mid = left + (right - left) / 2比(left + right) / 2更安全，可以防止大整数相加溢出。

参数说明：合并过程中if (arr[i] <= arr[j])中的等号保证了稳定性。如果改成arr[i] < arr[j]，相同元素会被提前挪到右侧，排序不再稳定。这道细节是选择题常客，写代码时也要注意。

3.4 二叉树遍历的递归框架与栈模拟

二叉树遍历是树章节的基础。课程会先讲递归版，再讲栈模拟的非递归版。递归版非常简单，但工程上递归深度过大会爆栈，所以非递归也必须能写出来。这里以前序遍历为例，展示两种实现。

// 二叉树节点定义 typedef struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; } TreeNode; // 递归前序遍历：根 -> 左 -> 右 void preorderRecursive(TreeNode *root) { if (root == NULL) return; printf("%d ", root->val); preorderRecursive(root->left); preorderRecursive(root->right); } // 非递归前序遍历：显式栈模拟系统栈 void preorderIterative(TreeNode *root) { if (root == NULL) return; TreeNode *stack[1024]; // 定长栈，节点数多时需扩容 int top = -1; stack[++top] = root; while (top >= 0) { TreeNode *cur = stack[top--]; printf("%d ", cur->val); // 栈是LIFO，先压右子再压左子，弹出顺序才是先左后右 if (cur->right) stack[++top] = cur->right; if (cur->left) stack[++top] = cur->left; } }

逻辑说明：递归版的三行代码对应“访问根、遍历左、遍历右”三个动作。非递归版用栈保存待访问节点，关键点是入栈顺序：先右后左，这样弹出时才能先处理左子树。很多人写反，导致输出变成“根右左”。

参数说明：这里的栈用了定长数组1024，只适合课堂演示。真正的 OJ 里树节点可能上万，需要用动态栈或者直接用malloc扩容。递归深度和树高成正比，最坏退化成链时深度为 n，程序会栈溢出；非递归版虽然用内存里的堆数组，同样受栈容量限制，但可控得多。

4. 避坑：自学这套课最常遇到的 5 个翻车现场

根据我自己的经验，像“数据结构与算法基础（青岛大学-王卓）.zip”这种资源，真正卡住人的不是课听不懂，而是用错方法。下面 5 个坑基本是自学者的通病，每条都按现象、原因、解决来讲。

4.1 只看视频不写代码，看到后面全忘了

现象：花了三周把视频全部看完，笔记也抄了一本，但一到自己写一个链表反转题，大脑一片空白。去 LeetCode 做题，连“判断链表是否有环”都想不出思路。

原因：数据结构是手艺课，不是看课。手指不敲键盘，大脑就不会形成“指针操作”的运动记忆。视频里老师写代码时，你处于被动接收状态，手眼的注意力被讲解带走，很难注意到边界条件。看得越顺，其实理解越浅。

解决：给自己定一个硬指标：每看完一个视频，必须当天完成一个独立的小实现。线性表看完就写顺序表插入和链表反转，栈看完就写用栈检查括号匹配，串看完就写 KMP 的 next 数组，树看完就写先序中序后序三种遍历。写不出来就回头重看，但绝不多看下一集。这个习惯能让你把看课的“明白感”转化为可测试的代码。

4.2 KMP 的 next 数组和 nextval 混用

现象：手算 next 数组时算出[0,1,1,2]，代码里却用[-1,0,0,1]，然后拿一个简单用例去测，发现匹配位置偏了几位。更迷惑的是网上有的代码用了nextval，得到的数组又不一样，于是开始怀疑自己理解错了。

原因：KMP 有两个版本。严蔚敏教材和大部分中文课用下标从 1 开始的 next 数组，递归回退时直接跳next[j]；而很多工程代码、LeetCode 题解按下标从 0 开始，next[0] = -1。nextval 是在 next 基础上对连续相等的字符做进一步压缩，它比 next 跳得更快。没有统一约定，所有手算结果都会对不上。

解决：选定一个版本并写进笔记开头。我建议用下标从 0 开始的版本，因为和 C 语言数组天然匹配。写代码时把next[0] = -1这个约定用注释标在函数上，并且手算测试时用同一个模式串ABABC，算一遍[-1,0,0,1,2]，再在getNext函数末尾加一个打印循环验证。遇到考试题，先看题目给的是 next 还是 nextval。

4.3 递归栈溢出，OJ 一测就崩

现象：把课程里的递归快排、递归二叉树遍历照搬到 OJ 上，输入数据量一大就直接 Runtime Error。本地调试时小数据是好的，但卡在深度很大的用例上。

原因：课程里为了讲清楚递归思想，通常不会强调系统栈容量。OJ 平台的栈空间普遍在 MB 级别，递归深度到几万层就会溢出，而课程里的测试数据往往只有几十个节点。另一个隐藏原因是递归里写错了终止条件，比如quickSort(low, i)传错区间，导致无限递归直到栈爆。

解决：先检查递归出口：快排是low >= high，二叉树是root == NULL，归并是left >= right。确认无误后，再用极端数据压测：生成一个按升序排好的大数组跑快排，如果卡死，说明枢轴选择退化了，改用随机枢轴或三数取中；生成一个退化成链的二叉树跑后序遍历，如果爆栈，改成用迭代栈模拟。OJ 题里很多递归代码要改成非递归，这是常态而不是特例。

4.4 排序算法背了一堆模板，却选不对场景

现象：能把快排、堆排、归并的代码默写出来，但问“给一个几乎有序的大文件，用哪个排序最好”时，毫不犹豫选了快排，结果复杂度分析错了。或者问“哪个排序是稳定的”时，把堆排也算成稳定。

原因：课程里排序章节的核心目标是教“每种排序怎么实现”，考试里更喜欢考“为什么这样实现”，也就是复杂度、稳定性、适用场景。只背代码而不对照参数表，等于不知道算法之间的区别。

解决：把排序整理成一张表：插入排序适合小规模或基本有序，快排适合大规模乱序但递归深度可控，归并适合外部排序和需要稳定的场景，堆排适合找 TopK 但 CPU 缓存不友好，希尔排序复杂度介于插入和快排之间。每次用完一个排序，就在笔记里记下它的最好、最坏、平均复杂度，以及是否稳定。这样从“会默写”升级为“会选型”。

4.5 用 Java/Python 刷题，却对着 C 语言的课抠语法

现象：课程代码全部是 C 语言，但自己在用 Java 刷 LeetCode，写链表时总想着 Java 没有指针，传参是引用传递，结果把 C 语言的ListNode *head硬套到 Java 的ListNode head上，空指针异常不断。

原因：这套课是基于严蔚敏教材的 C 语言版，指针、结构体、内存管理都是 C 的思维。如果你用 Java 或 Python，语法层面自然有差异，但逻辑层面的差异很小。问题不在 C 语言，而是你混淆了“逻辑”和“语法”：cur = cur->next在 Java 里等价于cur = cur.next，思想一样，只是表达不同。

解决：看这门课时只关注逻辑结构和算法思路，不背 C 语言语法。上机实现时，优先用自己的主语言重新实现一遍。如果主语言是 Python，链表反转写循环即可，不需要纠结struct。如果是考研 408，代码题通常允许用 C 或 C++，但从复习第一天开始就用 C 写，别中途换语言，免得现场手写 C 代码时连malloc都不熟。

5. 从听课到应试：搭配王道 408 的复习节奏与刷题参数

如果你是为了 408 考研来学这套课，那么光看完视频远远不够。需要把课程资源和王道 408 的复习框架结合起来，用“看课 + 写码 + 刷真题”三件套，把输入变成分数。下面的节奏是常见做法，你可以根据自己的基础和时间调整。

5.1 选择题怎么刷：用概念换读题速度

408 数据结构选择题的特点是概念细碎、计算量小、陷阱多。比如“某算法时间复杂度是 O(n²)”和“该算法时间复杂度是 Θ(n²)”其实是两个命题。课程视频里王卓老师会花整节课讲时间复杂度的推导，但不会给你讲 408 出题套路。这里需要你自己把视频里的推导语言翻译成选择题的判定标准。

我建议的做法：每学完一章，先不急着打开王道做题。先把这一章的“一页纸笔记”看一遍，然后用 10 分钟做 10 道选择题，掐表。做错的选择题，不要只对答案，要回到课程视频里找到对应的讲法，把“为什么错”写在题目旁边。比如“循环队列队满条件 Q.front == (Q.rear+1)%MAXSIZE”，很多选择题会故意给成相等判断，课程里讲的浪费一个存储空间的细节正好能帮你避坑。

刷题参数上，数据结构选择题建议在基础阶段每周刷 2-3 章，每章 15-20 题，错题二刷。不要追求量，408 里数据结构选择题的正确率目标定在 85% 以上，剩下的 15% 通常是算法设计题的前置判断，错了也能接受，但要确保不是概念性错误。

5.2 算法题怎么练：默写模板 + 变式训练

408 的大题里有一道算法设计题，常常是链表或树的操作。很多人看课程时觉得链表反转简单，考场上却因为边界条件丢分。解决的办法是建立“默写模板”的习惯。每一个核心算法，都要能在一分钟内写出骨架代码，时间超出就是没掌握。

模板清单按课程顺序整理：单链表反转、有序链表合并、栈实现队列、KMP 匹配、二叉树前中后序遍历（递归和迭代）、层序遍历、BST 插入删除、图的 DFS/BFS、Prim/Kruskal 最小生成树、Dijkstra 最短路径、快排、归并、堆排序。每个模板用固定格式记录：算法名称、时间复杂度、空间复杂度、易错边界。

然后做变式训练：把课后的习题和 408 真题对照，只看题目不看答案，先在纸上画出数据结构，再写代码。比如课程里只讲链表反转，408 就可能让你“反转链表的第 m 到第 n 个节点”；讲二叉树遍历，408 就可能让你“求二叉树宽度”或“判断是否为二叉搜索树”。这些变式本质是模板加一点条件判断，模板越牢，改起来越快。

“408 数据结构代码必背”这个说法有一定道理，但不是把代码死记硬背，而是把模板的骨架练到肌肉记忆。我一般给自己定的标准是：晚上睡前不看代码，在纸上默写快排和 KMP，如果第二天早上还能默写出来，才算真正记住。

5.3 复习节奏的参数建议：三轮走法与每日安排

为了把课程资源转化为战斗力，建议用三轮复习法。第一轮基础：用这套课配合严蔚敏教材过完所有知识点，目标是对每个算法“知道是什么、为什么用”，每章选做 5-10 道基础题，时间约 1.5 个月。第二轮强化：用王道 408 辅导书按专题刷题，数据结构部分大约 2 周，每个模板默写 3 遍以上，错题整理成 bug list，时间约 1 个月。第三轮冲刺：以 408 真题为主，限时模拟，数据结构部分用 20-25 分钟完成选择题，大题单题耗时控制在 15 分钟内，时间约 2-3 周。

每日安排可以细分：如果每天固定 2 小时学数据结构，可以用“看课 40 分钟 + 写码 40 分钟 + 刷题 40 分钟”的比例。看课阶段放在状态最好的时间，写码放在看完课立刻进行，刷题可以放在睡前用碎片时间。这个 4:4:4 的时间结构比只看课或只刷题都稳。

错题本的维护也有参数：不要抄题干，只抄考点和错误原因；每周日花 20 分钟重做本周错题；标记重复出错的题目，考前只看标记。注意，上面的时间参数针对的是数据结构单科，并且每天有完整 2 小时。如果你还在学计算机组成、操作系统、计算机网络，数据结构建议占总复习时间的四分之一到三分之一，不要把课程资源当成全部。

6. 最后留一手：给这套课配一个长期迭代的算法模板库

课程资源里的视频和课件是静态的，真正值钱的是你从里面提取出来的“可复用骨架”。我建议你从第一遍学习就开始维护一个算法模板库，每个算法占一个文件，头部写清楚元信息。比如我用的是这样一个格式：

# 单链表反转 - 场景：线性表操作 / 面试手撕 - 复杂度：时间O(n)，空间O(1) - 易错点：先保存cur->next再改指向；空链表和单节点直接返回 - 测试用例： 1. 空链表输入 -> 返回NULL 2. 单节点输入 -> 返回自身 3. 1->2->3 -> 3->2->1 - 模板代码： (将第三章节的reverseList函数粘贴到这里)

这个模板库可以放在本地仓库里，用 Markdown 文件维护，也可以配合自己的刷题记录。关键是要把自己踩过的坑记在易错点里，不要写教科书式的官方说明。比如快排的“枢轴取最左元素时，基本有序数组会退化”就是值得记的实战教训。

这样做的好处是：需要复习数据结构时，不用再翻视频找某一集，打开模板库的索引一眼就能定位。在 LeetCode 遇到变式题时，先到模板库里找到基础模板，改两行代码就能解决。它会成为课程资源之外属于你自己的第二份资料，而且会随着刷题而增长。

最后说一个我自己的习惯：我在第一遍学这套课时，只看视频不整理模板，结果二轮复习时重新翻视频，浪费了大量时间。后来把每个算法的复杂度、边界、测试用例写成模板后，复习效率明显提升。现在每次学新算法，我都会按固定格式补进模板库。资源包可以解压后吃灰，但你自己的模板库会一直帮你省时间。希望帮到你。

本文还有配套的精品资源，点击获取