2021-9-下旬 数据结构-线性表-双向链表-java代码实现（复习用）

public class DoubleLinkedListZH<E> {
    //调用方法参数是index的记得检测是否在合法范围（0~size-1）内，可以写一个arrangeCheck函数，我懒了，默认输入合法
    //双向链表，一个结点前后两个指针
    //双向链表相比单链表，add方法和remove方法大改，分四到三种情况，比较重要，时刻注意空指针报错
    //clear方法的实际意义涉及到java 的内存管理机制，也可以好好回顾
    //tostring也改了一下，sout（node）本质是调用node的toString函数,重写toString函数真的很实用，StringBuilder的用法也需要掌握

    public static final  int ELEMENT_NOT_FOUND = -1;

    private int size;//定义全局变量（不在函数里的）不初始化默认初始值为0，局部变量则初始值随机

    private DoubleLinkedListZH.Node<E> headNode;
    private DoubleLinkedListZH.Node<E> lastNode;

    private static class Node<E> {
        E element;
        DoubleLinkedListZH.Node<E> next = null;
        DoubleLinkedListZH.Node<E> prev = null;

        //JAVA把指针淡化了，C中需要Node *p = next；next -> nextNode;,Java中只要next=nextNode就可以了
        public Node(DoubleLinkedListZH.Node<E> prev ,E element, DoubleLinkedListZH.Node<E> next) {
            this.element = element;
            this.prev = prev;
            this.next = next;
        }
        public Node() {
        }

        @Override
        //重写了toString函数，输出：null<-0->1 一个结点及其前后指针和对应结点
        public String toString() {
            StringBuilder sb = new StringBuilder();
            if (prev!=null){
                sb.append(prev.element);
            }else{
                sb.append("null");
            }
            sb.append("<-").append(element).append("->");
            if (next!=null){
                sb.append(next.element);
            }else{
                sb.append("null");
            }
            return sb.toString() ;
        }
    }

    //非gc boot对象，即没有被栈指针或栈指针间接指向的对象，就被自动回收了
    public void clear(){
        headNode = null;
        lastNode = null;
        size = 0;
    }

    public void isEmptyPrint(){
        if (headNode == null){
            System.out.println("Empty");
        }else{
            System.out.println("Not Empty");
        }
    }

    //是否包含，一定记得看看有没有多余句子写到循环里了
    public void containsPrint(E element){
        DoubleLinkedListZH.Node<E> node = headNode;
        for(int i = 0;i < size ; i++){
            if (node.element == element){
                System.out.println("Contain");
                return;
            }
            node = node.next;
        }
        System.out.println("Not Contain");
    }

    //双向链表add，实际上有四种情况，分别是链表全空时插入，链表非空在头结点前插入，链表非空在尾结点后插入，链表非空在非头尾结点插入
    //时刻注意空指针错误！！！尤其链表题
    public void add(int index , E element){
        DoubleLinkedListZH.Node<E> node = new Node<>();
        node.element = element;
        if (size == 0){
            headNode = node;
            lastNode = node;
        }else if (index == 0){
            node.next = headNode;
            headNode.prev = node;
            headNode = node;
            node.prev = null;
        }else if (index == size){
            node.prev = lastNode;
            lastNode.next = node;
            lastNode = node;
            node.next = null;
        }else {
            DoubleLinkedListZH.Node cur = indexSearchNode(index);
            node.next = cur;
            node.prev = cur.prev;
            cur.prev.next = node;
            cur.prev = node;
        }
        size++;
    }

    public void remove(int index){
        DoubleLinkedListZH.Node<E> node = indexSearchNode(index);
        if(node.prev == null){
            headNode = node.next;
            node.next.prev = null;
        }
        if (node.next == null){
            node.prev.next = null;
            lastNode = node.prev;
        }else {
            node.prev.next = node.next;
            node.next.prev = node.prev;
        }
        size--;
    }

    public void add(E element){
        add(size,element);
    }

    //根据索引返回对应结点，注意返回值是Node<E>而不是E,该函数经常在别的函数内使用
    //注意这里是双向链表的优势之一，按index查找结点的平均时间要少，因为可以从两边往中间找，最坏就是在中间
    private DoubleLinkedListZH.Node<E> indexSearchNode (int index){
        DoubleLinkedListZH.Node node = new Node();
        if(index <= size / 2){
            node = headNode;
            for (int i = 0; i<index; i++){
              node = node.next;
            }
            }else{
            node = lastNode;
            for (int i = size - 1; i > index ; i--){
                node =node.prev;
            }
        }
        return node;
    }

    public String toString() {
        StringBuilder string = new StringBuilder();
        string.append("size=").append(size).append("  [");
        DoubleLinkedListZH.Node<E> node = headNode;
        for (int i = 0; i < size; i++) {
            if (i != 0) {
                string.append(", ");
            }

            string.append(node);

            node = node.next;
        }
        string.append("]");
        return string.toString();
    }

}