Clone Graph - Practice Coding Problems

Clone Graph - Problem

You're given a reference to a node in a connected undirected graph. Your task is to create a complete deep copy (clone) of the entire graph.

Each node in the graph contains:

An integer val (the node's value)
A List<Node> of its neighbors

The graph is connected, meaning you can reach any node from any other node. You need to return a reference to the cloned version of the given node.

Important: The cloned graph should be completely independent of the original - modifying the clone shouldn't affect the original graph.

Node Definition:

class Node {
    public int val;
    public List<Node> neighbors;
}

Input & Output

example_1.py — Simple 2-node cycle

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

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

💡 Note: The graph has 2 nodes. Node 1 is connected to node 2, and node 2 is connected to node 1. The cloned graph maintains the same structure.

example_2.py — 4-node complex graph

$ Input: adjList = [[2,4],[1,3],[2,4],[1,3]]

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

💡 Note: Node 1 connects to nodes 2 and 4. Node 2 connects to nodes 1 and 3. Node 3 connects to nodes 2 and 4. Node 4 connects to nodes 1 and 3. The clone preserves all connections.

example_3.py — Single node

$ Input: adjList = [[]]

› Output: [[]]

💡 Note: The graph contains only one node with no neighbors. The cloned graph is identical.

Visualization

Tap to expand

Understanding the Visualization

Start with Original

Begin with a reference to one node in the original graph

Create Clone Map

Use a HashMap to track which nodes have been cloned

BFS Traversal

Visit nodes level by level, cloning unvisited neighbors

Connect Clones

Link cloned nodes together maintaining original relationships

Return Clone

Return reference to the cloned starting node

Key Takeaway

🎯 Key Insight: HashMap prevents infinite loops while BFS ensures systematic traversal. Each original node maps to exactly one clone, preserving the graph's structure perfectly.

Time & Space Complexity

Time Complexity

⏱️

O(N + M)

Visit each node once (N) and process each edge once (M)

✓ Linear Growth

Space Complexity

O(N)

HashMap stores N node mappings plus queue can hold up to N nodes

✓ Linear Space

Constraints

The number of nodes in the graph is in the range [0, 100]
1 ≤ Node.val ≤ 100
Node.val is unique for each node
There are no repeated edges and no self-loops in the graph
The graph is connected and you can visit all nodes from the given node

Asked in

f Meta 45 G Google 38 a Amazon 32 ⊞ Microsoft 28 Apple 15

The optimal solution uses BFS with HashMap to clone the graph. We maintain a mapping from original nodes to their clones to avoid infinite loops and duplicate nodes. Time: O(N + M) where N is nodes and M is edges. Space: O(N) for the HashMap and queue.

Common Approaches

Approach	Time	Space	Notes
✓ BFS with HashMap (Optimal)	O(N + M)	O(N)	Use BFS traversal with HashMap for iterative, level-by-level cloning
DFS with HashMap	O(N + M)	O(N)	Use DFS traversal with a visited map to avoid infinite recursion

BFS with HashMap (Optimal) — Algorithm Steps

Create a HashMap to store original → clone mappings
Create a queue for BFS traversal, starting with the given node
Create clone of starting node and add to HashMap
While queue is not empty, process each node:
For each neighbor, create clone if not exists, then connect to current clone

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create clone of starting node, add to queue

Process Level 1

Process starting node, clone its unvisited neighbors

Process Level 2

Process neighbors from queue, connect to their neighbors

Complete

All nodes processed level by level

Code -

solution.c — C

struct Node* cloneGraph(struct Node* node) {
    if (!node) return NULL;
    
    // Simple array-based mapping (assuming node values 1-100)
    struct Node* visited[101] = {NULL};
    
    // Create clone of starting node
    visited[node->val] = malloc(sizeof(struct Node));
    visited[node->val]->val = node->val;
    visited[node->val]->numNeighbors = 0;
    
    // BFS queue (simple array implementation)
    struct Node* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = node;
    
    while (front < rear) {
        struct Node* current = queue[front++];
        
        // Process all neighbors
        for (int i = 0; i < current->numNeighbors; i++) {
            struct Node* neighbor = current->neighbors[i];
            
            if (visited[neighbor->val] == NULL) {
                // Create clone for unvisited neighbor
                visited[neighbor->val] = malloc(sizeof(struct Node));
                visited[neighbor->val]->val = neighbor->val;
                visited[neighbor->val]->numNeighbors = 0;
                queue[rear++] = neighbor;
            }
            
            // Connect current clone to neighbor clone
            visited[current->val]->neighbors[visited[current->val]->numNeighbors++] = visited[neighbor->val];
        }
    }
    
    return visited[node->val];
}

Time & Space Complexity

Time Complexity

⏱️

O(N + M)

Visit each node once (N) and process each edge once (M)

✓ Linear Growth

Space Complexity

O(N)

HashMap stores N node mappings plus queue can hold up to N nodes

✓ Linear Space

Constraints

The number of nodes in the graph is in the range [0, 100]
1 ≤ Node.val ≤ 100
Node.val is unique for each node
There are no repeated edges and no self-loops in the graph
The graph is connected and you can visit all nodes from the given node

89.2K Views

High Frequency

~25 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

BFS with HashMap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler