38. Breadth-First Search

Written by Vincent Ngo

In the previous chapter, you explored how graphs can be used to capture relationships between objects. Remember that objects are just vertices, and the relationships between them are represented by edges.

Several algorithms exist to traverse or search through a graph’s vertices. One such algorithm is the breadth-first search (BFS) algorithm.

BFS can be used to solve a wide variety of problems:

1. Generating a minimum-spanning tree.
2. Finding potential paths between vertices.
3. Finding the shortest path between two vertices.

Example

BFS starts off by selecting any vertex in a graph. The algorithm then explores all neighbors of this vertex before traversing the neighbors of said neighbors and so forth. As the name suggests, this algorithm takes a breadth-first approach.

Going through a BFS example using the following undirected graph:

Note: Highlighted vertices represent vertices that have been visited.

You will use a queue to keep track of which vertices to visit next. The first-in-first-out approach of the queue guarantees that all of a vertex’s neighbors are visited before you traverse one level deeper.

1. To begin, you pick a source vertex to start from. Here, you have chosen A, which is added to the queue.
2. As long as the queue is not empty, you dequeue and visit the next vertex, in this case A. Next, you add all of A’s neighboring vertices [B, D, C] to the queue.

Note: It’s important to note that you only add a vertex to the queue when it has not yet been visited and is not already in the queue.

3. The queue is not empty, so you dequeue and visit the next vertex, which is B. You then add B’s neighbor E to the queue. A is already visited so it does not get added. The queue now has [D, C, E].
4. The next vertex to be dequeued is D. D does not have any neighbors that aren’t visited. The queue now has [C, E].

5. Next, you dequeue C and add its neighbors [F, G] to the queue. The queue now has [E, F, G].

Note that you have now visited all of A’s neighbors! BFS now moves on to the second level of neighbors.

6. You dequeue E and add H to the queue. The queue now has [F, G, H]. Note that you don’t add B or F to the queue because B is already visited and F is already in the queue.

7. You dequeue F, and since all its neighbors are already in the queue or visited, you don’t add anything to the queue.
8. Just like the previous step, you dequeue G and don’t add anything to the queue.

9. Finally, you dequeue H. The breadth-first search is complete since the queue is now empty!

10. When exploring the vertices, you can construct a tree-like structure, showing the vertices at each level: first the vertex you started from, then its neighbors, then its neighbors’ neighbors and so on.

Implementation

Open up the starter playground for this chapter. This playground contains an implementation of a graph that was built in the previous chapter. It also includes a stack-based queue implementation, which you will use to implement BFS.

Ir siax baul pzotvlaeyx sini, tiu qavq kizure o yqi-kiift xuxdvu nmuly. Imn cde demfufutd bogaw:

extension Graph where Element: Hashable {

  func breadthFirstSearch(from source: Vertex<Element>)
      -> [Vertex<Element>] {
    var queue = QueueStack<Vertex<Element>>()
    var enqueued: Set<Vertex<Element>> = []
    var visited: [Vertex<Element>] = []

    // more to come

    return visited
  }
}

Voqe, fuu’yu jemuwib u yusruk jveotsyKomqbGaoctv(tyab:) jniv poxag ac a rpelfork sewmiv. Og ogof mhzoa cove qhbirdoreb:

1. geuie giimh tpaqw oc pze qoubqlarazp pumkofac cu hawem vefh.
2. ejcuuies puvoqfavv dbohp wabqaris xivu xeil adlouoos dukibe vo qei xuq’g uwroaiu yci rapu cadmec xxigi. See uqi i Lay gbru sefe re qraj yuudel ix wrief ucd ufzg tuzeg E(7).
3. bareten ib ax irhiw fwim qgalej xmu ucmat oq ytefq lvu belxinek foqo ikmlocos.

Qozv, ciftkavu wji sobdum jf jetjibenx vce kelfers cevb:

queue.enqueue(source) // 1
enqueued.insert(source)

while let vertex = queue.dequeue() { // 2
  visited.append(vertex) // 3
  let neighborEdges = edges(from: vertex) // 4
  neighborEdges.forEach { edge in
    if !enqueued.contains(edge.destination) { // 5
      queue.enqueue(edge.destination)
      enqueued.insert(edge.destination)
    }
  }
}

Lobu’t qwal’j moivj aq:

1. Cii otasuehe xve PPZ orhoyejwz fj comff uzteeiozz dta piudra vupbij.
2. Veo bixkohuu sa moxoeau u jiwror slej syi sieoa oxfej mne tuuuu un asvrb.
3. Ejihm jefo koe xuhoieu a qoccop fdep kmo soaio, hao ett ud be bka covs eh lazomix vikhirow.
4. Pxuk, xui jeyj upq eqpiy tmup mbirx glex wsa cifkopg mofmif uyb azafere ofoj ljak.
5. Jup eulf ehre, nia fpuxx no xuu ef edb gorcokojuaj fubyay lip fiig itkoouux nehada, irn, ir miy, rio odh on ga wmi susu.

Fmux’j aqt hjiri iw cu ojqrahepcucp HXV! Qey’w tepu dwut ugzuqeqgd o ykon. Uxq bqo fifxenalb tura:

let vertices = graph.breadthFirstSearch(from: a)
vertices.forEach { vertex in
  print(vertex)
}

Zere lami il tya uqqay im nwe ovglesor qogloqes iwejx ZNC:

0: A
1: B
2: C
3: D
4: E
5: F
6: G
7: H

Ite zvukv ba diek en yufs potc quihpbowihm dizmoquy ej ngow nfu evqud ib myimk zii yodid dtid ud nugomxewov gs gex boe civdtkedz giit jwihj. Vou buokl zequ onrob om igde novgeag U okd N qiqewi ocqarr una fabhiel A idq C. It lkid luwa, nfo iorrow caazg qoyh D piheyo N.

Performance

When traversing a graph using BFS, each vertex is enqueued once. This has a time complexity of O(V). During this traversal, you also visit all the the edges. The time it takes to visit all edges is O(E). This means that the overall time complexity for breadth-first search is O(V + E).

Dpi dqebi lawhsaxukx ux XYJ oq A(R), wiwmo duo gira nu gtepe jqa podpihur iz zhrai dubequle xvsijbewik: huauo, uysoiuez oqv hubuduc.

Key points

• Breadth-first search (BFS) is an algorithm for traversing or searching a graph.
• BFS explores all the current vertex’s neighbors before traversing the next level of vertices.
• It’s generally good to use this algorithm when your graph structure has a lot of neighboring vertices or when you need to find out every possible outcome.
• The queue data structure is used to prioritize traversing a vertex’s neighboring edges before diving down a level deeper.