BFS Program in C

BFS (breadth-first search) is an algorithm that is used for traversing or searching a graph or tree data structure. It starts at the root node (or any arbitrary node) and explores all the nodes at the current depth level before moving on to the nodes at the next depth level.

The algorithm uses a queue to keep track of which vertices to visit next. It starts by adding the root vertex to the queue and then repeatedly removes vertices from the front of the queue, adds their neighbors to the back of the queue, and marks them as visited. This process continues until the queue is empty, indicating that all reachable vertices have been visited.

Example:

Sample code to implement the BFS algorithm:

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

// A structure to represent a node in the adjacency list
struct node {
    int vertex;
    struct node* next;
};

// A structure to represent the adjacency list
struct adj_list {
    struct node* head;
};

// A structure to represent the graph
struct graph {
    int num_vertices;
    struct adj_list* adj_lists;
    int* visited;
};

// Create a new node in the adjacency list
struct node* new_node(int vertex) {
    struct node* new_node = (struct node*)malloc(sizeof(struct node));
new_node->vertex = vertex;
new_node->next = NULL;
    return new_node;
}

// Create a graph with n vertices
struct graph* create_graph(int n) {
    struct graph* graph = (struct graph*)malloc(sizeof(struct graph));
    graph->num_vertices = n;
    graph->adj_lists = (struct adj_list*)malloc(n * sizeof(struct adj_list));
    graph->visited = (int*)malloc(n * sizeof(int));

    int i;
    for (i = 0; i< n; i++) {
        graph->adj_lists[i].head = NULL;
        graph->visited[i] = 0;
    }

    return graph;
}

// Add an edge to the graph
void add_edge(struct graph* graph, int src, int dest) {
    // Add an edge from src to dest
    struct node* new_node1 = new_node(dest);
    new_node1->next = graph->adj_lists[src].head;
    graph->adj_lists[src].head = new_node1;

    // Add an edge from dest to src
    struct node* new_node2 = new_node(src);
    new_node2->next = graph->adj_lists[dest].head;
    graph->adj_lists[dest].head = new_node2;
}

// BFS traversal of the graph starting from vertex v
void bfs(struct graph* graph, int v) {
    // Create a queue for BFS
    int queue[1000];
    int front = -1;
    int rear = -1;

    // Mark the current node as visited and enqueue it
    graph->visited[v] = 1;
    queue[++rear] = v;

    // Loop to visit all the vertices in the graph
    while (front != rear) {
        // Dequeue a vertex from the queue and print it
        int current_vertex = queue[++front];
printf("%d ", current_vertex);

        // Get all the neighbors of the dequeued vertex
        struct node* temp = graph->adj_lists[current_vertex].head;
        while (temp != NULL) {
            int adj_vertex = temp->vertex;

            // If the neighbor has not been visited, mark it as visited and enqueue it
            if (graph->visited[adj_vertex] == 0) {
                graph->visited[adj_vertex] = 1;
                queue[++rear] = adj_vertex;
            }

            temp = temp->next;
        }
    }
}

int main() {
    // Create a graph with 6 vertices
    struct graph* graph = create_graph(6);

    // Add edges to the graph
add_edge(graph, 0, 1);
add_edge(graph, 0, 2);
add_edge(graph, 1, 3);
add_edge(graph, 1, 4);
add_edge(graph, 2, 4);
add_edge(graph, 3, 4);
add_edge(graph, 3, 5);
add_edge(graph, 4,5);
        // Perform BFS traversal starting from vertex 0
printf("BFS traversal starting from vertex 0: ");
bfs(graph, 0);

    return 0;
}

Output:

BFS traversal starting from vertex 0: 0 2 1 4 3 5

Similarly, when you run the code with the initial vertex as 1 the output would be:

BFS traversal starting from vertex 1: 1 4 3 0 5 2

Explanation:

This code creates a graph with 6 vertices and adds edges between them. After that, it performs a BFS traversal of the graph starting from vertex 0 and prints the order in which the vertices are visited. In this code, the 'struct node' represents a node in the adjacency list, 'struct adj_list' represents the adjacency list, and 'struct graph' represents the entire graph. The 'create_graph' function creates a new graph with 'n' vertices, and the 'add_edge' function adds an edge between two vertices.

The 'bfs' function implements the BFS algorithm, starting from the vertex 'v'. A queue and a visited array are used to keep track of which vertices should be visited next. The 'main' function creates a graph and adds some edges, and then calls the 'bfs' function starting from vertex 0.

The time and space complexities of this BFS algorithm can be discussed as follows:

Time complexity:

This algorithm has an O(V+E) time complexity, where V is the number of graph vertices and E is the number of graph edges.
In the worst case, we need to visit all the vertices and edges in the graph, so the time complexity is proportional to the size of the graph.

Space complexity:

The BFS algorithm has an O(V) space complexity, where V is the number of graph vertices. It is because we need to store the visited vertices and the vertices in the queue.
In the worst case, all vertices can be added to the queue, so the space complexity is proportional to the size of the graph.