How do BFS and DFS work in C programming for graphs?

Can you explain how BFS and DFS work in C programming?

Sure! BFS (Breadth-First Search) explores all neighbors at the present depth before moving on to nodes at the next depth level. DFS (Depth-First Search) explores as far as possible along each branch before backtracking.

What are the main differences between BFS and DFS?

The main differences are: BFS uses a queue and explores level by level, while DFS uses a stack (or recursion) and goes deep into a branch before backtracking.

Can you provide a simple C code example for both algorithms?

Absolutely! Here's a simple BFS implementation:

void BFS(int graph[MAX][MAX], int start, int n) {
    int queue[MAX], front = -1, rear = -1;
    int visited[MAX] = {0};
    queue[++rear] = start;
    visited[start] = 1;
    while (front != rear) {
        int current = queue[++front];
        printf("%d ", current);
        for (int i = 0; i < n; i++) {
            if (graph[current][i] && !visited[i]) {
                queue[++rear] = i;
                visited[i] = 1;
            }
        }
    }
}

And for DFS:

void DFS(int graph[MAX][MAX], int start, int visited[], int n) {
    visited[start] = 1;
    printf("%d ", start);
    for (int i = 0; i < n; i++) {
        if (graph[start][i] && !visited[i]) {
            DFS(graph, i, visited, n);
        }
    }
}

What are the time complexities of BFS and DFS?

Both BFS and DFS have a time complexity of O(V + E), where V is the number of vertices and E is the number of edges in the graph.