温故而知新---双向链表

概念

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

链表的基本操作：

定义：

/**
 * 双向链表基本节点类
 */
public class DoublyListNode {
    int val;
    DoublyListNode prev,next;
    public DoublyListNode(int val){
        this.val =val;
    }
}

/**
 * 双向链表
 */
public class MyDoublyListNode {
    int size;
    DoublyListNode head;
    DoublyListNode tail;

    /**
     * 获取某个下标的链表元素
     * @param index
     * @return
     */
    public int get(int index){
        if(index<0||index>=size){
            return -1;
        }
        int counter = 0;
        DoublyListNode visitor = head;
        while (counter!=index){
            visitor = visitor.next;
            counter ++;
        }
        return visitor.val;
    }

    /**
     * 删除头节点
     * @param val
     */
    public void addAtHead(int val){
        DoublyListNode newNode = new DoublyListNode(val);
        if(size==0){
            head = newNode;
            tail = newNode;
            size++;
            return;
        }
        newNode.next = this.head;
        this.head.prev = newNode;
        this.head = newNode;
        size++;
    }

    /**
     * 在尾部添加元素
     * @param val
     */
    public void addAtTail(int val){
        DoublyListNode newNode = new DoublyListNode(val);
        if(size==0){
            head = newNode;
            tail = newNode;
            size++;
            return;
        }
        tail.next = newNode;
        newNode.prev = tail;
        size++;
    }

    /**
     * 在下标index处添加元素val
     * @param index
     * @param val
     */
    public void addAtIndex(int index,int val){
        DoublyListNode newNode = new DoublyListNode(val);
        if(index==0){
            addAtHead(val);
            return;
        }
        if(index == size){
            addAtTail(val);
            return;
        }
        if(index<0 ||index>size){
            return;
        }
        int counter = 0;
        DoublyListNode visitor = head;
        while (counter != index){
            visitor = visitor.next;
            counter++;
        }
        newNode.next = visitor;
        newNode.prev = visitor.prev;
        visitor.prev.next = newNode;
        visitor.prev = newNode;  //注意此行不能与上一行交换，交换后就会失去对visitor的上一个节点的访问
        size++;
    }

    /**
     * 删除头部节点
     */
    public void deleteAtHead(){
        if(size<=1){
            this.head = null;
            this.tail = null;
            this.size = 0;
            return;
        }
        this.head.next.prev = null;
        this.head = head.next;
        this.size--;
    }

    /**
     * 删除尾部节点
     */
    public void deleteAtTail(){
        if(size<=0){
            this.head = null;
            this.tail = null;
            this.size = 0;
            return;
        }
        this.tail.prev.next = null;
        this.tail = this.tail.prev;
        size--;
    }

    /**
     * 删除下标index的节点元素
     * @param index
     */
    public void deleteAtIndex(int index){
        if(index<0 ||index>=size){
            return;
        }
        if(index==0){
            deleteAtHead();
            return;
        }
        if(index==size-1){
            deleteAtTail();
            return;
        }
        DoublyListNode visitor = head;
        for(int i=0; i<index; i++){
            visitor = visitor.next;
        }
        visitor.prev.next = visitor.next;
        visitor.next.prev = visitor.prev;  //此处不能和上一行代码交换顺序，要不然会导致引用丢失
        size--;
    }
}