Copy List with Random Pointer

A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.

Return adeep copyof the list.

Example 1: Input:

{"\$id":"1","next":{"\$id":"2","next":null,"random":{"\$ref":"2"},"val":2},"random":{"\$ref":"2"},"val":1}

Explanation:

Node 1's value is 1, both of its next and random pointer points to Node 2.
Node 2's value is 2, its next pointer points to null and its random pointer points to itself.

Note:

1. You must return the copy of the given head as a reference to the cloned list.

Solution & Analysis

HashMap 保存 old -> copy的映射，避免重复创建新Node。这样会用到O(n) space.

Approach 1: Recursion with O(N) Space

Complexity Analysis

• Time Complexity: O(N) where N is the number of nodes in the linked list.
• Space Complexity: O(N). If we look closely, we have the recursion stack and we also have the space complexity to keep track of nodes already cloned i.e. using the visited dictionary. But asymptotically, the complexity is O(N).
public class Solution {
// HashMap which holds old nodes as keys and new nodes as its values.
HashMap<Node, Node> visitedHash = new HashMap<Node, Node>();

public Node copyRandomList(Node head) {

if (head == null) {
return null;
}

// If we have already processed the current node, then we simply return the cloned version of
// it.
}

// Create a new node with the value same as old node. (i.e. copy the node)
Node node = new Node(head.val, null, null);

// Save this value in the hash map. This is needed since there might be
// loops during traversal due to randomness of random pointers and this would help us avoid
// them.

// Recursively copy the remaining linked list starting once from the next pointer and then from
// the random pointer.
// Thus we have two independent recursive calls.
// Finally we update the next and random pointers for the new node created.

return node;
}
}

*Approach 2: Iterative with O(N) Space

/*
// Definition for a Node.
class Node {
public int val;
public Node next;
public Node random;

public Node() {}

public Node(int _val,Node _next,Node _random) {
val = _val;
next = _next;
random = _random;
}
};
*/
class Solution {
HashMap<Node, Node> map = new HashMap<>();

private Node getCopy(Node node) {
if (node == null) {
return null;
}
if (!map.containsKey(node)) {
Node copy = new Node(node.val, null, null);
map.put(node, copy);
return copy;
}
return map.get(node);
}
public Node copyRandomList(Node head) {
Node o = head;
Node n = getCopy(o);

while (o != null) {
n.random = getCopy(o.random);
n.next = getCopy(o.next);

o = o.next;
n = n.next;
}

}
}

**Approach 3: Iterative with O(1) Space

A -> A' -> B -> B' -> C -> C'

Complexity Analysis

• Time Complexity : O(n)
• Space Complexity : O(1)
/*
// Definition for a Node.
class Node {
public int val;
public Node next;
public Node random;

public Node() {}

public Node(int _val,Node _next,Node _random) {
val = _val;
next = _next;
random = _random;
}
};
*/
public class Solution {
// Visited dictionary to hold old node reference as "key" and new node reference as the "value"
HashMap<Node, Node> visited = new HashMap<Node, Node>();

public Node getClonedNode(Node node) {
// If the node exists then
if (node != null) {
// Check if the node is in the visited dictionary
if (this.visited.containsKey(node)) {
// If its in the visited dictionary then return the new node reference from the dictionary
return this.visited.get(node);
} else {
// Otherwise create a new node, add to the dictionary and return it
this.visited.put(node, new Node(node.val, null, null));
return this.visited.get(node);
}
}
return null;
}

public Node copyRandomList(Node head) {

if (head == null) {
return null;
}

Node oldNode = head;

// Creating the new head node.
Node newNode = new Node(oldNode.val);
this.visited.put(oldNode, newNode);

// Iterate on the linked list until all nodes are cloned.
while (oldNode != null) {
// Get the clones of the nodes referenced by random and next pointers.
newNode.random = this.getClonedNode(oldNode.random);
newNode.next = this.getClonedNode(oldNode.next);

// Move one step ahead in the linked list.
oldNode = oldNode.next;
newNode = newNode.next;
}