数据结构入门：顺序表与链表的核心解析及实战对比

在数据结构的世界里，线性表是最基础、最常用的结构之一，而顺序表和链表则是线性表的两大核心实现方式。无论是日常开发中的数据存储，还是面试中的高频考点，这两种结构都占据着举足轻重的地位。很多初学者容易混淆二者的用法，不清楚什么时候该用顺序表，什么时候该选链表。今天就来一次性讲透它们的底层逻辑、核心操作、优缺点及适用场景，帮你快速理清思路，学以致用。

一、先搞懂：什么是顺序表？什么是链表？

线性表的核心定义是 “数据元素按线性顺序排列，每个元素有唯一的前驱和后继（除了首尾元素）”，而顺序表和链表的本质区别，在于 数据的存储方式和访问方式不同。

1. 顺序表：连续存储的 “数组容器”

顺序表是用一段地址连续的存储单元依次存储线性表中的各个元素，本质上就是我们平时用的 “数组”（或动态数组）。比如 C 语言中的静态数组、动态分配的数组（malloc 分配），底层实现都是顺序表。

举个通俗的例子：顺序表就像一排连续的储物柜，每个柜子对应一个数据元素，柜子的编号（地址）是连续的，我们可以通过编号（下标）直接找到对应的柜子，存取东西非常方便。

核心特点：

• 元素存储地址连续，逻辑顺序与物理顺序一致；
• 支持随机访问（通过下标直接访问，时间复杂度 O (1)）；
• 存储容量固定（静态顺序表）或动态扩容（动态顺序表，如 ArrayList 默认扩容为原来的 1.5 倍）。

2. 链表：离散存储的 “锁链结构”

链表是用一段地址离散的存储单元存储元素，每个元素（节点）除了存储自身数据，还会存储下一个（或上一个）节点的地址（指针），通过指针将所有节点串联成一条 “锁链”。常见的链表有单链表、双链表、循环链表，C 语言中链表多通过结构体和指针实现，也是最基础的链表编程场景。

通俗例子：链表就像一串糖葫芦，每个山楂（节点）都连着下一个山楂，想要找到最后一个山楂，必须从第一个山楂开始，一个个往下找，不能直接跳过中间的山楂。

核心特点：

• 元素存储地址离散，逻辑顺序通过指针维系；
• 不支持随机访问，只能从头节点（或尾节点）依次遍历，访问某个元素的时间复杂度 O (n)；
• 存储容量灵活，无需提前分配空间，新增 / 删除节点时只需修改指针，无需移动其他元素。

二、核心操作对比：增删改查的效率差异

对于线性表来说，增删改查是最基础的操作，而顺序表和链表的效率差异，也主要体现在这些操作上。我们用表格清晰对比（n 为元素个数）：

表格

💡 关键总结：顺序表的优势在 “随机访问” 和 “修改”，链表的优势在 “头部 / 尾部的增删” 和 “灵活扩容”。中间增删两者效率都不高，但链表无需移动元素，实际操作更轻便。

三、底层实现核心代码（以 C 语言为例）

光说不练假把式，我们用简单的代码片段，看看顺序表（动态数组）和链表（单链表）的核心实现，帮你理解底层逻辑（简化版，省略扩容、异常处理等细节，聚焦核心操作）。

1. 顺序表（简化版，动态数组实现）

c

运行

// 顺序表（动态数组）结构体定义<stdio.h><malloc.h>

typedef struct {
    int *data;  // 存储元素的动态数组指针
    int size;   // 当前元素个数
    int capacity;// 数组容量（简化版暂不重点体现扩容）
} MyArrayList;

// 初始化顺序表
MyArrayList* initList(int initialCapacity) {
    MyArrayList *list = (MyArrayList*)malloc(sizeof(MyArrayList));
    list->data = (int*)malloc(initialCapacity * sizeof(int));
    list->size = 0;
    list->capacity = initialCapacity;
    return list;
}

// 尾部插入元素
void add(MyArrayList *list, int e) {
    // 简化版，暂不处理扩容
    list->data[list->size] = e;
    list->size++;
}

// 随机访问（根据下标获取元素）
int get(MyArrayList *list, int index) {
    // 简化版，暂不处理下标越界
    return list->data[index]; // 直接通过下标访问，O(1)
}

// 中间插入（下标index处插入元素）
void insert(MyArrayList *list, int index, int e) {
    // 移动index及后续元素往后移一位
    for (int i = list->size; i > index; i--) {
        list->data[i] = list->data[i-1];
    }
    list->data[index] = e;
    list->size++;
}

// 中间删除（删除下标index处元素）
void removeAt(MyArrayList *list, int index) {
    // 移动index后续元素往前移一位
    for (int i = index; i < list->size - 1; i++) {
        list->data[i] = list->data[i+1];
    }
    list->size--;
    // 简化版，暂不释放多余内存
}

// 销毁顺序表（避免内存泄漏）
void destroyList(MyArrayList *list) {
    free(list->data);
    free(list);
}

2. 单链表（简化版）

c

运行

// 链表节点结构体<stdio.h<malloc.h>

typedef struct ListNode {
    int data;               // 节点数据
    struct ListNode *next;  // 指向 next 节点的指针
} ListNode;

// 链表结构体（记录头节点和长度）
typedef struct {
    ListNode *head; // 头节点
    int size;       // 当前元素个数
} MyLinkedList;

// 初始化链表
MyLinkedList* initLinkedList() {
    MyLinkedList *list = (MyLinkedList*)malloc(sizeof(MyLinkedList));
    list->head = NULL; // 初始头节点为空
    list->size = 0;
    return list;
}

// 头部插入元素
void addFirst(MyLinkedList *list, int e) {
    ListNode *newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->data = e;
    newNode->next = list->head; // 新节点指向原头节点
    list->head = newNode;       // 头节点更新为新节点
    list->size++;
}

// 尾部插入元素
void addLast(MyLinkedList *list, int e) {
    ListNode *newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->data = e;
    newNode->next = NULL;

    if (list->head == NULL) { // 链表为空时，新节点就是头节点
        list->head = newNode;
    } else {
        ListNode *cur = list->head;
        // 遍历到最后一个节点
        while (cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = newNode; // 最后一个节点指向新节点
    }
    list->size++;
}

// 随机访问（根据下标获取元素）
int get(MyLinkedList *list, int index) {
    // 简化版，暂不处理下标越界
    ListNode *cur = list->head;
    // 遍历index次，找到目标节点
    for (int i =< index; i++) {
        cur = cur->next;
    }
    return cur->data;
}

// 销毁链表（避免内存泄漏）
void destroyLinkedList(MyLinkedList *list) {
    ListNode *cur = list->head;
    while (cur != NULL) {
        ListNode *temp = cur;
        cur = cur->next;
        free(temp);
    }
    free(list);
}

四、优缺点全面总结

结合前面的分析，我们再梳理一下两者的优缺点，帮你快速判断场景。

1. 顺序表（动态数组）

优点：

• 随机访问效率高，O (1) 时间复杂度，适合频繁查询、修改的场景；
• 存储密度高，无需额外存储指针，节省内存空间；
• 实现简单，底层是数组，操作直观。

缺点：

• 增删操作效率低（尤其是头部、中间），需要移动大量元素；
• 动态扩容有开销，扩容时需复制所有元素，可能造成内存浪费；
• 固定大小的静态顺序表，容易出现内存不足或浪费的问题。

2. 链表（单链表 / 双链表）

优点：

• 增删操作灵活，头部 / 尾部增删 O (1)，中间增删无需移动元素，只需修改指针；
• 无需提前分配空间，动态增长，不会造成内存浪费；
• 适合频繁增删、元素个数不确定的场景。

缺点：

• 不支持随机访问，查询、修改效率低，O (n) 时间复杂度；
• 存储密度低，每个节点需额外存储指针，占用更多内存；
• 实现复杂，指针操作容易出现 bug（如空指针、循环链表）。

五、实战选型建议：什么时候用顺序表？什么时候用链表？

开发中选择哪种结构，核心看 “操作频率” 和 “数据规模”，记住以下 3 个核心原则，再也不纠结：

1. 如果频繁查询、修改，很少增删（比如存储用户信息、成绩列表，需要频繁根据下标查询），选顺序表（动态数组）；
2. 如果频繁增删（尤其是头部、尾部，比如队列、栈的实现，消息队列的元素入队出队），选链表（单链表 / 双链表）；
3. 如果数据量不确定，需要动态扩容，且增删频繁，选链表；如果数据量固定，查询频繁，选顺序表（动态数组）。

💡 补充注意：实际开发中，C 语言的顺序表（动态数组）和链表各有优化，比如顺序表的扩容策略（按需扩容减少开销）、链表的双向链表实现（方便双向遍历），所以不要死记硬背，要结合具体场景分析。比如，即使是中间增删，当数据量很小时，顺序表的效率可能比链表更高（因为链表的指针遍历也有开销）。

六、面试高频考点补充

最后，补充几个面试中常考的点，帮你巩固知识点：

• C 语言动态顺序表的扩容机制：通常手动实现，比如当元素个数达到容量上限时，重新分配一块更大的内存（如原容量的 1.5 倍），将原数据复制到新内存，释放旧内存；静态顺序表容量固定，无扩容逻辑；
• 链表为什么不能随机访问？因为 C 语言中链表节点地址离散，没有下标对应的连续内存地址，只能通过指针从头节点依次遍历，无法直接定位到目标节点；
• 顺序表和链表的内存占用对比：顺序表（动态数组）只存储元素，内存连续，存储密度高；链表每个节点需额外存储指针（单链表 1 个指针，双链表 2 个指针），占用更多内存，且节点地址离散，可能产生内存碎片；
• 循环链表和双链表的应用：C 语言中，循环链表适合环形结构（如约瑟夫问题），双链表适合需要双向遍历的场景（如双向队列），相比单链表，双链表删除中间节点时无需回溯前驱节点，效率更高。