深拷贝list，用CirDoublyList(CirDoublyList list) ，用java写，加main函数验证-Go服务器开发

以下是使用Java编写的示例代码，演示了如何实现深拷贝一个循环双向链表（CirDoublyList）：

class Node<T> {
    T data;
    Node<T> prev;
    Node<T> next;

    public Node(T data) {
        this.data = data;
    }
}

class CirDoublyList<T> {
    private Node<T> head;
    private int size;

    public CirDoublyList() {
        head = null;
        size = 0;
    }

    public void add(T element) {
        Node<T> newNode = new Node<>(element);
        if (head == null) {
            newNode.prev = newNode;
            newNode.next = newNode;
            head = newNode;
        } else {
            newNode.next = head;
            newNode.prev = head.prev;
            head.prev.next = newNode;
            head.prev = newNode;
        }
        size++;
    }

    public void display() {
        if (head == null) return;

        Node<T> current = head;
        do {
            System.out.print(current.data + " ");
            current = current.next;
        } while (current != head);
        
        System.out.println();
    }

    public CirDoublyList(CirDoublyList<T> list) {
        if (list.head == null) return;

        Node<T> currentOriginal = list.head;

        // 创建新的头节点
        this.head = new Node<>(currentOriginal.data);
        
         // 使用哈希表来保存原链表节点和新链表节点之间的对应关系，以便在后续步骤中进行连接操作
         HashMap<Node<T>, Node<T>> nodeMap= new HashMap<>();

         nodeMap.put(currentOriginal, head);

        Node<T> currentCopy = head;
        
        // 复制原链表中的节点，并建立新链表
        while (currentOriginal.next != list.head) {
            currentOriginal = currentOriginal.next;

            Node<T> newNode = new Node<>(currentOriginal.data);
            
            nodeMap.put(currentOriginal, newNode);
            
            currentCopy.next = newNode;
            newNode.prev = currentCopy;
            currentCopy = newNode;
        }
        
         // 连接新链表的头尾节点
         currentCopy.next = head;
         head.prev = currentCopy;

         // 根据哈希表恢复其他连接关系
         for (Node<T> original : list.nodeMap.keySet()) {
             Node<T> copy = list.nodeMap.get(original);
             
             copy.prev = list.nodeMap.get(original.prev);
             copy.next= list.nodeMap.get(original.next);
         }

        this.size = list.size;
    }
}

public class Main {
    public static void main(String[] args) {
        CirDoublyList<Integer> originalList = new CirDoublyList<>();
        originalList.add(1);
        originalList.add(2);
        originalList.add(3);

        System.out.println("原始链表:");
        originalList.display();

        CirDoublyList<Integer> copiedList = new CirDoublyList<>(originalList);

        System.out.println("复制后的链表:");
        copiedList.display();
    }
}

以上代码演示了一个循环双向链表（CirDoublyList）的实现，其中包括添加元素、展示列表和深拷贝等功能。在 main 函数中，我们创建了一个原始链表，然后通过调用深拷贝构造函数创建了一个新的链表，并展示了两个链表的内容。

内容由零声教学AI助手提供，问题来源于学员提问