【Java-数据结构篇】揭秘 Java LinkedList：链表数据结构的 Java 实现原理与核心概念

在 Java 中，LinkedList 是一种常用的线性数据结构，它是基于链表实现的。链表是一种通过节点（Node）连接起来的数据结构，每个节点包含数据和指向下一个节点的引用。与数组相比，链表在插入和删除元素时的效率较高，因为它不需要移动其他元素，只需要改变节点的链接。

1. LinkedList 的基本结构

LinkedList 是 Java 集合框架中的一个类，继承自 AbstractSequentialList 类，并实现了 List 接口。它使用链表结构来存储数据，每个元素都被包装在一个节点对象中，节点不仅存储数据，还存储一个指向下一个节点的引用（双向链表还包含指向上一个节点的引用）。

单向链表结构

class Node {
    Object data;  // 存储数据
    Node next;    // 指向下一个节点的引用

    public Node(Object data) {
        this.data = data;
        this.next = null;
    }
}

双向链表结构

在 Java 中，LinkedList 实际上是基于双向链表实现的，即每个节点不仅包含指向下一个节点的引用，还包含指向上一个节点的引用，这使得链表可以在两端进行操作。

class Node {
    Object data;  // 存储数据
    Node next;    // 指向下一个节点的引用
    Node prev;    // 指向上一个节点的引用

    public Node(Object data) {
        this.data = data;
        this.next = null;
        this.prev = null;
    }
}

2. LinkedList 的核心操作

LinkedList 提供了许多常见的操作，以下是一些最常用的操作：

1. 插入元素

在链表中插入元素，可以在头部、尾部或中间进行插入。由于链表的节点包含指向下一个节点的引用，插入操作的时间复杂度通常是 O(1)（如果知道插入位置），而不像数组那样需要移动其他元素。

public void addFirst(Object data) {
    Node newNode = new Node(data);
    newNode.next = head;
    if (head != null) {
        head.prev = newNode;
    }
    head = newNode;
    if (tail == null) {
        tail = newNode;
    }
}

public void addLast(Object data) {
    Node newNode = new Node(data);
    if (tail != null) {
        tail.next = newNode;
        newNode.prev = tail;
    }
    tail = newNode;
    if (head == null) {
        head = newNode;
    }
}

2. 删除元素

删除元素也可以通过调整链表节点之间的引用来实现。如果我们知道要删除节点的位置，那么删除操作的时间复杂度是 O(1)。

public void removeFirst() {
    if (head != null) {
        if (head.next != null) {
            head = head.next;
            head.prev = null;
        } else {
            head = tail = null;
        }
    }
}

public void removeLast() {
    if (tail != null) {
        if (tail.prev != null) {
            tail = tail.prev;
            tail.next = null;
        } else {
            head = tail = null;
        }
    }
}

3. 获取元素

获取链表中指定位置的元素时，我们需要从头部或尾部遍历链表，直到找到对应的节点。因此，获取操作的时间复杂度为 O(n)。

public Object get(int index) {
    Node current = head;
    int count = 0;
    while (current != null) {
        if (count == index) {
            return current.data;
        }
        current = current.next;
        count++;
    }
    throw new IndexOutOfBoundsException();
}

4. 查找元素

与获取元素类似，查找元素也是通过遍历链表来完成的，但我们只需要找到第一个匹配的元素即可。

public boolean contains(Object data) {
    Node current = head;
    while (current != null) {
        if (current.data.equals(data)) {
            return true;
        }
        current = current.next;
    }
    return false;
}

3. LinkedList 的优势与劣势

优势

插入和删除效率高：在已知位置的情况下，链表的插入和删除操作可以在 O(1) 时间内完成。
动态内存管理：链表是动态分配内存的，不需要像数组一样预先定义固定的大小。

劣势

查找效率低：由于链表不支持随机访问，因此获取元素时需要遍历整个链表，时间复杂度为 O(n)。
内存开销大：链表每个节点除了存储数据外，还需要存储一个或两个指针（在双向链表中），因此会占用更多的内存。

4. LinkedList 在 Java 集合框架中的使用

Java 的 LinkedList 类实现了 List、Deque 等接口，因此不仅可以作为一个顺序存储的列表，还可以作为一个双端队列。它提供了非常丰富的方法来操作数据，比如支持队列、栈的操作等。

栈操作

LinkedList<Integer> stack = new LinkedList<>();
stack.push(10);
stack.push(20);
System.out.println(stack.pop());  // 输出 20

队列操作

LinkedList<Integer> queue = new LinkedList<>();
queue.offer(10);
queue.offer(20);
System.out.println(queue.poll());  // 输出 10

双端队列操作

LinkedList<Integer> deque = new LinkedList<>();
deque.addFirst(10);
deque.addLast(20);
System.out.println(deque.removeFirst());  // 输出 10

5. 总结

Java 的 LinkedList 类是一个功能强大的数据结构，它通过双向链表实现了高效的插入和删除操作。尽管它在查找操作上不如数组高效，但在许多场景下，链表的数据结构优势能够提供更高效的内存和时间管理，特别是在频繁进行插入和删除的情况下。理解链表的实现原理以及如何使用 Java 提供的 LinkedList 类，可以帮助你在实际开发中更好地选择合适的容器类型。