# Borůvka's algorithm

__: Method for finding minimum spanning trees__

**Short description**Animation of Boruvka's algorithm | |

Class | Minimum spanning tree algorithm |
---|---|

Data structure | Graph |

Worst-case performance | [math]\displaystyle{ O(|E|\log |V|) }[/math] |

Worst-case space complexity | {{{space}}} |

**Borůvka's algorithm** is a greedy algorithm for finding a minimum spanning tree in a graph,
or a minimum spanning forest in the case of a graph that is not connected.

It was first published in 1926 by Otakar Borůvka as a method of constructing an efficient electricity network for Moravia.^{[1]}^{[2]}^{[3]}
The algorithm was rediscovered by Choquet in 1938;^{[4]} again by Florek, Łukasiewicz, Perkal, Steinhaus, and Zubrzycki in 1951;^{[5]} and again by Georges Sollin in 1965.^{[6]} This algorithm is frequently called **Sollin's algorithm**, especially in the parallel computing literature.

The algorithm begins by finding the minimum-weight edge incident to each vertex of the graph, and adding all of those edges to the forest. Then, it repeats a similar process of finding the minimum-weight edge from each tree constructed so far to a different tree, and adding all of those edges to the forest. Each repetition of this process reduces the number of trees, within each connected component of the graph, to at most half of this former value, so after logarithmically many repetitions the process finishes. When it does, the set of edges it has added forms the minimum spanning forest.

## Pseudocode

The following pseudocode illustrates a basic implementation of Borůvka's algorithm.
In the conditional clauses, every edge *uv* is considered cheaper than "None". The purpose of the *completed* variable is to determine whether the forest *F* is yet a spanning forest.

If edges do not have distinct weights, then a consistent **tie-breaking rule** must be used, e.g. based on some total order on vertices or edges.
This can be achieved by representing vertices as integers and comparing them directly; comparing their memory addresses; etc.
A tie-breaking rule is necessary to ensure that the created graph is indeed a forest, that is, it does not contain cycles. For example, consider a triangle graph with nodes {*a*,*b*,*c*} and all edges of weight 1. Then a cycle could be created if we select *ab* as the minimal weight edge for {*a*}, *bc* for {*b*}, and *ca* for {*c*}.
A tie-breaking rule which orders edges first by source, then by destination, will prevent creation of a cycle, resulting in the minimal spanning tree {*ab*, *bc*}.

algorithmBorůvkaisinput:A weighted undirected graphG= (V,E).output:F, a minimum spanning forest ofG. Initialize a forestFto (V,E') whereE'= {}.completed:=falsewhilenotcompleteddoFind the connected components ofFand assign to each vertex its component Initialize the cheapest edge for each component to "None"for eachedgeuvinE, whereuandvare in different components ofF: letwxbe the cheapest edge for the component ofuifis-preferred-over(uv,wx)thenSetuvas the cheapest edge for the component ofuletyzbe the cheapest edge for the component ofvifis-preferred-over(uv,yz)thenSetuvas the cheapest edge for the component ofvifall components have cheapest edge set to "None"then// no more trees can be merged -- we are finishedcompleted:=trueelsecompleted:=falsefor eachcomponent whose cheapest edge is not "None"doAdd its cheapest edge toE'functionis-preferred-over(edge1,edge2)isreturn(edge2is "None") or (weight(edge1) < weight(edge2)) or (weight(edge1) = weight(edge2) and tie-breaking-rule(edge1,edge2))functiontie-breaking-rule(edge1,edge2)isThe tie-breaking rule; returnstrueif and only ifedge1is preferred overedge2in the case of a tie.

As an optimization, one could remove from *G* each edge that is found to connect two vertices in the same component, so that it does not contribute to the time for searching for cheapest edges in later components.

## Complexity

Borůvka's algorithm can be shown to take O(log *V*) iterations of the outer loop until it terminates, and therefore to run in time O(*E* log *V*), where E is the number of edges, and V is the number of vertices in G (assuming *E* ≥ *V*). In planar graphs, and more generally in families of graphs closed under graph minor operations, it can be made to run in linear time, by removing all but the cheapest edge between each pair of components after each stage of the algorithm.^{[7]}

## Example

## Other algorithms

Other algorithms for this problem include Prim's algorithm and Kruskal's algorithm. Fast parallel algorithms can be obtained by combining Prim's algorithm with Borůvka's.^{[8]}

A faster randomized minimum spanning tree algorithm based in part on Borůvka's algorithm due to Karger, Klein, and Tarjan runs in expected O(*E*) time.^{[9]} The best known (deterministic) minimum spanning tree algorithm by Bernard Chazelle is also based in part on Borůvka's and runs in O(*E* α(*E*,*V*)) time, where α is the inverse of the Ackermann function.^{[10]} These randomized and deterministic algorithms combine steps of Borůvka's algorithm, reducing the number of components that remain to be connected, with steps of a different type that reduce the number of edges between pairs of components.

## Notes

- ↑ Borůvka, Otakar (1926). "O jistém problému minimálním" (in cs, de).
*Práce Mor. Přírodověd. Spol. V Brně III***3**: 37–58. https://dml.cz/handle/10338.dmlcz/500114. - ↑ Borůvka, Otakar (1926). "Příspěvek k řešení otázky ekonomické stavby elektrovodních sítí (Contribution to the solution of a problem of economical construction of electrical networks)" (in cs).
*Elektronický Obzor***15**: 153–154. - ↑ "Otakar Borůvka on minimum spanning tree problem: translation of both the 1926 papers, comments, history".
*Discrete Mathematics***233**(1–3): 3–36. 2001. doi:10.1016/S0012-365X(00)00224-7. - ↑ Choquet, Gustave (1938). "Étude de certains réseaux de routes" (in fr).
*Comptes Rendus de l'Académie des Sciences***206**: 310–313. - ↑ Florek, K. (1951). "Sur la liaison et la division des points d'un ensemble fini" (in fr).
*Colloquium Mathematicae***2**(3–4): 282–285. doi:10.4064/cm-2-3-4-282-285. https://eudml.org/doc/209969. - ↑ Sollin, Georges (1965). "Le tracé de canalisation" (in fr).
*Programming, Games, and Transportation Networks*. - ↑ Eppstein, David (1999). "Spanning trees and spanners". in Sack, J.-R.; Urrutia, J..
*Handbook of Computational Geometry*. Elsevier. pp. 425–461.; Mareš, Martin (2004). "Two linear time algorithms for MST on minor closed graph classes".*Archivum Mathematicum***40**(3): 315–320. http://www.emis.de/journals/AM/04-3/am1139.pdf.. - ↑ Bader, David A.; Cong, Guojing (2006). "Fast shared-memory algorithms for computing the minimum spanning forest of sparse graphs".
*Journal of Parallel and Distributed Computing***66**(11): 1366–1378. doi:10.1016/j.jpdc.2006.06.001. - ↑ Karger, David R.; Klein, Philip N.; Tarjan, Robert E. (1995). "A randomized linear-time algorithm to find minimum spanning trees".
*Journal of the ACM***42**(2): 321–328. doi:10.1145/201019.201022. - ↑ Chazelle, Bernard (2000). "A minimum spanning tree algorithm with inverse-Ackermann type complexity".
*J. ACM***47**(6): 1028–1047. doi:10.1145/355541.355562. http://www.cs.princeton.edu/~chazelle/pubs/mst.pdf.

Original source: https://en.wikipedia.org/wiki/Borůvka's algorithm.
Read more |