public class DoublyList { public DoubleNode head; public DoublyList() { this.head = new DoubleNode(); this.head.prev = null; this.head.next = null; } public String toString() { Stri...-Go服务器开发

这段代码实现了一个双链表类 DoublyList<T>，其中包含了一些方法来对双链表进行操作。下面我将逐句解释并给出每个方法的动态演示。

public class DoublyList<T> {
    public DoubleNode<T> head;

    public DoublyList() {
        this.head = new DoubleNode<T>();
        this.head.prev = null;
        this.head.next = null;
    }

这是 DoublyList 类的构造函数，初始化一个空的双链表。

public String toString() {
    String str = this.getClass().getName() + "(";
    for (DoubleNode<T> p = this.head.next; p != null; p = p.next)
    	str += p.data.toString() + ((p.next != null) ? "," : "");
    return str + ")";
}

toString() 方法用于返回双链表的字符串表示形式，通过遍历链表节点将元素以逗号分隔的形式拼接起来。

public DoubleNode<T> insert(T x) {
  if (x == null)
      return null;

  DoubleNode<T> rear = head;
  while (rear.next != null) {
      rear = rear.next;
  }
  DoubleNode<T> q = new DoubleNode<T>(x, rear, null);
  rear.next = q;

  return q;
}

insert() 方法用于在双链表末尾插入一个新节点，并返回该节点。如果插入元素为 null，则直接返回 null。
在方法中，首先找到链表的尾节点 rear，然后创建一个新的节点 q，将其插入到尾节点后面，并更新尾节点。

public DoublyList(DoublyList<T> list) {
    this();
    DoubleNode<T> rear = this.head;
    for(DoubleNode<T> p = list.head.next; p != null; p = p.next) {
        DoubleNode<T> q = new DoubleNode(p.data, rear, null);
        rear.next = q;
        q.prev = rear;
        rear = rear.next;
    }
}

这是另一个构造函数，用于根据给定的双链表 list 创建一个新的双链表对象。
首先调用默认构造函数初始化一个空链表。然后遍历给定链表中的每个节点，创建一个相同数据值的新节点 q，将其插入到当前链表末尾，并更新尾节点。

public void concat(DoublyList<T> list) {
     DoubleNode<T> rear = this.head;

    while (rear.next != null) {
        rear = rear.next;
    }
    rear.next = list.head.next;
    if (list.head.next != null)
    	list.head.next.prev = rear;
}

concat() 方法用于将另一个双链表 list 连接到当前链表的末尾。
首先找到当前链表的最后一个节点 rear。然后将另一个链表的第一个节点连接在 rear 之后，并更新它们之间的前驱和后继关系。

public void addAll(DoublyList<T> list) {
    this.concat(new DoublyList<T>(list));
}

addAll() 方法用于将另一个双链表 list 中的所有元素添加到当前链表的末尾。
它通过创建一个新的临时链表对象，并调用 concat() 方法将两个链表连接起来。

public DoublyList<T> union(DoublyList<T> list) {
    DoublyList<T> result = new DoublyList<>(this);
    result.addAll(list);
    return result;
}

union() 方法返回一个新的双链表，该链表包含当前链表和另一个链表 list 的所有元素。
首先创建一个新的双链表 result，使用当前链表初始化它。然后调用 addAll() 方法将另一个链表中的元素添加到结果链表中，并返回结果。

public static void main(String[] args) {
    DoublyList<Integer> list1 = new DoublyList<Integer>();
    DoublyList<Integer> list2 = new DoublyList<Integer>();
    for (int i = 1; i <= 5; i++)
        list1.insert(i);
    for (int i = 6; i <= 10; i++)
        list2.insert(i);
    System.out.println(list1.toString());
    System.out.println(list2.toString());
    list1.addAll(list2);
    System.out.println(list1.toString());
}