What is Breadth-First Search in C#?

Can you explain what Breadth-First Search is in C#?

Breadth-First Search (BFS) is an algorithm for traversing or searching tree or graph data structures. It starts at the root node and explores all of the neighbor nodes at the present depth prior to moving on to nodes at the next depth level.

How do I implement BFS in C#?

To implement BFS in C#, you can use a queue to keep track of nodes to visit. Here's a simple example:

using System;
using System.Collections.Generic;

class Node {
    public int Value;
    public List<Node> Neighbors;

    public Node(int value) {
        Value = value;
        Neighbors = new List<Node>();
    }
}

class Graph {
    public void BFS(Node start) {
        Queue<Node> queue = new Queue<Node>();
        HashSet<Node> visited = new HashSet<Node>();

        queue.Enqueue(start);
        visited.Add(start);

        while (queue.Count > 0) {
            Node current = queue.Dequeue();
            Console.WriteLine(current.Value);

            foreach (var neighbor in current.Neighbors) {
                if (!visited.Contains(neighbor)) {
                    queue.Enqueue(neighbor);
                    visited.Add(neighbor);
                }
            }
        }
    }
}

This code defines a simple graph and performs BFS starting from a given node.

What are the time and space complexities of BFS?

The time complexity of BFS is O(V + E), where V is the number of vertices and E is the number of edges. The space complexity is O(V) as well, due to the storage of the queue and the visited set.