Generic Template for Depth First Search (DFS) on a Graph

import java.util.*;

public class Graph {
    private int numVertices;
    private Map<Integer, List<Integer>> adjList;

    public Graph(int numVertices) {
        this.numVertices = numVertices;
        adjList = new HashMap<>();
        for (int i = 0; i < numVertices; i++) {
            adjList.put(i, new ArrayList<>());
        }
    }

    // Add an edge between vertices v and w
    public void addEdge(int v, int w) {
        adjList.get(v).add(w);
    }

    // DFS starting from vertex v
    public void DFS(int v) {
        boolean[] visited = new boolean[numVertices];
        DFSUtil(v, visited);
    }

    // Recursive utility function for DFS
    private void DFSUtil(int v, boolean[] visited) {
        // Mark the current node as visited and print it
        visited[v] = true;
        System.out.print(v + " ");

        // Visit all the adjacent vertices of the current node that are not visited
        for (int adjVertex : adjList.get(v)) {
            if (!visited[adjVertex]) {
                DFSUtil(adjVertex, visited);
            }
        }
    }

    public static void main(String[] args) {
        Graph g = new Graph(4); // create a graph with 4 vertices

        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("Depth First Traversal starting from vertex 2:");

        g.DFS(2);
    }
}

import java.util.*;

class Node {
    private String id;
    private String data;

    public Node(String id, String data) {
        this.id = id;
        this.data = data;
    }

    public String getId() {
        return id;
    }

    public String getData() {
        return data;
    }
}

public class Graph {
    private Map<Node, List<Node>> adjList;  // adjacency list representation of a graph

    public Graph() {
        adjList = new HashMap<>();
    }

    // Add a node to the graph
    public void addNode(Node node) {
        adjList.putIfAbsent(node, new ArrayList<>());
    }

    // Add an edge between nodes v and w
    public void addEdge(Node v, Node w) {
        adjList.get(v).add(w);
    }

    // DFS starting from node v
    public void DFS(Node startNode) {
        Set<Node> visited = new HashSet<>();
        DFSUtil(startNode, visited);
    }

    // Recursive utility function for DFS
    private void DFSUtil(Node current, Set<Node> visited) {
        // Mark the current node as visited and print it
        visited.add(current);
        System.out.print(current.getId() + " ");

        // Visit all the adjacent nodes of the current node that are not visited
        for (Node adjNode : adjList.get(current)) {
            if (!visited.contains(adjNode)) {
                DFSUtil(adjNode, visited);
            }
        }
    }

    public static void main(String[] args) {
        Graph g = new Graph();

        Node node0 = new Node("0", "data0");
        Node node1 = new Node("1", "data1");
        Node node2 = new Node("2", "data2");
        Node node3 = new Node("3", "data3");

        g.addNode(node0);
        g.addNode(node1);
        g.addNode(node2);
        g.addNode(node3);

        g.addEdge(node0, node1);
        g.addEdge(node0, node2);
        g.addEdge(node1, node2);
        g.addEdge(node2, node0);
        g.addEdge(node2, node3);
        g.addEdge(node3, node3);

        System.out.println("Depth First Traversal starting from node with ID 2:");
        g.DFS(node2);
    }
}