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

Example 1:

Input:
{“KaTeX parse error: Expected '}', got 'EOF' at end of input: …":"1","next":{"id”:“2”,“next”:null,“random”:{“KaTeX parse error: Expected 'EOF', got '}' at position 9: ref":"2"}̲,"val":2},"rand…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:
You must return the copy of the given head as a reference to the cloned list.

方法思路

Approach1:Two loops based HashMap.

An intuitive solution is to keep a hash table for each node in the list, via which we just need to iterate the list in 2 rounds respectively to create nodes and assign the values for their random pointers. As a result, the space complexity of this solution is O(N), although with a linear time complexity.

class Solution {
    //Runtime: 1 ms, faster than 95.83%
    //Memory Usage: 35.3 MB, less than 100.00%
    public Node copyRandomList(Node head) {
        if (head == null) return null;
  
        Map<Node, Node> map = new HashMap<>();
  
        // loop 1. copy all the nodes
        Node node = head;
        while (node != null) {
             map.put(node, new Node(node.val));
             node = node.next;
        }
  
        // loop 2. assign next and random pointers
        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);
    }
}

Approach2: Three loops

As an optimised solution, we could reduce the space complexity into constant. The idea is to associate the original node with its copy node in a single linked list. In this way, we don’t need extra space to keep track of the new nodes.

The algorithm is composed of the follow three steps which are also 3 iteration rounds.

1.Iterate the original list and duplicate each node. The duplicate
	of each node follows its original immediately.
2.Iterate the new list and assign the random pointer for each
	duplicated node.
3.Restore the original list and extract the duplicated nodes.

The algorithm is implemented as follows:

class Solution{
    //Runtime: 0 ms, faster than 100.00%
    //Memory Usage: 36.9 MB, less than 99.59%
    public Node copyRandomList(Node head) {
        Node iter = head, next;

        // First round: make copy of each node,
        // and link them together side-by-side in a single list.
        while (iter != null) {
            next = iter.next;
            Node copy = new Node(iter.val);
            iter.next = copy;
            copy.next = next;
            iter = next;
        }

        // Second round: assign random pointers for the copy nodes.
        iter = head;
        while (iter != null) {
            if (iter.random != null) {
            iter.next.random = iter.random.next;
            }
        iter = iter.next.next;
        }

        // Third round: restore the original list, and extract the copy list.
        iter = head;
        Node pseudoHead = new Node(0);
        Node copy, copyIter = pseudoHead;

        while (iter != null) {
            next = iter.next.next;

            // extract the copy
            copy = iter.next;
            copyIter.next = copy;
            copyIter = copy;

            // restore the original list
            iter.next = next;
            iter = next;
        }
        return pseudoHead.next;
    }
}