How do BFS and DFS work in code?

Can you explain how BFS and DFS algorithms work in coding?

Sure! BFS (Breadth-First Search) explores nodes level by level, while DFS (Depth-First Search) goes as deep as possible before backtracking.

What are the main differences between BFS and DFS?

The main differences are: BFS uses a queue and explores all neighbors at the present depth, while DFS uses a stack and explores as far as possible along each branch.

Can you provide a simple code example for both algorithms?

Absolutely! Here's a simple Python example:

# BFS
from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    while queue:
        vertex = queue.popleft()
        if vertex not in visited:
            visited.add(vertex)
            queue.extend(neighbor for neighbor in graph[vertex] if neighbor not in visited)

# DFS

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)
    return visited

This code demonstrates both BFS and DFS using a graph represented as an adjacency list.

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.