Breadth-first search, or BFS, explores a graph outward from a starting node in rings. It first visits every node one edge away, then every node two edges away, and so on, so it sweeps the graph level by level. The order is enforced by a queue: when a node is visited, all of its not-yet-seen neighbors are added to the back of the queue, and the next node to process is always taken from the front. Because the queue serves nodes in the order they were discovered, closer nodes are always fully explored before farther ones.
This level-by-level discipline gives BFS its signature property. In a graph where every edge counts the same, the first time BFS reaches a node it has reached it by a path with the fewest possible edges. That makes BFS the standard way to compute shortest paths in an unweighted graph, and the MIT 6.006 lecture on breadth-first search presents it exactly that way: as a single-source shortest-path algorithm that also records, for each node, its distance in edges and the node it was reached from.
The cost of BFS is linear in the size of the graph. Each node is placed on the queue once, and each edge is examined a constant number of times, so the running time is on the order of V plus E, where V is the number of vertices and E the number of edges. To avoid revisiting nodes and looping forever, BFS marks each node as it is discovered and skips any node already seen.
BFS is the breadth-oriented counterpart to depth-first search, which dives down one path as far as it can before backing up. The two share the same skeleton and the same O(V+E) cost; the only structural difference is the container that holds nodes waiting to be explored. BFS uses a first-in, first-out queue, which produces the expanding-rings behavior; depth-first search uses a last-in, first-out stack, which produces deep dives. The shortest-path guarantee is what makes BFS the right choice when the goal is the nearest target rather than full exploration.