Copy List with Random Pointer - Practice Coding Problems

Copy List with Random Pointer - Problem

Imagine you have a special linked list where each node not only points to the next node, but also has a random pointer that can point to any node in the list (or be null). Your task is to create a deep copy of this entire structure.

A deep copy means creating completely new nodes with the same values, where:

Each new node's next pointer points to the corresponding new node
Each new node's random pointer points to the corresponding new node
No pointers in the new list should reference the original list

For example, if the original list has nodes X and Y where X.random → Y, then in your copied list with nodes x and y, we should have x.random → y.

Input: Head of the original linked list
Output: Head of the deep copied linked list

Note: The problem description shows the list as [val, random_index] pairs for clarity, but your function only receives the head node.

Input & Output

example_1.py — Basic Case

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

› Output: [[7,null],[13,0],[11,4],[10,2],[1,0]]

💡 Note: The copied list maintains the same structure: node 13 points to node 7 (index 0), node 11 points to node 1 (index 4), node 10 points to node 11 (index 2), and node 1 points to node 7 (index 0).

example_2.py — Two Node Case

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

› Output: [[1,1],[2,1]]

💡 Note: Both nodes point to the second node (index 1) as their random pointer. The copy preserves this relationship with new nodes.

example_3.py — Single Node

$ Input: head = [[1,null]]

› Output: [[1,null]]

💡 Note: A single node with no random pointer. The copy is simply a new node with the same value and null random pointer.

Visualization

Tap to expand

Understanding the Visualization

Encounter Original Node

When we meet an employee in the original office, we check if they have an ID card in the new office

Create Card On-Demand

If no card exists, we create one immediately with the same info

Link Relationships

Set up their direct report (next) and mentor (random) relationships using the same process

Complete Network

By the end, we have a complete duplicate organizational structure

Key Takeaway

🎯 Key Insight: Hash map provides instant mapping between original and copied nodes, enabling efficient deep copy in just one pass through the list.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the list, hash map operations are O(1) on average

✓ Linear Growth

Space Complexity

O(n)

Hash map stores mapping for all n nodes

⚡ Linearithmic Space

Constraints

0 ≤ n ≤ 1000
-10⁴ ≤ Node.val ≤ 10⁴
Node.random is null or is pointing to some node in the linked list
You must return the copy of the given head as a reference to the cloned list

Asked in

a Amazon 42 ⊞ Microsoft 38 G Google 35 f Meta 29 Apple 18

The optimal solution uses a hash map with lazy node creation in a single pass. As we traverse the original list, we create new nodes on-demand when they're first encountered. This elegant approach handles both next and random pointers seamlessly, achieving O(n) time and O(n) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table with Lazy Creation (Optimal)	O(n)	O(n)	Build hash map and set pointers in a single pass using lazy node creation
Brute Force (Find Random Node Each Time)	O(n²)	O(1)	Create all nodes first, then find each random pointer target by traversing the list
Two-Pass Hash Table	O(n)	O(n)	Build hash map of original→new node mappings first, then set all pointers

One-Pass Hash Table with Lazy Creation (Optimal) — Algorithm Steps

Create a helper function that returns existing node from map or creates new one if not found
Single pass: for each original node, get/create its copy and set both next and random pointers
The helper function handles lazy creation of nodes we haven't seen yet
Return the copy of the original head

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Node 7

Create clone(7), set next to clone(13) [created on demand], no random

Process Node 13

Clone(13) exists, set next to clone(11) [created on demand], set random to clone(11)

Process Node 11

Clone(11) exists, set next to null, set random to clone(1) [created on demand]

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int val;
    struct Node *next;
    struct Node *random;
};

// Hash map implementation
#define HASH_SIZE 10007

struct HashEntry {
    struct Node* original;
    struct Node* copy;
    struct HashEntry* next;
};

struct HashEntry* hashTable[HASH_SIZE];

unsigned int hash(struct Node* node) {
    return ((unsigned long)node) % HASH_SIZE;
}

struct Node* getClone(struct Node* node) {
    if (!node) return NULL;
    
    unsigned int index = hash(node);
    struct HashEntry* entry = hashTable[index];
    
    // Look for existing entry
    while (entry) {
        if (entry->original == node) {
            return entry->copy;
        }
        entry = entry->next;
    }
    
    // Create new entry
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->val = node->val;
    newNode->next = NULL;
    newNode->random = NULL;
    
    struct HashEntry* newEntry = (struct HashEntry*)malloc(sizeof(struct HashEntry));
    newEntry->original = node;
    newEntry->copy = newNode;
    newEntry->next = hashTable[index];
    hashTable[index] = newEntry;
    
    return newNode;
}

struct Node* copyRandomList(struct Node* head) {
    if (!head) return NULL;
    
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    
    struct Node* curr = head;
    while (curr) {
        struct Node* clone = getClone(curr);
        clone->next = getClone(curr->next);
        clone->random = getClone(curr->random);
        curr = curr->next;
    }
    
    return getClone(head);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the list, hash map operations are O(1) on average

✓ Linear Growth

Space Complexity

O(n)

Hash map stores mapping for all n nodes

⚡ Linearithmic Space

Constraints

0 ≤ n ≤ 1000
-10⁴ ≤ Node.val ≤ 10⁴
Node.random is null or is pointing to some node in the linked list
You must return the copy of the given head as a reference to the cloned list

127.4K Views

High Frequency

~18 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Table with Lazy Creation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler