finished bfs and fixed dfs

Author: SravanthiSinha

0x06-graphs/4-depth_first_traverse

@@ -29,7 +29,7 @@ vertex_t *get_vertex_index(const graph_t *graph, size_t index)
 }
 
 /**
- * depth_first_traverse - A function that goes through a graph using the
+ * dfs_util - A function that goes through a graph using the
  * depth -first algorithm.
  * @v: index of the vertex
  * @visited: array of nodes marked visited or not
@@ -47,7 +47,7 @@ void dfs_util(int v, size_t *visited, size_t curr_depth, size_t *depth,
 	edge_t *edge;
 
 	curr = get_vertex_index(graph, v);
-	if (curr != NULL && visited[v] == BACKTRACK)
+	if (curr != NULL && visited[v] != EXPLORED)
 	{
 		action(curr, curr_depth);
 		if (curr_depth > *depth)
@@ -57,7 +57,7 @@ void dfs_util(int v, size_t *visited, size_t curr_depth, size_t *depth,
 		while (edge != NULL)
 		{
 			dest = edge->dest;
-			if (visited[dest->index] == BACKTRACK)
+			if (visited[dest->index] != EXPLORED)
 			{
 				dfs_util(dest->index, visited, curr_depth + 1,
 					 depth, graph, action);
@@ -86,9 +86,9 @@ size_t depth_first_traverse(const graph_t *graph,
 		visited = calloc(graph->nb_vertices, sizeof(size_t));
 
 		curr = graph->vertices;
-		while (curr)
+		if (curr)
 		{
-			if (visited[curr->index] == BACKTRACK)
+			if (visited[curr->index] == UNEXPLORED)
 				dfs_util(curr->index, visited, 0, &depth,
 					 graph, action);
 			curr = curr->next;

0x06-graphs/4-depth_first_traverse.c

@@ -0,0 +1,138 @@
+#include "graphs.h"
+
+/**
+ * createqueue_t - A function that creates a queue
+ * Return: queue created
+ */
+queue_t *createqueue_t()
+{
+	queue_t *q = malloc(sizeof(queue_t));
+
+	q->front = -1;
+	q->rear = -1;
+	return (q);
+}
+
+/**
+ * enqueue - A function that appends the item in queue
+ * @q: queue
+ * @value: value to be stored
+ */
+void enqueue(queue_t *q, int value)
+{
+	if (q->rear == SIZE - 1)
+		printf("\nqueue_t is Full!!");
+	else
+	{
+		if (q->front == -1)
+			q->front = 0;
+		q->rear++;
+		q->items[q->rear] = value;
+	}
+}
+
+/**
+ * dequeue - A function that fetches first item in queue
+ * @q: queue
+ *
+ * Return: first item in queue on success,  -1 on failure
+ */
+int dequeue(queue_t *q)
+{
+	int item;
+
+	if (q->rear == -1)
+	{
+		printf("queue_t is empty");
+		item = -1;
+	} else
+	{
+		item = q->items[q->front];
+		q->front++;
+		if (q->front > q->rear)
+		{
+			q->front = q->rear = -1;
+		}
+	}
+	return (item);
+}
+
+/**
+ * get_vertex_index - A function that fetches an vertex existing in graph by
+ * index
+ * @graph: A pointer to the graph
+ * @index: The index identifying the vertex
+ *
+ * Return: vertex on success,  NULL on failure
+ */
+vertex_t *get_vertex_index(const graph_t *graph, size_t index)
+{
+	vertex_t *node;
+
+	if (index > graph->nb_vertices)
+		return (NULL);
+	node = graph->vertices;
+	if (node == NULL)
+		return (NULL);
+	while (node != NULL)
+	{
+		if (node->index == index)
+		{
+			return (node);
+		}
+		node = node->next;
+	}
+	return (NULL);
+}
+
+/**
+ * breadth_first_traverse - A function that goes through a graph using the
+ * breadth -first algorithm.
+ * @graph: A pointer to the graph to traverse
+ * @action: A  pointer to a function to be called for each visited vertex.
+ * Return: The max breadth , or 0 on failure
+ */
+size_t breadth_first_traverse(const graph_t *graph,
+			      void (*action)(const vertex_t *v, size_t breadth))
+{
+	size_t breadth = 0, *visited; int index = 0;
+	vertex_t *curr, *dest;	edge_t *edge; queue_t *q;
+
+	if (graph == NULL || graph->nb_vertices == 0 || graph->vertices == NULL)
+		return (0);
+	visited = calloc(graph->nb_vertices, sizeof(size_t));
+	q = createqueue_t();
+	curr = graph->vertices;
+	enqueue(q, curr->index);	enqueue(q, LEVELBREAK);
+	while (q->rear != -1)
+	{
+		index = dequeue(q);
+		if (index == LEVELBREAK)
+		{
+			breadth++;
+			enqueue(q, LEVELBREAK);
+			index = dequeue(q);
+			if (index == LEVELBREAK)
+				break;
+		}
+		curr = get_vertex_index(graph, index);
+		if (visited[curr->index] != EXPLORED)
+		{
+			visited[curr->index] = EXPLORED;
+			action(curr, breadth);
+			edge = curr->edges;
+			while (edge)
+			{
+				dest = edge->dest;
+				if (dest && visited[dest->index] != EXPLORED)
+				{
+					enqueue(q, dest->index);
+					visited[dest->index] = BACKTRACK;
+				}
+				edge = edge->next;
+			}
+		}
+	}
+	free(visited);
+	return (breadth - 1);
+}

0x06-graphs/5-breadth_first_traverse.c

@@ -7,9 +7,18 @@
 
 * 1-graph_add_vertex.c - Contains a function that adds a vertex to an existing graph
 
+* 2-graph_add_edge.c - Contains a function that adds an edge to an existing graph
+
+* 3-graph_delete.c - Contains a function that deletes a graph
+
+* 4-depth_first_traverse.c - Contains a function that traverses the graph  in dfs way and returns the depth of the graph
+
+* 5-breadth_first_traverse.c - Contains a function that traverses the graph  in bfs way and returns the depth of the graph
+
+
 
 ## Resources:
 * [[EYNTK] Graphs](https://intranet.hbtn.io/concepts/86)
 * [Graphs Wiki](https://en.wikipedia.org/wiki/Graph_%28abstract_data_type%29)
 * [Graphs (Stanford lecture)](http://web.stanford.edu/class/cs161/Lectures/Lecture9/CS161Lecture09.pdf)
-* [https://intranet.hbtn.io/rltoken/ZBxeNNgwtzIDZI1PLLdt6Q](https://www.youtube.com/watch?v=gXgEDyodOJU)
+* [Introduction to graphs](https://www.youtube.com/watch?v=gXgEDyodOJU)

0x06-graphs/README.md

@@ -6,8 +6,11 @@
 
 #define  SUCCESS 1
 #define  FAILURE 0
+#define  UNEXPLORED 0
 #define  EXPLORED 1
-#define BACKTRACK 0
+#define BACKTRACK 2
+#define SIZE 1024
+#define LEVELBREAK -60
 /**
  * enum edge_type_e - Enumerates the different types of
  * connection between two vertices
@@ -70,6 +73,20 @@ typedef struct graph_s
 	vertex_t *vertices;
 } graph_t;
 
+/**
+ * struct queue_s - Representation of a queue
+ *
+ * @items: items to be queued
+ * @front: Pointer to the first item in queue
+ * @rear: Pointer to the last item in queue
+ */
+typedef struct queue_s
+{
+	int items[SIZE];
+	int front;
+	int rear;
+} queue_t;
+
 void graph_display(const graph_t *graph);
 graph_t *graph_create(void);
 vertex_t *graph_add_vertex(graph_t *graph, const char *str);

0x06-graphs/graphs.h

@@ -39,7 +39,8 @@ int main(void)
 	    !graph_add_vertex(graph, "Chicago") ||
 	    !graph_add_vertex(graph, "Houston") ||
 	    !graph_add_vertex(graph, "Las Vegas") ||
-	    !graph_add_vertex(graph, "Boston"))
+	    !graph_add_vertex(graph, "Boston") ||
+			!graph_add_vertex(graph, "Los Angeles"))
 	{
 		fprintf(stderr, "Failed to add vertex\n");
 		return (EXIT_FAILURE);

0x06-graphs/tests/4-main.c

@@ -6,8 +6,11 @@
 
 #define  SUCCESS 1
 #define  FAILURE 0
+#define  UNEXPLORED 0
 #define  EXPLORED 1
-#define BACKTRACK 0
+#define BACKTRACK 2
+#define SIZE 1024
+#define LEVELBREAK -60
 /**
  * enum edge_type_e - Enumerates the different types of
  * connection between two vertices
@@ -70,6 +73,20 @@ typedef struct graph_s
 	vertex_t *vertices;
 } graph_t;
 
+/**
+ * struct queue_s - Representation of a queue
+ *
+ * @items: items to be queued
+ * @front: Pointer to the first item in queue
+ * @rear: Pointer to the last item in queue
+ */
+typedef struct queue_s
+{
+	int items[SIZE];
+	int front;
+	int rear;
+} queue_t;
+
 void graph_display(const graph_t *graph);
 graph_t *graph_create(void);
 vertex_t *graph_add_vertex(graph_t *graph, const char *str);