【数据结构】线性表 ⑥ ( 双循环链表 | 双循环链表插入操作 | 双循环链表删除操作 | LinkedList 双循环链表源码分析 )

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

    transient int size = 0;

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;

    /**
     * 将指定的元素追加到此列表的末尾。
     *
     * <p>这个方法等价于 {@link #addLast}.
     *
     * @param e 元素添加到此列表
     * @return {@code true} (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    /**
     * 链接作为最后一个元素。
     */
    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++;
    }

    /**
     * 将指定元素插入此列表中的指定位置。
     * 将当前在该位置的元素(如果有的话)
     * 和任何后续元素向右移动(在它们的索引上加1)。
     *
     * @param index 要插入指定元素的索引
     * @param element 要插入的元素
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public void add(int index, E element) {
    	// 检查索引合法性
        checkPositionIndex(index);

        if (index == size)
        	// 如果是添加到末尾
            linkLast(element);
        else
        	// 如果是添加到非末尾的元素
            linkBefore(element, node(index));
    }

    /**
     * 在非空节点 succ 前插入元素 e
     */
    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        // 获取 succ 节点 前驱节点
        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++;
    }

    /**
     * 返回列表中指定位置的元素。
     *
     * @param index 要返回的元素的索引
     * @return 在此列表中指定位置的元素
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

    /**
     * 返回指定元素索引处的(非空)节点。
     */
    Node<E> node(int index) {
        // assert isElementIndex(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;
        }
    }

    /**
     * 移除此列表中指定位置的元素。
     * 将所有后续元素向左移动(从它们的索引中减去1)。
     * 返回从列表中删除的元素。
     *
     * @param index 要删除的索引
     * @return the 元素先前在指定位置
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

    /**
     * Unlinks non-null node x.
     */
    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;
    }