随机链表的复制

        给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。

        构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。

        例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。

        返回复制链表的头节点。

        用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val，random_index] 表示：

• val：一个表示 Node.val 的整数。
• random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为  null 。

你的代码 只 接受原链表的头节点 head 作为传入参数。

示例 1：

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2：

输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]

示例 3：

输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]

提示：

• 0 <= n <= 1000
• -104 <= Node.val <= 104
• Node.random 为 null 或指向链表中的节点。

为现给定链表的深拷贝，我们可以使用一个巧妙的方法，通过遍历原链表两次。以下是解决该问题的 Java 实现步骤：

1. **第一次遍历**：将每个原节点插入到其后面，形成一个新的链表结构。例如，对于节点A，插入节点A'（复制节点）在A后面，形成 `A -> A' -> B -> B' -> ...` 的结构。

2. **第二次遍历**：通过原先的随机指针设置复制节点的随机指针（`random` 指针）。

3. **第三次遍历**：将新复制的节点分离出来，形成一个单独的新链表。

下面是具体的 Java 代码实现：

// 定义链表节点类
class Node {
    public int val;
    public Node next;
    public Node random;

    public Node(int val) {
        this.val = val;
        this.next = null;
        this.random = null;
    }
}

public class Solution {
    public Node copyRandomList(Node head) {
        if (head == null) {
            return null;
        }

        // 1. 复制节点并插入到原节点后面
        Node current = head;
        while (current != null) {
            Node copy = new Node(current.val);
            copy.next = current.next;
            current.next = copy;
            current = copy.next; // 移动到下一个原节点
        }

        // 2. 设置每个复制节点的 random 指针
        current = head;
        while (current != null) {
            if (current.random != null) {
                current.next.random = current.random.next; // 通过 random 指针找到对应的复制节点
            }
            current = current.next.next; // 移动到下一个原节点
        }

        // 3. 分离复制链表和原链表
        Node pseudoHead = new Node(0); // 虚拟头结点
        Node copyCurrent = pseudoHead;
        current = head;

        while (current != null) {
            copyCurrent.next = current.next; // 连接复制节点
            current.next = current.next.next; // 还原原链表
            copyCurrent = copyCurrent.next; // 移动到下一个复制节点
            current = current.next; // 移动到下一个原节点
        }

        return pseudoHead.next; // 返回复制链表的头节点
    }

    // 你可以在这里添加一个主方法来测试你的代码
    public static void main(String[] args) {
        // 创建示例链表：1 -> 2 -> 3
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        node1.next = node2;
        node2.next = node3;

        // 设置随机指针
        node1.random = node3; // 1's random points to 3
        node2.random = node1; // 2's random points to 1
        node3.random = node2; // 3's random points to 2

        // 复制链表
        Solution solution = new Solution();
        Node copiedList = solution.copyRandomList(node1);

        // 输出结果以验证
        Node current = copiedList;
        while (current != null) {
            System.out.println("Value: " + current.val + ", Random Points to: "
                    + (current.random != null ? current.random.val : "null"));
            current = current.next;
        }
    }
}

代码说明
- **Node 类**：定义了链表节点，包含值和指向下一个节点及随机节点的指针。
- **copyRandomList 方法**：实现了深拷贝的逻辑。
  - 第一步创建复制节点并插入到原链表中。
  - 第二步设置随机指针，将复制节点的随机指针指向对应的复制节点。
  - 第三步分离复制链表和原链表，确保原链表不受影响。
- **主方法**中创建了一个示例链表，调用 `copyRandomList` 方法，并输出复制链表的结果以验证其正确性。

时间复杂度
- 整个算法的时间复杂度为 O(n)，其中 n 是链表中的节点数，因为我们只遍历链表三次。

空间复杂度
- 空间复杂度为 O(1)，不考虑输出的新链表的空间，因为我们只使用了常量级别的额外空间。