【无标题】

双向链表数据结构完整实现解析

一、数据结构定义

1.1 类声明

public class LinkedList<E> implements List<E> {
    transient int size = 0;      // 当前元素数量
    transient Node<E> first;     // 头节点指针
    transient Node<E> last;      // 尾节点指针
    
    // 节点内部类
    private static class Node<E> {
        E item;                 // 存储元素
        Node<E> next;           // 后驱指针
        Node<E> prev;           // 前驱指针
        
        public Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
}

1.2 关键设计特点

1. transient关键字：防止敏感字段被序列化
2. 泛型设计：支持类型安全的元素存储（<E>）
3. 双向链接：每个节点包含prev和next指针
4. 首尾哨兵：维护first/last指针实现快速访问
5. 动态扩容：自动处理节点间的链接关系

二、核心方法实现解析

2.1 节点插入

2.1.1 头部插入（linkFirst）

void linkFirst(E e) {
    final Node<E> f = first;                // 保存原头节点
    final Node<E> newNode = new Node<>(null, e, f); // 创建新节点
    first = newNode;                        // 更新头指针
    
    if (f == null) {                        // 空链表处理
        last = newNode;
    } else {
        f.prev = newNode;                   // 原头节点的前驱指向新节点
    }
    size++;
}

执行流程图：

2.1.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;                   // 原尾节点的后继指向新节点
    }
    size++;
}

2.2 节点删除（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;       // 前驱节点跳过当前节点
        x.prev = null;          // 清除当前节点前驱
    }

    // 处理后继节点
    if (next == null) {         // 删除的是尾节点
        last = prev;
    } else {
        next.prev = prev;       // 后继节点跳过当前节点
        x.next = null;          // 清除当前节点后继
    }

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

删除操作的三类场景：

1. 删除头节点：更新first指针
2. 删除尾节点：更新last指针
3. 删除中间节点：修改前后节点的引用关系

2.3 索引访问（node）

Node<E> node(int index) {
    // 二分查找优化：根据索引位置决定遍历方向
    if (index < (size >> 1)) {   // 前一半正向遍历
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {                    // 后一半逆向遍历
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

时间复杂度对比：

三、完整API说明

3.1 公共方法列表

3.2 私有方法列表

四、复杂度分析

4.1 时间复杂度

4.2 空间复杂度

• 总体空间：O(n)
• 每个节点需要额外存储两个指针（prev/next）

五、完整使用示例

5.1 基本操作

LinkedList<String> list = new LinkedList<>();

// 添加元素
list.add("Java");
list.addFirst("Python");
list.addLast("C++");

// 打印链表
list.printLinkList(); 
// 输出：目前的列表，头节点：Python 尾节点：C++ 整体：Python，Java，C++，

// 删除元素
list.remove("Java");
System.out.println(list.get(1)); // 输出：C++

// 遍历访问
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

5.2 边界测试

// 测试空链表
LinkedList<Integer> emptyList = new LinkedList<>();
emptyList.printLinkList();  // 输出：链表为空

// 测试单元素链表
LinkedList<Character> singleList = new LinkedList<>();
singleList.add('A');
singleList.remove('A');
singleList.printLinkList(); // 输出：链表为空

// 测试头尾操作
LinkedList<Double> edgeList = new LinkedList<>();
edgeList.addFirst(3.14);
edgeList.addLast(6.28);
edgeList.remove(3.14);
edgeList.printLinkList(); // 输出：目前的列表，头节点：6.28 尾节点：6.28 整体：6.28，

六、实现改进建议

6.1 功能扩展

1. 迭代器实现：

public Iterator<E> iterator() {
    return new LinkedListIterator();
}

private class LinkedListIterator implements Iterator<E> {
    private Node<E> current = first;
    
    public boolean hasNext() {
        return current != null;
    }
    
    public E next() {
        E item = current.item;
        current = current.next;
        return item;
    }
}

2. 序列化支持：

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException {
    s.defaultWriteObject();
    s.writeInt(size);
    for (Node<E> x = first; x != null; x = x.next)
        s.writeObject(x.item);
}

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    s.defaultReadObject();
    int size = s.readInt();
    for (int i = 0; i < size; i++)
        linkLast((E)s.readObject());
}

6.2 性能优化

1. 缓存最近访问节点：

transient Node<E> lastAccessed;
transient int lastIndex = -1;

Node<E> node(int index) {
    if (lastIndex != -1 && Math.abs(index - lastIndex) < 2) {
        // 使用缓存节点
    }
    // ...原有逻辑
    lastAccessed = result;
    lastIndex = index;
    return result;
}

七、与标准库对比