Class Solution
Medium
A linked list of length n
is given such that each node contains an additional random pointer, which could point to any node in the list, or null
.
Construct a deep copy of the list. The deep copy should consist of exactly n
brand new nodes, where each new node has its value set to the value of its corresponding original node. Both the next
and random
pointer of the new nodes should point to new nodes in the copied list such that the pointers in the original list and copied list represent the same list state. None of the pointers in the new list should point to nodes in the original list.
For example, if there are two nodes X
and Y
in the original list, where X.random --> Y
, then for the corresponding two nodes x
and y
in the copied list, x.random --> y
.
Return the head of the copied linked list.
The linked list is represented in the input/output as a list of n
nodes. Each node is represented as a pair of [val, random_index]
where:
val
: an integer representingNode.val
random_index
: the index of the node (range from0
ton-1
) that therandom
pointer points to, ornull
if it does not point to any node.
Your code will only be given the head
of the original linked list.
Example 1:
Input: head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
Output: [[7,null],[13,0],[11,4],[10,2],[1,0]]
Example 2:
Input: head = [[1,1],[2,1]]
Output: [[1,1],[2,1]]
Example 3:
Input: head = [[3,null],[3,0],[3,null]]
Output: [[3,null],[3,0],[3,null]]
Example 4:
Input: head = []
Output: []
Explanation: The given linked list is empty (null pointer), so return null.
Constraints:
0 <= n <= 1000
-10000 <= Node.val <= 10000
Node.random
isnull
or is pointing to some node in the linked list.
To solve the “Copy List with Random Pointer” problem in Java with a Solution
class, we’ll use a HashMap to maintain a mapping between the original nodes and their corresponding copied nodes. Below are the steps:
-
Create a
Solution
class: Define a class namedSolution
to encapsulate our solution methods. -
Create a
copyRandomList
method: This method takes the head node of the original linked list as input and returns the head node of the copied linked list. -
Initialize a HashMap: Create a HashMap named
nodeMap
to store the mapping between original nodes and their corresponding copied nodes. -
Create a deep copy of the list: Iterate through the original linked list and create a deep copy of each node. For each node
originalNode
in the original linked list:- Create a new node
copyNode
with the same value asoriginalNode
. - Put the mapping between
originalNode
andcopyNode
in thenodeMap
. - Set the
copyNode
’snext
andrandom
pointers accordingly. - Attach the
copyNode
to the copied linked list.
- Create a new node
-
Return the head of the copied linked list: After creating the deep copy of the entire list, return the head node of the copied linked list.
Here’s the Java implementation:
import java.util.HashMap;
import java.util.Map;
class Solution {
public Node copyRandomList(Node head) {
if (head == null) return null; // Check for empty list
Map<Node, Node> nodeMap = new HashMap<>(); // Initialize HashMap to store mapping between original and copied nodes
// Create a deep copy of each node in the list
Node current = head;
while (current != null) {
Node copyNode = new Node(current.val); // Create a new copy node
nodeMap.put(current, copyNode); // Put mapping between original and copied nodes in the map
current = current.next; // Move to the next node
}
// Set the next and random pointers of copied nodes
current = head;
while (current != null) {
Node copyNode = nodeMap.get(current); // Get copied node
copyNode.next = nodeMap.getOrDefault(current.next, null); // Set next pointer
copyNode.random = nodeMap.getOrDefault(current.random, null); // Set random pointer
current = current.next; // Move to the next node
}
return nodeMap.get(head); // Return the head of the copied linked list
}
// Definition for a Node
class Node {
int val;
Node next, random;
Node(int val) {
this.val = val;
this.next = null;
this.random = null;
}
}
}
This implementation follows the steps outlined above and efficiently constructs a deep copy of the linked list with random pointers in Java.
-
Constructor Summary
-
Method Summary
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
-
Constructor Details
-
Solution
public Solution()
-
-
Method Details
-
copyRandomList
-