算法通关村第一关|青铜学习

双向链表如何构造的

双向链表可以向前，也可以向后。有两个指针的好处自然是移动元素更方便。
定义头节点和尾节点

    private DoubleNode first;
    private DoubleNode last;
    public DoubleLinklist() {
        first = null;
        last = first;
    }

双链表的节点：

class DoubleNode {
        public int data;    //数据域
        public DoubleNode next;    //指向下一个结点
        public DoubleNode prev;

        public DoubleNode(int data) {
            this.data = data;
        }
    }

插入元素：
1.头部插入

  public void insertFirst(int data) {
        DoubleNode newDoubleNode = new DoubleNode(data);
        if (first==null) {
            last = newDoubleNode;
        } else {
            first.prev = newDoubleNode;    
        }
        newDoubleNode.next = first;       
        first = newDoubleNode;        
    }

2.尾部插入

 public void insertLast(int data) {
        DoubleNode newDoubleNode = new DoubleNode(data);
        if (first==null) {
        //若链表为空，则将first指向新的结点（newNode）
            first = newDoubleNode;       
        } else {
        //将last的previous指向last         
           newDoubleNode.prev = last;
            //将last.next(当前链表最后一个结点的next域)指向新的结点newNode
            last.next = newDoubleNode;    
        }
         //由于插入了一个新的结点，又因为是尾部插入，所以将last指向newNode
        last = newDoubleNode;                
    }

3.从某个节点的后部插入

  public void insertAfter(int key, int data) {
        DoubleNode newDoubleNode = new DoubleNode(data);
        DoubleNode current = first;
        while ((current != null) && (current.data != key)) {
            current = current.next;
        }
        //若当前结点current为空
        if (current == null) {                    //current为null有两种情况 一种是链表为空，一种是找不到key值
            if (first==null {                    //1、链表为空
                first = newDoubleNode;                //则插入第一个结点（其实可以调用其它的Insert方法）
                last = newDoubleNode;                    //first和last均指向该结点（第一个结点）
            } else {
                last.next = newDoubleNode;        //2、找不到key值
                newDoubleNode.prev = last;    //则在链表尾部插入一个新的结点
                last = newDoubleNode;
            }
        } else {
            if (current == last) {                    //第三种情况，找到了key值，分两种情况
                newDoubleNode.next = null;            //1、key值与最后结点的data相等
                last = newDoubleNode;                    //由于newNode将是最后一个结点，则将last指向newNode
            } else {
                newDoubleNode.next = current.next;        //2、两结点中间插入                                                                                                                            四
                current.next.prev = newDoubleNode;    //将current当前结点的下一个结点赋给newNode.next
            }                                        //将current下一个结点即current.next的previous域指向current
            current.next = newDoubleNode;                    //将当前结点的next域指向newNode
            newDoubleNode.prev = current;                //将新结点的previous域指向current（current在newNode前面一个位置）

        }

    }

删除元素
1.从头部删除结点

 public DoubleNode deleteFirst() {
        DoubleNode temp = first;
          //若链表只有一个结点，删除后链表为空，将last指向null
        if (first.next == null) {          
            last = null;
        } else {
          //若链表有两个（包括两个）以上的结点 ，因为是头部插入，则first.next将变成第一个结点，其previous将变成null
            first.next.prev = null;      
        }
        //将first.next赋给first
        first = first.next;        
          //返回删除的结点        
        return temp;                  
    }

2.从尾部删除结点

    //从尾部删除结点
    public DoubleNode deleteLast() {
        DoubleNode temp = last;
        if (first.next == null) {        //如果链表只有一个结点，则删除以后为空表,last指向null
            first = null;
        } else {
            last.prev.next = null;    //将上一个结点的next域指向null
        }
        last = last.prev;            //上一个结点称为最后一个结点，last指向它
        return temp;                    //返回删除的结点
    }

3.按值删除

 public DoubleNode deleteKey(int key) {
        DoubleNode current = first;
        while (current != null && current.data != key) {        //遍历链表寻找该值所在的结点
            current = current.next;
        }
        if (current == null) {                        //若当前结点指向null则返回null，
            return null;                        //两种情况当前结点指向null，一是该链表为空链表，而是找不到该值
        } else {
            if (current == first) {                //如果current是第一个结点
                first = current.next;            //则将first指向它，将该结点的previous指向null,其余不变
                current.next.prev = null;
            } else if (current == last) {            //如果current是最后一个结点
                last = current.prev;        //将last指向当前结点的上一个结点（我们将当前结点除名了以后它便不再是最后一个了）
                current.prev.next = null;    //相应的要删除结点的上一个结点的next域应指向null
            } else {
                current.prev.next = current.next;        //当前结点的上一个结点的next域应指向当前的下一个结点
                current.next.prev = current.prev;    //当前结点的下一个结点的previous域应指向当前结点的上一个结点
            }
        }
        return current;        //返回
    }