LinkedList 的底层原理

以下是 LinkedList 的底层原理的详细解析，结合其双向链表实现、节点结构、核心操作及性能特点：

---

一、底层数据结构：双向链表

LinkedList 的底层基于 双向链表（Doubly Linked List）实现，每个节点包含三个核心属性：
• item：存储当前节点的数据。
• next：指向下一个节点的引用。
• prev：指向前一个节点的引用。

双向链表结构示意图：

头节点 (first) ↔ 节点A ↔ 节点B ↔ ... ↔ 尾节点 (last)

• 头尾指针：通过 first 和 last 两个指针分别指向链表的首尾节点，支持快速访问两端元素。
• 动态扩展：无需预先分配固定内存空间，节点按需动态创建和链接。

---

二、核心操作原理

1. 插入操作

• 尾部插入（addLast() 或 add()）：
• 创建新节点，prev 指向原尾节点，next 置空。
• 若链表为空，将 first 和 last 均指向新节点；否则更新原尾节点的 next 为新节点，并更新 last 指针。
• 时间复杂度：O(1)。

• 头部插入（addFirst()）：
• 类似尾部插入，更新 first 指针和新节点的 next 引用。
• 时间复杂度：O(1)。

• 中间插入（add(index, element)）：
• 遍历链表找到目标位置的前驱节点，调整前驱、后继及新节点的指针。
• 时间复杂度：O(n)（遍历耗时）。

2. 删除操作

• 尾部删除（removeLast()）：
• 获取尾节点，断开其与前驱节点的链接，更新 last 指针。
• 时间复杂度：O(1)。

• 头部删除（removeFirst()）：
• 类似尾部删除，更新 first 指针。
• 时间复杂度：O(1)。

• 中间删除（remove(index)）：
• 遍历找到目标节点，调整其前驱和后继节点的指针，跳过当前节点。
• 时间复杂度：O(n)。

---

三、性能特点与对比

操作类型	LinkedList 时间复杂度	ArrayList 时间复杂度	说明
随机访问	O(n)	O(1)	LinkedList 需从头/尾遍历至目标位置
头部插入/删除	O(1)	O(n)	ArrayList 需移动后续元素
尾部插入/删除	O(1)	O(1)（均摊）	ArrayList 仅在扩容时触发 O(n) 耗时
中间插入/删除	O(n)（遍历）	O(n)（移动元素）	LinkedList 操作本身 O(1)，但遍历耗时 O(n)

内存开销

• 额外空间：每个节点需存储 prev 和 next 指针，内存占用高于 ArrayList。
• 适用场景：适合频繁插入/删除且内存敏感度低的场景，如队列、栈或动态调整的数据结构。

---

四、线程安全与解决方案

• 非线程安全：LinkedList 未内置同步机制，多线程并发修改可能导致数据不一致或 ConcurrentModificationException。
• 同步方案：
• 使用 Collections.synchronizedList(new LinkedList<>()) 包装为同步列表。
• 高并发场景采用 ConcurrentLinkedDeque 或 LinkedBlockingDeque。

---

五、应用场景

1. 频繁插入/删除：如实现队列（FIFO）或栈（LIFO），利用头尾操作的 O(1) 效率。
2. 动态数据管理：无需预分配内存，适合元素数量变化频繁的场景。
3. 双向遍历需求：如需要从尾部向前遍历或中间双向操作。

---

六、源码关键方法示例

1. 节点定义

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;
    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

2. 尾部插入（linkLast()）

void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode; // 原链表为空
    else
        l.next = newNode; // 更新原尾节点的 next 引用
    size++;
}

3. 中间删除（unlink()）

E unlink(Node<E> x) {
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;

    if (prev == null)
        first = next; // 删除头节点
    else
        prev.next = next; // 前驱节点跳过当前节点

    if (next == null)
        last = prev; // 删除尾节点
    else
        next.prev = prev; // 后继节点跳过当前节点

    x.item = null; // 帮助 GC
    size--;
    return element;
}

---

总结

LinkedList 通过双向链表实现高效的动态增删，但随机访问性能较差。其设计适用于频繁修改且无需快速随机访问的场景，如队列、栈或动态数据管理。在多线程环境下需配合同步机制使用，避免数据竞争问题。