## What is Depth-first?

A depth-first search (DFS) algorithm is a type of traversal algorithm that is used to explore all the nodes of a graph or tree data structure. The algorithm starts at the root node (or any arbitrary node) and explores as far as possible along each branch before backtracking. In this tutorial, we will show you how to implement a DFS algorithm in Java.

- First, you will need to create a Graph class that represents the graph you want to traverse. This class should contain an array or list of nodes, and each node should have a list of its neighboring nodes.
- Next, create a DFS method that takes the starting node as an input. This method should use a stack to keep track of the nodes to visit. To begin, push the starting node onto the stack and mark it as visited.
- In a while loop, check if the stack is empty. If it is, the DFS is complete. If not, pop a node from the stack and visit it. For each unvisited neighboring node, push it onto the stack and mark it as visited.

```
public void DFS(Node start) {
Stack<Node> stack = new Stack<>();
stack.push(start);
while (!stack.isEmpty()) {
Node current = stack.pop();
current.visited = true;
System.out.println(current.value);
for (Node neighbor : current.neighbors) {
if (!neighbor.visited) {
stack.push(neighbor);
neighbor.visited = true;
}
}
}
}
```

- To traverse the graph completely, you will need to call the DFS method for every unvisited node. You can do this by adding a for loop that iterates through all the nodes and calls DFS on any node that hasn’t been visited.

```
public void traverse() {
for (Node node : nodes) {
if (!node.visited) {
DFS(node);
}
}
}
```

- Finally, you can test the DFS algorithm by creating a Graph object, adding nodes and edges, and calling the traverse() method.

```
Graph graph = new Graph();
Node a = new Node("A");
Node b = new Node("B");
Node c = new Node("C");
Node d = new Node("D");
graph.addEdge(a, b);
graph.addEdge(a, c);
graph.addEdge(b, d);
graph.traverse();
```

Keep in mind that this is a basic implementation of the DFS algorithm, there are many variations and optimizations that can be made to adapt it for specific use cases. Additionally, this example use a stack to keep track of the nodes to visit, but you can also implement DFS with recursion as well.