Implementation of DFS using C language

Depth First Search (DFS) is an algorithm that traverses a graph, visiting all nodes before backtracking. It can also determine whether a path exists between two nodes. DFS begins at the root node and explores as far as possible along each branch before backtracking. DFS searches a graph or tree in a 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 already in the stack, we push it onto the stack and mark it as visited.

• Step 3 ? Next, check whether the current node matches our search criteria.

• Step 3.1 ? If it is present, then our task is done.

• Step 4 ? Otherwise, we need to visit all the adjacent nodes of the current node.

• Step 4.1 ? Then visit all such nodes in any random order and continue searching.

• Step 5 ? If all adjacent nodes have been visited, it becomes a dead end.

• Step 6 ? We return to the previously visited node and pop the most recent node from the stack.

• Step 7 ? The algorithm will terminate when all nodes have been searched or the desired result is found.

Depth First Search (DFS)

Here is a C program for implementing Depth First Search(DFS). This program uses a stack to traverse a graph, adding edges and vertices, marking the nodes and displaying them.

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

#define MAX 5

void addVertex(char);
void addEdge(int, int);
void displayVertex(int);
void depthFirstSearch();
int getAdjUnvisitedVertex(int);

struct Vertex {
   char label;
   bool visited;
};

// stack variables
int stack[MAX];
int top = -1;

// graph variables
// array of vertices
struct Vertex* lstVertices[MAX];
// adjacency matrix
int adjMatrix[MAX][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() { return top == -1; }

// graph functions
// add vertex to the vertex list
void addVertex(char label) {
   struct Vertex* vertex = (struct Vertex*)malloc(sizeof(struct Vertex));
   vertex->label = label;
   vertex->visited = false;
   lstVertices[vertexCount++] = vertex;
}

// add edge to edge array
void addEdge(int start, int end) {
   adjMatrix[start][end] = 1;
   adjMatrix[end][start] = 1;
}

// display the vertex
void displayVertex(int vertexIndex) {
   printf("%c ", lstVertices[vertexIndex]->label);
}

// get the adjacent unvisited vertex
int getAdjUnvisitedVertex(int vertexIndex) {
   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
      int unvisitedVertex = getAdjUnvisitedVertex(peek());
      // no adjacent vertex found
      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
         adjMatrix[i][j] = 0;

   addVertex('S');  // 0
   addVertex('A');  // 1
   addVertex('B');  // 2
   addVertex('C');  // 3
   addVertex('D');  // 4

   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