This Java program demonstrates how to perform Depth-First Search (DFS) traversal in a graph. DFS is used for exploring a graph in a way that it exhaustively searches all branches and backtracks when it reaches the end of a branch.

Java Code

import java.util.*;

class Graph {
    private int V;   // No. of vertices
    private LinkedList<Integer> adj[]; // Adjacency lists

    // Constructor
    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) {
        adj[v].add(w); // Add w to v's list.
    }

    // 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(int v) {
        // 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
        DFSUtil(v, visited);
    }
}

public class DFSDemo {
    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 " +
                           "(starting from vertex 2)");

        g.DFS(2);
    }
}

Explanation of the Code

The program is structured as follows:

• Graph Class: This class handles the graph’s representation and operations. The graph is represented using an adjacency list.
• addEdge Method: Adds a directed edge from vertex ‘v’ to vertex ‘w’.
• DFS Method: Initiates the DFS traversal from a given source node. This method uses recursive calls to explore all vertices deeply before backtracking.
• DFSUtil Method: A helper recursive function that marks a vertex as visited and then recurs for all vertices adjacent to the vertex that have not been visited yet.

This DFS implementation is crucial for algorithms that need to explore all possibilities such as puzzle solving, navigating through complex networks, and analyzing networks deeply.