线性表深度解析：从顺序表与链表原理到实战应用与性能优化

线性表顺序表链表

于 2026-07-31 07:06:47 修改

·本内容遵循CC 4.0 BY-SA版权协议

1. 项目概述：为什么线性表是程序世界的“地基”

干了这么多年开发，我越来越觉得，数据结构这东西，就像盖房子前得先懂砖头、钢筋和水泥。你光会写业务逻辑，不懂底层数据怎么组织，代码跑起来要么慢得像蜗牛，要么内存泄漏搞得系统三天两头崩溃。而在所有数据结构里，线性表（List） 绝对是那个最基础、最常用，但也最容易被轻视的“地基”。

线性表是什么？简单说，它就是一种数据元素的有限序列。你可以想象成一串糖葫芦，或者一列整齐的队伍，每个元素（山楂果或人）都按顺序排列，有且仅有一个直接前驱和一个直接后继（除了头尾两个）。这种“一对一”的线性关系，构成了我们处理有序数据最直观的模型。无论是你购物车里的商品列表、聊天记录的时间线，还是后台待处理的任务队列，本质上都是线性表的不同表现形式。

为什么它如此重要？因为它定义了数据存储和访问的基本规则。数组（Array）、链表（Linked List）、栈（Stack）、队列（Queue）这些你耳熟能详的结构，都可以看作是线性表在特定约束下的实现或变体。理解了线性表，你就拿到了打开数据结构大门的钥匙。很多新手觉得链表难、栈和队列抽象，根源往往在于没吃透线性表“顺序存储”和“链式存储”这两种最核心的物理结构思想。

这篇文章，我会结合十多年踩坑填坑的经验，把线性表从里到外掰开揉碎了讲。不止是教科书上的定义和代码，更重要的是在不同场景下如何选型、如何避坑、如何写出既高效又健壮的代码。无论你是正在啃《数据结构》课本的学生，还是工作中被性能问题困扰的开发者，相信都能找到你需要的那块“砖”。

2. 线性表的核心思想与两种实现哲学

线性表的概念很朴素，但它的两种实现方式——顺序表和链表，却代表了计算机科学中两种根本不同的设计哲学，直接决定了程序的性能特征。选错了，可能就是“失之毫厘，谬以千里”。

2.1 顺序表：用“连续”换取高速访问

顺序表，通常就是我们说的数组（Array）。它的核心思想是：在内存中找一块连续的存储空间，把数据元素一个挨一个地放进去。

为什么连续存储这么重要？ 这涉及到计算机底层的一个关键机制：缓存行（Cache Line） 和 局部性原理。现代CPU从内存读取数据时，并不是一次只拿一个字节，而是会一次性抓取一块连续的内存（比如64字节）到高速缓存中。如果数据是连续存放的，那么当你访问第一个元素时，它后面紧挨着的几个元素很可能也被一起加载到了缓存里。接下来访问这些相邻元素的速度，会比从主内存读取快几十甚至上百倍。这就是顺序表随机访问时间复杂度为O(1)的硬件基础——通过首地址和下标偏移量，能直接计算出元素的内存地址。

但是，连续存储也是一把双刃剑。最大的痛点在于“扩容”。想象一下，你租了一排连续的公寓（数组），一开始只住了5户（长度）。后来朋友要来，需要住10户。你不可能让邻居为你腾地方，唯一的办法是去找一片能容纳10户的、全新的连续公寓区，然后把所有家当（数据）搬过去。这个过程（重新分配内存+数据拷贝）的时间复杂度是O(n)，在数据量大时是致命的性能开销。因此，使用顺序表时，如果能预估数据规模，提前分配一个合理的初始容量，是避免频繁扩容、提升性能的关键技巧。

实操心得：在Java的ArrayList或Python的list中，内部都有一个capacity（容量）的概念。它们并非每次添加元素都扩容，而是采用一种“惰性”或“预分配”策略。例如，ArrayList默认初始容量为10，当元素超过容量时，通常会扩容为原来的1.5倍。了解你所用语言的扩容因子，对于编写高性能代码很有帮助。

2.2 链表：用“指针”换取灵活伸缩

链表走了另一条路：它放弃了对存储空间连续性的要求。每个数据元素被封装在一个“结点（Node）”里，结点除了存储数据本身（数据域），还存储了下一个结点在内存中的地址（指针域或引用域）。

这种设计带来了无与伦比的灵活性。增删元素，尤其是中间位置的增删，变成了O(1)时间复杂度的操作（前提是已知操作位置的前驱结点）。你只需要修改几个指针的指向，就像火车车厢之间重新挂钩，完全不需要像顺序表那样进行大规模的数据搬迁。对于频繁插入删除的场景，比如实现一个文本编辑器的撤销操作栈，链表的天生优势就体现出来了。

然而，灵活的代价是牺牲了随机访问的能力。要访问链表的第i个元素，你没有捷径，必须从表头开始，沿着指针“next”一个一个地数过去，直到第i个。这个过程的时间复杂度是O(n)。此外，每个结点除了存储有效数据，还需要额外的空间来存储指针，因此空间利用率不如顺序表。更重要的是，由于结点在内存中分散存储，破坏了空间局部性，对CPU缓存不友好，遍历访问的速度往往比顺序表慢。

链表还有多种变体，核心是为了解决特定问题：

单向链表：最基础，每个结点只指向下一个。问题在于，你无法快速找到上一个结点。
双向链表：每个结点有prev和next两个指针，分别指向前驱和后继。牺牲了一点空间，但换来了前后双向遍历的能力，删除指定结点时也更方便（因为可以直接拿到前驱结点）。Java的LinkedList、C++的std::list就是双向链表。
循环链表：把尾结点的next指向头结点，形成一个环。适用于需要循环处理所有数据的场景，比如操作系统的时间片轮转调度。

2.3 选型决策：一张表看懂何时用谁

理论说再多，不如一张对比表来得直观。在实际开发中，我通常会根据以下维度来做选择：

特性维度	顺序表 (数组/ArrayList)	链表 (LinkedList)	核心考量与场景举例
访问方式	随机访问，O(1)	顺序访问，O(n)	需要频繁按索引查找吗？例如，实现一个排行榜，需要经常取第N名的数据，顺序表是唯一选择。
插入/删除	平均O(n)（需移动元素）	已知位置时O(1)（修改指针）	增删操作的位置和频率？在列表中间频繁增删（如实时消息流），链表优势大。在尾部追加，两者差不多，但顺序表可能触发扩容。
内存使用	内存连续，无额外开销，缓存友好	内存分散，有指针开销，缓存不友好	数据规模极大或对内存敏感吗？嵌入式开发或处理海量数据时，顺序表的紧凑存储和缓存优势是关键。
空间预分配	需要，可能浪费或需扩容	动态分配，无浪费但分配开销大	能否预估数据量？能预估则用顺序表并初始化合适大小；不能预估且增长不确定，链表更省心。
典型实现	Java `ArrayList`, Python `list`, C++ `std::vector`	Java `LinkedList`, C++ `std::list`, 自定义结点	语言生态支持？多数语言对顺序表优化极好，链表则需注意其遍历开销。

一个经典误区：很多人觉得链表插入删除就是快，无脑用。但如果你要在Java的LinkedList中间插入元素，你得先遍历找到那个位置，这个遍历过程已经是O(n)了，整体复杂度还是O(n)。只有在已经持有某个结点引用的情况下（比如在遍历过程中插入），链表的O(1)优势才能发挥。而ArrayList在尾部添加元素（add）是摊销O(1)的，很多时候反而更快。

3. 从零实现：手撕一个健壮的动态数组

看懂了原理，最好的巩固方式就是自己动手实现一个。我们来实现一个简化版的动态数组（类似ArrayList），我会把工业级设计中的关键细节和坑点都讲清楚。

3.1 定义接口与初始结构

首先，我们定义线性表应该支持哪些基本操作，用一个接口（或抽象类）来约定：

JAVA

public interface MyList<T> {

/** 获取当前元素数量 */

int size();

/** 判断是否为空 */

boolean isEmpty();

/** 获取索引为index的元素 */

T get(int index);

/** 设置索引为index的元素为新值，返回旧值 */

T set(int index, T element);

/** 在尾部添加元素 */

boolean add(T element);

/** 在指定索引处插入元素 */

void add(int index, T element);

/** 删除指定索引处的元素，返回被删元素 */

T remove(int index);

/** 删除首次出现的指定元素 */

boolean remove(Object element);

/** 返回指定元素的索引，未找到返回-1 */

int indexOf(Object element);

/** 清空所有元素 */

void clear();

}

接下来是具体的实现类。核心在于三个成员变量：

JAVA

public class MyArrayList<T> implements MyList<T> {

// 存储数据的底层数组

private Object[] elementData;

// 当前列表中实际元素的数量

private int size;

// 默认初始容量

private static final int DEFAULT_CAPACITY = 10;

public MyArrayList() {

this.elementData = new Object[DEFAULT_CAPACITY];

this.size = 0;

}

public MyArrayList(int initialCapacity) {

if (initialCapacity < 0) {

throw new IllegalArgumentException("初始容量不能为负数: " + initialCapacity);

}

this.elementData = new Object[initialCapacity];

this.size = 0;

}

// ... 其他方法实现

}

这里第一个坑就来了：为什么用Object[]而不是T[]？ 这是因为Java的泛型有类型擦除，运行时T会被擦除成Object，我们无法直接创建泛型数组（new T[capacity]）。用Object[]然后强制转换是通用做法。size是逻辑大小，elementData.length是物理容量，一定要区分开。

3.2 核心方法实现与边界处理

1. 添加元素与动态扩容 (add) 这是顺序表的灵魂所在。尾部添加相对简单，但必须考虑扩容。

JAVA

@Override

public boolean add(T element) {

// 关键：添加前检查容量是否足够

ensureCapacityInternal(size + 1);

elementData[size++] = element;

return true;

}

private void ensureCapacityInternal(int minCapacity) {

if (minCapacity - elementData.length > 0) {

// 容量不足，需要扩容

grow(minCapacity);

}

private void grow(int minCapacity) {

int oldCapacity = elementData.length;

// 新容量 = 旧容量的1.5倍（这是ArrayList的策略，平衡空间和时间）

int newCapacity = oldCapacity + (oldCapacity >> 1);

// 如果1.5倍仍不够，则直接使用所需的最小容量

if (newCapacity - minCapacity < 0) {

newCapacity = minCapacity;

}

// 如果新容量超过了某个巨大值（防止溢出），则进行限制

if (newCapacity - MAX_ARRAY_SIZE > 0) {

newCapacity = hugeCapacity(minCapacity);

}

// 核心操作：创建新数组，拷贝数据

elementData = Arrays.copyOf(elementData, newCapacity);

}

在指定索引插入则更复杂，需要将插入点及之后的元素都向后移动一位：

JAVA

@Override

public void add(int index, T element) {

// 坑点1：索引越界检查必须在最前面

rangeCheckForAdd(index);

ensureCapacityInternal(size + 1);

// 坑点2：使用System.arraycopy进行高效数据移动

// 将elementData从index开始，复制到index+1的位置，共复制(size-index)个元素

System.arraycopy(elementData, index, elementData, index + 1, size - index);

elementData[index] = element;

size++;

}

private void rangeCheckForAdd(int index) {

if (index > size || index < 0) {

throw new IndexOutOfBoundsException("索引: " + index + ", 大小: " + size);

}

注意事项：System.arraycopy是原生方法，比用for循环逐个移动快得多。这是实现高性能集合库的必备技巧。

2. 删除元素与内存清理 (remove) 删除操作是添加的逆过程，但有一个隐形坑：内存泄漏。

JAVA

@Override

public T remove(int index) {

rangeCheck(index); // 检查index是否在 [0, size) 范围内

T oldValue = (T) elementData[index];

int numMoved = size - index - 1;

if (numMoved > 0) {

// 将index后面的元素向前移动一位

System.arraycopy(elementData, index + 1, elementData, index, numMoved);

}

// 关键步骤：将最后一个位置置为null，让GC可以回收该对象

elementData[--size] = null;

return oldValue;

}

private void rangeCheck(int index) {

if (index >= size || index < 0) {

throw new IndexOutOfBoundsException("索引: " + index + ", 大小: " + size);

}

如果不执行elementData[--size] = null;，那么数组末尾仍然持有对这个对象的引用，即使逻辑上它已被移除，垃圾回收器也无法释放其内存。这是手动管理底层数组时必须牢记的。

3. 查找与迭代 按索引查找get(int index)很简单，直接返回(T) elementData[index]，但要记得做rangeCheck。按值查找indexOf(Object element)需要注意处理null值：

JAVA

@Override

public int indexOf(Object element) {

if (element == null) {

for (int i = 0; i < size; i++) {

if (elementData[i] == null) {

return i;

}

} else {

for (int i = 0; i < size; i++) {

if (element.equals(elementData[i])) {

return i;

}

return -1;

}

这里用了equals方法进行对象比较，意味着存放在列表中的对象，其equals方法的实现必须符合预期（比如重写后比较内容而非地址）。

3.3 实现迭代器与“快速失败”机制

一个完整的集合类应该支持for-each循环。我们需要实现Iterable<T>接口，并提供一个Iterator。

JAVA

@Override

public Iterator<T> iterator() {

return new Itr();

}

private class Itr implements Iterator<T> {

int cursor; // 下一个要返回的元素的索引

int lastRet = -1; // 上一次返回的元素的索引，-1表示没有

@Override

public boolean hasNext() {

return cursor != size;

}

@Override

public T next() {

// 关键：在迭代过程中，检查列表结构是否被修改

checkForComodification();

int i = cursor;

if (i >= size) {

throw new NoSuchElementException();

}

Object[] elementData = MyArrayList.this.elementData;

if (i >= elementData.length) {

throw new ConcurrentModificationException();

}

cursor = i + 1;

lastRet = i;

return (T) elementData[i];

}

@Override

public void remove() {

if (lastRet < 0) {

throw new IllegalStateException();

}

checkForComodification();

try {

MyArrayList.this.remove(lastRet);

cursor = lastRet; // 因为后面的元素前移了，游标指回当前位置

lastRet = -1;

expectedModCount = modCount; // 更新修改计数

} catch (IndexOutOfBoundsException ex) {

throw new ConcurrentModificationException();

}

final void checkForComodification() {

if (modCount != expectedModCount) {

throw new ConcurrentModificationException();

}

这里引入了modCount（修改次数）和expectedModCount（期望修改次数）来实现 “快速失败（fail-fast）” 机制。在MyArrayList中，任何会改变结构的方法（add, remove, clear）都会使modCount++。迭代器在创建时记录当前的modCount为expectedModCount。如果在迭代过程中，列表被其他线程（或当前线程通过非迭代器自己的remove方法）修改了，modCount就会变化。下一次调用next()或remove()时，检查发现两者不等，立刻抛出ConcurrentModificationException，避免因数据不一致导致更诡异的行为。

实操心得：这是集合类设计中一个非常重要的安全机制。它不能解决并发问题，但能快速暴露问题。在单线程环境下，常见的错误是在for-each循环中直接调用集合的remove方法删除元素，这就会触发此异常。正确的做法是使用迭代器的remove方法，或者使用CopyOnWriteArrayList这类并发容器。

4. 链表实现精要：指针操作的细节魔鬼

实现链表，关键是对指针（引用）的操作必须精确无误，否则极易产生断链、内存泄漏或循环引用。

4.1 结点定义与基础链表框架

我们以双向链表为例，因为它最具代表性：

JAVA

public class MyLinkedList<T> implements MyList<T> {

// 内部结点类

private static class Node<T> {

T item;

Node<T> prev;

Node<T> next;

Node(Node<T> prev, T element, Node<T> next) {

this.item = element;

this.prev = prev;

this.next = next;

}

// 链表的两个哨兵结点：头结点和尾结点

transient Node<T> first;

transient Node<T> last;

transient int size = 0;

public MyLinkedList() {

// 初始为空链表

}

// ... 其他方法

}

使用first和last两个引用分别指向链表的首尾，可以让我们在两端进行操作时达到O(1)时间复杂度。transient关键字表示这些字段在序列化时会被忽略，因为链表关系可以通过数据重建。

4.2 链表的增删：指针重排的艺术

在链表头部添加元素：

JAVA

private void linkFirst(T element) {

final Node<T> f = first;

final Node<T> newNode = new Node<>(null, element, f); // 新结点的prev是null，next是原first

first = newNode; // 头指针指向新结点

if (f == null) {

// 原链表为空，新结点同时也是尾结点

last = newNode;

} else {

// 原链表不为空，原首结点的prev指向新结点

f.prev = newNode;

}

size++;

}

在指定结点前插入元素：

JAVA

void linkBefore(T element, Node<T> succ) {

// 在非空结点succ之前插入

final Node<T> pred = succ.prev; // succ的前驱

final Node<T> newNode = new Node<>(pred, element, succ);

succ.prev = newNode; // succ的prev指向新结点

if (pred == null) {

// 说明succ是原首结点，新结点成为新的首结点

first = newNode;

} else {

pred.next = newNode; // 原前驱的next指向新结点

}

size++;

}

删除指定结点：

JAVA

T unlink(Node<T> x) {

// 假设x非空

final T element = x.item;

final Node<T> next = x.next;

final Node<T> prev = x.prev;

// 处理前驱指针

if (prev == null) {

first = next; // x是头结点，新头结点是next

} else {

prev.next = next; // 前驱结点绕过x，直接指向x的后继

x.prev = null; // 帮助GC，断开x指向前驱的引用

}

// 处理后继指针

if (next == null) {

last = prev; // x是尾结点，新尾结点是prev

} else {

next.prev = prev; // 后继结点绕过x，直接指向x的前驱

x.next = null; // 帮助GC，断开x指向后继的引用

}

x.item = null; // 帮助GC，清空数据引用

size--;

return element;

}

注意事项：注意看unlink方法中，将x.prev、x.next、x.item都置为null的步骤。这在Java中不是必须的（因为从链表中断开后，结点不可达，最终会被GC），但是一种良好的实践，可以显式地切断不必要的引用关系，在某些复杂场景下有助于避免内存问题的误判。在C++等需要手动管理内存的语言中，这一步就是必须的——要先保存next指针，再delete当前结点，否则就找不到下一个结点了。

4.3 链表遍历与索引操作的效率陷阱

链表最大的性能陷阱在于按索引访问。get(int index)、add(int index, T element)、remove(int index)这些方法，都需要先定位到索引对应的结点。

JAVA

Node<T> node(int index) {

// 优化：如果索引在前半部分，从头开始找；否则从尾开始找

if (index < (size >> 1)) {

Node<T> x = first;

for (int i = 0; i < index; i++) {

x = x.next;

}

return x;

} else {

Node<T> x = last;

for (int i = size - 1; i > index; i--) {

x = x.prev;

}

return x;

}

即使有这种优化，时间复杂度仍然是O(n)。所以，千万不要用for (int i=0; i<list.size(); i++) { list.get(i); }的方式来遍历链表，这会变成O(n²)的灾难。正确的遍历方式是使用迭代器（foreach）或者ListIterator。

5. 线性表的高级应用与性能实战

理解了基础实现，我们来看看线性表在复杂场景下的应用和性能调优。

5.1 栈与队列：受限的线性表

栈（Stack）和队列（Queue）是线性表加上特定操作规则后的产物。

栈（LIFO）：只允许在一端（栈顶）进行插入（push）和删除（pop）。可以用顺序表（尾部作为栈顶）或链表（头部作为栈顶）轻松实现。应用场景：函数调用栈、表达式求值、括号匹配、浏览器的前进后退。
队列（FIFO）：允许在一端（队尾）插入（enqueue），在另一端（队头）删除（dequeue）。顺序表实现队列有个问题：出队时，为了保持数据在数组头部，需要移动所有元素，效率低。更优的方案是使用循环队列：把数组想象成一个环，用两个指针front和rear分别指向队头和队尾，当指针到达数组末尾时，绕回开头。这样可以实现O(1)的入队出队。链表实现队列则很自然。

实现循环队列的关键点：

JAVA

public class CircularQueue<T> {

private Object[] items;

private int front; // 队头下标

private int rear; // 队尾下标（指向下一个空位）

private int capacity;

public CircularQueue(int capacity) {

this.capacity = capacity;

this.items = new Object[capacity];

this.front = 0;

this.rear = 0;

}

public boolean enqueue(T item) {

// 判断队列是否已满：(rear + 1) % capacity == front

if ((rear + 1) % capacity == front) {

return false; // 队列满

}

items[rear] = item;

rear = (rear + 1) % capacity; // 循环

return true;

}

public T dequeue() {

if (front == rear) {

return null; // 队列空

}

T item = (T) items[front];

items[front] = null; // 帮助GC

front = (front + 1) % capacity;

return item;

}

注意，我们牺牲了一个存储单元来区分队满和队空的条件。队空：front == rear。队满：(rear + 1) % capacity == front。

5.2 算法实战：如何高效合并两个有序链表？

这是一个经典的面试题，也是链表操作能力的试金石。假设有两个升序排列的单链表，合并成一个新的升序链表。

迭代法（推荐，空间复杂度O(1)）：

JAVA

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

// 创建一个哑结点（dummy node），简化边界处理

ListNode dummy = new ListNode(-1);

ListNode prev = dummy; // prev指针用于构建新链表

while (l1 != null && l2 != null) {

if (l1.val <= l2.val) {

prev.next = l1;

l1 = l1.next;

} else {

prev.next = l2;

l2 = l2.next;

}

prev = prev.next; // prev指针前进

}

// 合并后，l1和l2最多还有一个未合并完，直接接上去

prev.next = (l1 == null) ? l2 : l1;

return dummy.next; // 返回哑结点的下一个，即新链表的头

}

核心技巧：使用哑结点（Dummy Node）。它可以避免对空链表的特殊判断，让代码在处理头结点时和普通结点一样，逻辑更清晰。这是链表题中一个非常实用的技巧。

递归法（更简洁，但空间复杂度O(n) due to recursion stack）：

JAVA

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

if (l1 == null) return l2;

if (l2 == null) return l1;

if (l1.val < l2.val) {

l1.next = mergeTwoLists(l1.next, l2);

return l1;

} else {

l2.next = mergeTwoLists(l1, l2.next);

return l2;

}

递归解法体现了“分治”思想，代码非常简洁。但在实际工程中，如果链表很长，递归深度可能导致栈溢出，因此迭代法通常是更安全的选择。

5.3 性能调优与排查技巧

场景一：ArrayList的contains操作巨慢？ ArrayList的contains(Object o)方法内部使用indexOf，是遍历查找，O(n)复杂度。如果需要在海量数据中频繁判断是否存在，线性表不是合适的数据结构，应该考虑HashSet（O(1)平均）或TreeSet（O(log n)）。

场景二：LinkedList遍历比ArrayList慢很多？ 除了因为缓存不友好，还可能是因为你用了错误的遍历方式。对比以下两种：

JAVA

// 错误做法：每次get都是O(n)的遍历

for (int i = 0; i < linkedList.size(); i++) {

Object obj = linkedList.get(i); // 性能灾难！

}

// 正确做法：使用迭代器，O(n)完成遍历

for (Object obj : linkedList) {

// ...

}

// 或者使用ListIterator

ListIterator<Object> it = linkedList.listIterator();

while (it.hasNext()) {

Object obj = it.next();

}

场景三：需要线程安全的列表怎么办？ ArrayList和LinkedList都不是线程安全的。多线程环境下，有几种选择：

使用Collections.synchronizedList(new ArrayList<>())：得到一个同步包装器，所有方法都用synchronized修饰，是粗粒度锁，并发性能较差。
使用CopyOnWriteArrayList：写操作（add, set, remove）时，会复制整个底层数组，修改在副本上进行，最后替换原数组引用。读操作无锁。适用于读多写极少的场景（如监听器列表）。写操作频繁时，复制数组的开销巨大。
使用ConcurrentLinkedQueue（并发队列）：如果业务场景符合队列模型，这是一个高性能的无锁并发实现。
手动管理同步：在业务代码层，对列表操作进行加锁（synchronized或ReentrantLock），控制更精细，但复杂度高。

选择哪一种，取决于你的读写比例和性能要求。没有银弹，只有最适合场景的解决方案。

6. 线性表在真实项目中的设计思考

最后，跳出代码细节，聊聊在系统设计中，如何基于线性表的特性做更高层次的决策。

案例：实现一个最近使用的文件列表（MRU） 需求：展示最近打开的10个文件，新打开的文件排在最前，如果文件已存在列表中，则将其提到最前，列表超过10个则淘汰最旧的那个。

方案选择与演进：

初版（使用ArrayList）：每次打开文件，先调用indexOf查找（O(n)），如果存在则remove（O(n)）再add(0, file)（O(n)）。如果不存在，直接add(0, file)（O(n)），然后检查大小，如果超过10则remove(10)（O(n)）。性能堪忧，每次操作都可能接近O(n)。
优化版（使用LinkedList）：查找仍需O(n)，但删除已知结点和头部插入是O(1)。性能有所提升，但查找仍是瓶颈。
进阶版（LinkedList + HashMap）：这就是LRU Cache的简化版思路。用LinkedList维护顺序，用HashMap<文件名, 链表结点>实现O(1)查找。这样，判断是否存在、定位结点都是O(1)，再配合链表的O(1)插入删除，整体效率最优。Java中的LinkedHashMap就是为此类场景设计的。

这个案例告诉我们，没有完美的数据结构，只有针对特定操作组合的优化设计。线性表作为基础组件，常常需要和其他数据结构（如哈希表、树）结合，才能应对复杂的业务需求。

另一个思考：不可变列表（Immutable List） 在多线程或函数式编程中，不可变对象是避免并发问题、简化推理的利器。像String一样，不可变列表一旦创建就不能修改，任何“修改”操作（如add, remove）都会返回一个全新的列表。这听起来很浪费，但实现上往往采用结构共享（Persistent Data Structure）。例如，在链表头部添加元素，并不需要复制整个链表，只需要新建一个结点指向原链表的头，然后返回这个新结点作为新链表的头即可。原链表保持不变。Clojure、Scala等语言的默认列表就是不可变的。在Java中，Collections.unmodifiableList可以包装一个列表使其不可变，但底层数据变化它也会变，是“视图”不可变，而非真正结构共享的不可变。

理解线性表的可变与不可变，顺序与链式，是理解更高级数据结构和编程范式的基础。它远不止是教科书上的几个概念，而是贯穿我们编程生涯的、活生生的设计工具。下次当你面对一个数据集合时，不妨先问自己几个问题：它的规模会变化吗？主要的操作是访问、插入还是删除？需要线程安全吗？回答了这些问题，你自然就知道该用哪种“表”了。