Last updated on October 5th, 2024 at 05:28 pm

Here, We see ** Clone Graph LeetCode Solution**. This Leetcode problem is done in many programming languages like C++, Java, JavaScript, Python, etc. with different approaches.

*List of all LeetCode Solution*

*List of all LeetCode Solution*

## Topics

Breadth-First Search, Depth-First Search, Graph

## Companies

Facebook, Google, Uber, Pocketgems

## Level of Question

Medium

**Clone Graph LeetCode Solution**

## Table of Contents

**Problem Statement**

Given a reference of a node in a **connected** undirected graph.

Return a **deep copy** (clone) of the graph.

Each node in the graph contains a value (`int`

) and a list (`List[Node]`

) of its neighbors.class Node { public int val; public List<Node> neighbors; }

**Test case format:**

For simplicity, each node’s value is the same as the node’s index (1-indexed). For example, the first node with `val == 1`

, the second node with `val == 2`

, and so on. The graph is represented in the test case using an adjacency list.

**An adjacency list** is a collection of unordered **lists** used to represent a finite graph. Each list describes the set of neighbors of a node in the graph.

The given node will always be the first node with `val = 1`

. You must return the **copy of the given node** as a reference to the cloned graph.

**Example 1:**

**Input:** adjList = [[2,4],[1,3],[2,4],[1,3]] **Output:** [[2,4],[1,3],[2,4],[1,3]] **Explanation:**

There are 4 nodes in the graph.

1st node (val = 1)’s neighbors are 2nd node (val = 2) and 4th node (val = 4).

2nd node (val = 2)’s neighbors are 1st node (val = 1) and 3rd node (val = 3).

3rd node (val = 3)’s neighbors are 2nd node (val = 2) and 4th node (val = 4).

4th node (val = 4)’s neighbors are 1st node (val = 1) and 3rd node (val = 3).

**Example 2:**

**Input:** adjList = [[]] **Output:** [[]] **Explanation:** Note that the input contains one empty list. The graph consists of only one node with val = 1 and it does not have any neighbors.

**Example 3:****Input:** adjList = [] **Output:** [] **Explanation:** This an empty graph, it does not have any nodes.

**1. Clone Graph LeetCode Solution C++**

class Solution { public: Node* dfs(Node* cur,unordered_map<Node*,Node*>& mp) { vector<Node*> neighbour; Node* clone=new Node(cur->val); mp[cur]=clone; for(auto it:cur->neighbors) { if(mp.find(it)!=mp.end()) { neighbour.push_back(mp[it]); } else neighbour.push_back(dfs(it,mp)); } clone->neighbors=neighbour; return clone; } Node* cloneGraph(Node* node) { unordered_map<Node*,Node*> mp; if(node==NULL) return NULL; if(node->neighbors.size()==0) { Node* clone= new Node(node->val); return clone; } return dfs(node,mp); } };

**2. Clone Graph LeetCode Solution Java**

class Solution { public Node cloneGraph(Node node) { if (node == null) { return null; } Map<Node, Node> visited = new HashMap<>(); return cloneGraphHelper(node, visited); } private Node cloneGraphHelper(Node node, Map<Node, Node> visited) { Node copy = new Node(node.val); visited.put(node, copy); for (Node neighbor : node.neighbors) { if (visited.containsKey(neighbor)) { copy.neighbors.add(visited.get(neighbor)); } else { Node neighborCopy = cloneGraphHelper(neighbor, visited); copy.neighbors.add(neighborCopy); } } return copy; } }

**3. Clone Graph LeetCode Solution JavaScript**

var cloneGraph = function(node) { let start = node; if (start === null) return null; const vertexMap = new Map(); const queue = [start] vertexMap.set(start, new Node(start.val)); while (queue.length > 0) { const currentVertex = queue.shift(); for (const neighbor of currentVertex.neighbors) { if (!vertexMap.has(neighbor)) { vertexMap.set(neighbor, new Node(neighbor.val)) queue.push(neighbor); } vertexMap.get(currentVertex).neighbors.push(vertexMap.get(neighbor)); } } return vertexMap.get(start); };

**4. Clone Graph Solution Python**

class Solution(object): def cloneGraph(self, node): if not node: return None cloned = {} stack = [node] cloned[node] = Node(node.val) while stack: curr = stack.pop() for neighbor in curr.neighbors: if neighbor not in cloned: cloned[neighbor] = Node(neighbor.val) stack.append(neighbor) cloned[curr].neighbors.append(cloned[neighbor]) return cloned[node]