LeetCode

Copy List with Random Pointer

2014.1.13 20:45

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.

Solution:

　　First of all, the problem description indicated that you have to return a deep copy of the linked list.

　　Here are the wikis for deep copy and shallow copy for your information.

　　My solution is to mark each list node with a number, which makes them easy to be numbered and identified.

　　Marking the nodes with numbers and recording the pointings between these numbers are like object serialization, while recontrcuting another identical list using these marked numbers is exactly the deserialization process.

　　Pointers are not persistent data, that's why you have to serialize them before making a deep copy. If you don't, you get a shallow copy instead.

　　Time complexity is O(n * log(n)), as stl <map> requires O(log(n)) time for each search and insert operation. Space complexity is O(n) using stl <map>.

　　If you replace stl <map> with <unordered_map>, you'll theoretically achieve O(n) time, but actually you get tiny improvement in performance. As <map> is not that slow and <unordered_map> not that fast too. Space usages are on the same level.

Accepted code:

// 1CE, 1RE, 2WA, 1AC, not easy~
#include <map>
using namespace std;
/**
 * Definition for singly-linked list with a random pointer.
 * struct RandomListNode {
 *     int label;
 *     RandomListNode *next, *random;
 *     RandomListNode(int x) : label(x), next(NULL), random(NULL) {}
 * };
 */
class Solution {
public:
    RandomListNode *copyRandomList(RandomListNode *head) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int n;
        
        if(nullptr == head){
            return nullptr;
        }
        
        n = 0;
        RandomListNode *ptr;
        
        mri.clear();
        mir.clear();
        
        ptr = head;
        while(ptr != nullptr){
            ++n;
            mri[ptr] = n;
            ptr = ptr->next;
        }
        
        RandomListNode *root = new RandomListNode(0), *tail;
        ptr = head;
        // 1CE here, undefined $i
        int i = 0;
        tail = root;
        while(ptr != nullptr){
            ++i;
            tail->next = new RandomListNode(ptr->label);
            tail = tail->next;
            mir[i] = tail;
            ptr = ptr->next;
        }
        
        RandomListNode *p1, *p2;
        
        p1 = head;
        p2 = root->next;
        while(p1 != nullptr){
            // 1RE here, mapping using nullptr doesn't work
            if(p1->random != nullptr){
                p2->random = mir[mri[p1->random]];
            }
            p1 = p1->next;
            // 2WA here, forgot to move $p2 forward
            p2 = p2->next;
        }
        
        head = root->next;
        delete root;
        mir.clear();
        mri.clear();
        
        return head;
    }
private:
    map<RandomListNode *, int> mri;
    map<int, RandomListNode *> mir;
};