顺序表详解：从数组到动态扩容，掌握数据结构的地基

不知道你有没有过这种经历：学《数据结构》的时候翻开课本，第一章绪论还没看完就翻到线性表，看到“顺序表”三个字，心里想的是——“这不就是数组吗？有什么好学的？”

然后你就跳过去了。

等到做实验、准备面试、刷 LeetCode 的时候才发现，随便一个“数组去重”“合并区间”“LRU 缓存”背后全是数组和顺序表的影子。甚至在考研里，严蔚敏那本 C 语言版教材的第一道算法大题，就可能让你手写顺序表的插入或删除。你如果当初真的把顺序表当成“数组换了个名字”给跳过去，后面补起来就特别痛苦。

顺序表是整个数据结构体系里最基础也最容易被人低估的一块：它既是“线性结构”的代表，也是理解后续栈、队列、字符串、哈希表的基础；同时它本身的小细节——扩容、移动、边界处理、复杂度分析——又足够支撑起一场完整的面试。

这篇文章我把顺序表从头到尾完整拆一遍。从存储结构为什么要这么设计，到插入、删除、查找每一步代码是怎么推出来的，再到动态扩容为什么通常是翻倍而不是加固定大小，最后聊一些我实际调试和写工程代码时遇到过的坑。不管你是期末复习、考研刷题，还是面试前临时抱佛脚，都应该能用得上。

1. 为什么说顺序表是数据结构这座楼的“地基”

1.1 从“零基础学数组”到“学会抽象数据类型”

很多人第一次接触编程语言，学的第一个复合数据结构就是数组。比如 C 语言里：

c复制int a[10];

这行代码的意思是：向操作系统申请 10 个连续的 int 类型内存空间。访问 a[0]、a[3]、a[9]，本质上就是在连续地址上做偏移计算。这个阶段我们对数组的理解是语法层的——“一组同类型变量的集合”，下标从 0 开始。

但到了数据结构这门课，“数组”不再只是一个语法结构，而是上升成一个逻辑结构 + 物理结构的组合体：

• 逻辑上，这些元素线性排列，之间存在“一对一”的前驱后继关系；
• 物理上，它们存放在一片地址连续的内存单元中；
• 此外我们还要往上面施加操作——插入、删除、查找、修改。

这里就自然引出了数据结构课程最核心的一个思想转变：我们不再只是“使用”一块内存区域，而是要“管理”一个能完成特定操作的存储结构。 数组只是一个原材料，顺序表才是用这个原材料加工出来的第一个产品。

这个思维转变是刚学数据结构的人最难跨过的一道坎。很多同学看课本上的线性表定义能背下来——“由 n 个数据元素组成的有限序列”，但是一到写代码就不知道怎么把“序列”这个概念落地。顺序表就是最简单的一个落地方式：用数组去存，再用一个变量记录现在里面到底有多少个元素。这个形式简单到不能再简单，却把“数据的逻辑结构”和“存储结构”挂上了钩。

1.2 地基为什么重要：后续几乎所有结构都建立在它之上

栈可以用顺序栈来实现，本质就是一个限制了插入删除位置的顺序表；循环队列虽然逻辑上是个环，但仍然是用一个连续数组配合 head、tail 指针来模拟的。字符串的顺序存储、图论里经常用到的邻接矩阵，核心也都是顺序表结构。

包括我们去读各种编程语言标准库：C++ 的 vector、Java 的 ArrayList、Python 的 list，底层全都是“可动态扩容的顺序表”，也就是把“数组”包在一个管理结构里，自动帮你完成扩容和元素维护。所以你把 C 语言版的顺序表理解透了，读这些标准库源码时会有一种恍然大悟的感觉——原来大家都长一个样。

反过来讲，如果你顺序表没学好，链表学起来会缺少对比对象，因为链表的很多设计动机正是为了弥补顺序表的缺点。后面学的跳跃表、B+ 树这些更复杂的结构，也经常要回到“连续存储可以做二分查找”“连续存储 cache 友好”这类底层认知上去。这也是为什么很多考研辅导视频里，老师都会把顺序表这一节反复讲，比如网上流传很广的王卓老师的 PPT，光是线性表这一章就能拆出大量细节。

顺序表真正的价值，恰恰在于它足够简单——简单到你能把数据结构最核心的概念都放在“显微镜”下看清楚：存储密度、随机存取、时间复杂度、空间扩容、边界条件的判断。

2. 存储结构的三个关键字段：为什么这么设计

2.1 顺序表的 C 语言定义：不只是“动态数组”

先看严蔚敏版教材里最经典的结构定义，我用比较贴近实战的方式写一个版本：

c复制#define INIT_SIZE 10      // 初始容量
#define INCREMENT 5       // 扩容增量（实际工程中很少用，后面说明）

typedef struct {
    int *data;            // 指向动态分配数组的指针
    int length;           // 当前顺序表中元素个数
    int maxSize;          // 当前分配的存储容量（最多能放多少个元素）
} SeqList;

这里最关键的一点是：顺序表不是一个裸数组，而是一个带“管理信息”的结构体。 data 指针负责指向实际存储元素的那片内存，length 记录当前有多少个有效元素，maxSize 则表示这片内存最多能容纳多少个元素。

为什么还需要 maxSize？这就涉及一个刚写顺序表时特别容易犯的错误——把数组空间当成无限大。你给 data 分配了能容纳 10 个 int 的空间，如果已经放进 10 个元素了，现在还要再插一个进去，如果你不去检查 maxSize，直接往 data[10] 上写数据，那就是内存越界写入，程序表现往往是“有时正常、有时崩溃”，特别难排查。

2.2 length 和 maxSize 的区别：酒店“已入住房间”和“总房间数”

我上课的时候总喜欢给学生打一个比方：把 maxSize 想成一家酒店的总房间数，length 就是此刻已经入住的房间数。酒店有 100 间房（maxSize=100），不代表今天必须住满，可能只住了 37 位客人（length=37）。明天又来 20 位客人，发现空房间不够了怎么办？要么换一家更大的酒店（申请一块更大的内存，把原酒店所有客人搬过去），要么拒绝客人入住（返回插入失败）。

这个类比正好把顺序表的容量管理和动态扩容点明了。新手比较容易混淆的就是把 maxSize 和 length 混着用：要么插入时判断 length 和 maxSize 判断错，要么初始化时忘记给 maxSize 赋值，导致后续扩容逻辑全部失效。所以每次初始化和操作后，都要确保 length 一定小于等于 maxSize。只要 length < maxSize，说明数组里还有空闲位置，可以继续插入。

2.3 随机存取的底层原理：为什么按下标访问是 O(1)

顺序表最常被提到的一个优势叫“随机存取”，意思是只要给一个下标 i，就能直接访问第 i 个元素，时间复杂度是 O(1)。这个性质并不是“免费的”，它建立在连续内存存储的基础上。

C 语言里数组名 a 本质上是首元素地址（不考虑 &a 这种特殊情况）。当我们要访问下标为 i 的元素时，编译器会做一次简单运算：

code复制第 i 个元素的地址 = 起始地址 + i * sizeof(ElemType)

这里的起始地址就是 a[0] 的地址，sizeof(ElemType) 是每个元素占用的字节数。比如 int 占 4 字节，那么 data[5] 的地址就是 data 首地址往后偏移 20 个字节。

正是因为这是“一次乘法和一次加法”，和 i 的大小无关，所以无论访问第 1 个还是第 1000000 个元素，耗时都是一样的。如果存储不是连续的，比如链表，你必须从头结点开始，一个一个顺着 next 指针往下找，才能找到第 i 个结点，这就是顺序存取，时间复杂度是 O(n)。连续存储是随机存取的前提，这是顺序表所有性能优势的物理学基础。

理解了这一点，你就能理解为什么有些数据结构题会在“判断数组下标是否越界”上埋坑：数组下标越界之所以危险，正是因为编译器根本不会帮你检查，它只会按照上面的公式直接计算地址并读写，至于那块地址是不是属于你这片数组，它不关心。越界写到别人地盘上，自然就产生了难以预料的 Bug。

3. 增删查改：核心代码是怎么一步步推出来的

顺序表的操作不难，但一旦笔试让手写，很多人的代码能在边界条件上暴露出大问题。下面我按“初始化 → 插入 → 删除 → 查找”的顺序过一遍完整实现，并解释每一步背后的设计逻辑。

3.1 初始化：分配内存不难，难在异常处理

c复制int InitList(SeqList *L) {
    L->data = (int *)malloc(INIT_SIZE * sizeof(int));
    if (L->data == NULL) {
        // 内存分配失败
        return 0;
    }
    L->length = 0;
    L->maxSize = INIT_SIZE;
    return 1;
}

初始化看似就三件事：给 data 分配内存、把 length 设为 0、把 maxSize 设成当前容量。

但很多人会漏掉对 malloc 返回值的判断。malloc 并不是一定会成功的，当申请的内存太大，或者系统内存不足时，它会返回 NULL。如果不管这个返回值，下一行直接去写 L->data[0]，就是对空指针解引用，程序直接崩溃。

这个习惯在大学实验里可能不太容易暴露，因为分配几个 int 一般很难失败。但等到做工程项目，内存资源紧张是常事，不检查返回值迟早要吃大亏。

还有一种常见bug是把结构体定义成指针版本：

c复制SeqList *L = (SeqList *)malloc(sizeof(SeqList));

这时不仅 L 要 malloc，L->data 也要单独 malloc，而且记得在使用后分别释放。很多同学只释放了 L，没释放 L->data，内存泄漏就是这么来的。

3.2 插入操作：搬家为什么要从后往前搬

插入操作是在指定位置 pos（我用 1~length+1 表示，符合教材习惯）放入一个新元素。逻辑分三步：

1. 判断 pos 是否合法；2. 判断表是否已满；3. 把 pos 及其后面的元素全部后移一位；4. 在 pos 处放入新元素，length++。

写成代码：

c复制int ListInsert(SeqList *L, int pos, int elem) {
    // 位置从1开始计，其有效范围是 1 <= pos <= length+1
    if (pos < 1 || pos > L->length + 1) {
        printf("插入位置非法\n");
        return 0;
    }
    if (L->length >= L->maxSize) {
        printf("顺序表已满\n");
        return 0;
    }

    // 从最后一个元素开始，依次向后移动
    for (int i = L->length; i >= pos; i--) {
        L->data[i] = L->data[i - 1];
    }

    L->data[pos - 1] = elem;
    L->length++;
    return 1;
}

最核心的移动逻辑就是这个循环：从最后一个元素开始，逐个往后挪一格。 为什么非要从最后一个开始？

你可以想一想，如果从 pos 位置的元素开始，先执行 data[pos] = data[pos-1]，把原来 pos 位置的元素覆盖掉了，那么接下来你用什么值去覆盖 pos+1 位置？源数据已经被覆盖，整段数据就乱了。

所以搬家必须“从后往前”：先把最末尾的数据移到后面的空位里，然后倒数第二个再移到原来的最后一个位置，依此类推，最后腾出 pos-1 这个下标给新元素。

有人可能会问：为什么不先判断表满？因为插入之前需要先看有没有空位；如果是动态扩容版本，表满时不是直接返回失败，而是先扩容，再插入。这两者的区别我会在第 4 节专门展开。

还有一个细节：位置 pos 用 1 起始，但数组下标是 0 起始。所以代码里写 data[i] = data[i-1] 和 data[pos-1] = elem，都要做一次“减一”的换算。很多刚开始写的人非常容易在这里晕，建议代码中统一用一个变量 index = pos - 1 来表示数组下标，避免到处都是 +1/-1 把自己绕晕。

3.3 删除操作：往前覆盖顺序不能反

删除位置 pos 的元素，逻辑是：先把 pos 之后的元素依次向前移动一个位置，覆盖掉被删元素，然后 length--。

c复制int ListDelete(SeqList *L, int pos, int *deletedElem) {
    if (pos < 1 || pos > L->length) {
        printf("删除位置非法\n");
        return 0;
    }

    *deletedElem = L->data[pos - 1];

    // 从被删除位置的下一个元素开始，依次向前移动
    for (int i = pos; i < L->length; i++) {
        L->data[i - 1] = L->data[i];
    }

    L->length--;
    return 1;
}

注意这里的判断范围：删除位置的有效范围是 1 到 length，因为只有当 pos 处有元素时才能删。对比插入的 pos 范围是 1 到 length+1，后者多了一个“可以在表尾追加元素”的位置。这两个边界条件经常被搞混，一混淆，代码就废了。

删除时数据的移动方向跟插入完全相反：从被删元素的下一个位置开始，把它往前覆盖前一个位置。

这里有一个容易犯的错：写了 for (int i = pos - 1; i < L->length - 1; i++) 这种从被删下标开始而不是从后一个下标开始的循环，结果一上来就把被删位置覆盖成后面的数据，但后面数据还等着用呢——等等，删除操作反过来，从前往后覆盖是对的。其实删除就是要用 data[pos] 覆盖 data[pos-1]，用 data[pos+1] 覆盖 data[pos]，一路往前搬，所以“从前往后”搬才是对的，从后往前反而是错的。这也是新手最容易犯糊涂的地方，记不住的时候就画一个 5 个元素的数组，手动模拟一遍两个方向的移动，马上就能看出区别。

删除会不会出现物理上的“删干净”？不会。delete 后最后一个位置还残留着原来的数据，但由于 length 已经减一，所有合法操作都不会再访问那个位置，所以不需要清空它。被删元素的值如果调用方需要，就通过指针参数 deletedElem 带出去。

3.4 查找：按下标和按值，时间复杂度完全不一样

按位置查找是最简单的：

c复制int GetElem(SeqList *L, int pos, int *elem) {
    if (pos < 1 || pos > L->length) return 0;
    *elem = L->data[pos - 1];
    return 1;
}

因为顺序表支持随机访问，这个操作的时间复杂度是 O(1)，链表做不到。

按值查找则需要遍历：

c复制int LocateElem(SeqList *L, int elem) {
    for (int i = 0; i < L->length; i++) {
        if (L->data[i] == elem) {
            return i + 1;  // 返回逻辑位置，从1开始
        }
    }
    return -1;  // 没找到
}

这段代码简单，但要注意比较方式。如果 data 是 int 类型，直接用 == 没问题；如果 ElemType 是结构体，比如存学生信息，那就不能直接用 == 整体比较了（C 语言结构体不支持 == 运算符），需要指明按哪个字段比较，通常是把 key 传进来只比 id 或者 name。

3.5 复杂度分析的“平均代价”到底是什么

插入和删除时间复杂度很容易被说成 O(n)，但严谨的推导需要说明平均情况是怎么来的。

以长度为 n 的表中插入为例。插入位置一共有 n+1 种可能（1 到 n+1）。假设每个位置被插入的概率相等，即 p = 1/(n+1)。如果插入到位置 1，需要移动 n 个元素；位置 2 需要移动 n-1 个；位置 n+1（表尾）需要移动 0 个。所以平均移动次数是：

code复制( n + (n-1) + ... + 1 + 0 ) / (n+1) = n/2

因此平均时间复杂度是 O(n)。如果每次都插到表头，那是最坏情况 O(n)；每次都插到表尾，是最好的情况 O(1)，也是顺序表作为“栈”使用时 push 操作能做到 O(1) 均摊的原因。

删除同理。删除位置有 n 种可能，移动次数是 n-1 到 0，平均是 (n-1)/2，时间复杂度 O(n)。

这个平均分析有一个隐藏前提是“每个位置插入概率相等”，也就是等概率假设。现实中如果你的代码总是往头部插入，那复杂度永远是 O(n)，别被“平均 O(n)”骗了。

用一张表总结一下顺序表各操作的复杂度：

4. 动态扩容：从固定空间到自动增长的完整设计

4.1 为什么静态数组无法满足实际需求

如果顺序表的最大容量在初始化时就定死，不再改变，那它就是一个静态顺序表。静态数组的问题很明显：你无法预知未来要存多少数据。

比如你初始化了 100 个元素的顺序表，结果用户突然要录入 500 个学生信息，你怎么办？你没法在同一个数组上变成 500 个连续内存空间。更惨的是 C 语言里 int arr[100] 是分配在栈上的，数组大小必须在编译期确定，运行时无法改变。

所以真正的顺序表通常要支持动态扩容。实现方式就是在运行时发现 length == maxSize 时，申请一块更大的新内存空间，把旧数组里的所有元素复制过去，然后释放旧空间。

代码实现：

c复制int ExpandList(SeqList *L) {
    int newSize = L->maxSize * 2;
    int *newData = (int *)malloc(newSize * sizeof(int));
    if (newData == NULL) {
        return 0; // 扩容失败
    }

    // 把旧数据拷贝到新空间
    for (int i = 0; i < L->length; i++) {
        newData[i] = L->data[i];
    }

    free(L->data);       // 释放旧空间
    L->data = newData;   // 指向新空间
    L->maxSize = newSize;
    return 1;
}

然后插入函数中，判断表满的地方不再是直接返回失败，而是先调用扩容：

c复制if (L->length >= L->maxSize) {
    if (!ExpandList(L)) {
        return 0;  // 扩容失败才返回错误
    }
}

4.2 为什么扩容因子通常是 2 倍而不是加固定大小

这里有个很多教材根本不展开、但是特别值得想明白的问题：为什么一般都说扩容到原来的 2 倍，而不是每次多分配 10 个或者 5 个空间？

如果每次扩容固定增加 10 个位置，那么从长度 10 增加到 10 万的过程中，一共需要搬迁 10 万/10 = 1 万次左右的数组复制，累计移动的元素个数是：

code复制10 + 20 + 30 + ... + 100000

这个和是一个等差数列，量级是 O(n^2)。也就是说，虽然每次插入表面上 O(1)，但因为频繁触发扩容，最终累计的性能会非常难看。

如果是翻倍扩容呢？数组容量从 1 增长到 2、4、8、16、32……到 n，每次扩容后需要复制的元素个数分别是 1、2、4、8……加起来大约是 2n。这意味着：在 n 次插入操作中，总复制元素的次数是 O(n)，平均下来每次插入是 O(1)。这就是所谓的均摊时间复杂度。

翻倍扩容的均摊代价，可以这样理解：多出来的那部分空间不是白白浪费的，它相当于“预支”了未来 n/2 次插入不需要扩容的额度。用较少次数的内存复制，换来大量 O(1) 的尾部插入。工程上 C++ vector、Java ArrayList 也都是这么做的，只是具体倍数不同。Java ArrayList 默认扩容到原来的 1.5 倍，C++ vector 通常 2 倍，Python list 大约是 1.125 倍。

为什么不是越大越好？比如扩容到 100 倍，均摊时间也 O(1)，但是空间浪费巨大：明明只存 200 个元素，可能分配了 2 万个空间。而且操作系统真实分页是按内存页对齐的，申请超大块内存不一定更高效。这就是为什么常用 1.5 倍或 2 倍——在“扩容次数”和“空间浪费”之间找一个均衡点。

4.3 realloc 其实可能是个偷懒的好工具

C 语言里还有一个更省事的函数叫 realloc：

c复制int *newData = (int *)realloc(L->data, newSize * sizeof(int));
if (newData != NULL) {
    L->data = newData;
    L->maxSize = newSize;
}

realloc 的行为分两种：如果后面紧邻的连续内存够大，它会原地扩展，直接返回原指针；如果不够，它会申请新内存、自动把旧数据复制过去并释放旧空间。理论上讲，用 realloc 可以少写很多代码。

但我在实际教学和工程中更建议新手先写 malloc + 拷贝 + free 的版本，理由有两个。第一，realloc 成功和失败的语义比较微妙，如果 realloc 失败，原指针仍然是有效的，但直接赋值给 L->data 会造成原数据丢失，正确写法要先判断非空再赋值。第二，手写一遍扩容过程，你对“旧数据要搬到新家、旧空间要被释放”这个流程理解才深。后面学顺序表在内存中搬迁的原理，再看 realloc 的源码就不难。

4.4 要不要做缩容？我的答案很明确：慎做

很多学生学会了扩容之后，会顺着“空间不够自动变大”的自然想法问：那我删除元素删到只有一半容量时，是不是也应该自动缩容，省点内存？

实际工程中缩容是一个非常危险的操作。你缩容要申请更小内存、搬数据、释放旧内存，然后用户下一个操作又插入一大批数据，再次触发扩容。如果数据量在阈值附近反复横跳，就会导致频繁的内存申请 + 数据搬迁，性能反而急剧下降，甚至不如完全不缩容。

Java 的 ArrayList 就明确“不自动缩容”，需要调用 trimToSize 手动提交缩容请求；C++ vector 也有 shrink_to_fit，但同样不是自动的。自动缩容带来的好处只是内存占用减少，代价却是性能不确定和机制复杂化，权衡之下多数标准库选择不做自动缩容。初学阶段你就记住一句话：扩容是刚需，缩容是优化。在没搞清性能瓶颈前，不做缩容不会出大问题，乱做缩容反而容易翻车。

5. 顺序表和链表该怎么选：别只会背“数组查快、链表改快”

5.1 教科书结论的局限性

每一本《数据结构》教材在讲完顺序表和链表之后，都会画一张对比表：

这张表本身没有问题，问题在于很多人把它背成了两句话：顺序表适合查找多、增删少的场景；链表适合增删多、查找少的场景。这个说法方向是对的，但它漏掉了一个在工程中极其重要的因素——内存的局部性和 CPU 缓存，而这一块在真实性能表现里往往比“理论复杂度”更致命。

5.2 为什么连续内存访问更快：Cache 的魔法

现代 CPU 访问内存并不是一个字节一个字节去读的，而是一块一块地读入缓存（Cache Line，常见是 64 字节）。当你访问 data[0] 时，CPU 不光把 data[0] 加载到高速缓存里，还会把它附近 64 字节内的内容一并加载进来。

顺序表的元素在物理上是连续的，遍历 data[0] 到 data[9]，正好都在同一块或相邻的两三块缓存行上，CPU 读第一块内存后，后面几个元素几乎都能直接从缓存中命中，速度非常快。

链表就麻烦了，每个节点是单独 malloc 出来的，申请内存时不保证两个相邻节点在物理上也相邻。遍历链表时，你访问完 node1，下一个 node2 很可能不在刚才加载的缓存行里，只能再去内存中加载。频繁的缓存未命中会让实际耗时会比理论复杂度高一个数量级以上。

用大白话来讲：顺序表是在“一条街上逛商铺”，走两步就是下一家；链表是“在地图上跳着点外卖”，每一家都要单独跑一趟。如果你要完整遍历一批数据，顺序表天然有物理连续性的加成。所以即使是插入删除操作，在数据量不大、操作位置靠近尾部时，顺序表的表现也常常优于链表。

5.3 真正的选型框架：按场景算账，而不是背口诀

工程里要选哪个结构，我的习惯是先把数据规模、操作分布、内存约束列出来，再估算实际开销。

场景一：你要维护一个高得分排行榜，高频读取 Top10，偶尔更新分数。元素个数几百，基本没有删除需求。这时候顺序表是默认选择：用动态数组存所有记录，排序或者用堆维护都方便。

场景二：你要实现一个聊天软件的消息列表，用户会不断往列表底部追加消息，偶尔往中间插入一条转发消息，也要支持上滑加载历史。消息量可能几十万条。这种情况顺序表也够用，因为主要操作是尾部追加和按下标分页加载，已经是 O(1) 或 O(n) 里最友好的场景了。Java 里聊天记录列表也通常用 ArrayList，而不是 LinkedList。

场景三：你要做一个任务队列，业务上总是在队头插入高优先级任务，队尾取出执行。如果用顺序表，每次队头插入都要把现有元素全部往后搬一次。如果你频繁插入头部，显然不合适。这时候可以考虑真正用链表（或者双端队列 deque）。

场景四：你要存一个“好友列表”，每个用户的好友数量可能差别很大，且经常上下线，要频繁加好友、删好友。如果用顺序表，你无法预知每个人最多多少好友，并且删除时可能频繁搬元素。这里链表“按需分配节点”的优势就显现了。

所以你看，真正决策要分析的具体操作模式是：插入主要发生在头部、中部还是尾部？删除频繁吗？随机访问的频率高不高？预估最大数据量是多少？对内存碎片敏感吗？ 这些放在一起才能给出可靠答案，单纯说“查多选顺序表、改多选链表”是偷懒。

5.4 现实很残酷：标准库都在“偏爱”顺序表

还有一个反直觉的现象值得注意：C++ 的 std::list 是双向链表，但在大多数算法竞赛和工程实践里，std::vector（顺序表）的综合表现往往更好；Java 的 LinkedList 在大多数业务代码中几乎没有出场机会；Python 的 list 名字听起来像链表，实际上底层却是“动态数组”。

原因就是上面说的局部性。当 n 不太大时，顺序表的连续内存访问效率高；当 n 很大时，链表的每个节点多存一两个指针，内存开销更大，而且节点间跳跃访问对缓存不友好。链表真正的不可替代优势是在“任何位置插入删除都是 O(1)（前提是已经拿到该位置的指针）”以及“结构变化不需要搬运大量元素”这两点上。对于很少需要从任意位置增删、或者根本不知道节点指针只有值的情况，顺序表几乎总是更优的选择。

学数据结构时当然要搞懂链表，但在真实编码中，我的默认启动结构永远是顺序表而不是链表。这是一个很多教程不会明说的经验，也是我踩过不少坑之后才真正认同的。

6. 顺序表实现中最容易翻车的几个经典 Bug 现场

6.1 内存泄漏：malloc 了两次，free 却少了一次

用 C 语言写顺序表，内存管理是个绕不开的坎。最常见的内存泄漏发生在销毁函数里只 free 了结构体指针，没有先释放 data 字段：

c复制void DestroyList(SeqList *L) {
    // 错误示范：直接 free(L)，L->data 指向的内存就泄漏了
    // free(L);
    
    // 正确做法
    if (L->data != NULL) {
        free(L->data);
        L->data = NULL;
    }
    L->length = 0;
    L->maxSize = 0;
}

如果你是在函数内部动态创建了 SeqList 结构体本身，还需要再 free(L)。但如果 L 是在栈上定义的局部变量，那就不能 free，只能通过指针 free L->data。

这里我建议写代码前先明确一件事：哪块内存是我 malloc 的，就应该在哪个层次释放。data 是 InitList 里分配的，所以销毁时应在 DestroyList 里释放；如果 SeqList 的整体对象也是 malloc 出来的，那才需要额外销毁它。经验不足的人可以用 valgrind 或 AddressSanitizer 来检查，实际编码中很快能暴露问题。

6.2 栈上数组当顺序表用：忘了 length 的维护也会出错

还有不少初学者嫌 malloc 麻烦，直接在 main 里写：

c复制int data[100];
int length = 0;

然后把这个数组传给插入函数时才发现问题——函数参数传的是数组，你如何在函数内部准确知道当前有多少个元素？只传数组不行，还必须把 length 和 capacity 也传进去，而且对 length 的修改无法通过值传递带出来，得用指针。

这就是为什么一定要用一个结构体把 data、length、maxSize 打包。很多教材在讲顺序表时反复强调“用结构体封装”的原因就在这里：只有打包成一个整体，你才能把顺序表当成一个完整的抽象数据类型来使用，传参时只传一个结构体指针，内部的所有状态一目了然。

6.3 忘记“满”就插入：越界写让程序随机崩溃

你以为你定义了个能放 100 个数的数组，就可以往里塞 101 个数吗？在 C 语言里，你敢塞进去，编译器不会提醒你，运行时不一定会立即报错，而是可能正好把 data[100] 写到了紧挨着数组的其他变量地址上，覆盖了别人的数据。

这种内存越界问题的诡异之处在于：问题往往不会当场爆发，而是在执行到很远之后的某段代码时才突然崩溃，让你完全摸不着头脑。排查方法也很痛苦——需要用 AddressSanitizer 或者把数组前后都放上“哨兵”值，观察它有没有被意外修改。

所以插入函数中 if (L->length >= L->maxSize) 这个判断是保命的。即使你确定自己不会填满，也别省这个判断。写底层一点的数据结构代码，对内存边界要有敬畏感。

6.4 删除循环写错方向，导致数据被提前覆盖

前文讲过，插入要后移，需要从后往前循环；删除要前移，需要从前往后循环。很多同学不是不知道这个原则，而是写完 for 循环后，边界条件设错了：

• 插入：for (int i = length; i >= pos; i--) 这里的 i >= pos 能取到边界吗？如果 pos=1，i 最后要 i=1 时把 data[0] 后移到 data[1]，所以 i >= 1 是正确的。如果写成 i > pos，那 data[pos-1] 原位元素永远不会被移走，插入时直接把它覆盖了，数据就丢了。
• 删除：for (int i = pos; i < length; i++)，这里 i 的最后一次取值是 length-1，把 data[length-1] 往前搬到 data[length-2]，覆盖掉要删除位置之后的最后一个元素。如果写成 i <= length，就会去读 data[length]，越界了。

碰到这类问题我建议别靠脑子硬转，直接在草稿纸上画 5 个格子，标好下标和元素，模拟走一遍循环，你立刻就能发现问题。

6.5 按值查找时对结构体直接用了“==”

这也是很多人会踩的坑。数据结构教材里的例子多用 int，导致不少人形成惯性，认为 ElemType 支持 ==。可一旦你的 ElemType 是个 struct Student，在 C 语言里根本没有默认的结构体相等比较运算符。

正确做法是定义比较函数（类似于 C++ 里的 operator==、Java 里的 equals），比如比较两个学生是否相等只看学号是否相同。顺序表的查找函数应该接受一个 key 参数，而不是一个完整的 ElemType 对象；把“如何判断两个元素相等”的策略交给调用方去写。这也是后面学哈希表、搜索树时你会反复遇到的设计思想——把“相等”的语义从数据容器里解耦出来。

6.6 忘记长度变化：插入后末尾残留旧值引发误判

最后一个颇具迷惑性的 Bug 是：删除一个元素后，最后一个位置还残留旧值。假设顺序表是 [1,2,3,4,5]，删除第一个元素后变成 [2,3,4,5, ?]，data[4] 仍然可能是 5，只不过因为 length 从 5 变成了 4，这个位置已经不在表内了。逻辑上没问题，但如果你写遍历的时候习惯用 maxSize 而不是 length 作为循环终点，就会把残留值也打印出来，控制台输出“2 3 4 5 5”，怎么看怎么诡异，查半天发现是遍历条件写错了。

我见过不止一个同学在这个问题上浪费时间。经验只有一条：遍历顺序表只看 length，永不看 maxSize。maxSize 只用于判断“还有没有空间”，永远不要拿它来决定“当前有多少个逻辑元素”。

7. 学习顺序表之后，下一步该往哪里走

顺表本身并不难，但它是你在数据结构这条路上观察“抽象”与“实现”如何分离的第一个窗口。学完之后我建议不要急着往后翻书，先花时间把这几件事补上：用 typedef 把 ElemType 提成通用类型，把代码改成可存储任意数据类型；手写一个支持动态扩容的版本，至少跑通 10 万次随机插入删除不出问题；用 AddressSanitizer 启动一次自己的代码，亲眼看一看以前有没有越界。

等你把顺序表真正写熟了，你会发现后面的栈——限制插入删除位置的顺序表、队列——头尾操作受限的顺序表、哈希表——以哈希函数决定下标的数组，全都是同一棵知识树上的分支。许多号称“高级”的结构，说到底也绕不开“连续空间里的位置计算”这几个字。所以别嫌它基础，基础到极致，就是整个学科的骨架。

我在实际调试顺序表相关代码时的一个小习惯也和你说一下：每次插入或删除后，我会顺手打印 length、maxSize 以及整个表的内容。看起来有点笨，但数据规模一上来，你对着日志一眼就能看出“是不是插入到错误位置”“是不是忘记维护 length”这些最初级的 Bug。数据结构这东西，写的是底层代码，治的是逻辑病，多打点日志永远不算亏。