DFS Implementation in Java

1. Recursive Approach

import java.util.*;
class Graph {
private int vertices; // Number of vertices
private LinkedList<Integer> adjList[]; // Adjacency list
// Constructor
Graph(int v) {
vertices = v;
adjList = new LinkedList[v];
for (int i = 0; i < v; i++) {
adjList[i] = new LinkedList<>();
}
}
// Add edge to the graph
void addEdge(int v, int w) {
adjList[v].add(w); // Add w to v's list
}
// Recursive DFS method
void DFSUtil(int v, boolean visited[]) {
visited[v] = true; // Mark the current node as visited
System.out.print(v + " "); // Print the node
// Recur for all the vertices adjacent to this vertex
for (Integer neighbor : adjList[v]) {
if (!visited[neighbor]) {
DFSUtil(neighbor, visited);
}
}
}
// The function to do DFS traversal
void DFS(int start) {
boolean visited[] = new boolean[vertices]; // Mark all the vertices as not visited
DFSUtil(start, visited); // Call the recursive helper function
}
}
// Example usage
public class Main {
public static void main(String args[]) {
Graph g = new Graph(5); // Create a graph with 5 vertices
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 3);
g.addEdge(1, 4);
g.addEdge(2, 4);
System.out.println("Depth First Traversal starting from vertex 0:");
g.DFS(0); // Start DFS from vertex 0
}
}

2. Iterative Approach

import java.util.*;
class Graph {
private int vertices; // Number of vertices
private LinkedList<Integer> adjList[]; // Adjacency list
// Constructor
Graph(int v) {
vertices = v;
adjList = new LinkedList[v];
for (int i = 0; i < v; i++) {
adjList[i] = new LinkedList<>();
}
}
// Add edge to the graph
void addEdge(int v, int w) {
adjList[v].add(w); // Add w to v's list
}
// Iterative DFS method
void DFSIterative(int start) {
boolean visited[] = new boolean[vertices]; // Mark all the vertices as not visited
Stack<Integer> stack = new Stack<>(); // Create a stack for DFS
stack.push(start); // Push the starting vertex
while (!stack.isEmpty()) {
int v = stack.pop(); // Get the top vertex
if (!visited[v]) {
visited[v] = true; // Mark it as visited
System.out.print(v + " "); // Print the vertex
}
// Push all unvisited adjacent vertices to the stack
for (Integer neighbor : adjList[v]) {
if (!visited[neighbor]) {
stack.push(neighbor);
}
}
}
}
}
// Example usage
public class Main {
public static void main(String args[]) {
Graph g = new Graph(5); // Create a graph with 5 vertices
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 3);
g.addEdge(1, 4);
g.addEdge(2, 4);
System.out.println("Depth First Traversal (Iterative) starting from vertex 0:");
g.DFSIterative(0); // Start DFS from vertex 0
}
}

Explanation

• Graph Representation: The graph is represented using an adjacency list.
• DFS Methods: The DFSUtil method is used for the recursive approach, while the DFSIterative method implements the iterative approach using a stack.
• Example Usage: The main method demonstrates how to create a graph, add edges, and perform DFS starting from a specified vertex.
  This code provides a clear and functional implementation of the DFS algorithm in Java, suitable for both educational and practical purposes. For more details, you can refer to the sources from GeeksforGeeks and Programiz.

  2
• 2 Sources

  2