Java中的LinkedList

LinkedList是一个实现了List接口和Deque接口，基于双向列表数据结构实现的集合类。

特点

1. 动态大小：列表可以动态变化长度，不需要预先指定容量大小
2. 有序集合：列表按照插入顺序存储，可以使用索引查找元素
3. 增删的效率高：在列表头尾或者中间增删效率高，只需要修改相关节点的引用
4. 查找的效率低：列表不是连续的存储空间，不能通过索引直接访问。每次查找都需要从头或者尾部开始遍历
5. 线程不安全：多线程操作不能保证列表数据的完整性和一致性

节点数据结构

LinkedList中的节点数据结构：

1. 当前节点的数据
2. 当前节点的前一个节点引用
3. 当前节点的后一个节点引用

    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;
        }
    }

LinkedList数据结构

LinkedList数据结构如下：

1. 列表的长度
2. 列表的头节点引用
3. 列表的尾节点引用

//截取部分源码
public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    transient int size = 0;

    /**
     * Pointer to first node.
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     */
    transient Node<E> last;
}

注意事项

列表循环推荐使用迭代器，不要使用for循环 + get(i)；for循环本身要循环查询n次，列表的get(i)操作，每次都要从头或者尾部查找。时间复杂度为O(n²)

ArrayList使用for循环 + get(i)，每次get(i)可以直接根据索引快读查找到元素，只有for会循环n次，时间复杂度为O(n)

使用场景

1. 需要频繁的插入删除的操作(栈，队列，LRU缓存)
2. 实现了Deque接口，可以实现双端队列

方法

头部添加节点

    //第一次向列表加添头节点：创建一个node节点，列表first，last都指向同一个节点
    //不是第一次：创建一个新节点，将列表中的first指向新节点，前一个节点与新节点建立prev，next
    private 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++;
        modCount++;
    }

 

尾部添加节点

    //第一次创建新的节点：列表first，last指向同一个节点
    //后续创建节点：原列表尾节点的next指向newNode，newNode的前一个节点指向原尾节点
    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++;
        modCount++;
    }

中间添加节点

    //succ是插入的位置，创建一个新的节点，newNode的prev指向succ的prev节点，newNode的next指向succ
    //将原succ的prev节点本身的next重新指向newNode，succ原本的prev指向newNode
    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        final Node<E> pred = succ.prev;
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }

 

删除头部指针

    //将头部节点的item(数据)置为null，头部节点的next置为null
    //将头部节点的下一个节点获取到，将它的prev置为null
    //将列表中的first指向原头部节点的下一个节点
    private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        final E element = f.item;
        final Node<E> next = f.next;
        f.item = null;
        f.next = null; // help GC
        first = next;
        if (next == null)
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

删除尾部节点

    //将尾部节点的item置为null，尾部的prev置为null
    //获取到尾部节点的前一个节点，将它的next置为null
    //将列表的last指向原尾部节点的前一个节点
    private E unlinkLast(Node<E> l) {
        // assert l == last && l != null;
        final E element = l.item;
        final Node<E> prev = l.prev;
        l.item = null;
        l.prev = null; // help GC
        last = prev;
        if (prev == null)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

删除中间节点

    //获取到节点的前一个节点prev；后一个节点next
    //将prev.next指向next；将next.prev指向prev
    //将当前节点x.prev置为null，x.next置为null，x.item置为null
    E unlink(Node<E> x) {
        // assert x != null;
        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;
        size--;
        modCount++;
        return element;
    }

 获取头尾部节点

直接获取列表中的first或者last

    public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }

    /**
     * Returns the last element in this list.
     *
     * @return the last element in this list
     * @throws NoSuchElementException if this list is empty
     */
    public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }

实现Deque接口

队列

添加节点

    //尾部添加节点
    public boolean offer(E e) {
        return add(e);
    }

    //头部添加节点
    public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }

    //尾部添加节点
    public boolean offerLast(E e) {
        addLast(e);
        return true;
    }

删除节点

    //删除头部节点
    public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

    //删除头部节点
    public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

    //删除尾部节点
    public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }

栈

入栈出栈

    //入栈
    public void push(E e) {
        addFirst(e);
    }

    //出栈
    public E pop() {
        return removeFirst();
    }