Merge pull request #13 from programmingbookclub/22-linked-list

Meetup 22 20210309 linked list

Author: ytyubox

紀錄/22 20210309.md

@@ -7,13 +7,194 @@
  4. 地點: google meet 線上 (前 10 分鐘預備鏈接)
  5. 解題項目:  [Linked list](https://leetcode.com/explore/learn/card/linked-list/210/doubly-linked-list/)
 
-      ```text、
+```text
    5. Medium    138.  Copy List with Random Pointer 
                                    > Hint: Using a hash set maybe is a good idea. Refer to our hash table card if you are not familiar with the hash set.
    6. Medium 61.  Rotate List 
                                   > Come up with as many solutions as you can. 
 
 
-     ```
+```
 
   6. 共筆: GitHub https://github.com/programmingbookclub/Leetcode-club
+
+  # Copy List with Random Pointer
+
+Solution
+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 representing Node.val
+random_index: the index of the node (range from 0 to n-1) that the random pointer points to, or null if it does not point to any node.
+Your code will only be given the head of the original linked list.
+
+
+```java=
+// Java recursion
+/*
+// 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 {
+  // 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.
+    if (this.visitedHash.containsKey(head)) {
+      return this.visitedHash.get(head);
+    }
+
+    // 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.
+    this.visitedHash.put(head, node);
+
+    // 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.
+    node.next = this.copyRandomList(head.next);
+    node.random = this.copyRandomList(head.random);
+
+    return node;
+  }
+}
+```
+
+```java=
+// JAVA
+// Iterative
+/*
+// 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;
+    }
+    return this.visited.get(head);
+  }
+}
+```
+
+```text
+[[7,null],[13,0],[11,4],[10,2],[1,0]]
+[[7,null],[7',null],[13,0],[13, 0],[11,4],[11,4],[10,2],[10,2], [1,0], [1,0]] 
+[[7',null],[13',0.next],[11',4.next],[10',2.next],[1',0.next]]
+```
+* 下面的解法會破壞原linked list的結構，正確的解法是中間再多一個while來指定每個新node的random
+```python=
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
+        self.val = int(x)
+        self.next = next
+        self.random = random
+"""
+
+class Solution:
+    def copyRandomList(self, head: 'Node') -> 'Node':
+        if not head:
+            return head
+        hash_table = {}
+        dummy = head
+        while(head):
+            clone_node = Node(head.val, head.next, head.random)
+            head.next = clone_node
+            head = head.next.next
+        head = dummy
+        while(head):
+            next = head.next.next
+            old = head
+            new = head.next
+            if new.next:
+                new.next = new.next.next
+            else:
+                new.next = None
+            if old.random:
+                new.random = old.random.next
+            else:
+                new.random = None
+            head = next
+        return dummy.next
+```