实现一个具备增删改查功能的双向链表-CSDN博客

LinkedList，它是无边界的一个集合类型的数据结构，底层通过泛型Node<E>节点去存储元素，元素前后通过前继指针和后继指针链接，因此它可以存储非常多的元素。它不像ArrayList，当不指定长度时，添加的元素超过默认长度后，会进行扩容操作。
LinkedBlockingDeque，它是一个有界的阻塞队列，底层也是通过双向链表实现，因此它可以将元素添加到链表尾部或者头部，可以获取头部元素或者尾部元素。
AbstractQueuedSynchronizer，即AQS，它是抽象队列同步器，用于各类锁的实现。底层也是通过双向链表维护节点。AQS源码解读可参考读者另一篇文章AQS源码剖析。

3.手动实现一个双向链表

双向链表中的节点，都有两个变量（Java知识复习：实际上是指针，通过指针可以访问到new出来创建的对象，对象都存储在堆空间），分别指向它的前驱节点和后驱节点。

下图是双向链表的存储结构图，它的节点对象存在于JVM中最大的一块内存区域——堆空间。接着还有两个成员属性head和tail分别表示该链表的头、尾节点，它们本质上是一个引用变量（对象的内存地址），通过这两个头尾指针就可以访问双向链表的元素了。

在图中的head和tail为什么会是存在于栈空间呢？因为操作一个对象需要在一个方法中，而方法中的局部变量其实是存在于JVM的栈空间。

因此，一个双向链表的源码如下。它有两个成员变量，head以及tail，当在某个方法中操作该双向链表实例时，如果想要顺序遍历获取元素就需要用到头节点，如果想要倒序遍历则需要用到尾节点。

public class DoubleLinkedList {
    private int size;
    private Node head;// 头节点
    private Node tail;// 尾节点

    static class Node{
        private int val;
        private Node pre;// 前驱节点
        private Node next;// 后驱节点

        public Node(int val, Node pre, Node next) {
            this(val);
            this.pre = pre;
            this.next = next;
        }
    }
}

3.1 增加方法

双向链表既可以往尾部添加，也可以往头部添加，接下来编码实现两种添加方式。

linkLast方法实现了将元素添加到双向链表尾部，添加到尾部的步骤如下：

创建临时变量originTail去引用原来的尾节点tail（请记住：该临时变量是一个引用变量，其实指向的是存在于堆空间的原tail节点对象）。
接着创建一个新节点，它的后驱节点是null，前驱节点是originTail变量，表示新节点和老尾节点建立连接关系。
tail变量重新指向新节点，表示当前双向链表的尾节点更新为新添加的节点。
根据originTail变量是否为null，null则说明原来的尾节点也是null的，这种情况下就是双向链表此时是空的。如果为空的情况，将头节点指针head变量赋值为tail，即此时队列只有新添加的节点，新节点即是头节点也是尾节点。如果此时队列不为空，则直接通过originTail变量找到旧尾节点将其后继节点设置为新节点，表示旧尾节点和新尾节点建立了连接关系。

    
    // 添加元素到双向链表尾部
    private void linkLast(int val) {
       Node originTail = tail;
       Node newNode = new Node(val, originTail, null);
       tail = newNode;
       if (originTail != null){
           originTail.next = tail;
       }else {
           head = tail;
       }
    }
    // 添加元素到双向链表头部
    private void linkFirst(int val) {
        Node originHead = head;
        Node newNode = new Node(val, null, originHead);
        head = newNode;
        if (originHead != null){
            originHead.pre = head;
        }else {
            tail = head;
        }
    }

linkFirst方法则是将元素添加到双向链表的头部，与linkLast的方法思路其实一模一样，由于这次添加的是到头部，因此需要先创建临时变量originHead（引用变量，即指针）指向在堆空间的旧头节点，原因就是需要通过指针找到旧头节点重新和新头节点链接起来。

3.2 删除方法

由于双向链表有头、尾节点，因此删除节点同样可以顺序删除或者倒序删除，但是篇幅有限，将介绍顺序删除的方法。

删除方法要注意对于头和尾节点的正确维护，为什么这么说呢？因为，双向链表的遍历，无论顺序遍历还是倒序遍历都是需要从头节点和尾节点开始的。

因此在下面的顺序遍历删除方法中的步骤是：

先创建一个临时变量（引用变量，初始化时指向头节点的堆中对象，下文称当前节点），接着以当前节点不为null作为条件开始遍历。
如果此时当前节点（即待删节点）正是头节点的话，则要为head指针重新指向旧头节点的后驱节点，让该后驱节点重新成为头节点。接着判断当前的head指针（已经指向了新的头节点）是否为null，是则说明此时双向链表已经空了，因此需要将尾节点也置为空，这样无论从前还是后面遍历该双向链表时都不能读取到任意节点了。如果当前的head指针不是null，则需要将head指针的前驱节点指向null，因为该head指针目前指向的是旧节点的后驱节点，该后驱节点实际上还与旧头节点保持着链接，因此需要断开。
如果此时当前节点是尾节点的话，则需要将tail指针重新指向旧尾节点的前驱节点，让该前驱节点重新成为尾节点。接着此时由于此时tail指针的指向已经发生变化，因此需要将它的后驱节点指向null，表示与旧节点断开链接。
如果当前节点即不是头节点或者尾节点的话，则需要将当前节点原来的前后节点互相链接在一起，即可完成节点的删除。

    private void delete(int val) {
        // 顺序遍历的方式删除节点，因此需要创建一个临时变量
        Node currentNode = head;
        while (currentNode != null){
            if (currentNode.val == val){
                if (currentNode == head){// 如果正好是头节点
                    head = currentNode.next; // head重新指向下一个节点
                    if (head != null){
                        head.pre = null;// 和旧头节点断开链接
                    }else {
                        tail = null; // 如果只有一个节点，则tail也要置空
                    }
                }else if (currentNode == tail){// 如果正好是尾节点
                    tail = currentNode.pre; // tail重新指向待删节点的前节点
                    tail.next = null; // tail和老尾节点断开链接
                }else {
                    // 待删节点的前节点和待删节点后节点链接
                    currentNode.pre.next = currentNode.next;
                    currentNode.next.pre = currentNode.pre;
                }
            }
            // 让currentNode重新指向头节点对象的下一个对象地址
            currentNode = currentNode.next;
        }
    }

不过这里插入一个Java知识：什么时候，一个对象会被垃圾回收器回收呢？

答案是当这个对象没有被任何引用变量引用的时候或者所引用该对象的变量被赋值为null。

其实这个知识跟上面删除方法息息相关，以a-b-c的双向链表为例，要删除的节点是c节点，结合上面的代码，tail指针此时指向b，b的后驱节点指向null，但是注意c的前驱节点此时还指向b，只不过c已经没有被b引用了，也就是说此时b没有被任何变量引用着，因此c此时将会被垃圾回收器回收。

3.3 修改方法

以本文的Node节点为例子，修改方法主要实现修改节点的值，因此这里以顺序遍历方式去实现去修改某个节点的值。

修改的方法较为简单，因为不涉及头、尾节点的维护以及两两节点之间引用的重新设置等操作，只需要创建一个临时变量（下称当前节点）指向头节点对应的对象，然后判断当前节点的值是否是要更新的值，是则更新。

接着将当前节点重新指向它的下一个节点，继续遍历重复上述操作即可。

    private void update(int originVal, int updateVal){
        Node currentNode = head;
        while (currentNode !=null){
            if (currentNode.val == originVal){
                currentNode.val = updateVal;
            }
            currentNode = currentNode.next;// currentNode重新指向它的下一个节点
        }
    }

3.4 查询方法

双向链表由于存在头、尾指针分别指向链表队列的头部节点和尾部节点，因此可以顺序读取或者逆序读取，这里以逆序读取去实现一个查询队尾元素的方法。

由于是从队列尾部获取元素，即和增加方法一样，如果是操作双向链表的尾部，则需要重新维护tail指针，因此步骤为：

创建一个临时变量last，指向原尾节点对应在堆对象的实际对象，最后会返回这个last变量给调用方法，其控制权从链表转为调用方。
通过last.pre找到原尾节点的前驱节点thePreOfOriTal。
将此时双向链表的尾节点tail变量重新指向thePreOfOriTal，表示此时的尾节点更新老尾节点的前驱节点了。
根据原尾节点的前驱节点thePreOfOriTal是否为null判断：如果是null，说明此时双向链表只有一个元素，它既是尾节点也是头节点，因此需要同样将头节点置为null。如果不是null，则说明此时不止一个节点，因此将原尾节点的前驱节点（此时升级为新尾节点）和老尾节点断开，即通过设置后继节点为null——此时老尾节点的引用将会交给调用方法，由它们负责该老节点的“存活”了。

    private Node getLast(){
        Node last = tail;
        if (last == null){
            throw new NullPointerException();
        }
        Node thePreOfOriTal = last.pre;
        tail = thePreOfTal;
        if (thePreOfTal == null){
            head = null;// 头指针不再指向原头节点对象，那么头节点对象会因为失去引用而被GC回收
        }else {
            tail.next = null;//新尾节点不再引用老尾节点，这样老尾节点没有被引用就会GC回收
        }
        return last;
    }

4.总结

双向链表的核心在于其通过内部的头节点、尾节点去维护一个链式的数据结构。

由于存在头、尾节点，所以可以以顺序或者逆序的方式分别从链表的头部、尾部插入、删除、获取元素。
由于元素之间是通过前后指针互相引用，因此断开某个元素仅需要维护好头节点、尾节点、重新定义待删除节点前后节点的连接关系即可。不需要像数组删除元素一样，需要移动内存空间。
由于双向链表没有数组的下标，因此访问双向链表的时间复杂度是O（n），并且不支持随机访问。数组的时间复杂度则是O（1），可以通过下标随机访问元素。