顺序表从零手写：存储结构、增删查改与避坑指南

很多朋友学《数据结构》遇到的第一个“拦路虎”，不是树也不是图，而是开篇的顺序表。别看顺序表结构简单，它却是整个数据结构体系的地基——后面学的栈、队列、字符串，底层大多都离不开顺序存储的思想。数组大家都会，可是什么时候用静态分配、什么时候用动态分配，插入元素为什么要倒着移动，位序和下标到底差多少，这些细节不亲手写一遍代码，光看书很容易眼高手低。

这篇文章我会把顺序表掰开了讲，从内存布局到代码实现，从初始化到增删查改，尽量把每个细节都讲透。正在准备考研或期末复习的朋友，可以把它当作一份提纲挈领的复习资料；正在做课程设计的同学，拿到这份内容，实验报告的核心代码部分基本能直接用了。目标是让你学完之后，能自己把整个顺序表从零写出来，并且知道每个函数为什么这么写。

1. 顺序表到底是什么：从“数组”到“顺序表”的认知升级

第一个问题其实是很多初学者卡住的地方：我都已经会数组了，顺序表这东西不就是换个名字吗？说实话，我第一次上课的时候也这么想。但后来才意识到，数组是编程语言里的一种语法机制，而顺序表是“数据结构”层面的抽象——它不关心你用 C 还是 Java 还是 Python，它关心的是一组数据在内存里“怎么摆”、“怎么管”、“怎么用”。

1.1 线性表与顺序表的关系

先把这个关系捋清楚。数据结构里，线性表是一种逻辑结构，它描述的是数据元素之间存在“一对一”的线性关系：每个元素都有且只有一个直接前驱和一个直接后继（首尾元素除外）。这就像一个排队购物的队伍，你前面是谁、后面是谁都是确定的。

那顺序表是什么？顺序表是线性表的一种存储结构。你可以把“线性表”理解成“要表达的意思”，把“存储结构”理解成“用嘴说出来还是用笔写下来”。同样的线性关系，在计算机里既可以用一段连续的内存来存（这叫做顺序存储），也可以用零散的内存靠指针串起来存（这叫做链式存储），前者就是顺序表，后者就是链表。

这个“逻辑结构 vs 存储结构”的区分，是整门数据结构课的第一个考点，很多学校的期末考试、考研真题第一题就会考这个。你需要记住：线性表是逻辑上的“线性”，顺序表是存储上的“连续”。

1.2 数组和顺序表“像但不一样”

回到开头那个困惑：数组和顺序表有什么区别？

打个比方。数组就像你租了一个固定大小的仓库，里面划分成一格一格的小隔间，每一格都有一个编号，你想放东西就放进对应编号的格子。但仓库管理很“原始”——你得自己记住放了多少个格子是有货的，自己保证不要把东西塞到编号不存在的地方去。

顺序表呢，是在这个仓库基础上加了一套“库存管理系统”。系统里有一个计数器 length，准确告诉你现在用了多少个格子；所有对仓库的操作（拿货、进货、清点）都走标准流程，先检查位置合不合法再动手。这套系统就是那批封装好的函数。

所以一句话概括：顺序表 = 数组 + 长度信息 + 一堆操作函数。数组是“死的”，顺序表是“活的”；数组只管存，顺序表管存、管取、管数量、管合法性。

提示：很多非科班转行做开发的朋友，第一次接触 ArrayList（Java）或者 Python 的 list，其实底层就是顺序表的思想。你理解了这一步，后面看这些语言内置容器的源码会轻松很多。

2. 存储结构解剖：连续内存到底长什么样

这一节我们从底层的角度看看，顺序表那块连续的内存到底是怎么组织的。理解了这一步，“按下标访问为什么是 O(1)”、“插入为什么慢”这些问题都会迎刃而解。

2.1 结构体定义：data 数组 + length 长度

在 C 语言里，一个最简单的顺序表定义长这样：

c复制#define MaxSize 50        // 顺序表的最大容量

typedef struct {
    int data[MaxSize];    // 用数组存储数据元素
    int length;           // 顺序表的当前长度
} SqList;

我在刚开始写代码的时候，最大的疑问是：data 数组不是有 MaxSize 个位置吗，为什么还要单独搞一个 length？直接用数组长度不就行了？

这个问题的答案，恰恰是顺序表的精髓。数组的 MaxSize 是容量，表示这块内存最多能装多少；而 length 是实际装了多少。你定义一个 MaxSize=50 的顺序表，可能只用了 3 个格子，那么真正操作的时候只需要管前 3 个，后面 47 个虽然是分配好了的，但属于“未使用区域”，根本不用去碰。还有个隐含的好处：只有维护了 length，下次插入元素时才知道往哪个位置写。

另一个容易忽略的点是 data 的类型。上面用了 int，实际上顺序表不关心元素具体是什么类型——学生信息结构体、字符串、浮点数都可以。所以更通用的定义是把类型名抽象成 ElemType：

c复制typedef int ElemType;      // 将来要改类型，只改这一行
#define MaxSize 50

typedef struct {
    ElemType data[MaxSize];
    int length;
} SqList;

2.2 静态分配和动态分配怎么选

上面这种写法叫静态分配，因为数组的大小在编译阶段就定死了，MaxSize 是多少就是多少，运行过程中没法改。它的优点是简单、不会产生内存泄漏、考研和期末写代码首选；缺点也很明显——如果预估 MaxSize=50，实际来了 100 个元素，直接放不下。

所以实际开发中更常用的是动态分配。先用指针申请一块堆内存，如果不够了，可以再申请一块更大的，把旧数据搬过去，来一次“扩容”：

c复制#define InitSize 100

typedef struct {
    int *data;        // 动态分配数组的指针
    int MaxSize;      // 最大容量
    int length;       // 当前长度
} SeqList;

初始化的时候这样写：

c复制void InitSeqList(SeqList *L) {
    L->data = (int *)malloc(InitSize * sizeof(int));
    if (L->data == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    L->MaxSize = InitSize;
    L->length = 0;
}

注意 malloc 之后一定检查返回值是不是 NULL，这个习惯比写代码本身重要一万倍。动态分配最典型的应用场景是扩容，比如新增元素发现 length == MaxSize 的时候，申请一块 2 倍大小的新内存，用循环把旧数据复制过去，再释放旧内存。这个“倍增扩容”的策略在 Java 的 ArrayList、Go 的 slice 里都能看到影子，本质都是顺序表在玩动态扩容。

提示：静态分配的顺序表存放在栈区，动态分配的数据部分存放在堆区。栈区空间通常只有几 MB，堆区可以有几个 GB。如果你要存储大对象、大数据量，几乎必须用动态分配。

3. 从零手写：初始化与基础工具函数

定义完结构体，接下来要做的就是把它“用起来”。很多人学数据结构只背了定义，结果一上机发现连个能运行的程序都写不出来。这一章我们把最基础的工具函数走一遍，每一个我都附上说明。

3.1 初始化函数：不初始化一定出 bug

顺序表定义出来之后，绝对不能直接就用。为什么？因为结构体变量里的 length 是个未初始化的“野值”，可能是 0，可能是 374563，还可能是负数。你说要往顺序表里加元素，如果 length 是个随机大数，插入的时候就不知道会写到哪里。

初始化要做的事情很简单：把 length 置为 0，表示“当前一个元素都没有”。如果用了静态分配的数组，不需要动 data，因为没有任何元素需要初始化。

c复制void InitList(SqList *L) {
    L->length = 0;
}

这里有个 C 语言的关键点：函数参数一定要传指针。你写 void InitList(SqList L) 这样的版本，函数内部改的是形参的拷贝，外面的 L 根本不会变。每学期都有同学在这上面踩坑，写完了之后发现插入了半天 length 还是 0，一查，就是没传指针。

3.2 判空、判满、求长度、打印

这几个函数虽然逻辑很简单，却非常值得写。它们就像仓库管理系统的“查询工具”，让代码可读性更高，也让后面所有操作函数的实现更清晰。

c复制bool Empty(SqList L) {
    return L.length == 0;
}

bool Full(SqList L) {
    return L.length == MaxSize;
}

int Length(SqList L) {
    return L.length;
}

void PrintList(SqList L) {
    for (int i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");
}

注意求长度这个函数，虽然它只是一行 return L.length，但是在开发中，所有“获得长度”的操作都应该通过这个函数完成，而不是到处直接访问 L.length。这是一种封装思想，将来如果 length 的计算方式变了，你只需要改这一个函数。

提示：这里有一类问题是新手常犯的——打印循环写成了 i < MaxSize，结果把未使用的那 47 个“垃圾值”也打出来了。记住，遍历永远是 0 到 length-1，不是 0 到 MaxSize-1。

4. 核心操作拆解：插入与删除为什么是 O(n)

顺序表最核心的操作就是插入和删除。这两个操作的实现思路很朴素，但背后的细节多到让我当年debug到怀疑人生。这一章我们重点拆这两个函数。

4.1 插入操作完整实现与逐行解析

先说实现逻辑。要在第 pos 个位置（位序从 1 开始）插入一个元素 elem，核心步骤是：

1. 先通过后移的方式，给新元素腾出位置；
2. 把 elem 放进腾出来的位置；
3. length 加 1。

后移必须从最后一个元素开始，从后往前一个一个挪。如果你从前往后挪，后面的元素会把前面的覆盖掉，数据就丢了。

c复制bool ListInsert(SqList *L, int pos, int elem) {
    // 1. 位置合法性检查
    if (pos < 1 || pos > L->length + 1) {
        return false;
    }
    // 2. 空间检查
    if (L->length >= MaxSize) {
        return false;
    }
    // 3. 从最后一个元素开始，依次后移一位
    for (int i = L->length; i >= pos; i--) {
        L->data[i] = L->data[i - 1];
    }
    // 4. 放入新元素
    L->data[pos - 1] = elem;
    // 5. 长度加 1
    L->length++;
    return true;
}

逐行看几个关键点：

位置检查为什么是 pos > L->length + 1？ 因为允许在表尾插入。当表里有 length 个元素时，合法插入位置是 1 到 length+1。比如表里现在有 3 个元素，你可以在第 4 个位置插入，也就是“追加到末尾”。如果 pos 是 5，就不合法了。这个 length + 1 是个细节，好多版本的书上写的是 pos > L->length，那就把“表尾插入”给禁止了，是不完整的。

循环为什么从 i = L->length 开始，到 i >= pos 结束？ 因为下标 i 对应的数据要放到 i+1 的位置。从最末尾的元素开始，先把 data[length] = data[length-1]，这是把最后一个元素往后挪；然后 i 减 1，继续挪倒数第二个……直到把原来 pos-1 这个位置的数据挪到 pos 位置。这样 pos-1 位置就空出来了。

最后为什么是 data[pos - 1] = elem 而不是 data[pos]？ 因为入参的 pos 是位序，从 1 开始；数组下标从 0 开始。位序 1 就是 data[0]，位序 2 就是 data[1]，所以位序 pos 对应 data[pos - 1]。位序和下标之间的这个“差一”转换，是顺序表最常见的错误来源，后面专门展开讲。

4.2 删除操作完整实现与逐行解析

删除比插入稍微简单一些：把目标位置后面的元素整体往前挪一位，把空出来的“最后一位”覆盖掉，length 减 1。我们往往需要把被删掉的那个元素的值返回出来，所以用指针参数带出去。

c复制bool ListDelete(SqList *L, int pos, int *elem) {
    // 1. 位置合法性检查
    if (pos < 1 || pos > L->length) {
        return false;
    }
    // 2. 先用指针把被删元素带出去
    *elem = L->data[pos - 1];
    // 3. 从 pos 位序的后一个元素开始，依次前移一位
    for (int i = pos; i < L->length; i++) {
        L->data[i - 1] = L->data[i];
    }
    // 4. 长度减 1
    L->length--;
    return true;
}

删除时的检查是 pos > L->length，不需要加 1，因为你要删的必须是一个“真实存在的元素”。如果表里只有 3 个元素，你删第 4 个位置的元素，那是没有的。

前移的循环从 i = pos 开始，也就是把下标 pos 的元素移到 pos-1，下标 pos+1 的移到 pos……一直到最后。熟悉了数组移位之后，你会发现前移和后移的循环边界特别容易写错，多写几道题练一练就顺了。

4.3 时间复杂度分析：平均要挪 n/2 个元素

为什么顺序表的插入、删除复杂度是 O(n)？直观上想一下：插入位置越靠前，要移动的元素越多。插入到第 1 个位置要移动 n 个元素，插入到第 n+1 个位置（表尾）移动 0 个元素。平均下来，在等概率的情况下，平均移动次数是：

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

所以平均时间复杂度是 O(n)。这也是顺序表最“痛”的一个点——它查得快（O(1)），但改结构（插入、删除）会慢。这个“快慢不均”的特性，是后面选型时最重要的判断依据。

5. 高频操作实现：查找、修改与遍历的最佳实践

插入和删除是顺序表变化最频繁的操作，但在实际项目中，你天天在做的事其实是查：查某个位置是谁，查某个值在哪里，查完了改一下，然后遍历输出。

5.1 按位查找：数组的天然优势

按位查找，就是“给我第 pos 个位置的元素”。因为顺序表的底层是连续内存，所以不需要从头遍历，直接用数组下标访问：

c复制ElemType GetElem(SqList L, int pos) {
    if (pos < 1 || pos > L.length) {
        return -1;  // 实际应用中，更规范的做法是返回布尔值+指针出参
    }
    return L.data[pos - 1];
}

这里一定要区分：用户说“第 1 个元素”和数组里的“data[0]”，这是同一个东西。所以函数里必须做 pos - 1。这个函数的时间复杂度是 O(1)，也就是常说的“随机存取”，这是顺序表对比链表最核心的优势。

5.2 按值查找与顺序查找代码实现

按值查找，就是“给一个值，找出它在表中的位置”。因为数据没有排序，只能从头到尾一个一个比，这叫做顺序查找：

c复制int LocateElem(SqList L, ElemType elem) {
    for (int i = 0; i < L.length; i++) {
        if (L.data[i] == elem) {
            return i + 1;  // 返回位序
        }
    }
    return 0;  // 查找失败，返回 0 表示不存在
}

注意返回值处理：找到时，返回的是位序（i + 1），不是下标；找不到返回 0。因为位序是从 1 开始的，0 是一个天然的“不存在”标志。要是你返回的是 -1，调用方往往还得额外处理一下，不如返回 0 来得自然。

按值查找的时间复杂度是 O(n)，最好情况是第一个就找到 O(1)，最坏是最后一个才找到 O(n)，等概率下平均比较次数是 (n+1)/2。

5.3 修改与遍历的注意事项

修改的本质是查找 + 赋值，没太多花样：

c复制bool UpdateElem(SqList *L, int pos, ElemType val) {
    if (pos < 1 || pos > L->length) {
        return false;
    }
    L->data[pos - 1] = val;
    return true;
}

遍历的时候再提醒一句：一定是用 length 控制循环边界。好多初学者在遍历时写成 for (int i = 0; i < MaxSize; i++)，打印出来的全是数组里没有意义的旧数据。在实际调试的时候，如果发现打印结果里有一大堆莫名其妙的大数，先检查你循环的边界条件。

6. 实战避坑指南：初始化、边界与调试血泪教训

这一章聊聊我实际调试顺序表代码时踩过的坑。这些坑在书上通常不会专门写，但每一个都能让你的程序“看起来没问题却跑不对”。

6.1 位序与下标的“差一错误”

这是顺序表最经典的 bug 类型。用户的角度是位序：第 1 个、第 2 个……；计算机的角度是下标：0、1、2……。两者永远差 1。

我在调试时总结了一个口诀：入参位序，下标减一；遍历输出，下标直用；返回位序，下标加一。 也就是说：

• 插入、删除、修改、按位查找的参数 pos 传进来后，访问数组时写 data[pos - 1]；
• 遍历打印时，循环变量 i 直接当数组下标用，写 i < length 就够了，别画蛇添足；
• 按值查找返回位置时，return i + 1。

6.2 边界检查的完整套路

位置参数的合法性检查，是保证程序不崩溃的最后一道防线。我见过非常多的同学，写完了 ListInsert 不检查 pos，直接 L->data[pos - 1] = elem;，然后在 main 函数里调用 ListInsert(&L, 999, 5)，数据直接写到了数组越界的内存里。这种 bug 不会当场报错，会在程序跑很久之后才莫名其妙崩溃，找起来极其痛苦。

我的建议是：所有操作函数开头，先检查再干活。插入检查 pos < 1 || pos > length + 1，删除检查 pos < 1 || pos > length。这个习惯要形成肌肉记忆，将来写树、写图、写各种数据结构的时候，你都会感谢当年的自己。

6.3 动态内存分配与释放

如果你的顺序表用了 malloc 动态分配，用完一定要 free，否则会发生内存泄漏。在复杂程序中，内存泄漏是“慢性病”，一时半会儿看不出问题，跑久了内存占用越来越高，直到程序卡死。

另外还有个常见问题：动态扩容时，旧内存释放的时机不对。正确的顺序是：先用新内存把旧数据复制过去，再 free 旧指针，最后让结构体里的 data 指针指向新内存。顺序反了，数据就全没救了。

我见过一个让我印象很深的 bug：某同学实现了扩容，结果每次扩容后只复制了前几个元素，后面的全是乱码。后来一查，他那循环写的是 for(int i = 0; i < L->length; i++)，但 length 在扩容时被错误地重置成了 0，循环体压根没执行。这类问题，调试时在循环前打个断点观察 length 的值，立刻就能暴露。

7. 延伸思考：顺序表和链表到底怎么选

这一节其实是“顺序表（下