138. Copy List with Random Pointer

https://leetcode.com/problems/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.

The Linked List is represented in the input/output as a list of n nodes. Each node is represented as a pair of [val, random_index] where:

• val: an integer representing Node.val

• random_index: the index of the node (range from 0 to n-1) where random pointer points to, or null if it does not point to any node.

Example 1:

Input: head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
Output: [[7,null],[13,0],[11,4],[10,2],[1,0]]

Example 2:

Input: head = [[1,1],[2,1]]
Output: [[1,1],[2,1]]

Example 3:

Input: head = [[3,null],[3,0],[3,null]]
Output: [[3,null],[3,0],[3,null]]

Example 4:

Input: head = []
Output: []
Explanation: Given linked list is empty (null pointer), so return null.

Constraints:

• -10000 <= Node.val <= 10000

• Node.random is null or pointing to a node in the linked list.

• The number of nodes will not exceed 1000.

• you should restore the original linked list

Solution

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
public:
    Node* copyRandomList(Node *const head) {
        if (head == nullptr) return head;
        Node *current = head;
        while (current != nullptr) {
            Node *node = new Node(current->val);
            node->next = current->next;
            node->random = current->random;
            current->next = node;
            current = current->next->next;
        }
        Node *const new_head = head->next;
        Node *original = head;
        current = new_head;
        while (current->next != nullptr && current->next->next != nullptr) {
            if (current->random) current->random = current->random->next;
            current = current->next->next;
        }
        if (current->random) current->random = current->random->next;
        
        current = new_head;
        while (current->next != nullptr && current->next->next != nullptr) {
            original->next = current->next;
            current->next = current->next->next;
            current = current->next;
            original = original->next;
        }
        current->next = nullptr;
        original->next = nullptr;
        return new_head;
    }
};

• #linkedlist