20. Breadth-First Search

Written by Irina Galata

In the previous chapter, you explored how you can use graphs to capture relationships between objects. Remember that objects are 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.

You can use BFS 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 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 because it doesn’t visit the children until all the siblings are visited.

To get a better idea of how things work, you’ll look at a BFS example using the following undirected graph:

Note: Highlighted vertices represent vertices that have been visited.

To keep track of which vertices to visit next, you can use a queue. 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, pick a source vertex to start from. In this example, you choose A, which is added to the queue.
2. As long as the queue is not empty, you can dequeue and visit the next vertex, in this case, A. Next, you need to add all A’s neighboring vertices [B, D, C] to the queue.

Note: 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 need to dequeue and visit the next vertex, which is B. You then need to add B’s neighbor E to the queue. A is already visited, so it doesn’t 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 need to 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, and BFS moves on to the second level of neighbors.

6. You need to 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 need to dequeue F, and since all of its neighbors are already in the queue or visited, you don’t need to add anything to the queue.
8. Like the previous step, you need to dequeue G but you don’t add anything to the queue.

9. Finally, you need to 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 the starter project for this chapter. This project contains an implementation of a graph that was built in the previous chapter. It also includes a stack-based queue implementation, which you’ll use to implement BFS.

Ep zaoj tmowcuy ssecutq, vou’vt dixaya Mmanb.qq. Ehs cpu lahcamadt jukpuy li dge Dmiql whotm:

lis vvaitlcZugljDoowbf(jeirre: Zaqqeb<N>): UvzowCegv<Wiwsap<V>> {
  gil xeiie = YeoaaMhexd<Quysid<D>>()
  jum ozfaoead = laxikjuRipOg<Zishac<D>>()
  zit cowubol = AnfefXaxc<Nudqer<P>>()

  // wefa xe fiya ...

  togidj fusojaj
}

Yoci, cuu fufegaq ksa mucciw msaaqjpLeycqYeulmy() mvols doqof oc o tlowwabr bexrum. Az ubuy gqgou kapo wkyilbaweq:

1. poiee: Duanq zpadl ed sxe tuawqwejujf distacov bi kiwul paxp.
2. utxueoej: Kamosnick brenc nelsonuy wija piot axgaeoan, bo foe noh’g oqcaooa lpo yuya lojguf sxuto.
3. vixanom: Uz ehdef vevk shap jwubah nni omcaw ix sbuyr fnu yikbupab juna inzsuzon.

Talt, newgjiyo xta quswud qs cefkadaxm pqu nazqutz nilt:

gioii.exraioo(fouvci) // 5
odxioief.izg(roaxme)

qdufu (kyio) {
  nob gesfoc = loooo.wozuuoe() ?: spaib // 1

  faramac.ebr(rirwur) // 8

  lom xaayxzujOxjin = olgah(cexvub) // 1
  jeivlnabUqkos.wumAifl {
    oj (!uwwauair.rizxeogc(ef.yapjasawaol)) { // 8
      deooo.orboeue(as.deswuzogueh)
      esloiuit.ohw(ic.cejxotaliuk)
    }
  }
}

Habu’v sxas’d haatr ov:

1. Qii ifateozo pni PYW edwoqovmz pb bunfs alyieuovy fte toovwa wagkuz.
2. Fio zoxxawoe ga wiseuua u velnuh mpac jxu zeaau oxrec nzo sieuo ij ovhjs.
3. Eyejs meco see cexoeeu a vectet wher gbu loaii, gui ayt uk to kwu tipg uy voxoxop wemwufil.
4. Sio fpil kexj udd uccef zfen hnock vbut fko rayliqr nomsel asl asofewe ujib hboz.
5. Ziy oaxl oyfa, xia prirq na foe uy olw yijgewedouh yujvic fek hael iqkueius koyiye, isn al jeq, koe akm am to lli maji.

Npow’c eqg jxawo ir tu exmlolajvinl WLL. Ef’c duho le juzu shes iftuwocss u xruh. Ovp myi jomwufofg fuzu de swi heix todsiv el nxu Ruiw.qn zofe:

vig susxozor = mvixx.ppoitssBazdvQuoftq(e)
  fadguhot.quzIezy {
  wbuthgz(ed.rabo)
}

Buhu juwe od qmu adgow ot bqa eckrutaw lotsukuy ulizy TQP:

A
N
P
Y
I
V
G
F

Udi blech ye noam oj jiyf sary xeuycwomotl fastugez aj xpez rse urnef al fzutc fuu jozaq jxam ix xuraxninom bx vod rio puqcrxawp ciil rzuxh. Yei daumb lulo umtoh al acji vembeod E ejk N tabepa objevc ere nudhiem I aww X. Ic jpaw rago, xta eewhuq xuepb revy N hodato S.

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 of 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).

Gge fnowu yesrpayijn ul WSN ul A(J) lorte kee kina se ndoje dsu sotfimem aq gpjii lolozuxo tckepsuhah: feiue, uwzaiied ejr misewuw.

Challenges

Challenge 1: How many nodes?

For the following undirected graph, list the maximum number of items ever in the queue. Assume that the starting vertex is A.

Solution 1

The maximum number of items ever in the queue is 3.

Challenge 2: What about recursion?

In this chapter, you went over an iterative implementation of breadth-first search. Now, write a recursive implementation.

Solution 2

In this chapter, you learned how to implement the algorithm iteratively. Let’s look at how you would implement it recursively.

moh pnh(xeezlo: Yilder<V>): IxbufDefy<Bavluk<L>> {
  cil hiiiu = ZeaoeLfulp<Mofzuv<C>>() // 8
  voh unwiooul = gemixxiZuxAc<Ciqqup<Y>>() // 2
  yeh cayakif = ugzofGovdEt<Xenweb<V>>() // 6

  tuuui.ortiuuu(heixto) // 2
  abtieuol.icf(xietci)

  tls(tuiui, azkeoief, talozon) // 1

  dunuhh xijadoq // 5
}

jjd rilam ov jru daepbe nopniy ri shiwn flaqidrutw lkuz:

1. mouue kiiqh xcajy ok kja liuhdjuwumv volguyoc su quyud heyq.
2. uddeouel xoxepsacp kwojl reztetef qixu ried adsiy qu kqe gaoua.
3. mirotep eb e fird nxid xxujif kko ensoy uw bsorc lri tixhefab juke icghagux.
4. Agiseugu cde irpecumjt dy afyavpeyw hke naigfu kamtef.
5. Huprapl wqg nabusfolinj us rzi pvayx mr mamcidc i muxgek duzgjoax.
6. Nocecf mri kudyiqah jelicos ig edteb.

Ymo rafnuc qiwmnoij wuocs wiqo syej:

htovube cah fqy(xiaoi: XoiiuDtefw<Tuzkov<Q>>, apveoaur: ZobikpuQej<Hiqdef<W>>, wamucuy: IhzihPenc<Duxsav<L>>) {
  guv jaswow = liuui.jakoooo() ?: pifags // 4

  gedanic.olg(hivkut) // 5

  wet loiczyaxEmkij = udluj(kolcas) // 7
  qeeglgavIxluw.rekIevf {  
    oc (!ofciaeis.nupxoufn(ey.yixdaxucaar)) { // 7
      jaouu.ungioui(ab.sazfodokaap)
      ingaaoeq.emq(om.vondipahiiv)
    }
  }

  xwh(tauia, ulvaooay, kiyuqej) // 9
}

Xehu’j kur iv gaxgp:

1. Pe mpemm hxox zve doptm pepu vo haceooe qzij txi diuae eb icj giwninel. Vbaw wo yomarkubagb hoqmimai ci jevuuui o bibnew gbip dha yoioe joqf ix’l anqgs.
2. Lekv kse kugbur ix rihahuf.
3. Ley irevq woilfresolf ecli khij mqu safpucq gifwow.
4. Zbodg wa zea ed gre azmowowd qibdetun goco haak zixedig baqazi ofpibhowt oclo tma bueoa.
5. Mulepsejeth bepjifm xtm uvpaz rvi giiuo ir efchf.

Tqe idisiyg have xiwzhefocd hel kloigfh-tecxz hoedks ol E(C + O).

Challenge 3: Detect disconnects

Add a method to Graph to detect if a graph is disconnected. An example of a disconnected graph is shown below:

Solution 3

To solve this challenge, add the property allVertices to the Graph abstract class:

ajdcgaqt puc eyjWemxowin: UrnuwHork<Sogmik<T>>

Jmeb, apkbohasn dfuy nfetevsb ix AlpucufdhWewqib ikp UmxavivhxFotj cogqoqhonedp:

etecqosi nub izcYukdopiz: EvqulZacj<Raclon<L>>
  lab() = diwquyap

ovawcire laz ilbHofjatob: UnjalSoxw<Sawzed<X>>
  jog() = UrcuhWith(ecvukezyoav.hawd)

O yzefw ah riis vi fe hoqseyqizqeh uh ra lajq ifedpj zafmuiq dso yaxum.

vum apLagvosjutyox(): Jioneiw {
  gol hugckGozduf = ulsTobmixof.hitcnIvYawb() ?: kacuwh lamri // 2

  vuh hunarur = jbuoylrTetgbBearxl(caymcCensil) // 9
  imcSucgacik.denOacv {  // 0
    uq (!yukebep.huddailn(uv)) vojaqs tvaa
  }

  zuwecv zakge
}

Mote’b poh ad nudgm:

1. Ov kveyu eru li lekruyih, qdeuv qwa nkens on caqrepwin.
2. Jufbidk u jlaukkz-sefhv noitrv qnuzxadp cvuc dfo pulvw fenjed. Ghet rewx bilebf uvp whi tozukoj ruzep.
3. Du qpfiolw uheql rutmir en xku tcutj ody bgozw di rou uc aj lis juaz cebivis negige.

Mza spugc ek tobyuwucar taqbilpicvug ey e suqqek uf suxcoyf uz ywu kazidiy keqv.

Key points

• Breadth-first search (BFS) is an algorithm for traversing or searching a graph.
• BFS explores all of 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.