**I just announced the new *** Learn Spring * course, focused on the fundamentals of Spring 5 and Spring Boot 2:

*Learn Spring*course, focused on the fundamentals of Spring 5 and Spring Boot 2:

**>> CHECK OUT THE COURSE**

Last modified: June 14, 2019

In this quick tutorial, we'll learn how we can** detect a cycle in a given directed graph.**

For this tutorial, we'll stick with the adjacency list graph representation.

Firstly, let's start by defining a *Vertex* in Java:

```
public class Vertex {
private String label;
private boolean beingVisited;
private boolean visited;
private List<Vertex> adjacencyList;
public Vertex(String label) {
this.label = label;
this.adjacencyList = new ArrayList<>();
}
public void addNeighbor(Vertex adjacent) {
this.adjacencyList.add(adjacent);
}
//getters and setters
}
```

**Here, the adjacencyList of a vertex v holds a list of all vertices adjacent to v.** The

We've also defined two *boolean* parameters,** beingVisited and visited, which represent whether the node is currently being visited or has already been visited.**

A graph can be thought of as a group of vertices or nodes connected through the edges.

So, let's now quickly represent a *Graph* in Java:

```
public class Graph {
private List<Vertex> vertices;
public Graph() {
this.vertices = new ArrayList<>();
}
public void addVertex(Vertex vertex) {
this.vertices.add(vertex);
}
public void addEdge(Vertex from, Vertex to) {
from.addNeighbor(to);
}
// ...
}
```

We'll use the *addVertex()* and* addEdge()* methods to add new vertices and edges in our graph.

To detect a cycle in a directed graph,** we'll use a variation of DFS traversal:**

- Pick up an unvisited vertex
*v*and mark its state as*beingVisited* - For each neighboring vertex
*u*of*v,*check:- If
*u*is already in the*beingVisited*state, it clearly means**there exists a backward edge and so a cycle has been detected** - If
*u*is yet in an unvisited state, we'll recursively visit*u*in a depth-first manner

- If
- Update the vertex
*v*‘s*beingVisited*flag to*false*and its*visited*flag to*true*

Note that** all the vertices of our graph are initially in an unvisited state as both their beingVisited and visited flags are initialized with false. **

Let's now look at our Java solution:

```
public boolean hasCycle(Vertex sourceVertex) {
sourceVertex.setBeingVisited(true);
for (Vertex neighbor : sourceVertex.getAdjacencyList()) {
if (neighbor.isBeingVisited()) {
// backward edge exists
return true;
} else if (!neighbor.isVisited() && hasCycle(neighbor)) {
return true;
}
}
sourceVertex.setBeingVisited(false);
sourceVertex.setVisited(true);
return false;
}
```

We can use any vertex in a graph to be the source or the starting vertex.

**For a disconnected graph, we'll have to add an additional wrapper method:**

```
public boolean hasCycle() {
for (Vertex vertex : vertices) {
if (!vertex.isVisited() && hasCycle(vertex)) {
return true;
}
}
return false;
}
```

This is to ensure that we visit every component of a disconnected graph for detecting a cycle.

Let's consider the below cyclic directed graph:

We can quickly write a JUnit to verify our *hasCycle()* method for this graph:

```
@Test
public void givenGraph_whenCycleExists_thenReturnTrue() {
Vertex vertexA = new Vertex("A");
Vertex vertexB = new Vertex("B");
Vertex vertexC = new Vertex("C")
Vertex vertexD = new Vertex("D");
Graph graph = new Graph();
graph.addVertex(vertexA);
graph.addVertex(vertexB);
graph.addVertex(vertexC);
graph.addVertex(vertexD);
graph.addEdge(vertexA, vertexB);
graph.addEdge(vertexB, vertexC);
graph.addEdge(vertexC, vertexA);
graph.addEdge(vertexD, vertexC);
assertTrue(graph.hasCycle());
}
```

Here, our *hasCycle()* method returned *true* denoting that our graph is cyclic.

In this tutorial, we learned how to check if a cycle exists in a given directed graph in Java.

As usual, the code implementation with examples is available over on Github.