线性表的定义与基本操作 — 从逻辑结构到 ADT 接口

引言

第一次接触"线性表"这个名词时，第一反应是把它和数组（Array，一组连续内存）划等号。学完链表之后，又觉得"线性表就是数组或链表的一种"

线性表（Linear List）本质上是一个逻辑结构（Logical Structure）概念。它描述的是数据元素之间"一对一"的线性关系，与数据在内存中如何存放------顺序存储还是链式存储------是两个层次的问题。本文逐层拆解线性表的定义、九种 ADT 接口规范，为后续顺序表和链表的实现篇铺路。

📌 核心要点

线性表是逻辑结构，不是物理实现。 顺序表（Sequential List）和链表（Linked List）是线性表的两种存储方式------同一套逻辑接口,两种不同的物理组织。

线性表 ADT 定义了九种基本操作。 InitList、DestroyList、ListInsert、ListDelete、LocateElem、GetElem、Length、PrintList、Empty 构成线性表的完整接口契约（Interface Contract），所有实现都必须支持这些操作。

位序从 1 开始计数。 线性表的位序（Position）是 1-based，与 C 语言数组下标（0-based）不同，代码中需要 i-1 转换。

"数据元素"不同于"数据项"。 一个数据元素可以有多个数据项（如学生记录包含学号、姓名、成绩），把"学号"误称为"数据元素"是选择题中反复出现的干扰项设计手法。

什么是线性表------从逻辑结构谈起

$共识$ 线性表的严格定义：由 n (n >= 0) 个相同数据类型 （Data Type）的数据元素（Data Element）组成的有限序列（Finite Sequence）。记作：

L=(a1,a2,...,ai,ai+1,...,an) L = (a_1, a_2, \ldots, a_i, a_{i+1}, \ldots, a_n) L=(a1,a2,...,ai,ai+1,...,an)

其中 n 为表长（Length）。当 n = 0 时，L 为空表（Empty List）。每个 a_i 是一个数据元素，可以是简单的整数值，也可以是复杂的结构体------但同一线性表中所有元素的数据类型必须相同。

$共识$ 线性结构区别于树结构和图结构的根本特征在于"一对一"的逻辑关系：除第一个元素（表头元素）无直接前驱、最后一个元素（表尾元素）无直接后继外，表中每个数据元素有且仅有一个直接前驱 （Immediate Predecessor）和一个直接后继（Immediate Successor）。这种线性约束将元素组织成一条逻辑上的"链"，而非树的一对多展开或图的多对多网状连接。对此类比的系统讨论可参见本系列第六章关于图结构作为非线性结构的代表的文章。

数据元素（Data Element）vs 数据项（Data Item）------这是 408 选择题中反复出现的一对概念，近十年真题中至少出现了 5 次 $引用$ 。二者的区别在于层级：数据元素是线性表的基本组成单位，而一个数据元素内部可以包含多个数据项。以学生信息表为例：整个表是一个线性表；表中每一位学生的完整记录是一个数据元素；而学号、姓名、成绩分别是这个数据元素的三个数据项。题干中常见的干扰手法是把"学号"或"成绩"描述为"数据元素"------这正是偷换了层级关系。

记忆锚点： "有限序列，同类数据，线性关系"------12 个字概括线性表的全部定义要素。
**📊 线性表逻辑结构示意**

复制代码

位置:   第1位      第2位      第3位      第4位      第5位
      ┌─────┐   ┌─────┐   ┌─────┐   ┌─────┐   ┌─────┐
      │ a₁  │ → │ a₂  │ → │ a₃  │ → │ a₄  │ → │ a₅  │
      └─────┘   └─────┘   └─────┘   └─────┘   └─────┘
      ↑ 无前驱                              ↑ 无后继
      首元素                                尾元素
      
每个中间元素 aᵢ (i=2,3,4)：唯一前驱 aᵢ₋₁ + 唯一后继 aᵢ₊₁

线性表不等于顺序表------逻辑与物理的层次分离

数据结构的三要素------逻辑结构、存储结构（物理结构）和运算------构成了一个自上而下的层次体系。线性表位于逻辑结构层，描述的是元素之间"是什么关系"；而数据具体怎样存放在内存中，属于存储结构层的事。把线性表等同于顺序表，就像把"交通工具"等同于"汽车"------前者是抽象类别，后者是具体实现。

顺序表采用顺序存储 （Sequential Storage）：所有元素存放在一片地址连续的存储单元中，逻辑相邻的元素物理上也相邻。链表采用链式存储 （Linked Storage）：元素分布在不连续的内存空间，通过每个结点携带的指针（Pointer）串联其逻辑后继。二者都以线性表的逻辑关系为蓝本，但在物理组织方式上完全不同。因此以下说法在 408 考试中是错误的------"线性表的存储结构是顺序存储"------正确表述应该是"线性表可以采用顺序存储结构实现"。

学完链表后，被问到"什么是线性表"时脱口而出"线性表就是数组或链表"。这正是逻辑结构与物理结构的混淆------把接口和实现看成了同一个东西。先定义接口（ADT，Abstract Data Type，抽象数据类型）再讨论实现，不是课本在故弄玄虚，而是软件工程中最基本的抽象分层思想。定义清楚"线性表能做什么"之后，再分别用顺序存储和链式存储去兑现这些接口------这本质上就是面向对象设计中"面向接口编程"（Program to an Interface）在数据结构领域的直接映射。

线性表的 ADT------九种基本操作

严蔚敏《数据结构（C 语言版）》将线性表的基本操作归纳为以下九种 $引用$ ，构成一套完整的接口契约。任何线性表的实现------无论是基于数组的顺序表，还是基于指针的链表------都必须对外提供这九种操作。

下面给出完整的数据类型定义和九种操作的函数签名。为便于阅读，先定义基础类型别名和顺序表结构体（链式版本将在后续文章展开）：

c 复制代码

// 基础类型定义
#define MAXSIZE 100        // 顺序表最大容量（可根据需要调整）

typedef int ElemType;      // 元素类型：示例使用 int，实际可替换为任意类型
typedef int Status;        // 操作状态返回值：OK 或 ERROR
#define OK      1
#define ERROR   0

// 顺序表结构体定义
typedef struct {
    ElemType data[MAXSIZE]; // 存储数据元素的数组
    int   length;           // 当前表长（已存储的元素个数）
} SqList;

在此结构体之上，九种基本操作的接口规范如下：

c 复制代码

/* 1. 初始化线性表：构造一个空表，将 length 置 0 */
Status InitList(SqList *L);

/* 2. 销毁线性表：释放表占用的内存资源（静态数组无需额外释放，
      动态分配的数组需调用 free） */
Status DestroyList(SqList *L);

/* 3. 插入操作：在表 L 的第 i 个位序处插入元素 e
      插入前要求 1 <= i <= L.length + 1（允许在表尾后一个位置插入）
      插入成功后原第 i 个及之后元素依次后移一位，表长 +1 */
Status ListInsert(SqList *L, int i, ElemType e);

/* 4. 删除操作：删除表 L 的第 i 个位序处的元素，用 *e 返回其值
      删除后原第 i+1 个及之后元素依次前移一位，表长 -1 */
Status ListDelete(SqList *L, int i, ElemType *e);

/* 5. 按值查找：在表 L 中查找第一个值等于 e 的元素
      返回其位序（1-based），若未找到则返回 0 */
int LocateElem(SqList L, ElemType e);

/* 6. 按位查找：返回表 L 中第 i 个位序的元素值，通过 *e 传出
      注意：i 是线性表位序（1-based），不是 C 数组下标 */
Status GetElem(SqList L, int i, ElemType *e);

/* 7. 求表长：返回表 L 中当前数据元素的个数 */
int Length(SqList L);

/* 8. 输出全表：依次打印表 L 中所有元素的值 */
Status PrintList(SqList L);

/* 9. 判空：若表 L 为空表（length == 0）返回 true，否则返回 false */
bool Empty(SqList L);

以上九种操作可以根据其功能归纳为一条记忆口诀："增删改查，创建销毁，判空求长，遍历输出。" 其中 ListInsert 和 ListDelete 是两种核心写操作------它们的实现细节（元素移动、边界判断、时间复杂度分析）构成了后续顺序表和链表文章的主体内容。

值得留意的是，所有操作中使用位序的参数 i 都从 1 开始取值。这并非来自 C 语言的惯例，而是 ADT 层面的独立设计------位序概念属于逻辑层，不应被具体编程语言的下标规则所约束。下一节会展开讨论这一设计选择带来的实际编码影响。
**📊 九种基本操作速查表**

操作名	参数	功能摘要	返回值	位序相关
`InitList(&L)`	线性表引用	构造一个空的线性表	OK / ERROR	否
`DestroyList(&L)`	线性表引用	销毁线性表，释放所有资源	OK / ERROR	否
`ListInsert(&L, i, e)`	线性表引用, 位序, 元素	在第 i 位插入元素 e	OK / ERROR	是 (1 ≤ i ≤ length+1)
`ListDelete(&L, i, &e)`	线性表引用, 位序, 元素引用	删除第 i 位元素并用 e 返回	OK / ERROR	是 (1 ≤ i ≤ length)
`LocateElem(L, e)`	线性表, 元素值	查找第一个值为 e 的元素位序	位序 (0 表示未找到)	否 (按值查找)
`GetElem(L, i)`	线性表, 位序	获取第 i 位元素的值	元素值 / NULL	是 (1 ≤ i ≤ length)
`Length(L)`	线性表	返回线性表中元素的个数	整数 (≥ 0)	否
`PrintList(L)`	线性表	遍历输出线性表所有元素	无	否
`Empty(L)`	线性表	判断线性表是否为空	true / false	否

位序从 1 开始------一个细节

线性表的位序（Position）从 1 开始计数：a_1 是第 1 个元素，a_2 是第 2 个元素，依次类推至 a_n。这与 C 语言中数组下标从 0 开始的惯例形成了一处需要时刻注意的"翻译"关系。

教材统一采用 1-based 位序并非随意为之。一方面，序列中"第 1 个"的表述来自数学中的自然数序，贴合人类的直觉------没有人会说"第 0 个学生"。另一方面，位序的定义独立于任何编程语言：无论你使用 C（0-based 数组）、Fortran（1-based 数组）还是 Python（0-based list），线性表 ADT 的位序始终是 1 到 n。这使得接口规范具有语言无关性------先定好逻辑层的坐标系，再交给具体语言去做映射。

但在用 C 语言实现时，位序 i 与数组下标 i-1 之间的转换是绕不开的一步。以顺序表的按位查找操作为例：

c 复制代码

// 按位查找：获取顺序表 L 中第 i 个位置（位序）的元素值
// 参数说明：L 为顺序表（值传递，因为只读）；i 为位序（1-based）
//           *e 为传出参数，用于接收查找到的元素值
Status GetElem(SqList L, int i, ElemType *e) {
    // 步骤 1：位序合法性检查
    // i 的合法范围是 [1, L.length]，注意这里用了 L.length 而非 MAXSIZE
    if (i < 1 || i > L.length) {
        return ERROR;
    }
    // 步骤 2：位序 → 数组下标的转换
    // a1 存放在 data[0]，a2 存放在 data[1]，......，ai 存放在 data[i-1]
    *e = L.data[i - 1];
    return OK;
}

这段不到十行的代码中，L.data[i - 1] 的转换是 408 选择题和代码填空题直接考察最多的细节之一。命题人常在循环条件、边界判断和数组下标中把 i 和 i-1 互换，以检验考生是否真正理解了两套计数体系的关系。建议在草稿纸上建立一个简单的对应表------位序在上、数组下标在下------写代码时逐项核对，避免凭直觉直接填入。

两种物理实现的预览------顺序存储与链式存储

$共识$ 线性表的两种基本物理实现方式，在内存组织和操作效率上存在系统性差异。以下先给出概念层面的对比，后续四篇文章将逐一对每种实现展开代码级分析。

顺序存储（Sequential Storage）------顺序表。 所有数据元素存放在一片连续的存储单元中。由于逻辑相邻的元素物理上也相邻，顺序表支持 O(1) 的随机存取 （Random Access）------给出位序 i，直接通过 data[i-1] 即可访问。代价是插入和删除操作需要移动大量元素，平均时间复杂度为 O(n)。

链式存储（Linked Storage）------链表。 数据元素存储在任意位置，每个结点（Node）除数据域外还包含指针域（Pointer Field），指向其逻辑上的后继结点。逻辑相邻的元素在物理上可以相距很远。链表的插入和删除不需要移动元素（仅修改指针即可），时间复杂度为 O(1)；但按位查找需要从表头逐个遍历，时间复杂度为 O(n)。

$共识$ 两条重要结论：(1) 两种实现方式下，同一逻辑操作的时间复杂度不同------例如按位查找，顺序表是 O(1)，链表是 O(n)。(2) 即使某操作在两种实现下的时间复杂度量级相同，实际运行效率也可能差异显著 $经验$ ------例如顺序表的遍历受益于 CPU 缓存（Cache）友好的连续内存布局，而链表遍历伴随频繁的指针跳转和缓存未命中（Cache Miss），常数因子可以相差数倍。这正是"时间复杂度相同的算法实际性能也接近"这一常见误区的反例。
**📊 顺序存储 vs 链式存储概览**

对比维度	顺序存储（顺序表）	链式存储（链表）
内存布局	连续的一段存储空间	离散的结点，通过指针串联
按位查找	O(1)，地址公式直接计算	O(n)，需从头遍历
插入删除	O(n)，需移动后续元素	O(1)（已知位置），仅修改指针
空间开销	仅数据域，密度 100%	额外指针域，密度 ~50%（单链表）
随机存取	支持	不支持
扩容代价	需预分配或整体搬迁	按需分配，无扩容开销
缓存友好	是（连续内存，预取友好）	否（指针追逐，cache miss 高）
适用场景	频繁查找、数据量可预测	频繁增删、数据量波动大

常见问题 FAQ

Q1：线性表和顺序表到底有什么区别？为什么考研题里反复考这个？

线性表是逻辑结构，定义了元素间一对一的线性关系；顺序表是存储结构，是线性表在连续内存中的一种具体实现。二者是"接口"与"实现"的关系。它直接检验考生是否建立了数据结构三要素（逻辑结构、存储结构、运算）的分层认知------而不是靠死记代码来应试。

Q2：线性表是逻辑结构，那数组是逻辑结构还是存储结构？

在 C 语言的语境下，数组本质上是一种存储结构------它代表一段连续内存，每个元素大小相同，支持按下标的快速寻址。当我们说"用数组实现线性表"时，数组充当的是物理存储的载体。在 408 考试体系中，通常将数组归类为存储结构概念，顺序表则是"以数组为存储载体的线性表实现"。需要区分的是：数组的下标规则（0-based）是语言层面的约定，不是逻辑结构的属性。

Q3：为什么要先学 ADT 再看具体实现，直接学代码不行吗？

ADT 的价值在于分离"做什么"和"怎么做"。先掌握九种操作的接口语义，再去学顺序表和链表的代码实现，你会发现两种实现虽然内部机制差别很大------一个靠下标跳转、一个靠指针遍历------但对外提供的操作名称和参数完全一致。这层抽象不仅减少记忆负担（不需要为每种实现单独背一套操作清单），也是工程实践中"面向接口编程"的核心思想 $经验$ 。

Q4：位序从 1 开始，代码里每次都要写 i-1 吗？能提前把 i-- 再用吗？

是的，在 C 语言实现的顺序表中，因为数组下标从 0 开始而位序从 1 开始，确实需要在位序 i 和数组下标之间做 i-1 转换。但不建议在调用方就把 i 减 1 再传入------这会导致位序的含义在调用链中不一致，后续维护代码时极容易出错 $经验$ 。推荐做法是：保持接口参数 i 的语义为位序（1-based），在函数体内部完成合法性检查（i < 1 || i > L.length），后续所有数组访问统一写成 data[i - 1]，转换点集中、可追溯。

总结

线性表是数据结构学习中第一个需要透彻理解"逻辑结构独立于存储结构"这一分层原则的概念。它以九种 ADT 操作为接口契约，由顺序表和链表分别用不同的物理组织方式去兑现。掌握这一分层思想之后，学习栈、队列、串、树、图等后续章节时，你自然会先问"它的逻辑结构是什么"，再问"有哪些实现方式"------这正是 408 考试希望考察的系统性思维，也是工程师面对复杂系统时最重要的一种抽象能力。

下一篇将深入线性表的顺序存储实现： $顺序表的结构定义、插入删除与扩容$ 。

📚 延伸阅读 (Further Reading)

本系列第 2 篇： $线性表的顺序存储实现------顺序表$ ------ 动态内存分配、插入删除的 O(n) 分析、扩容策略源码解读。
本系列第 3 篇： $线性表的链式存储实现------单链表$ ------ 结点结构、头插法与尾插法、带头结点与不带头结点的设计权衡。
非线性结构对比： $图结构作为非线性结构的代表$ ------ 理解线性结构"一对一"的约束边界之后，再对比图结构"多对多"的自由连接模型。