## Tuesday, May 3, 2022

### Question 86 : Write algorithm to do depth first search in a graph

Graph traversal Algorithms

2. Depth-first search in java

In DFS,  You start with an un-visited node and start picking an adjacent node, until you have no choice, then you backtrack until you have another choice to pick a node, if not, you select another un-visited node.

DFS can be implemented in two ways.

• Recursive
• Iterative

### Iterative

Depth-first search can be implemented using an iterative approach.
Let's see with the help of an example:

We start with node 40. It then visits node 20, node 50, and node 70 respectively as they are directly connected. After that, it backtracks to node 20 and visits node 60, node 30, and node 10 respectively.

`````` // Iterative DFS using stack
public  void dfsUsingStack(Node node)
{
Stack<Node> stack=new  Stack<Node>();
while (!stack.isEmpty())
{
Node element=stack.pop();
if(!element.visited)
{
System.out.print(element.data + " ");
element.visited=true;
}

List<Node> neighbours=element.getNeighbours();
for (int i = 0; i < neighbours.size(); i++) {
Node n=neighbours.get(i);
if(n!=null && !n.visited)
{
}
}
}
}
``````

### Recursive

Depth-first search can be implemented using recursion too. We do not need to maintain an external stack, it will be taken care by recursion.

``````// Recursive DFS
public  void dfs(Node node)
{
System.out.print(node.data + " ");
List neighbours=node.getNeighbours();
node.visited=true;
for (int i = 0; i < neighbours.size(); i++) {
Node n=neighbours.get(i);
if(n!=null && !n.visited)
{
dfs(n);
}
}
}``````

## Java DFS Example

There are two ways to represent a graph.

• Using Neighbours list

### Using Neighbours list

In this, you can have List<Node> as neighbors in the Node class as below.

``````static class Node
{
int data;
boolean visited;
List<Node> neighbours;

Node(int data)
{
this.data=data;
this.neighbours=new ArrayList<>();

}
{
}
public List getNeighbours() {
return neighbours;
}
public void setNeighbours(List neighbours) {
this.neighbours = neighbours;
}
}``````

Here is the complete java program for DFS implementation for iterative as well as recursive methods.

``````import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class DepthFirstSearchExampleNeighbourList
{

static class Node
{
int data;
boolean visited;
List<Node> neighbours;

Node(int data)
{
this.data=data;
this.neighbours=new ArrayList<>();

}
{
}
public List<Node> getNeighbours() {
return neighbours;
}
public void setNeighbours(List<Node> neighbours) {
this.neighbours = neighbours;
}
}

// Recursive DFS
public  void dfs(Node node)
{
System.out.print(node.data + " ");
List<Node> neighbours=node.getNeighbours();
node.visited=true;
for (int i = 0; i < neighbours.size(); i++) {
Node n=neighbours.get(i);
if(n!=null && !n.visited)
{
dfs(n);
}
}
}

// Iterative DFS using stack
public  void dfsUsingStack(Node node)
{
Stack<Node> stack=new  Stack<Node>();
while (!stack.isEmpty())
{
Node element=stack.pop();
if(!element.visited)
{
System.out.print(element.data + " ");
element.visited=true;
}

List<Node> neighbours=element.getNeighbours();
for (int i = 0; i < neighbours.size(); i++) {
Node n=neighbours.get(i);
if(n!=null && !n.visited)
{
}
}
}
}

public static void main(String arg[])
{

Node node40 =new Node(40);
Node node10 =new Node(10);
Node node20 =new Node(20);
Node node30 =new Node(30);
Node node60 =new Node(60);
Node node50 =new Node(50);
Node node70 =new Node(70);

DepthFirstSearchExampleNeighbourList dfsExample = new DepthFirstSearchExampleNeighbourList();

System.out.println("The DFS traversal of the graph using stack ");
dfsExample.dfsUsingStack(node40);

System.out.println();

// Resetting the visited flag for nodes
node40.visited=false;
node10.visited=false;
node20.visited=false;
node30.visited=false;
node60.visited=false;
node50.visited=false;
node70.visited=false;

System.out.println("The DFS traversal of the graph using recursion ");
dfsExample.dfs(node40);
}
}
``````

When you run the above program, you will get below output

``````The DFS traversal of the graph using stack
40 20 50 70 60 30 10
The DFS traversal of the graph using recursion
40 10 30 60 70 20 50``````

Adjacency_matrix is used to find the connection between two nodes.

if adjacency_matrix[i][j]==1, then nodes at index i and index j are connected

``````import java.util.ArrayList;
import java.util.Stack;

public class DepthFirstSearchExample
{

static ArrayList<Node> nodes=new ArrayList<>();
static class Node
{
int data;
boolean visited;

Node(int data)
{
this.data=data;

}
}

// find neighbors of node using adjacency matrix
// if adjacency_matrix[i][j]==1, then nodes at index i and index j are connected
{
int nodeIndex=-1;

ArrayList<Node> neighbours=new ArrayList<>();
for (int i = 0; i < nodes.size(); i++) {
if(nodes.get(i).equals(x))
{
nodeIndex=i;
break;
}
}

if(nodeIndex!=-1)
{
for (int j = 0; j < adjacency_matrix[nodeIndex].length; j++) {
{
}
}
}
return neighbours;
}

// Recursive DFS
public  void dfs(int adjacency_matrix[][], Node node)
{

System.out.print(node.data + " ");
node.visited=true;
for (int i = 0; i < neighbours.size(); i++) {
Node n=neighbours.get(i);
if(n!=null && !n.visited)
{
}
}
}

// Iterative DFS using stack
public  void dfsUsingStack(int adjacency_matrix[][], Node node)
{
Stack<Node> stack=new  Stack<>();

while (!stack.isEmpty())
{
Node element=stack.pop();
if(!element.visited)
{
System.out.print(element.data + " ");
element.visited=true;
}

for (int i = 0; i < neighbours.size(); i++) {
Node n=neighbours.get(i);
if(n!=null &&!n.visited)
{
}
}
}
}

public static void main(String arg[])
{

Node node40 =new Node(40);
Node node10 =new Node(10);
Node node20 =new Node(20);
Node node30 =new Node(30);
Node node60 =new Node(60);
Node node50 =new Node(50);
Node node70 =new Node(70);

{0,1,1,0,0,0,0},  // Node 1: 40
{0,0,0,1,0,0,0},  // Node 2 :10
{0,1,0,1,1,1,0},  // Node 3: 20
{0,0,0,0,1,0,0},  // Node 4: 30
{0,0,0,0,0,0,1},  // Node 5: 60
{0,0,0,0,0,0,1},  // Node 6: 50
{0,0,0,0,0,0,0},  // Node 7: 70
};

DepthFirstSearchExample dfsExample = new DepthFirstSearchExample();

System.out.println("The DFS traversal of the graph using stack ");

System.out.println();

clearVisitedFlags();

System.out.println("The DFS traversal of the graph using recursion ");

}

public static void clearVisitedFlags()
{
for (int i = 0; i < nodes.size(); i++) {
nodes.get(i).visited=false;
}
}
}``````
When you run the above program, you will get below output
``The DFS traversal of the graph using stack40 20 50 70 60 30 10The DFS traversal of the graph using recursion40 10 30 60 70 20 50``

Don't miss the next article!
Be the first to be notified when a new article or Kubernetes experiment is published.