Using a DFS to compute distance from source node - c

Question

I am trying to use a DFS algorithm to calculate the distance from a source node for each node. Currently it outputs a distance of 0 for the source vertex but 1 for all the other vertices, even though there should be a couple with a distance of 2. The printf in the DFS does print out the right order, with the source first then the vertices with distance 1 and then distance 2. So where in the algorithm would I need to put the distance increase.
void dfs(int vertex1) {
graph[vertex1-1].visited = 1;
printf("%d \n",vertex1);
struct edge *e;
e = graph[vertex1-1].edgePtr;
while (e) {
if (!(graph[e->vertexIndex - 1].visited)){
graph[e->vertexIndex - 1].distance++;
dfs(e->vertexIndex);
}
e = e->edgePtr;
}
}

Answer 1

I think I have figured out a way to make the DFS calculate the distance and it is correct except the last vertex found it says that the distance is 3 instead of 2.
5
(2,3)
(1,4)
(1,3)
(3,4)
(4,5)
#include <stdio.h>
#include <stdlib.h>
#include "../HW3/input_error.h"
#define VertexToSearch 1
typedef struct edge {
int vertexIndex;
struct edge *edgePtr;
} edge;
typedef struct vertex {
int vertexKey;
struct edge *edgePtr;
int visited;
int distance;
} vertex;
int vertexCount = 0;
struct vertex graph[];
void load_file(char*);
void insertEdge(int, int, struct vertex[]);
void InsertVertex(int, struct vertex[]);
void printGraph();
void dfs();
void print_distances();
enum error program_error;
int count;
int main(int argc, char** argv) {
load_file(argv[1]);
printGraph();
dfs(VertexToSearch);
print_distances();
return 0;
}
void load_file(char* filename) {
int vertex1;
int vertex2;
FILE* file = fopen(filename, "r");
if (file == NULL) {
printf("%s did not open\n", filename);
program_error = FILE_FAILED_TO_OPEN;
exit(program_error);
}
fscanf(file, "%d", &count);
graph[count];
for (int i = 0; i < count; i++) {
InsertVertex(i+1, graph);
}
for (int i = 0; i < count; i++) {
fscanf(file, "\n(%d,%d)", &vertex1, &vertex2);
insertEdge(vertex1, vertex2, graph);
}
fclose(file);
}
void InsertVertex(int vertexKey, struct vertex graph[]) {
graph[vertexCount].vertexKey = vertexKey;
graph[vertexCount].edgePtr = NULL;
graph[vertexCount].visited = 0;
graph[vertexCount].distance = 0;
vertexCount++;
}
void insertEdge(int vertex1, int vertex2, struct vertex graph[]) {
struct edge *e, *e1, *e2;
e = graph[vertex1 - 1].edgePtr;
while (e && e->edgePtr) {
e = e->edgePtr;
}
e1 = (struct edge *) malloc(sizeof (*e1));
e1->vertexIndex = vertex2;
e1->edgePtr = NULL;
if (e)
e->edgePtr = e1;
else
graph[vertex1 - 1].edgePtr = e1;
e = graph[vertex2 - 1].edgePtr;
while (e && e->edgePtr) {
e = e->edgePtr;
}
e2 = (struct edge *) malloc(sizeof (*e2));
e2->vertexIndex = vertex1;
e2->edgePtr = NULL;
if (e)
e->edgePtr = e2;
else
graph[vertex2 - 1].edgePtr = e2;
}
void printGraph() {
int i;
struct edge *e;
for (i = 0; i < vertexCount; i++) {
printf("%d(%d)", i+1, graph[i].vertexKey);
e = graph[i].edgePtr;
while (e) {
printf("->%d", e->vertexIndex);
e = e->edgePtr;
}
printf("\n");
}
}
void dfs(int vertex1) {
graph[vertex1 - 1].visited = 1;
printf("%d \n", vertex1);
struct edge *e;
e = graph[vertex1 - 1].edgePtr;
for (int i = 0; i < count; i++) {
if (graph[i].visited == 0 && e->vertexIndex != VertexToSearch) {
graph[i].distance++;
}
}
while (e) {
if (!(graph[e->vertexIndex - 1].visited)) {
dfs(e->vertexIndex);
}
e = e->edgePtr;
}
}
void print_distances(){
for(int i = 0;i < count; i++){
printf("%d %d\n", i+ 1,graph[i].distance);
}
}