138. Copy List with Random Pointer 133. Clone Graph

133:

/**
 * Definition for undirected graph.
 * struct UndirectedGraphNode {
 *     int label;
 *     vector<UndirectedGraphNode *> neighbors;
 *     UndirectedGraphNode(int x) : label(x) {};
 * };
 */
class Solution {
public:
    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
        if (node == NULL) {
            return node;
        }
        vector<UndirectedGraphNode *> nodes = find_all_nodes(node);
        unordered_map<UndirectedGraphNode *, UndirectedGraphNode *> map =
            copy_node(nodes);
        connect(map, nodes);
        return map[node];
    }
private:
    vector<UndirectedGraphNode *> find_all_nodes(UndirectedGraphNode *node) {
        vector<UndirectedGraphNode *> nodes;
        queue<UndirectedGraphNode *> q;
        set<UndirectedGraphNode *> s;
        q.push(node);
        s.insert(node);
        nodes.push_back(node);
        while (!q.empty()) {
            UndirectedGraphNode *node = q.front();
            q.pop();
            vector<UndirectedGraphNode *> neighbor_nodes = node->neighbors;
            for (int i = 0; i < neighbor_nodes.size(); i++) {
                UndirectedGraphNode * neighbor_node = neighbor_nodes[i];
                if (s.find(neighbor_node) != s.end()) {
                    continue;
                }
                q.push(neighbor_node);
                s.insert(neighbor_node);
                nodes.push_back(neighbor_node);
            }
        }
        return nodes;
    }
    unordered_map<UndirectedGraphNode *, UndirectedGraphNode *> copy_node(
        vector<UndirectedGraphNode *> nodes) {
        unordered_map<UndirectedGraphNode *, UndirectedGraphNode *> map;
        for (int i = 0; i < nodes.size(); i++) {
            map[nodes[i]] = new UndirectedGraphNode(nodes[i]->label);
        }
        return map;
    }
    void connect(unordered_map<UndirectedGraphNode *, UndirectedGraphNode *> map, 
                vector<UndirectedGraphNode *> nodes) {
        for (int i = 0; i < nodes.size(); i++) {
            UndirectedGraphNode *node = nodes[i];
            vector<UndirectedGraphNode *> neighbor_nodes = node->neighbors;
            vector<UndirectedGraphNode *> neighbor_nodes1 = map[node]->neighbors;
            for (int j = 0; j < neighbor_nodes.size(); j++) {
                UndirectedGraphNode *neighbor_node = neighbor_nodes[j];
                neighbor_nodes1.push_back(map[neighbor_node]);
            }
            map[node]->neighbors = neighbor_nodes1;
        }
    }
};

138:

/**
 * 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) {
        if (head == NULL) {
            return head;
        }
        unordered_map<RandomListNode *, RandomListNode *> map = copy_node(head);
        connect(head, map);
        return map[head];
    }
private:
    unordered_map<RandomListNode *, RandomListNode *> copy_node(RandomListNode* node) {
        unordered_map<RandomListNode *, RandomListNode *> map;
        while (node != NULL) {
            map[node] = new RandomListNode(node->label);
            node = node->next;
        }
        return map;
    }
    void connect(RandomListNode *node,
                unordered_map<RandomListNode *, RandomListNode *> map) {
        while (node != NULL) {
            map[node]->next = map[node->next];
            map[node]->random = map[node->random];
            node = node->next;
        }
    }
};