[LeetCode] Copy List with Random Pointer

Well, since we need to make a deep copy of the list and nodes in the list have a random pointer that may point to any node in the list (or NULL), we need to maintain a mapping from each node in the origianl list to the node in the copy list. If the copy of a node already exists, just use that copy without copying it again; otherwise, create a new copy and add it to the mapping.

The following code is pretty straight-forward.

class Solution {
public:
    RandomListNode *copyRandomList(RandomListNode *head) {
        if (!head) return NULL;
        mp[head] = new RandomListNode(head -> label);
        RandomListNode* run = head;
        RandomListNode* temp = mp[head];
        while (run) {
            /* Process the next pointer */
            if (run -> next) {
                if (mp.find(run -> next) == mp.end())
                    mp[run -> next] = new RandomListNode(run -> next -> label);
                temp -> next = mp[run -> next];
            }
            /* Process the random pointer */
            if (run -> random) {
                if (mp.find(run -> random) == mp.end())
                    mp[run -> random] =  new RandomListNode(run -> random -> label);
                temp -> random = mp[run -> random];
            }
            run = run -> next;
            temp = temp -> next;
        }
        return mp[head];
    }
private:
    unordered_map<RandomListNode*, RandomListNode*> mp;
};

This code also has a very concise and easy-to-understand recursive solution as follows.

class Solution {
public:
    RandomListNode *copyRandomList(RandomListNode *head) {
        if (!head) return NULL;
        if (mp.find(head) != mp.end())
            return mp[head];
        RandomListNode* node = new RandomListNode(head -> label);
        mp[head] = node;
        node -> next = copyRandomList(head -> next);
        node -> random = copyRandomList(head -> random);
        return mp[head];
    }
private:
    unordered_map<RandomListNode*, RandomListNode*> mp;
};

This link has a clever solution using O(1) extra space, which is rewritten below in C++.

class Solution {
public:
    RandomListNode *copyRandomList(RandomListNode *head) {
        if (!head) return NULL;
        RandomListNode* run = head;
        /* Insert the copy of each node after it. */
        while (run) {
            RandomListNode* copy = new RandomListNode(run -> label);
            copy -> next = run -> next;
            run -> next = copy;
            run = run -> next -> next;
        }
        /* Set the random pointer for each copy. */
        run = head;
        while (run) {
            if (run -> random)
                run -> next -> random = run -> random -> next;
            run = run -> next -> next;
        }
        /* Extract the copy list. */
        RandomListNode* new_head = new RandomListNode(0);
        RandomListNode* new_run;
        run = head;
        new_head -> next = head -> next;
        while (run) {
            new_run = run -> next;
            run -> next = new_run -> next;
            if (run -> next)
                new_run -> next = new_run -> next -> next;
            run = run -> next;
        }
        return new_head -> next;
    }
};