一刷329-哈希表-138. 复制带随机指针的链表（m）（同：剑指 Offer 35. 复杂链表的复制）

题目：
同：请实现 copyRandomList 函数，复制一个复杂链表。
在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，
还有一个 random 指针指向链表中的任意节点或者 null。
-------------------
给你一个长度为 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 作为传入参数。
--------

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

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

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

输入：head = []
输出：[]
解释：给定的链表为空（空指针），因此返回 null。
 
提示：
0 <= n <= 1000
-104 <= Node.val <= 104
Node.random 为 null 或指向链表中的节点。
----------------------
思考：哈希表
普通链表的节点定义如下：
// Definition for a Node.
class Node {
    int val;
    Node next;
    public Node(int val) {
        this.val = val;
        this.next = null;
    }
}
-------------------
本题链表的节点定义如下：
// Definition for a Node.
class Node {
    int val;
    Node next, random;
    public Node(int val) {
        this.val = val;
        this.next = null;
        this.random = null;
    }
}
---------------
给定链表的头节点 head ，复制普通链表很简单，
只需遍历链表，每轮建立新节点 + 构建前驱节点 pre 和当前节点 node 的引用指向即可。
----------------
本题链表的节点新增了 random 指针，指向链表中的 任意节点 或者 null。
这个 random 指针意味着在复制过程中，除了构建前驱节点和当前节点的引用指向 pre.next ，
还要构建前驱节点和其随机节点的引用指向 pre.random 。

本题难点： 在复制链表的过程中构建新链表各节点的 random 引用指向。
-------------------

利用哈希表的查询特点，考虑构建 原链表节点 和 新链表对应节点 的键值对映射关系，
再遍历构建新链表各节点的 next 和 random 引用指向即可。
------------------
算法流程：
1、若头节点 head 为空节点，直接返回 null ；
2、初始化： 哈希表 dic ， 节点 cur 指向头节点；
3、复制链表：
	1、建立新节点，并向 dic 添加键值对 (原 cur 节点, 新 cur 节点） ；
	2、cur 遍历至原链表下一节点；
4、构建新链表的引用指向：
	1、构建新节点的 next 和 random 引用指向；
	2、cur 遍历至原链表下一节点；
5、返回值： 新链表的头节点 dic[cur] ；
------------------
复杂度分析：
时间复杂度 O(N)： 两轮遍历链表，使用 O(N) 时间。
空间复杂度 O(N)： 哈希表 dic 使用线性大小的额外空间。
-----------------
/*
// Definition for a Node.
class Node {
    int val;
    Node next;
    Node random;

    public Node(int val) {
        this.val = val;
        this.next = null;
        this.random = null;
    }
}
*/
class Solution {
    public Node copyRandomList(Node head) {
        if (head == null) return null;//特判
        Node cur = head;//创建cur节点 初始化指向头节点
        Map<Node, Node> map = new HashMap<>();//创建哈希表
        while (cur != null) {//复制链表：
            map.put(cur, new Node(cur.val));//复制各节点，建立 原节点->新节点 的map映射
            cur = cur.next;//更新
        }
        cur = head;//再次初始化cur节点
        while (cur != null) {//构建新链表的 next 和 random指向
            map.get(cur).next = map.get(cur.next);
            map.get(cur).random = map.get(cur.random);
            cur = cur.next;
        }
        return map.get(head);//返回新链表的头节点
    }
}

LC