顺序表与单链表的数据存储差异： 为何顺序表元素用指针，链表节点数据不用？

我在学习线性表的过程中，产生一个疑问：为什么定义顺序表结构体时，存储元素的成员是指针类型 eleType* elements，而单链表节点中存储数据的成员却是直接的 eleType data，而非指针？

一、指针在两种结构中的不同角色

在分析差异前，我们先明确指针在顺序表和单链表中的核心作用 ------ 指针的存在永远是为了解决 "如何存储 / 链接数据" 的问题，只是两种结构的解决思路完全不同：

数据结构	指针成员	指针的核心作用	非指针成员的作用
顺序表	eleType* elements	指向整块连续内存的起始地址，管理动态扩容的数组	size/capacity：描述内存的使用状态（元素数 / 总容量）
单链表节点	ListNode* next	链接下一个离散的节点，串联整个链表	eleType data：存储当前节点的具体数据

简单来说：顺序表的指针管 "整块内存"，链表的指针管 "节点链接"------ 这是理解后续内容的关键。

二、顺序表：eleType* elements 必须用指针的 3 个核心原因

顺序表的本质是动态可扩容的连续数组，其设计目标是 "连续存储、快速随机访问、动态调整容量"，而指针是实现这些目标的唯一选择。

1. 静态数组的局限性：无法满足 "动态扩容" 需求

如果我们尝试把顺序表的元素成员写成非指针形式，会立刻暴露问题：

// 错误示范1：仅能存储单个元素，失去"表"的意义
struct SequentialList {
    eleType elements; // 只能存一个元素，顺序表成了"单个值"
    int size;
    int capacity;
};

// 错误示范2：静态数组容量固定，无法扩容
struct SequentialList {
    eleType elements[100]; // 容量固定为100，存101个元素直接溢出
    int size;
    int capacity;
};

顺序表作为线性表的一种，核心需求是 "存储一组元素" 且 "容量可动态调整"：

• 静态数组的容量是编译期固定的，无法应对 "元素数量不确定" 的场景（比如用户输入数据、动态生成数据）；
• 单个元素变量更是完全违背 "表" 的设计初衷。

2. 指针的核心作用：管理堆上的动态连续内存

eleType* elements 中的指针，本质是堆内存的 "地址标识" ------ 通过 new eleType[capacity] 在堆区分配一块 "能存储 capacity 个 eleType 类型元素" 的连续内存，elements 保存这块内存的起始地址。

举个初始化顺序表的例子：

// 初始化容量为10的顺序表
SequentialList* list = new SequentialList();
list->elements = new int[10]; // elements指向堆上10个int的连续内存
list->size = 0;               // 初始无元素
list->capacity = 10;          // 总容量10

此时我们可以通过 elements[0]、elements[1] 访问内存中的第 1、2 个元素 ------ 数组下标本质是 "指针偏移"（elements[i] 等价于 *(elements + i)），没有 elements 这个指针，我们甚至找不到这块连续内存的起始位置。

3. 动态扩容的实现：依赖指针重定向

当顺序表的元素数 size 等于容量 capacity 时，需要扩容（通常扩容为原容量的 2 倍），核心逻辑是：

1. 分配一块更大的新内存；
2. 将旧内存的元素拷贝到新内存；
3. 释放旧内存；
4. 让 elements 指向新内存。

如果没有指针，我们无法完成 "内存地址重定向"------ 这是顺序表必须用指针管理元素的核心原因。

三、单链表节点：eleType data 不用指针的 2 个核心原因

单链表的本质是离散节点的链式结构，其设计目标是 "灵活插入 / 删除、不依赖连续内存"，每个节点只需完成 "存储单个数据 + 链接下一个节点" 的核心职责，因此数据成员无需指针。

1. 节点的核心职责：存储单个数据，而非管理内存

单链表的每个节点都是独立的 "最小单元"，其职责是：

• 存储一个具体的数据（比如一个整数、一个字符串）；
• 通过 next 指针链接下一个节点，实现 "多元素串联"。

因此 data 只需要保存 "单个具体值"，比如 data=10 就是这个节点存储的数值 ------ 用指针反而画蛇添足：

// 错误示范：data用指针，增加无意义的复杂度
struct ListNode {
    eleType* data;    // 需额外分配内存存储单个值，增加开销
    ListNode* next;
};

// 正确写法：直接存储具体值
struct ListNode {
    eleType data;     // 简洁高效，直接存储单个值
    ListNode* next;
};

如果 data 用指针，会带来两个问题：

• 额外的内存开销：需要为 data 单独分配堆内存，且使用后需手动释放，增加内存泄漏风险；
• 违背设计初衷：节点的核心是 "存数据"，而非 "管理数据的内存"，过度使用指针只会增加代码复杂度。

2. 链表的 "多元素存储"：靠节点链接，而非连续内存

顺序表靠 "一块连续内存" 存储多个元素，因此需要指针管理这块内存；而链表靠 "多个离散节点通过 next 指针链接" 存储多个元素 ------ 每个节点只存一个元素，自然不需要为数据加指针。

举个链表的例子：

// 创建3个节点，串联成链表
ListNode* node1 = new ListNode(10); // data=10，next=NULL
ListNode* node2 = new ListNode(20); // data=20，next=NULL
ListNode* node3 = new ListNode(30); // data=30，next=NULL

node1->next = node2; // 节点1链接节点2
node2->next = node3; // 节点2链接节点3

遍历链表时，我们通过 curr = curr->next 从一个节点跳到下一个节点 ------ 遍历的核心是 next 指针的链接作用，而非 data 的存储形式。

四、通俗类比：帮你记住核心差异

为了更直观理解，我们用生活中的场景类比两种结构：

数据结构	存储方式类比	指针的作用	数据存储形式
顺序表	一排连续的储物柜	指针指向第一个储物柜的门牌号	所有物品（元素）放在连续的储物柜里
单链表	一串散落的珍珠	每个珍珠（节点）的 "线"（next 指针）链接下一颗	每个珍珠只装一个小物件（data），无需门牌号

• 顺序表的 elements 指针 = 储物柜的 "起始门牌号"：必须用指针才能找到这一排连续的储物柜，否则无法存取物品；
• 链表节点的 data = 珍珠里的小物件：直接装进去就行，不需要 "门牌号"（指针）；
• 链表节点的 next 指针 = 串珍珠的线：负责把散落的珍珠连起来，实现 "多元素存储"。

五、总结：核心差异源于存储逻辑

对比维度	顺序表 eleType* elements	单链表节点 eleType data
存储形式	整块连续内存存储多个元素	单个节点存储单个元素
指针作用	管理动态连续内存（扩容 / 访问）	无指针，直接存储具体值
设计目标	快速随机访问、动态扩容	灵活插入删除、离散存储
不用指针的后果	无法存储多元素 / 动态扩容	增加复杂度，无任何收益