力扣 138. 复制带随机指针的 链表
题目描述
给你一个长度为 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]] 示例 4：
输入：head = []
输出：[]
解释：给定的链表为空（空指针），因此返回 null。 提示：
- 0 <= n <= 1000
- -10000 <= Node.val <= 10000
- Node.random 为空（null）或指向链表中的节点。
解决方案
方法一：回溯 + 哈希表
思路及算法
本题要求我们对一个特殊的链表进行深拷贝。如果是普通链表，我们可以直接按照遍历的顺序创建链表节点。而本题中因为随机指针的存在，当我们拷贝节点时，「当前节点的随机指针指向的节点」可能还没创建，因此我们需要变换思路。一个可行方案是，我们利用回溯的方式，让每个节点的拷贝操作相互独立。对于当前节点，我们首先要进行拷贝，然后我们进行「当前节点的后继节点」和「当前节点的随机指针指向的节点」拷贝，拷贝完成后将创建的新节点的指针返回，即可完成当前节点的两指针的赋值。
具体地，我们用哈希表记录每一个节点对应新节点的创建情况。遍历该链表的过程中，我们检查「当前节点的后继节点」和「当前节点的随机指针指向的节点」的创建情况。如果这两个节点中的任何一个节点的新节点没有被创建，我们都立刻递归地进行创建。当我们拷贝完成，回溯到当前层时，我们即可完成当前节点的指针赋值。注意一个节点可能被多个其他节点指向，因此我们可能递归地多次尝试拷贝某个节点，为了防止重复拷贝，我们需要首先检查当前节点是否被拷贝过，如果已经拷贝过，我们可以直接从哈希表中取出拷贝后的节点的指针并返回即可。
在实际代码中，我们需要特别判断给定节点为空节点的情况。
C++
class Solution {
public:
unordered_map<Node*, Node*> cachedNode;
Node* copyRandomList(Node* head) {
if (head == nullptr) {
return nullptr;
}
if (!cachedNode.count(head)) {
Node* headNew = new Node(head->val);
cachedNode[head] = headNew;
headNew->next = copyRandomList(head->next);
headNew->random = copyRandomList(head->random);
}
return cachedNode[head];
}
}; Java
class Solution {
Map<Node, Node> cachedNode = new HASH Map<Node, Node>();
public Node copyRandomList(Node head) {
if (head == null) {
return null;
}
if (!cachedNode.containsKey(head)) {
Node headNew = new Node(head.val);
cachedNode.put(head, headNew);
headNew.next = copyRandomList(head.next);
headNew.random = copyRandomList(head.random);
}
return cachedNode.get(head);
}
} C#
public class Solution {
Dictionary<Node, Node> cachedNode = new Dictionary<Node, Node>();
public Node CopyRandomList(Node head) {
if (head == null) {
return null;
}
if (!cachedNode.ContainsKey(head)) {
Node headNew = new Node(head.val);
cachedNode.Add(head, headNew);
headNew.next = CopyRandomList(head.next);
headNew.random = CopyRandomList(head.random);
}
return cachedNode[head];
}
} JavaScript
var copyRandomList = function(head, cachedNode = new Map()) {
if (head === null) {
return null;
}
if (!cachedNode.has(head)) {
cachedNode.set(head, {val: head.val}), Object.assign(cachedNode.get(head), {next: copyRandomList(head.next, cachedNode), random: copyRandomList(head.random, cachedNode)})
}
return cachedNode.get(head);
} Golang
var cachedNode map[*Node]*Node
func deepCopy(node *Node) *Node {
if node == nil {
return nil
}
if n, has := cachedNode[node]; has {
return n
}
newNode := &Node{Val: node.Val}
cachedNode[node] = newNode
newNode.Next = deepCopy(node.Next)
newNode.Random = deepCopy(node.Random)
return newNode
}
func copyRandomList(head *Node) *Node {
cachedNode = map[*Node]*Node{}
return deepCopy(head)
} C
struct HashTable {
struct Node *key, *val;
UT_hash_handle hh;
} * cachedNode;
struct Node* deepCopy(struct Node* head) {
if (head == NULL) {
return NULL;
}
struct HashTable * tmp;
HASH_FIND_PTR(cachedNode, &head, tmp);
if (tmp == NULL) {
struct Node* headNew = malloc(sizeof(struct Node));
headNew->val = head->val;
tmp = malloc(sizeof(struct HashTable));
tmp->key = head, tmp->val = headNew;
HASH_ADD_PTR(cachedNode, key, tmp);
headNew->next = deepCopy(head->next);
headNew->random = deepCopy(head->random);
}
return tmp->val;
}
struct Node* copyRandomList(struct Node* head) {
cachedNode = NULL;
return deepCopy(head);
}
复杂度分析
- 时间复杂度：O(n)，其中 n 是链表的长度。对于每个节点，我们至多访问其「后继节点」和「随机指针指向的节点」各一次，均摊每个点至多被访问两次。
- 空间复杂度：O(n)，其中 n 是链表的长度。为哈希表的空间开销。
本文作者：力扣
声明：本文归“力扣”版权所有，如需转载请联系。
