线性表详解：顺序表与链表的底层逻辑、核心操作与选型指南

1. 动手前先理清：线性表到底是什么

1.1 一句话定义与两类“存储面孔”

线性表是数据结构里最基础也最“绕”的一个概念。说它基础，是因为几乎所有专业的数据结构教材第一课都会讲它；说它绕，是因为很多人在学完数组和链表之后，反而说不清“线性表”这三个字到底指什么。我给大家一个能记一辈子的定义：线性表是由 n 个数据元素组成的有限序列，元素之间是一对一的线性关系。拆开来看，关键就三个点——“有限”强调元素个数是确定的，“序列”强调有先后顺序，“一对一”强调除了头尾，每个元素都有唯一的前驱和唯一的后继。

你别小看这三句话，我当年在上面栽过跟头。考试的时候问“线性表和数组有什么区别”，我洋洋洒洒写了一大段，结果只得了两分，因为答案核心其实只有一句：线性表是一种逻辑结构，数组是它的顺序存储方式之一。换句话说，线性表描述的是“数据之间有顺序关系”这件事本身，至于数据在内存里怎么放，线性表自己说了不算，要看底层选择顺序存储还是链式存储。这个“逻辑结构”和“物理存储”的二分法，是整个数据结构课程的第一道分水岭，理解不了它，后面学栈和队列必然越学越糊涂——因为栈和队列在逻辑上其实就是受限的线性表。这个项目适合正在上数据结构课的同学、准备考研刷题的人，以及那些学完了一学期但还是“看得懂代码、写不出代码”的困惑er，我接下来会把两种存储方式的核心实现逻辑和真正的坑都拆开讲清楚。

1.2 边界感：线性表为什么不是“某一种具体的代码”

我观察到很多同学有一个误区，觉得“实现了顺序表就算学会了线性表，链表是另一门课”。这种割裂的理解方式，会直接导致你后期看源码时产生巨大障碍。实际上，线性表更像是一个抽象接口，它规定了一组该有的操作：初始化一个空表、按位置取元素、按值查找、插入一个元素、删除一个元素、求表长。至于底层是拿一段连续数组去实现，还是拿散落四处的节点用指针串起来，这些都是“实现细节”。

我习惯用“笔记本联系簿”来给零基础朋友打比方：线性表就是“联系簿”这个抽象概念，它规定你要能在第 3 个位置插入一个联系人，要能删除第 5 个联系人，要能翻到第 10 个联系人看看是谁。而顺序表像一本装订好的纸质通讯录，每一页紧挨着上一页，翻到第 10 个联系人很快，但要在第 3 页和第 4 页之间插入一页新的，你得把后面所有页都重抄一遍。单链表则像一叠用线串起来的便利贴，每张便利贴上只写了下一个人的名字和位置，要找到第 10 个人你只能一张张顺着线往下摸，但在中间插入一张新便利贴，只需要拆线、穿线两步。

这种“抽取共性，先定规则，再谈实现”的思考方式，会在你后续面对文件系统、内存池、缓存淘汰策略时反复出现。我把话放这儿：线性表的本质是一种“纪律性的数据组织方式”，它是你从“会用变量”走向“会设计数据组织”的第一级阶梯。下一节开始，我们进入真正的核心：两种存储结构的实现细节和为什么要这样实现。

2. 顺序表：连续内存里的三大操作

2.1 结构定义与初始化：length 为什么要单独维护

顺序表的实现思路非常直白：用一块连续内存保存所有元素，用数组下标体现元素的线性次序。C 语言里最经典的定义是这样的：

#define MAXSIZE 100 typedef struct { int data[MAXSIZE]; int length; } SeqList;

很多新手看到这个结构体就懵了：既然 data 数组本身就有长度，为什么还要一个额外的 length 字段？这个问题问得非常好，答案是：数组的长度描述的是容量，是这块内存最多能装多少元素；而 length 描述的是当前实际装了多少元素。数组建好了就固定不变，但表的内容会随着插入、删除不断变化。如果不用 length 单独记录，你就永远不知道“有效数据”到哪里结束，遍历时会读到一堆没初始化过的垃圾值。这就像你租了一个能放一百本书的书架，但你只摆了三十本，如果哪天忘了这回事，伸手去拿第 31 本书，抓到的就是一团空气。

初始化操作要做两件事：把 length 置 0，同时尽量把 data 数组清一遍。虽然不用清零也能工作，但我强烈建议新手上机时养成 memset 的习惯，不是你偷懒不清会出 bug，而是调试程序时如果出不想要的“脏数据”，你很难分辨它到底是逻辑问题还是残留内存。真正的老手都很重视这类“无害但能节省调试时间”的习惯。

2.2 插入操作：为什么必须“从后往前”动

顺序表最核心的操作用两个词就能概括：移位和覆盖。先看插入，标准写法是在第 pos 个位置插入一个值为 e 的元素，核心代码长这样：

int SeqListInsert(SeqList *L, int pos, int e) { if (L->length >= MAXSIZE) return -1; // 空间满了 if (pos < 1 || pos > L->length + 1) return -1; // 位置非法 for (int j = L->length; j >= pos; j--) { L->data[j] = L->data[j - 1]; } L->data[pos - 1] = e; L->length++; return 0; }

这里有一个非常多初学者搞不懂的点：为什么插入要从最后一个元素开始往前搬，而不能从前往后搬？我打个比方你就明白了。有一排人站在公交站台上，第一个人后面要硬插一个新排队者，新排队者说“你们每个人往后退一格”。如果你从队头开始动作，第一个人往后一退就把第二个人撞了个趔趄，第二个人还没来得及往后退，位置又被占了，整个队伍瞬间乱套。正确的做法是最后一个人先退一步，倒数第二个人再退，顺着队伍依次往前，每个人都是退到一个已经空出来的位置。写代码也一样，只有从 length-1 这个下标开始，逐个把 data[j-1] 的值搬到 data[j]，才不会被前一次赋值覆盖掉还没搬运的数据。

顺序表插入的平均时间复杂度是 O(n)，因为它本质上要搬动约一半的元素。这个 O(n) 不是背下来的，你想想就明白：表里有 n 个元素，插到第 1 个位置要搬 n 个，插到最后一个位置要搬 0 个，平均下来就是移动 n/2 次。理解了这个推导，以后再面试被问到“顺序表插入的时间复杂度是多少”，你就能很自信地讲出来，而不是背一个结论。位置校验的 pos > L->length + 1 这一条尤其重要，它允许你在表尾追加元素，但禁止你在第 length+2 的位置“凭空塞一个进去”——位置不存在，插不了。

2.3 删除操作：从前往后覆盖，别忘检查空表

删除恰好是插入的镜像操作。删除第 pos 个元素，要把后面的所有元素整体前移一位，最后把 length 减一：

int SeqListDelete(SeqList *L, int pos, int *e) { if (pos < 1 || pos > L->length) return -1; *e = L->data[pos - 1]; for (int j = pos; j < L->length; j++) { L->data[j - 1] = L->data[j]; } L->length--; return 0; }

插入时从后往前，删除时从前往后，这两个方向经常有人搞反。有一个实操心得可以帮你记忆：插入是“腾位置”，所以从远端往近端搬；删除是“填坑”，从坑的下一格往坑里搬。删除操作有个极其典型的边界 bug，就是删除前没有判断表是否为空。你想想，如果 length 已经是 0，pos=1，此时 pos > L->length 立刻成立，返回 -1，看起来没问题。但如果你偷懒没写这条判断，循环执行时 j < L->length 根本不成立，循环体不执行，length 变成 -1，整个表的状态就崩了。这个 bug 的可怕之处在于它不报错，只是让程序在某个不可预知的时间点出现诡异行为，排查起来非常耗时。

顺序表的删除还有一个“伪释放”的细节。我们从逻辑上讲，删掉一个元素后它就不属于这个表了，但底层数组里那个位置还残留着旧值。如果不做任何处理，遍历表时由于 length 已经减小，你不会读到它，所以不影响正确性。但严谨起见，有些场景（比如表里存的是指针、文件名等需要回收的资源）我会在删除后主动把那个位置置空，避免出现“悬挂引用”隐患。这个习惯在 C 语言里特别重要，因为 C 语言不会自动管理这些内存。

2.4 按值查找：最简单的遍历为什么也容易出错

按值查找的逻辑很简单，遍历整个表，找到第一个等于目标值的元素就返回它的位置，找不到就返回 0 或者 -1。代码就几行：

int SeqListLocate(SeqList *L, int e) { for (int i = 0; i < L->length; i++) { if (L->data[i] == e) return i + 1; } return -1; }

有个细节有意思：返回值是 i+1，即逻辑位置从 1 开始计数，而数组下标从 0 开始。很多教材故意这样做，让你感受“逻辑位置”和“物理下标”的区别。考试时经常有这种题：线性表第 3 个元素存到数组的哪个下标？答案是 2。这个坑非常小，但面试手写代码时写错了，就是致命伤。

查找操作的时间复杂度也是 O(n)，最坏情况就是目标值在表尾或者根本不存在，你得从头到尾摸一遍。到这里，顺序表这个“脆弱的巨人”我们已经拿下了。它能 O(1) 随机访问，但插入删除得拖着全员搬家的包袱。下一节我们换个思路，看看链表是怎么用“指针散兵游勇”来解构这个问题的。

3. 单链表：指针就是你要维护的“路标”

3.1 节点结构与头指针、头节点的区别

链表的思想特别叛逆：既然连续内存会导致插入删除的成本集中在“搬动元素”上，那我让每个元素各自住在独立的小房间里，房间里挂一个门牌号指向下一个房间，不就行了吗？这个“门牌号”就是指针。单链表节点在 C 语言里是一个结构体：

typedef struct Node { int data; struct Node *next; } LNode;

在动手写链表之前，有一个概念必须刻进 DNA，否则你看很多带头节点的代码会一头雾水：头指针和头节点是两个完全不同的东西。头指针是一个变量，它存的是链表第一个节点的地址，它本身不是链表的一部分。而头节点（也叫哨兵节点）是一个真实存在的节点，它不存数据，只是固定在链表的第一个位置，让“插入/删除第一个元素”这种特殊操作也能被统一处理。

为什么要有头节点？我举个非常具体的例子。假设你要在没有任何节点的空链表头部插入第一个元素，如果没有头节点，你需要修改头指针的指向，而头指针是外部变量的指针，你得用二级指针传入函数才能改得动。如果你不嫌麻烦倒也可以用二级指针，但很多 API 设计者发现，只要在链表最前面放一个不存数据的占位节点，那么“插入到第一个位置”“插入到中间位置”的逻辑就完全统一了，永远只需要改当前节点的 next，不需要碰头指针。这就是为什么有头节点的链表实现几乎成为教学和工业界的默认选择——它不是必要的，但它把很多麻烦都抹平了。我自己在实际项目里，除非明确要求不带头节点，否则一律用带哨兵节点的写法，省心。

3.2 前插法与后插法：两种建表思路的取舍

建单链表有两种方法：头插法和尾插法。头插法极其简洁，每次都在链表的头部插入新节点，代码逻辑如下：

LNode *List_HeadInsert() { LNode *head = (LNode*)malloc(sizeof(LNode)); head->next = NULL; int x; while (scanf("%d", &x) != EOF) { LNode *s = (LNode*)malloc(sizeof(LNode)); s->data = x; s->next = head->next; head->next = s; } return head; }

头插法的妙处在于时间复杂度是 O(1)，不管链表现在有多长，新节点永远是塞在最前面。但它有一个致命副作用：你输入元素的顺序和最终链表里的顺序是反的。你依次输入 1、2、3，到头来链表是 3、2、1。这是很多教材喜欢考的点，也是一些数据结构“反转链表”题的实现基础。如果你需要一个和输入顺序一致的链表，要么用尾插法，要么头插完再整体反转，看业务需求。

尾插法要维护一个尾指针，每次插入新节点后都把它更新到新节点上：

LNode *List_TailInsert() { LNode *head = (LNode*)malloc(sizeof(LNode)); LNode *tail = head; head->next = NULL; int x; while (scanf("%d", &x) != EOF) { LNode *s = (LNode*)malloc(sizeof(LNode)); s->data = x; s->next = NULL; tail->next = s; tail = s; } return head; }

尾插法的优点是不改变输入顺序，缺点是需要维护一个尾指针。有些同学问：那我每次插入都先去遍历到最后一个节点，再接通行不行？行，但这样建表的时间复杂度就从 O(n) 退化成了 O(n²)，数据量大了之后极其痛苦。我见过不少新手写尾插法时忘了更新尾指针，导致每次都从第一个节点重新开始找尾巴，代码倒是能跑，但一测性能直接爆炸，这就是“能跑”和“跑得好”的区别。

3.3 删除节点：二级指针、prev 追踪和“先备份再释放”

单链表删除操作是事故高发区。核心逻辑是：要删第 i 个节点，先找到它的前驱节点，然后让前驱的 next 跳过它，指向它的后继，最后把它释放掉。传统的写法需要用一个指针 cur 从头遍历，同时用一个指针 prev 一直记录 cur 的前驱。

int ListDelete(LNode *head, int i, int *e) { LNode *p = head; int j = 0; while (p->next != NULL && j < i - 1) { p = p->next; j++; } if (p->next == NULL) return -1; LNode *q = p->next; p->next = q->next; *e = q->data; free(q); return 0; }

这段代码有四个细节值得拿出来讲。第一，p 从头节点开始，经过 j 次移动后指向第 i-1 个节点，这个“循环条件”一不小心就多走一格或者少走一格，建议在纸上画三个节点然后手动模拟一遍。第二，删除之前你必须在 q 变量里保存好被删节点，因为一旦 free，它的内存就不归你了，要是你先把 p->next = p->next->next 执行了再想取被删节点的值，那就是在访问已经被“绕开”但仍未释放的对象，逻辑上还能拿到，但代码可读性很差。第三，我最想强调的一点是：free(q) 之后，理想情况下把 q 置空，即 q = NULL。虽然 q 马上就会被废弃，但这个习惯在你以后管理长生命周期对象时会救你一命，避免出现悬空指针。第四，如果你要删除的是第一个有效节点，因为有了头节点，这里 p 指向头节点，条件仍然成立，处理逻辑和删除中间的节点完全一致，这正是头节点最大的价值。

3.4 按位查找：别被“O(n)”骗了，内层还有玄机

链表没有随机访问能力，要找到第 i 个节点，只能从第一个节点开始沿着 next 走 i-1 步。代码很短，但从工程角度讲，这里有个极易被忽略的问题：如果 i 比链表长度大很多，程序会一直走到链表尾部，然后返回 NULL，这个过程不会报错。所以调用者必须在使用返回值之前做空指针判断，否则一旦拿到 NULL 还去访问它的 data，就会触发段错误（Segmentation Fault），程序直接崩溃。

从复杂度的角度，按位查找 an 平均要移动 n/2 次，时间复杂度 O(n)。你要特别注意：它和顺序表的按位查找虽然都叫“按位”，但前者是 O(1)，后者是 O(n)，这直接决定了两种结构在“按位置频繁取值”场景下的差距。我们说链表适合插入删除频繁的场景，前提是你已经知道要操作的位置在哪里，如果连找到那个位置都要遍历一整遍，那总成本往往比顺序表还要高。这个权衡思想，我后面单独拿出来说。

4. 双链表与循环链表：扩展场景里的细节

4.1 双链表：多一个指针，少一层麻烦

单链表有一个天然的窘境：想删除当前节点，必须知道它的前驱，而找前驱需要从头再遍历一遍。如果我们的操作经常是“给你一个节点，请把它删掉”，单链表就非常尴尬。双链表就是为了解决这个问题而生的，它的每个节点有两个指针，一个指向前驱，一个指向后继：

typedef struct DNode { int data; struct DNode *prior; struct DNode *next; } DNode;

双链表的插入和删除代码比单链表长，但更“对称”，也更省心。比如在节点 p 之后插入新节点 s，核心四步是：s->next = p->next; p->next->prior = s; s->prior = p; p->next = s。这里每一步的先后顺序非常重要，有一条铁律你得记死：先处理最远的连接，再处理当前的连接，避免指针断链。如果顺序搞反，比如先把 p->next 改了，那 p 原来的后继节点就找不到了，整条链就断在中间。

双链表的删除操作就优雅得多：要删除节点 p，只需要 p->prior->next = p->next 和 p->next->prior = p->prior 两条语句。代价是什么？每个节点多了一个指针域，内存占用增大，而且插入和删除操作因为要维护两条链，复杂度常数因子更大。这是典型的“空间换时间”“代码长度换操作便利”。我在实际项目中，只要需要频繁执行“给定任意节点删除它”这类操作，几乎一律优先双链表。

4.2 循环链表：从尾找头只需要一步

循环链表是单链表的变种，把尾节点的 next 从 NULL 改成指向头节点（或者第一个节点），整个链表就闭环了。循环链表最大的好处是：从任意一个节点出发，都能遍历到整个链表。这在处理约瑟夫环问题、循环队列、时间片轮转调度等场景时特别契合。

用循环链表一定要小心一个陷阱：遍历的终止条件不是“p == NULL”，而是“p->next == head”，或者回到起点。很多新手第一次接触循环链表时，条件判断写错，程序直接陷入死循环。我们有个概念叫“表尾判定的改写”，你一旦决定用循环链表，就要把对 NULL 的所有检查改为对头节点的检查。还有一个实战小技巧：用循环链表时往往不保留头指针，而是保留一个指向尾节点的指针 tail，这样 tail->next 就是第一个节点，从尾部插入元素是 O(1)，从尾部找头部也是 O(1)，非常丝滑。

4.3 静态链表：没有指针的“链表”

有些读者可能见过“静态链表”这个说法，它们通常出现在考研教材的角落位置，考完就忘。它的思想是用数组下标模拟指针，每个数据元素额外存一个 int 类型的“游标”，指向下一个元素所在的下标。为什么要这么干？因为它能让链式存储的思想在没有指针的语言里落地实现，比如早期的 Basic、Fortran 等。在现代工程里静态链表用得不多，但理解它对打通“物理存储”和“逻辑结构”这两个概念非常有帮助。我想提醒你的是，如果你在一个高级语言里遇到了类似“用 index 串起来的数据结构”，别慌，它本质上就是静态链表思想，处理逻辑和链表一模一样，只是把指针换成了下标。

5. 顺序表 vs 链表：六维对比帮你做选择

5.1 六维对比：一张表看清两种结构

很多同学学完两种结构，一到实际项目就不知道该用哪个，仿佛学了个寂寞。我给你一张我用了很多年的对比表，它解决了我 80% 的选型困惑：

需要我多说一句的是“缓存局部性”。这个维度在很多传统教材里不会专门展开，但在现代计算机体系下极其重要。CPU 读取数据时不是一次读一个字节，而是把整块内存按缓存行（通常 64 字节）加载进来。顺序表的数据在物理上紧挨着，你遍历它的时候，前面预取的缓存行后面的数据大概率都在里面，速度飞快；链表节点则散落在堆的各个角落，每次访问都可能触发一次缓存未命中，性能差距在数据量大时可能达到十几倍。这就是为什么很多看起来“链表复杂度更低”的算法，实际跑起来反而不如数组快。复杂度分析是理论层面的，缓存友好是工程层面的，两者都要看。

5.2 真实业务场景走查：什么时候选谁

我拿三个真实的开发场景带大家走一遍选型过程。

第一个场景：一个通讯录应用，需要频繁按姓名秒查联系人和地址，很少做插入删除。这种场景直接上顺序表（数组），因为数据量不大，而且读取频繁。你要是非要用链表，每次“翻到第 100 个联系人”都要从头跑一遍，用户一滑动就卡顿，体验极差。

第二个场景：一个日志记录模块，数据只会不断追加到末尾，基本不会从中间删改。这看起来顺序表能胜任（尾部插入 O(1)），但如果日志量不可预估且内存可能不足，链表反而更合适——按需申请节点，不会因为预分配空间不够而扩容失败。不过实际工程里这个场景更常用动态数组+扩容策略，因为尾部追加且随机访问的需求往往共存。

第三个场景：一个音乐播放器的“播放队列”，用户可以随时往任意位置插入一首歌或删掉一首歌，但也需要显示“这是第几首歌”。这类中等规模数据结构在操作频繁时兼顾两种访问方式，实际上用双链表配合一个“节点指针数组”做索引的混合结构更常见。你看，真实世界永远不是非黑即白，而是两种结构混合使用的。

5.3 混合结构的灵感：别把两者对立起来

我见过最有意思的“混合结构”是很多排序算法和数据库底层里常用的“数组+链表”组合，比如带链地址法的哈希表，每个桶就是一个链表，而这些桶本身存在一个连续的数组里。哈希函数 O(1) 定位到桶，链表的增删能力又保证了冲突时的灵活性。

这个组合模式给我一个很深的启示：顺序表和链表不是互斥的敌人，而是互补的工具。你在设计一个经常要“随机访问 + 频繁增删”的结构时，可以尝试用一个数组作为“索引层”，每个数组元素指向一个链表的头节点。这样你既享受了随机访问的便利，又保留了链表插入删除的低成本。这就是数据结构里“以空间换时间、以结构换效率”的高级思维，也是从“会用”走向“会设计”的分界线。当然，真到这种复杂度，通常已经有现成的容器类可以用了，但在理解底层机制之后，你对那些容器的内部性能特征会更有直觉，调优时也更稳。

6. 调试与踩坑实录：这五个问题我当年全遇过

6.1 段错误排障三板斧

如果你写链表相关代码遇到段错误（Segmentation Fault），先别急着崩溃。我有一套排障三板斧，成功率极高，按照顺序执行就行。

第一板斧：检查空指针。在所有使用指针成员之前，想想这个指针有没有可能还是 NULL。典型场景是遍历链表时，循环体里访问 p->data，而 p 已经等于 NULL 了。很多段错误就是这样引起的。你可以在每个访问点之前加一句 if (p == NULL) 打印调试信息，用这种暴力排查法快速定位。

第二板斧：检查是否误操作了“已释放”的内存。free 之后不再置空，再访问就是悬空指针。解决方法是严格执行“free 后置 NULL”原则，并且每次访问指针前都检查一下。我见过把已经 free 的节点又拿去访问的 bug，排查时简直抽丝剥茧。

第三板斧：检查数组/循环边界。顺序表场景里，数组下标越界往往是元凶。比如你计算插入位置时忘了 +1 或者 -1，直接越界写内存，这种错误表面不会立刻崩溃，但会随机破坏其他变量，属于“隐蔽杀手”。可以用断言或者开启编译器的越界检查选项，快速暴露问题。

这套三板斧用熟了，你会发现自己对指针的“警惕雷达”越来越灵敏，写完代码甚至能在编译之前就嗅到风险，这是每位搞底层编程的开发者必经的成长过程。

6.2 边界检查速查清单

我整理了一份写线性表代码时必须过一遍的边界清单，每次写完代码照着检查，能拦截掉 90% 的潜在 bug：

其中“删除最后一个节点后 tail 更新了吗”这条，是很多用尾指针的人踩坑的重灾区。你删掉了 tail 节点，却没有把 tail 移到前一个节点上，下次想加元素时 tail->next 变成了野指针，整个链表直接乱套。这个 bug 在某些情况下不会立刻报错，而是等到下一次插入时才爆，让人摸不着头脑。我在项目里为了杜绝这类问题，删除函数里都加上“如果要删的节点就是 tail，则回退 tail”，宁可多写两行，也不留隐患。

6.3 从易到难的上手路径：给不同基础的同学

关于怎么练，我给三条明确路径的意见。

如果你完全是零基础，还在纠结指针和结构体，那先不要碰链表，先去写十道顺序表的题：插入、删除、查找、合并、反转数组、去重等。顺序表不需要动指针，逻辑直观，能帮你建立“数据结构操作”的整体感觉，也顺便把边界检查练熟了。等你写顺序表不再想着编译错误，再开始链表。

如果你已经能写链表插入删除，但总是小 bug 不断，那就练一到两周的“手动模拟”：给你一个链表的状态图，逐步画出删除一个节点后所有指针的变化，直到你不用画图也能在脑中完成模拟为止。这个方法看似笨，但效果奇好，几乎每个面过试的人都练过。

如果你是冲着面试和竞赛去的，那就必须再往前一步：把顺序表和链表里所有操作的时间复杂度推导都写下来，并且思考它们背后的“为什么”——为什么插入要搬 n/2 次？为什么链表查找是 O(n)？为什么我们用头节点能让代码统一？把这些“为什么”想透彻，面试官从你嘴里听到的就不再是背诵，而是理解，这种感觉是不一样的。

写在最后

回到开头那个问题，线性表到底重要在哪里？我个人十几年的使用经验是：它是所有数据结构里少有的“你甚至不需要专门背它，但它渗透在所有地方”的基础结构——操作系统的空闲内存管理、文件系统的目录项、数据库的表记录、浏览器的历史记录，到处都能看到线性表的身影。你真正掌握它之后，去学栈、队列、字符串、广义表，会发现它们大多是线性表的“改头换面”。

我在实际带人过程中也发现，一个人写线性表代码时的干净程度——有没有检查边界、有没有置空指针、有没有统一接口——基本能预测他后续写树和图代码的质量。这不是玄学，因为线性表强制你把最基础的工程素养练到位了。如果你看完这篇文章能自己动手把顺序表和单链表从头到尾手写一遍，并且不用调试就通过，那这门课你已经算是踏踏实实过了第一关。接下来，继续往前推吧。