|
|
| (One intermediate revision by one other user not shown) |
| Line 1: |
Line 1: |
| {{refimprove|date=April 2012}}
| |
| {{Infobox Algorithm
| |
| |class=[[Search algorithm]]
| |
| |image=[[Image:Breadth-first-tree.svg|none|300px|Order in which the nodes get expanded]]
| |
| |caption = Order in which the nodes are expanded</small>
| |
| |data=[[Graph (data structure)|Graph]]
| |
| |time=<math>O(|E|) = O(b^d)</math>
| |
| |space=<math>O(|V|) = O(b^d)</math>
| |
| |optimal=yes (for unweighted graphs)
| |
| |complete=yes
| |
| }}
| |
|
| |
|
| In [[graph theory]], '''breadth-first search''' ('''BFS''') is a [[graph search algorithm|strategy for searching in a graph]] when search is limited to essentially two operations: (a) visit and inspect a node of a graph; (b) gain access to visit the nodes that neighbor the currently visited node. The BFS begins at a root node and inspects all the neighboring nodes. Then for each of those neighbor nodes in turn, it inspects their neighbor nodes which were unvisited, and so on. Compare BFS with the equivalent, but more memory-efficient [[Iterative deepening depth-first search]] and contrast with [[depth-first search]].
| |
|
| |
|
| [[Image:Animated BFS.gif|thumb|187px|Animated example of a breadth-first search]]
| | Salvador Henning is what my wife loves to call me though I am really like being called like it. To model railways is some thing which she is very addicted to make sure you. I used to be unemployed but now i am a transporting and receiving officer there isn't anything don't think I'll change it anytime early. Florida is discover he loves most anf the will never move. Go to my web site find out more: http://www.hopesgrovenurseries.co.uk/<br><br>Feel free to surf to my web page :: [http://www.hopesgrovenurseries.co.uk/ garden hedges] |
| | |
| == Algorithm ==
| |
| [[Image:MapGermanyGraph.svg|thumb|250px|right|An example map of [[Germany]] with some connections between cities]]
| |
| [[Image:GermanyBFS.svg|thumb|250px|right|The breadth-first tree obtained when running BFS on the given map and starting in [[Frankfurt]]]]
| |
| {{Tree search algorithm}}
| |
| | |
| The algorithm uses a [[queue (data structure)|queue]] data structure to store intermediate results as it traverses the graph, as follows:
| |
| # Enqueue the root node
| |
| # Dequeue a node and examine it
| |
| #* If the element sought is found in this node, quit the search and return a result.
| |
| #* Otherwise enqueue any successors (the direct child nodes) that have not yet been discovered.
| |
| # If the queue is empty, every node on the graph has been examined – quit the search and return "not found".
| |
| # If the queue is not empty, repeat from Step 2.
| |
| | |
| '''Note''': Using a [[Stack (data structure)|stack]] instead of a queue would turn this algorithm into a [[depth-first search]].
| |
| | |
| === Pseudocode ===
| |
| '''Input''': A graph ''G'' and a root ''v'' of G
| |
| | |
| 1 '''procedure''' BFS(''G'',''v'') '''is'''
| |
| 2 create a queue ''Q''
| |
| 3 create a set ''V''
| |
| 4 enqueue ''v'' onto ''Q''
| |
| 5 add ''v'' to ''V''
| |
| 6 '''while''' ''Q'' is not empty '''loop'''
| |
| 7 ''t'' ← Q.dequeue()
| |
| 8 '''if''' ''t'' is what we are looking for '''then'''
| |
| 9 return ''t''
| |
| 10 '''end if'''
| |
| 11 '''for all''' edges e in G.adjacentEdges(t) '''loop'''
| |
| 12 ''u'' ← G.adjacentVertex(''t'',''e'')
| |
| 13 '''if''' ''u'' is not in ''V'' '''then'''
| |
| 14 add ''u'' to ''V''
| |
| 15 enqueue ''u'' onto ''Q''
| |
| 16 '''end if'''
| |
| 17 '''end loop'''
| |
| 18 '''end loop'''
| |
| 19 return ''none''
| |
| 20 '''end''' BFS
| |
| | |
| == Features ==
| |
| | |
| === Space complexity ===
| |
| When the number of vertices in the graph is known ahead of time, and additional data structures are used to determine which vertices have already been added to the queue, the space complexity can be expressed as <math>O(|V|)</math> where <math>|V|</math> is the [[cardinality]] of the set of vertices.
| |
| If the graph is represented by an [[Adjacency list]] it occupies <math>\Theta(|V|+|E|)</math><ref>Cormen, Thomas H., Charles E. Leiserson, and Ronald L. Rivest. p.590</ref> space in memory, while an [[Adjacency matrix]] representation occupies <math>\Theta(|V|^2)</math>.<ref>Cormen, Thomas H., Charles E. Leiserson, and Ronald L. Rivest. p.591</ref>
| |
| | |
| === Time complexity ===
| |
| The time complexity can be expressed as <math>O(|V|+|E|)</math> <ref>Cormen, Thomas H., Charles E. Leiserson, and Ronald L. Rivest. p.597</ref> since every vertex and every edge will be explored in the worst case. Note: <math>O(|E|)</math> may vary between <math>O(|V|)</math> and <math> O(|V|^2)</math>, depending on how sparse the input graph is (assuming that the graph is connected).
| |
| | |
| == Applications ==
| |
| Breadth-first search can be used to solve many problems in graph theory, for example:
| |
| * Finding all nodes within one [[connected component (graph theory)|connected component]]
| |
| * Copying Collection, [[Cheney's algorithm]]
| |
| * Finding the [[shortest path]] between two nodes ''u'' and ''v'' (with path length measured by number of edges)
| |
| * Testing a graph for [[Bipartite graph|bipartite]]ness
| |
| * [[Cuthill–McKee algorithm|(Reverse) Cuthill–McKee]] mesh numbering
| |
| * [[Ford–Fulkerson algorithm|Ford–Fulkerson method]] for computing the [[maximum flow problem|maximum flow]] in a [[flow network]]
| |
| * Serialization/Deserialization of a binary tree vs serialization in sorted order, allows the tree to be re-constructed in an efficient manner.
| |
| * Construction of the ''failure function'' of the [[Aho-Corasick]] pattern matcher.
| |
| | |
| === Finding connected components ===
| |
| The set of nodes reached by a BFS (breadth-first search) form the connected component containing the starting node.
| |
| | |
| === Testing bipartiteness ===
| |
| BFS can be used to test [[Bipartite graph|bipartiteness]], by starting the search at any vertex and giving alternating labels to the vertices visited during the search. That is, give label 0 to the starting vertex, 1 to all its neighbours, 0 to those neighbours' neighbours, and so on. If at any step a vertex has (visited) neighbours with the same label as itself, then the graph is not bipartite. If the search ends without such a situation occurring, then the graph is bipartite.
| |
| | |
| == See also ==
| |
| * [[Depth-first search]]
| |
| * [[Level structure]]
| |
| * [[Lexicographic breadth-first search]]
| |
| | |
| == References ==
| |
| {{reflist}}
| |
| {{refbegin}}
| |
| * {{Citation
| |
| | last=Knuth
| |
| | first=Donald E.
| |
| | title=The Art Of Computer Programming Vol 1. 3rd ed.
| |
| | publisher=Addison-Wesley
| |
| | place=Boston
| |
| | year=1997
| |
| | ISBN=0-201-89683-4
| |
| | url=http://www-cs-faculty.stanford.edu/~knuth/taocp.html
| |
| }}
| |
| {{refend}}
| |
| | |
| == External links ==
| |
| {{Commons category|Breadth-first search}}
| |
| * [http://www.cse.ohio-state.edu/~gurari/course/cis680/cis680Ch14.html#QQ1-46-92 Breadth-First Explanation and Example]
| |
| * [http://opendatastructures.org/versions/edition-0.1e/ods-java/12_3_Graph_Traversal.html#SECTION001531000000000000000 Open Data Structures - Section 12.3.1 - Bread-First Search]
| |
| | |
| [[Category:Graph algorithms]]
| |
| [[Category:Search algorithms]]
| |
Salvador Henning is what my wife loves to call me though I am really like being called like it. To model railways is some thing which she is very addicted to make sure you. I used to be unemployed but now i am a transporting and receiving officer there isn't anything don't think I'll change it anytime early. Florida is discover he loves most anf the will never move. Go to my web site find out more: http://www.hopesgrovenurseries.co.uk/
Feel free to surf to my web page :: garden hedges