Implementation of DFS using C language

CServer Side ProgrammingProgramming

Depth First Search (DFS) is an algorithm which traverses a graph and visits all nodes before coming back it can determine. Also, it determines whether a path exist between two nodes.

It searches a graph or tree in depth-wise manner.

Algorithm

Given below is an algorithm for the implementation of the Depth First Search (DFS) −

Step 1 − Initially stack is empty.

Step 2 − If a node to be visited is not present in the stack, then we push it onto the stack and mark it as visited.

Step 3 − Then, check if the current node matches our search criteria or not.

Step 3.1 − If it is there, then we are done.

Step 4 − Otherwise, we need to go to all the adjacent nodes from the current node.

Step 4.1 − Then visit all that types of nodes, in any random order, and keep searching.

Step 6 − We go to the previously visited node and pop the recent node from the stack.

Step 7 − The algorithm will terminate if all the nodes have been searched, or if we get our answer.

Program

Following is the C program for the implementation of the Depth First Search (DFS)

Live Demo

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MAX 5
void displayVertex(int);
void depthFirstSearch();
struct Vertex {
char label;
bool visited;
};
//stack variables
int stack[MAX];
int top = -1;
//graph variables
//array of vertices
struct Vertex* lstVertices[MAX];
//vertex count
int vertexCount = 0;
//stack functions
void push(int item) {
stack[++top] = item;
}
int pop() {
return stack[top--];
}
int peek() {
return stack[top];
}
bool isStackEmpty() {
}
//graph functions
//add vertex to the vertex list
struct Vertex* vertex = (struct Vertex*) malloc(sizeof(struct Vertex));
vertex->label = label;
vertex->visited = false;
lstVertices[vertexCount++] = vertex;
}
}
//display the vertex
void displayVertex(int vertexIndex) {
printf("%c ",lstVertices[vertexIndex]->label);
}
int i;
for(i = 0; i < vertexCount; i++) {
if(adjMatrix[vertexIndex][i] == 1 && lstVertices[i]->visited == false) {
return i;
}
}
return -1;
}
void depthFirstSearch() {
int i;
//mark first node as visited
lstVertices[0]->visited = true;
//display the vertex
displayVertex(0);
//push vertex index in stack
push(0);
while(!isStackEmpty()) {
//get the unvisited vertex of vertex which is at top of the stack
if(unvisitedVertex == -1) {
pop();
} else {
lstVertices[unvisitedVertex]->visited = true;
displayVertex(unvisitedVertex);
push(unvisitedVertex);
}
}
//stack is empty, search is complete, reset the visited flag
for(i = 0;i < vertexCount;i++) {
lstVertices[i]->visited = false;
}
}
int main() {
int i, j;
for(i = 0; i < MAX; i++) // set adjacency {
for(j = 0; j < MAX; j++) // matrix to 0
addEdge(0, 1); // S - A
addEdge(0, 2); // S - B
addEdge(0, 3); // S - C
addEdge(1, 4); // A - D
addEdge(2, 4); // B - D
addEdge(3, 4); // C - D
printf("Depth First Search: ");
depthFirstSearch();
return 0;
}

Output

When the above program is executed, it produces the following result −

Depth First Search: S A D B C
Published on 03-Sep-2021 06:37:28