138. Copy List with Random Pointer

138. Copy List with Random Pointer

Medium

1367395FavoriteShare

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 a deep copy of 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.

/*
// 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 {
    public Node copyRandomList(Node head) {
        if(head == null) return null;
        Map<Node, Node> map = new HashMap<Node, Node>();
         Node node = head;
        while(node != null){
            map.put(node, new Node(node.val,node.next, node.random));
            node = node.next;
            }
         node = head;
        while(node != null){
            map.get(node).next = map.get(node.next);
            map.get(node).random = map.get(node.random);
            node = node.next;
        }
        return map.get(head);
    }
}

让我返回用已给出的head？你实在为难我胖虎。

要deep copy一个链表，deep copy是新建列表，这个列表的所有nodes里面的value和原始nodes的value相同，但是不可以用之前的reference，也就是所有nodes都是新的。

这里用hashmap比较好，既然要我返回时用head，那我就把map的key设成旧nodes，value成为新建的nodes

第一次while后，新链表有了所有的value,但是没有被连接起来，所以在第二个while里改变node的next和random的next。

详解见 https://blog.csdn.net/linhuanmars/article/details/22463599/

 

 

Shallow copies: duplicate as little as possible. A shallow copy of a collection is a copy of the collection structure, not the elements. With a shallow copy, two collections now share the individual elements.

Deep copies: duplicate everything. A deep copy of a collection is two collections with all of the elements in the original collection duplicated.