双向链表

 

public class Eriksenn {
    class Node{
        public int data;
        //保存双向链表的后驱信息
        public Node prev;
        //双向链表的前驱
        public Node next;
        public Node (int data){
            //创建构造方法 保证data为我们所用的值
            this.data=data;
        }
        public class MyLinkedList{
            public Node head;
            public Node tail;//定义尾
            public void headFirst(){
                Node node=new Node(data);
                //当第一次插入时
                if(this.head==null){
                    //让head tail指向node
                    this.head=node;
                    this.tail=node;
                } else {
                    node.next=this.head;
                    this.head.prev=node;
                    this.head=node;
                }
            }
        }
    }

双向链表实现在index位插入一个节点

 

//1.检查index是否合法
            private void checkindex(int index){
                if(index<0||index>size()){
                    System.out.println(false);
                }
            }
            //查找index在哪一个位
            //与单链表不同的是 双链表找到这一位并插入 而不是找到前一位
            private Node searchindex(int index){
                Node cur=this.head;
                while(index!=0){
                    cur=cur.next;
                    index--;
                }
                return cur;
            }
            public void index(int index,int data){
                    Node node=new Node(data);
                    if(index==0) {//相当于头插
                        if(this.head==null){
                            this.head=node;
                            this.tail=node;
                        } else {
                            node.next=this.head;
                            this.head.prev=node;
                            this.head=node;
                        }
                    }
                    //相当于尾插
                    if(index==size()){
                        AddLast();
                    }
                checkindex(index);
               Node cur= searchindex(index);
               //先搞定node
                node.next=cur;
                node.prev=cur.prev;
                //再搞定别的
                //最好的方法就是自己画图解决
                //通过箭头的指向 赋值时通常赋值箭头指向的方向的上面的地址
                cur.prev.next=node;
                cur.prev=node;
            }
        }
    

双链表  要删除其中的一个data为key的节点

 

public int remove(int key) {
                Node cur = this.head;
                while (cur != null) {
                    if (cur.data == key) {
                        int oldData = cur.data;
                        //如果要删除的是头节点
                        if (cur == this.head) {
                            this.head = this.head.next;
                            this.head.prev = null;
                        } else {
                            cur.prev.next = cur.next;
                            if (cur.next != null) {
                                cur.next.prev = cur.prev;
                            } else {
                                //要删除的是尾节点 只需移动tail即可
                                // cur是局部变量在函数调用结束后自动消失
                                this.tail = cur.prev;
                            }
                        }
                        //找得到返回 返回之后就不会再去找了  
                        return oldData;
                    }
                    cur=cur.next;
                }
                //找不到返回-1
                return -1;
            }

找到所有data为key的节点并且删除 记住是所有 那么找到一个key时我们就不能return了

public int remove(int key) {
                Node cur = this.head;
                while (cur != null) {
                    if (cur.data == key) {
                        
                        //如果要删除的是头节点
                        if (cur == this.head) {
                            this.head = this.head.next;

                             if(this.head!=null){
                               //如果head指向的是继续找前驱的话会出现空指针异常
                            this.head.prev = null;
                          }
                        } else {
                            cur.prev.next = cur.next;
                            if (cur.next != null) {
                                cur.next.prev = cur.prev;
                            } else {
                                //要删除的是尾节点 只需移动tail即可
                                // cur是局部变量在函数调用结束后自动消失
                                this.tail = cur.prev;
                            }
                        }
                    }
                    cur=cur.next;
                }
                //找不到返回-1
                return -1;
            }

清空双链表

 //与单链表不一样 双链表需要一个一个清空
            public void clear(){
                Node cur=this.head;
                while(cur!=null){
                    //由于头节点已经都是null的了 那么直接跳过它
                    cur=this.head.next;
                    head.next=null;
                    head.prev=null;
                    //更改头节点释放null了的节点
                    head=cur;
                }
            }