Depth First Search or DFS for disconnected Graph Last Updated : 13 Jun, 2023 Summarize Comments Improve Suggest changes Share Like Article Like Report Given a Disconnected Graph, the task is to implement DFS or Depth First Search Algorithm for this Disconnected Graph. Example: Input: Disconnected Graph Output: 0 1 2 3 Algorithm for DFS on Disconnected Graph:In the post for Depth First Search for Graph, only the vertices reachable from a given source vertex can be visited. All the vertices may not be reachable from a given vertex, as in a Disconnected graph. This issue can be resolved by following the below idea: Iterate over all the vertices of the graph and for any unvisited vertex, run a DFS from that vertex. The recursive function in this case remains the same as in the previous post. Code Implementation of DFS for Disconnected Graph: C++ // C++ program to print DFS // traversal for a given graph #include <bits/stdc++.h> using namespace std; class Graph { // A function used by DFS void DFSUtil(int v); public: map<int, bool> visited; map<int, list<int> > adj; // Function to add an edge to graph void addEdge(int v, int w); // Prints DFS traversal of the complete graph void DFS(); }; void Graph::addEdge(int v, int w) { // Add w to v’s list. adj[v].push_back(w); } void Graph::DFSUtil(int v) { // Mark the current node as visited and print it visited[v] = true; cout << v << " "; // Recur for all the vertices adjacent to this vertex list<int>::iterator i; for (i = adj[v].begin(); i != adj[v].end(); ++i) if (!visited[*i]) DFSUtil(*i); } // The function to do DFS traversal. It uses recursive // DFSUtil() void Graph::DFS() { // Call the recursive helper function to print DFS // traversal starting from all vertices one by one for (auto i : adj) if (visited[i.first] == false) DFSUtil(i.first); } // Driver's Code int main() { // Create a graph given in the above diagram Graph g; g.addEdge(0, 1); g.addEdge(0, 2); g.addEdge(1, 2); g.addEdge(2, 0); g.addEdge(2, 3); g.addEdge(3, 3); cout << "Following is Depth First Traversal \n"; // Function call g.DFS(); return 0; } Java // Java program to print DFS // traversal from a given graph import java.io.*; import java.util.*; // This class represents a // directed graph using adjacency // list representation class Graph { private int V; // Array of lists for // Adjacency List Representation private LinkedList<Integer> adj[]; // Constructor @SuppressWarnings("unchecked") Graph(int v) { V = v; adj = new LinkedList[v]; for (int i = 0; i < v; ++i) adj[i] = new LinkedList(); } // Function to add an edge into the graph void addEdge(int v, int w) { // Add w to v's list. adj[v].add(w); } // A function used by DFS void DFSUtil(int v, boolean visited[]) { // Mark the current node as visited and print it visited[v] = true; System.out.print(v + " "); // Recur for all the vertices adjacent to this // vertex Iterator<Integer> i = adj[v].listIterator(); while (i.hasNext()) { int n = i.next(); if (!visited[n]) DFSUtil(n, visited); } } // The function to do DFS traversal. It uses recursive // DFSUtil() void DFS() { // Mark all the vertices as not visited(set as // false by default in java) boolean visited[] = new boolean[V]; // Call the recursive helper function to print DFS // traversal starting from all vertices one by one for (int i = 0; i < V; ++i) if (visited[i] == false) DFSUtil(i, visited); } // Driver's Code public static void main(String args[]) { Graph g = new Graph(4); g.addEdge(0, 1); g.addEdge(0, 2); g.addEdge(1, 2); g.addEdge(2, 0); g.addEdge(2, 3); g.addEdge(3, 3); System.out.println( "Following is Depth First Traversal"); // Function call g.DFS(); } } Python3 # Python3 program to print DFS traversal # for complete graph from collections import defaultdict # This class represents a directed graph # using adjacency list representation class Graph: # Constructor def __init__(self): # Default dictionary to store graph self.graph = defaultdict(list) # Function to add an edge to graph def addEdge(self, u, v): self.graph[u].append(v) # A function used by DFS def DFSUtil(self, v, visited): # Mark the current node as visited and print it visited.add(v) print(v, end=" ") # Recur for all the vertices # adjacent to this vertex for neighbour in self.graph[v]: if neighbour not in visited: self.DFSUtil(neighbour, visited) # The function to do DFS traversal. # It uses recursive DFSUtil def DFS(self): # Create a set to store all visited vertices visited = set() # Call the recursive helper function # to print DFS traversal starting from all # vertices one by one for vertex in self.graph: if vertex not in visited: self.DFSUtil(vertex, visited) # Driver's code if __name__ == "__main__": print("Following is Depth First Traversal") g = Graph() g.addEdge(0, 1) g.addEdge(0, 2) g.addEdge(1, 2) g.addEdge(2, 0) g.addEdge(2, 3) g.addEdge(3, 3) # Function call g.DFS() C# // C# program to print DFS // traversal from a given graph using System; using System.Collections.Generic; // This class represents a // directed graph using adjacency // list representation public class Graph { private int V; // Array of lists for // Adjacency List Representation private List<int>[] adj; // Constructor Graph(int v) { V = v; adj = new List<int>[ v ]; for (int i = 0; i < v; ++i) adj[i] = new List<int>(); } // Function to add an edge into the graph void addEdge(int v, int w) { // Add w to v's list. adj[v].Add(w); } // A function used by DFS void DFSUtil(int v, bool[] visited) { // Mark the current // node as visited and print it visited[v] = true; Console.Write(v + " "); // Recur for all the // vertices adjacent to this vertex foreach(int i in adj[v]) { int n = i; if (!visited[n]) DFSUtil(n, visited); } } // The function to do // DFS traversal. It uses recursive DFSUtil() void DFS() { // Mark all the vertices as not visited(set as // false by default in java) bool[] visited = new bool[V]; // Call the recursive helper // function to print DFS // traversal starting from // all vertices one by one for (int i = 0; i < V; ++i) if (visited[i] == false) DFSUtil(i, visited); } // Driver's code public static void Main(String[] args) { Graph g = new Graph(4); g.addEdge(0, 1); g.addEdge(0, 2); g.addEdge(1, 2); g.addEdge(2, 0); g.addEdge(2, 3); g.addEdge(3, 3); Console.WriteLine( "Following is Depth First Traversal"); // Function call g.DFS(); } } JavaScript // JavaScript program to print DFS // traversal from a given graph // This class represents a // directed graph using adjacency // list representation class Graph { // Constructor constructor(v) { this.V = v; this.adj = new Array(v).fill([]); } // Function to Add an edge into the graph AddEdge(v, w) { // Add w to v's list. this.adj[v].push(w); } // A function used by DFS DFSUtil(v, visited) { // Mark the current // node as visited and print it visited[v] = true; console.log(v + " "); // Recur for all the // vertices adjacent to this vertex for (const n of this.adj[v]) { if (!visited[n]) this.DFSUtil(n, visited); } } // The function to do // DFS traversal. It uses recursive DFSUtil() DFS() { // Mark all the vertices as not visited(set as var visited = new Array(this.V).fill(false); // Call the recursive helper // function to print DFS // traversal starting from // all vertices one by one for (var i = 0; i < this.V; ++i) if (visited[i] == false) this.DFSUtil(i, visited); } } // Driver Code var g = new Graph(4); g.AddEdge(0, 1); g.AddEdge(0, 2); g.AddEdge(1, 2); g.AddEdge(2, 0); g.AddEdge(2, 3); g.AddEdge(3, 3); console.log("Following is Depth First Traversal"); g.DFS(); OutputFollowing is Depth First Traversal 0 1 2 3 Time complexity: O(V + E), where V is the number of vertices and E is the number of edges in the graph.Auxiliary Space: O(V), since an extra visited array of size V is required. Comment More infoAdvertise with us Next Article Printing pre and post visited times in DFS of a graph A animeshdey Follow Improve Article Tags : Graph DSA DFS Practice Tags : DFSGraph Similar Reads Depth First Search or DFS for a Graph In Depth First Search (or DFS) for a graph, we traverse all adjacent vertices one by one. When we traverse an adjacent vertex, we completely finish the traversal of all vertices reachable through that adjacent vertex. This is similar to a tree, where we first completely traverse the left subtree and 13 min read DFS in different languageC Program for Depth First Search or DFS for a GraphDepth First Traversal (or DFS) for a graph is similar to Depth First Traversal of a tree. The only catch here is, that, unlike trees, graphs may contain cycles (a node may be visited twice). To avoid processing a node more than once, use a boolean visited array. A graph can have more than one DFS tr 4 min read Depth First Search or DFS for a Graph - PythonDepth First Traversal (or DFS) for a graph is similar to Depth First Traversal of a tree. The only catch here is, that, unlike trees, graphs may contain cycles (a node may be visited twice). To avoid processing a node more than once, use a Boolean visited array. A graph can have more than one DFS tr 4 min read Java Program for Depth First Search or DFS for a GraphDepth First Traversal (or DFS) for a graph is similar to Depth First Traversal of a tree. Prerequisite: Graph knowledge is important to understand the concept of DFS. What is DFS?DFS or Depth First Traversal is the traversing algorithm. DFS can be used to approach the elements of a Graph. To avoid p 3 min read Iterative Depth First Traversal of Graph Given a directed Graph, the task is to perform Depth First Search of the given graph.Note: Start DFS from node 0, and traverse the nodes in the same order as adjacency list.Note : There can be multiple DFS traversals of a graph according to the order in which we pick adjacent vertices. Here we pick 10 min read Applications, Advantages and Disadvantages of Depth First Search (DFS) Depth First Search is a widely used algorithm for traversing a graph. Here we have discussed some applications, advantages, and disadvantages of the algorithm. Applications of Depth First Search:1. Detecting cycle in a graph: A graph has a cycle if and only if we see a back edge during DFS. So we ca 4 min read Difference between BFS and DFS Breadth-First Search (BFS) and Depth-First Search (DFS) are two fundamental algorithms used for traversing or searching graphs and trees. This article covers the basic difference between Breadth-First Search and Depth-First Search.Difference between BFS and DFSParametersBFSDFSStands forBFS stands fo 2 min read Depth First Search or DFS for disconnected Graph Given a Disconnected Graph, the task is to implement DFS or Depth First Search Algorithm for this Disconnected Graph. Example: Input: Disconnected Graph Output: 0 1 2 3 Algorithm for DFS on Disconnected Graph:In the post for Depth First Search for Graph, only the vertices reachable from a given sour 7 min read Printing pre and post visited times in DFS of a graph Depth First Search (DFS) marks all the vertices of a graph as visited. So for making DFS useful, some additional information can also be stored. For instance, the order in which the vertices are visited while running DFS. Pre-visit and Post-visit numbers are the extra information that can be stored 8 min read Tree, Back, Edge and Cross Edges in DFS of Graph Given a directed graph, the task is to identify tree, forward, back and cross edges present in the graph.Note: There can be multiple answers.Example:Input: GraphOutput:Tree Edges: 1->2, 2->4, 4->6, 1->3, 3->5, 5->7, 5->8 Forward Edges: 1->8 Back Edges: 6->2 Cross Edges: 5- 9 min read Transitive Closure of a Graph using DFS Given a directed graph, find out if a vertex v is reachable from another vertex u for all vertex pairs (u, v) in the given graph. Here reachable means that there is a path from vertex u to v. The reach-ability matrix is called transitive closure of a graph. For example, consider below graph: GraphTr 8 min read Variations of DFS implementationsImplementation of DFS using adjacency matrixDepth First Search (DFS) has been discussed in this article which uses adjacency list for the graph representation. In this article, adjacency matrix will be used to represent the graph.Adjacency matrix representation: In adjacency matrix representation of a graph, the matrix mat[][] of size n*n (wh 8 min read Graph implementation using STL for competitive programming | Set 1 (DFS of Unweighted and Undirected)We have introduced Graph basics in Graph and its representations. In this post, a different STL-based representation is used that can be helpful to quickly implement graphs using vectors. The implementation is for the adjacency list representation of the graph. Following is an example undirected and 7 min read Graph implementation using STL for competitive programming | Set 2 (Weighted graph)In Set 1, unweighted graph is discussed. In this post, weighted graph representation using STL is discussed. The implementation is for adjacency list representation of weighted graph. Undirected Weighted Graph We use two STL containers to represent graph: vector : A sequence container. Here we use i 7 min read Like