下面是使用Java编写的深拷贝函数，使用了循环双向链表（CirDoublyList）作为示例，并在main函数中进行验证。

import java.util.*;

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

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

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

    public CirDoublyList() {
        this.head = null;
    }

    // 添加元素到链表尾部
    public void add(T element) {
        if (head == null) {
            head = new Node<>(element);
            head.next = head;
            head.prev = head;
        } else {
            Node<T> newNode = new Node<>(element);
            newNode.next = head;  // 新节点的next指向头结点
            newNode.prev = head.prev;  // 新节点的prev指向原尾节点
            head.prev.next = newNode;  // 原尾节点的next指向新节点
            head.prev = newNode;  // 头结点的prev指向新节点
        }
    }

    // 获取链表元素数量
    public int size() {
        int count = 0;
        if (head != null) {
            count++;
            Node<T> currNode = head.next;
            while (currNode != head) {
                count++;
                currNode = currNode.next;
            }
        }
        return count;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        if (head != null) {
            sb.append(head.data.toString()).append(" ");
            Node<T> currNode = head.next;
            while (currNode != head) {
                sb.append(currNode.data.toString()).append(" ");
                currNode = currNode.next;
            }
        }
        return sb.toString();
    }

    // 深拷贝构造函数
    public CirDoublyList(CirDoublyList<T> list) {
        if (list.head == null) {
            this.head = null;
        } else {
            Map<Node<T>, Node<T>> oldToNewMap = new HashMap<>();  // 用于映射原链表节点和新链表节点的关系

            // 复制头结点
            this.head = new Node<>(list.head.data);
            oldToNewMap.put(list.head, this.head);

            // 复制其余节点
            Node<T> oldCurrNode = list.head.next;
            Node<T> prevNewNode = this.head;

            while (oldCurrNode != list.head) {
                Node<T> newCurrNode = new Node<>(oldCurrNode.data);
                oldToNewMap.put(oldCurrNode, newCurrNode);

                prevNewNode.next = newCurrNode;
                newCurrNode.prev = prevNewNode;

                prevNewNode = newCurrNode;
                oldCurrNode = oldCurrNode.next;
            }

            // 连接首尾节点形成循环
            prevNewNode.next = this.head;
            this.head.prev = prevNewNode;

            // 更新next和prev指针
            for (Map.Entry<Node<T>, Node<T>> entry : oldToNewMap.entrySet()) {
                Node<T> oldNode = entry.getKey();
                Node<T> newNode = entry.getValue();

                newNode.next = oldToNewMap.get(oldNode.next);
                newNode.prev = oldToNewMap.get(oldNode.prev);
            }
        }
    }
}

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.toString());

        // 深拷贝链表
        CirDoublyList<Integer> deepCopyList = new CirDoublyList<>(originalList);

        // 修改原链表（不影响深拷贝的链表）
        originalList.add(4);
        
        System.out.println("修改后的原链表：" + originalList.toString());
        
        // 打印深拷贝的链表
        System.out.println("深拷贝后的链表：" + deepCopyList.toString());
    }
}

运行上述代码，将输出以下结果：

原链表：1 2 3 
修改后的原链表：1 2 3 4 
深拷贝后的链表：1 2 3 

可以看到，通过深拷贝构造函数创建的新链表不受原链表的修改影响。


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