双向链表和其常规方法

双向链表

双向链表的定义

结构：

LLink-----Data-----RLink

1. 每个节点具有三个字段，中间为数据字段。左右各有两个链接字段，分别为LLINK和RLINK。

2. 通常加上一个表头，此表中不存在任何数据，其左边链接字段指向表中最后一个节点，而右边链接指向第一个节点

 

 

双向链表的节点插入

• 将新节点加入链表的第一个节点前

  1. 将新节点的右链接指向原表的第一个节点

  2. 将原表第一个节点的左链接指向新节点

  3. 将原表的表头指针head指向新节点，且新节点的左连接指向null

• 将新节点加入词表的最后一个节点

  1. 将原表的最后一个节点的右链接指向新节点

  2. 将新节点的做链接指向原表的最后一个节点，并将新节点的右链接指向NULL

• 将新节点加入到ptr节点之后

  1. 将ptr节点的右链接指向新节点

  2. 将新节点的做链接指向ptr节点

  3. 将ptr节点的下一个节点的左链接指向新节点

  4. 将新节点的右链接指向ptr的下一个节点

双向链表节点的删除

• 删除表的第一个节点

  1. 将表头指针head知道原表的第二个节点

  2. 将新的表头指针指向NULL

• 删除原表的最后一个节点

  1. 将原表最后一个节点之前一个节点的右链接指向null即可

• 删除表中间的ptr节点

  1. 将ptr节点的前一个节点右链接指向ptr节点的下一个节点

  2. 将ptr节点的下一个节点做链接指向ptr节点的上一个节点

 

Node类

 package 双向链表;
 ​
 /**
  * @author YanAemons
  * @date 2021/10/6 14:49
  */
 public class Node {
     int data;
     Node rnext;
     Node lnext;
     public Node(int data)
     {
         this.data = data;
         this.rnext = null;
         this.lnext = null;
     }
 ​
 }
 ​

Doubly类

 package 双向链表;
 ​
 /**
  * @author YanAemons
  * @date 2021/10/6 14:50
  */
 public class Doubly {
     public Node first;
     public Node last;
 ​
     public boolean isEmpty()
     {
         return first == null;
     }
 ​
     public void print()
     {
         Node current = first;
         while (current != null)
         {
             System.out.println("["+current.data+"]");
             current = current.rnext;
         }
         System.out.println();
     }
 ​
     public void insert(Node newN)
     {
         Node tmp;
         Node newNode;
         if (this.isEmpty())
         {
             first = newN;
             first.rnext = last;
             last = newN;
             last.lnext = first;
         }
         else
         {
             if (newN.lnext == null)
             {
                 first.lnext = newN;
                 newN.rnext = first;
                 first = newN;
             }
             else
             {
                 if (newN.rnext == null)
                 {
                     last.rnext = newN;
                     newN.lnext = last;
                     last = newN;
                 }
                 else
                 {
                     newNode = first;
                     tmp = first;
                     while (newN.rnext != newNode.rnext)
                     {
                         tmp = newNode;
                         newNode = newNode.rnext;
                     }
                     tmp.rnext = newN;
                     newN.rnext = newNode;
                     newNode.lnext = newN;
                     newN.lnext = tmp;
                 }
             }
         }
     }
 ​
     public void delete(Node delNode)
     {
         Node newNode;
         Node tmp;
         if (first == null)
         {
             System.out.println("表是空的");
             return;
         }
         if (delNode == null)
         {
             System.out.println("错误，del不是表中的节点");
             return;
         }
         if (first.data == delNode.data)
         {
             first = first.rnext;
             first.lnext = null;
         }
         else if (last.data == delNode.data)
         {
             newNode = first;
             while (newNode.rnext != last) newNode = newNode.rnext;
             newNode.rnext = null;
             last = newNode;
         }
         else
         {
             newNode = first;
             tmp = first;
             while (newNode.data != delNode.data)
             {
                 tmp = newNode;
                 newNode = newNode.rnext;
             }
             tmp.rnext = delNode.rnext;
             tmp.lnext = delNode.lnext;
         }
     }
 }
 ​