雙向連結串列

雙向連結串列的定義

結構：

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;
     }
   }
}
​