双向链表的使用

双向链表也称为双链表，是链表的一种，它的每个数据节点都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个节点开始，都可以很方便地访问它的前驱节点和后继节点。

• 双向链表是这种通过pir知道自己的前面是谁，next知道自己后面是谁
• 下面这个图片是用一种平面的方式描绘出来
  
  

代码实现

package com.rj.bd.LXY.Test.Node;

import lombok.SneakyThrows;

/**
 * @author LXY
 * @desc
 * @time 2023--04--11--14:55
 */
public class LinkNode<T> {

    //首个
     Node<T> first;
     //最后的
     Node<T> last;

     int size = 0;

     //删除方法
     public  void remove(int index){
         //查询出来需要的Node
         Node<T> temp = getnode(index);

         //取出Node之中的前面的元素和后面的元素
         Node next=temp.next;
         Node per=temp.pri;

         if (per==null){
             //反向思考，如果per==null，代表的是他删除的是第一个元素   就直接让first等于剩下的元素即可
             first=next;
         }else {
             //否则的话删除的不是第一个元素,不是第一个元素的话
             per.next=next;
             temp.pri=null;
         }

         if (next==null){
             //删除的是最后一个元素
             last=per;
         }else {
             next.pri = per;
             temp.next = null;
         }
        size--;
     }





    /**
     * 查询方法
     * @param index
     * @return
     */
     public T get(int index){
         //点睛之笔，如果传递的索引小于一半了，就从first开始查  ，否则就从last开始查

        return getnode(index).data;
     }

     //查询数据，返回需要的Node节点
     public Node<T> getnode(int index){
         if (index < (size >> 1)) {
             Node<T> temp = this.first;
             for (int i = 0; i < index; i++) {
                 //后移，后移到想要的数据，返回
                 temp=temp.next;
             }
             return  temp;
         }
         else{
             Node<T> temp = this.last;
             for (int i = size - 1; i > index; i--){
                 //后移，后移到想要的数据，返回
                 temp=temp.pri;
             }
             return  temp;
         }
     }


    /**
     * 添加功能  first是从前往后进行存储    last是从后往前进行存储
     */
    public void add(T e){
        //临时变量承接
        final Node<T> temp = this.last;
        //新的newnode
        Node<T> newNode = new Node<T>(temp, e, null);
        last=newNode;

        if (temp==null)
            first=newNode;
        else
            temp.next=newNode;
        size++;
    }


    /**
     * Node实体
     * @param <T>
     */
    public  static  class Node <T> {
        private  T data;
        //上坐标
        private  Node<T> pri;
        //下坐标
        private  Node<T>next;
        public Node( Node<T> pri,T data, Node<T> next) {
            this.data = data;
            this.pri = pri;
            this.next = next;
        }
        public Node( ) {
        }
    }



}

• remove方法是有点不好理解，其原理是将查询出来的数据分为了
• Node next=temp.next;
  Node per=temp.pri;
  per的next数据是有脏数据的，需要per.next=next;，这样per的数据就不是脏数据了
  next的per是有脏数据的，将没有脏数据的per直接装入进入就没脏数据了，这样两个都没脏数据了，实现了删除