数据结构-双向链表

• 定义

  • 双向链表是一种特殊的单链表，它每个节点都有一个指向前一个节点的引用（称为 prev）和一个指向后一个节点的引用（称为 next）。这使得双向链表中的元素可以双向遍历。

• 底层实现

  • 节点

    public class Node {
        int data;
        Node next;
        Node prev;
        public Node(int data) {
            this.data = data;
        }
    }

  • 链表实现

    public class DoubleLinkedList {
        //表头节点指针
        private Node head;
        //表尾节点指针
        private Node tail;
        //1.增加节点
        public void append(int data){
            Node newNode = new Node(data);
            //如果链表为空
            if (head==null){
                head=newNode;
                tail=newNode;
            //如果链表不为空
            }else {
                tail.next=newNode;
                newNode.prev=tail;
                tail=newNode;
            }
        }
        //2.插入节点
        public void insert(int data,int position){
            Node newNode = new Node(data);
            //如果在表头插入
            if (position<=0){
                newNode.next=head;
                head.prev=newNode;
                head=newNode;
            //如果在表尾插入
            }else if (position>=size()){
                tail.next=newNode;
                newNode.prev=tail;
                tail=newNode;
            //如果在中间插入
            }else {
                Node current=head;
                for (int i = 0; i < position-1; i++) {
                    current=current.next;
                }
                newNode.next=current.next;
                newNode.prev=current;
                current.next.prev=newNode;
                current.next=newNode;
            }
        }
        //3.删除节点
        public void delete(int data){
            Node current=head;
            //链表不为空
            while (current!=null){
                //当前节点不是要找的节点则向后移动
                if (current.data!=data){
                    current=current.next;
                //当前节点是要找的节点
                }else {
                    //如果当前节点不是头节点
                    if (current.prev!=null){
                        current.prev.next=current.next;
                    //如果当前节点是头节点
                    }else {
                        head=current.next;
                    }
                    //如果当前节点不是尾节点
                    if (current.next!=null){
                        current.next.prev=current.prev;
                    //如果当前节点是尾节点
                    }else {
                        tail=current.prev;
                    }
                }
            }
        }
        //4.获取节点个数
        public int size(){
            int count=0;
            Node current=head;
            while (current!=null){
                count++;
                current=current.next;
            }
            return count;
        }
        //5.打印链表
        public void print(){
            Node current=head;
            while (current!=null){
                System.out.print(current.data+" ");
                current=current.next;
            }
            System.out.println();
        }
    }

• LinkedList实现双向链表

  public class DoubleLinkedJavaDemo {
      //使用final保证线程安全
      private final LinkedList<Integer> list;
  
      public DoubleLinkedJavaDemo() {
          this.list = new LinkedList<>();
      }
      //1.添加元素
      public void append(int data){
          list.addLast(data);
      }
      //2.插入元素
      public void insert(int index,int data){
          if (index < 0 || index > list.size()){
              throw new IndexOutOfBoundsException();
          }
          list.add(index,data);
      }
      //3.删除元素
      public void delete(int data){
          //删除所有值为data的数据
          list.removeIf(item->item==data);
      }
      //4.获取大小
      public int size(){
          return list.size();
      }
      //5.打印链表
      public void print(){
          for (int item:list){
              System.out.println(item+" ");
          }
          System.out.println();
      }
  }

• 循环链表

  • 在单循环链表中尾节点的next指针指向第一个带数据的节点
  • 在双循环链表中，每个节点都有一个prev域和next域，它们分别指向链表中前一个节点和下一个节点。在只有一个节点的双循环链表中，该节点的prev域指向它自己，next域也指向它自己，除此之外，尾节点的next域指向头节点。头节点的prev域指向尾节点。