C++, LEDA und STL Visualisierung minimal/maximal

Fachbereich IV, Informatik
Softwarepraktikum
C++, LEDA und STL
Visualisierung minimal/maximal
aufspannender Bäume
Wintersemester 2004/2005
Dokumentation
Algorithmen zur Lösung von
MST - Problemen
Nicolas Mertes
Matrikel Nr. 697862
1
Inhaltsverzeichnis
Inhaltsverzeichnis..................................................................................................... 2
0. VORWORT ............................................................................................................. 3
1. EINLEITUNG .......................................................................................................... 4
2. GRAPHEN .............................................................................................................. 5
2.1 Allgemeines....................................................................................................... 5
2.2 Definition (gerichteter Graph) ............................................................................ 5
2.2 Definition (ungerichteten Graph) ....................................................................... 5
2.3 Definition (Ausgangsgrad, Eingangsgrad) ......................................................... 6
2.3 Definition (benachbart, Weg, Länge, geschlossen) ........................................... 6
2.4 Definition (zusammenhängend)......................................................................... 6
2.5 Definition (Pfad, Kreis) ...................................................................................... 6
2.6 Definition (azyklisch) ......................................................................................... 6
3. BÄUME................................................................................................................... 7
3.1 Definition (zyklenfrei, Wald)............................................................................... 7
3.2 Definition (Baum)............................................................................................... 7
3.3 Definition (Netzwerk) ......................................................................................... 7
3.3 Definition (minimal /maximal erzeugender Baum) ............................................. 8
4. ALGORITHMEN ZUR LÖSUNG VON MSB PROBLEMEN ................................ 9
4.1 Allgemeines...................................................................................................... 9
4.2 Der Algorithmus von Kruskal ........................................................................... 9
4.2.1 Beschreibung und Verfahren......................................................................... 9
4.2.2 Algorithmus im Pseudocode........................................................................ 10
4.2.3 Beispiel zur Vorgehensweise ...................................................................... 11
4.2.4 Laufzeitanalyse ........................................................................................... 12
4.3 Der Algorithmus von Prim............................................................................... 12
4.3.1 Beschreibung und Verfahren....................................................................... 12
4.3.2 Algorithmus im Pseudocode........................................................................ 13
4.3.3 Beispiel zur Vorgehensweise ...................................................................... 13
4.3.4 Laufzeitanalyse ........................................................................................... 15
4.4 Der Algorithmus von Boruvka ........................................................................ 15
4.4.1 Beschreibung und Verfahren........................................................................ 15
4.4.2 Algorithmus im Pseudocode........................................................................ 15
4.4.3 Beispiel zur Vorgehensweise ...................................................................... 16
4.4.4 Laufzeitanalyse ........................................................................................... 17
Quellenverzeichnis ................................................................................................. 18
2
0. Vorwort
Diese Dokumentation ist im Rahmen, des im Wintersemester 2004/2005, an der Universität Trier, stattgefundenen Softwarepraktikums C++, LEDA und STL entstanden.
Die Hauptthematik unserer Gruppe widmete sich hier vor allem der Implementierung
von Graphalgorithmen zur Berechnung von minimal / maximal aufspannenden Bäume.
Aufgabe war es, mittel GraphWin®, einem Editor zur Erzeugung, Manipulation und
Speicherung von Graphen, ein Programm zu entwickeln. Dieses sollte drei Algorithmen (Boruvka, Prim und Kruskal) zur Berechnung von minimalen / maximalen Netzwerken eines gegebenen Graphen implementieren. Ferner sollten die Ergebnisse der
Berechnungen dieser Algorithmen schrittweise visualisiert werden.
Die folgenden Abschnitte dieser Dokumentation widmen sich hierbei nicht unserer
expliziten Implementierung der Algorithmen. Es sollen hier lediglich die theoretischen
Grundlagen zu Graphen und die prinzipielle Vorgehensweise der Algorithmen von
Boruvka, Prim und Kruskal vermittelt werden.
3
1. Einleitung
Das erste Problem, welches mittels Graphentheorie gelöst wurde, war das berühmte
Königsberger Brückenproblem :
Die Stadt Königsberg in Preußen liegt am Zusammenfluss zweier Arme der Pregel.
Die Stadt besitzt (1736) sieben Brücken, die die einzelnen Stadteile miteinander verbinden, die an den verschiedenen Ufern dieser Flussarme und auf einer Insel im
Fluss liegen. Gefragt wird, ob es einem Spaziergänger möglich ist, die sieben Brücken von Königsberg genau einmal zu überqueren und an den Ausgangspunkt zurückzukehren.
Leonard Euler löste 1736 dieses Problem allgemein, indem er die Situation als Graph
darstellte, also einer Struktur, die nur aus Knoten und einzelnen Verbindungskanten
zwischen diesen Knoten besteht.
Modellierung des
Abbildung 1
Königsberger Brückenproblem
Er zieht dabei alle Örtlichkeiten der Stadt, die voneinander erreichbar sind, ohne
dass dabei eine Brücke überquert werden muss, zu einem Knoten zusammen und
verbindet diese mittels Kanten.
Bezogen auf den dabei entstandenen Graphen lautet die Frage nun: Gibt es einen
Weg, der von einem beliebigen Knoten des Graphen ausgeht, genau einmal über jede Kante des Graphen verläuft und zum Ausgangspunkt zurückführt?
Auf der Basis des graphentheoretischen Modells von Königsberg kann Euler nun
sehr einfach zeigen, dass es keinen Rundgang der gewünschten Art gibt: Auf solch
einem Rundgang, bei dem jede Kante nur einmal abgelaufen würde, müsste nämlich
die Anzahl der Ankünfte und Abgänge, dem so genannten Grad, in jedem Zwischenknoten gerade sein.
Tatsächlich hat der Graph, der die Stadt Königsberg modelliert jedoch die Eigenschaft, dass jeder seiner Knoten einen ungeraden Grad besitzt.
4
2. Graphen
2.1 Allgemeines
Um die in Abschnitt 4 vorgestellten Algorithmen zur Berechnung von minimal / maximal aufspannenden Bäumen verstehen zu können, bedarf es zunächst einiger theoretischen Grundlagen zum Thema Graphen. Im Folgenden soll nun erläutert werden,
was man generell unter einem Graphen versteht. Ferner sollen weitere Begriffe, die
damit in unmittelbarem Zusammenhang stehen und für das weitere Verstehen notwendig sind, definiert werden.
2.2 Definition (gerichteter Graph)
Ein gerichteter Graph G = (V, E) ist eine Struktur, die aus zwei Bestandteilen besteht:
Einer Menge V und einer Relation E V V über dieser Menge V. Die Elemente v
der Menge V werden Knoten genannt, die Elemente e = (v,u) der Menge E sind die
Kanten des Graphen. Die Kante e verbindet die Knoten u und v. u wird in diesem Zusammenhang auch Startknoten und u Endknoten von e genannt. Die Kante e hat
hierbei eine Richtung von u nach v. Es gilt ferner: E {(u,v ) | u,v V }
Zwei Knoten, die durch eine Kante miteinander verbunden sind, heißen adjazent.
Abbildung 2
Gerichteter Graph
2.2 Definition (ungerichteten Graph)
Ein ungerichteter Graph hat dieselbe Struktur wie ein gerichteter Graph. Er unterscheidet sich jedoch hinsichtlich der Kantenrichtungen. Hier ist die Richtung der Kanten egal. Verbindet eine Kante Knoten u mit Knoten v, so verbindet sie auch Knoten
v mit Knoten u Kanten gehen also in beide Richtungen und sind somit ungerichtet.
Es gilt daher für die Kantenmenge E: E {{u,v } | u,v V }
5
Abbildung 3
Ungerichteter Graph
2.3 Definition (Ausgangsgrad, Eingangsgrad)
Sei G = (V, E) ein Graph und v ein Knoten von G. Der Ausgangsgrad outdeg(v) von v
ist die Anzahl der Kanten, die v als Startknoten besitzen, der Eingangsgrad indeg(v)
von v ist die Zahl der Kanten, die in v enden. Es gilt damit
out deg(v ) | {u V : (v , u ) E } | und in deg(v ) | {u V : (u,v ) E } | . Ist G ein ungerichteter Graph so stimmen indeg(v) und oudeg(v) für alle v aus G überein und es
wird kurz von Grad deg(v) gesprochen.
2.3 Definition (benachbart, Weg, Länge, geschlossen)
Sei G = (V, E) ein Graph, und u und v seien zwei Knoten in G.
1. u und v heißen benachbart, wenn eine Kante von u nach v führt, wenn also
(u,v ) E gilt.
2. Ein Weg von u nach v ist eine Folge jeweils benachbarter Knoten u0, u1, , un mit
u=u0 und v=un. Die Länge des Weges ist n. Ein Weg der Länge 0 wird trivialer
Weg genannt, er besteht aus einem Knoten.
3. Ein Weg heißt geschlossen, wenn seine beiden Endknoten gleich sind.
2.4 Definition (zusammenhängend)
Zwei Knoten u und v eines ungerichteten Graphen G = (V, E) heißen zusammenhängend, wenn es in G einen Weg von u nach v gibt.
2.5 Definition (Pfad, Kreis)
1. Als Pfade werden Wege in einem Graphen bezeichnet, bei denen keine Kante
zweimal durchlaufen wird. Ein geschlossener Pfad heißt Kreis.
2. Ein einfacher Pfad ist ein Pfad, bei dem kein Knoten mehrfach durchlaufen wird.
Ein geschlossener Pfad, der mit Ausnahme seines Ausgangspunkts einfach ist,
heißt einfacher Kreis.
2.6 Definition (azyklisch)
Ein Graph G = (V, E) heißt azyklisch, wenn er keine Kreise hat.
6
3. Bäume
In den verschiedenen Anwendungsgebieten der Informatik spielen Graphen, die keine geschlossenen Wege besitzen, eine herausragende Rolle. Mit diesen als Bäume
bezeichneten Graphen wollen wir uns als nächstes beschäftigen. Aufbauend auf verschiedenen Definitionen wollen wir letztlich zu den minimal / maximal aufspannenden
Bäumen kommen, die für das nächste Kapitel von besonderer Bedeutung sind.
3.1 Definition (zyklenfrei, Wald)
1. Ein Graph heißt zyklenfrei, wenn es keinen geschlossenen Weg der Länge
gibt.
2. Ein ungerichteter Graph heißt Wald, wenn er zyklenfrei ist.
1
Abbildung 4
Wald mit zwei Komponenten
3.2 Definition (Baum)
Ein ungerichteter Graph heißt Baum, wenn er zyklenfrei und zusammenhängend ist.
Abbildung 5
Baum mit vier Knoten
3.3 Definition (Netzwerk)
Unter einem Netzwerk versteht man einen Graphen G = (V, E), auf dem eine Kostenbzw. Gewichtsfunktion w : E
definiert ist. Bei dieser Gewichtsfunktion wird jeder
Kante e E ein numerischer Wert aus dem Wertebereich
zugeordnet.
7
Abbildung 6
Beispiel eines Netzwerks mit Kantenkosten aus
+
3.3 Definition (minimal /maximal erzeugender Baum)
Sei Graph G = (V, E) ein Netzwerk mit Gewichtsfunktion w : E
menge T der Kantenmenge E von G heißt
w (T )
. Für jede Teil-
w (e )
e T
das Gewicht von T. Ein erzeugender Baum T von G heißt minimal erzeugender
Baum, wenn sein Gewicht unter allen erzeugenden Bäumen minimal ist. Ein erzeugender Baum T von G heißt maximal erzeugender Baum, wenn sein Gewicht unter
allen erzeugenden Bäumen maximal ist.
Im folgenden Abschnitt wollen wir uns auf minimal erzeugende Bäume, deren Gewichtsfunktion nur positive Werte annimmt, konzentrieren. Hier gilt also für die Gewichtsfunktion w : E
.
8
4. Algorithmen zur Lösung von MSB
Problemen
4.1 Allgemeines
Minimal erzeugende Bäume wurden erstmals von Boruvka im Jahre 1926 betrachtet.
Kurz nach 1920 sollte das ländliche Süd-Mähren elektrifiziert werden. Für das zu
konstruierende Netzwerk sollte eine möglichst ökonomische Lösung gefunden werden.
Boruvka entdeckte schließlich einen Algorithmus, mit dem es möglich war, einen minimalen Spannbaum eines gewichteten Netzwerkes zu ermitteln.
Boruvkas Arbeiten sind lange Zeit unbeachtet geblieben; häufig wird die Lösung des
Problems, minimale Bäume zu finden, immer noch auf Kruskal und Prim zugeschrieben, obwohl beide Boruvka zitieren.
Für die Suche nach minimal / maximal aufspannenden Bäumen finden sich besonders in heutiger Praxis überraschend viele Anwendungsbeispiele. Es stellen sich dabei oft die Fragen nach Einsparung und der Minimierung von Kosten, Wegen oder
Verbindungen.
Egal, ob beim Entwurf von Computernetzwerken, Fernmeldeverbindungen, Kanalisationen, Straßennetzen oder elektronischen Schaltungen, hier gilt es stets so viel Material wie möglich einzusparen, um somit kosteneffizient arbeiten zu können.
In den nachfolgenden Abschnitten sollen verschiedene Algorithmen zur Berechnung
minimal / maximal aufspannender Bäume näher untersucht werden. Hierbei werden
diese Algorithmen nicht nur anhand konkreter Beispiele illustriert, eine gesonderte
Betrachtung der einzelnen Laufzeiten soll hier ebenfalls Aufschluss über die Effizienz
der einzelnen Vorgehensweisen geben.
Ausgangslage für alle nachfolgenden Algorithmen ist, dass der zu behandelnde
Graph, gewichtet, zusammenhängend und ungerichtet ist.
4.2 Der Algorithmus von Kruskal
4.2.1 Beschreibung und Verfahren
Der erste Algorithmus, den wir hier näher unter die Lupe nehmen wollen, ist der Algorithmus von Kruskal. Dieser wurde erstmals 1930 von Jarnik entworfen, Kruskal
selber griff ihn im Jahre 1956 wieder auf.
Der Algorithmus von Kruskal arbeitet nach einen so genannten gierigen (engl.: greedy) Verfahren, was bedeutet, dass Entscheidungen die während des Verfahrens getroffen werden, nicht reversibel sind.
Der Kruskal - Algorithmus operiert hierbei auf einer sortierten Kantenliste. Diese setzt
sich aus allen Kanten zusammen, welche im Ausgangsgraph enthalten sind. Eine
geeignete Datenstruktur zur Speicherung dieser Kanten ist eine Prioritätsschlange,
welche die Kanten gemäß ihrer Kantengewichtung organisiert. Jede Kante dieser
Liste wird betrachtet und wird anschließend entweder verworfen oder für die Konstruktion des entsprechenden minimalen Spannbaum ausgewählt.
9
Der minimale Spannbaum wird so sequentiell aus Teilbäumen aufgebaut.
Das Verfahren ist in den nachfolgenden Zeilen erläutert:
1. Der Algorithmus startet zunächst mit einer leeren Kantenmenge. Jeder Knoten
des Graphen wird als eigenständige Komponente angesehen.
2. Die Kanten des Graphen sind gemäß ihrer Kantengewichtung in einer Prioritätswarteschlange organisiert.
3. Aus dieser Prioritätswarteschlange wird nun die Kante mit geringster Gewichtung
extrahiert.
4. Nun wird geprüft, ob die Knoten, die durch diese Kante verbunden werden, in unterschiedlichen Komponenten liegen.
Wenn ja: Kante aus Warteschlange löschen, die entsprechenden Komponenten vereinigen und Kante in Ergebnisliste aufnehmen.
Wenn nein: Kante nur aus Warteschlange löschen
5. Solange Prioritätswarteschlange nicht leer, gehe zu 3.
6. Ende
4.2.2 Algorithmus im Pseudocode
Gegeben sei ein zusammenhängender, ungerichteter Graph G mit Knotenmenge
V = 1,...,n und Gewichtsfunktion w : E
. Dabei seien die Kanten von G nach
aufsteigendem Gewicht geordnet, also E = {e1, , en} mit w(e1) ... w(en).
Als Eingabe erhält der Algorithmus von Kruskal den Graphen G mit seiner entsprechenden Gewichtsfunktion w. Die Ausgabe ist der minimale Spannbaum T von G.
Prozedur KRUSKAL(G,w;T)
(1)
(2)
(3)
(4)
(5)
(6)
(7)
T
for k = 1 to n do Vi {i} od;
bilde aus E eine Priority-Queue Q mit Prioritätsfunktion w;
while Q
do
e:= DELETEMIN(Q);
finde die Endpunkte u und v von e;
finde die Komponenten Vu bzw. Vv, die u
bzw. v enthalten
(8)
if Vu
Vv then MERGE(Vu,Vv); T T e ; fi
(9) od
10
4.2.3 Beispiel zur Vorgehensweise
Das folgende Beispiel soll die Vorgehensweise des Algorithmus verdeutlichen.
Ausgehend vom nachfolgenden Graphen soll ein minimaler Spannbaum erzeugt
werden. Die Abbildungen sind hierbei der GraphWin - Visualisierung unserer Implementierung des Kruskal - Algorithmus entnommen. Kanten und Knoten die in den
minimalen Spannbaum aufgenommen werden, sind rot unterlegt dargestellt.
1.
Ausgangsgraph
2.
Aus der Prioritätsschlange wird
die Kante mit niedrigster Gewichtung genommen. Dies ist die Kante
(1,2) mit w(1,2) = 10, die darauf
aus der Schlange entfernt wird.
3.
Die nächst kleinere Kante ist
(3,4) mit w(3,4) = 15. Sie verbindet zwei Knoten unterschiedlicher Komponenten und wird daher
auch in den minimalen Spannbaum
aufgenommen.
4.
Als nächstes wird die Kante (2,3)
mit w(2,3) = 20 aufgenommen.
11
5.
Als letztes wird die Kante (0,1)
hinzugefügt. Alle Knoten sind somit verbunden und der minimale
Spannbaum wurde somit generiert.
4.2.4 Laufzeitanalyse
Die Laufzeit des Algorithmus hängt maßgeblich von Schritt 3 ab.
Normalerweise kann zur Sortierung der Kanten des Graphen jeder Sortieralgorithmus verwendet werden. Die Laufzeit des Algorithmus ist hierbei entscheidend.
Setzt man beispielsweise Bubblesort als Algorithmus ein, so werden die Kanten in
Zeit O(|E|2) sortiert. Für den restlichen Algorithmus schätzt man O(|V2|) ab und erhält
somit eine Gesamtlaufzeit von O(|V2|).
Verwendet man jedoch in Schritt 3 die oben angesprochene Priority - Queue als Datenstruktur, so ist das Auffinden und Entfernen der minimalen Kante e in O(log E )
Schritten möglich. Die Vereinigung der zunächst n Komponenten der Partition kann
in insgesamt O(n log n ) Schritten erfolgen. Der Graph G hat mindestens n-1 Kanten, da er zusammenhängend ist.
Die Gesamtkomplexität beträgt somit O( E
log E ) .
4.3 Der Algorithmus von Prim
4.3.1 Beschreibung und Verfahren
Dieser Algorithmus geht im Wesentlichen auf Jarnik zurück und wurde von Dijkstra
und Prim wieder entdeckt. Er ist auch unter dem Namen Prim Dijkstra - Algorithmus
bekannt.
Der Algorithmus von Prim liefert, ebenso wie der Kruskal - Algorithmus, durch ein
gieriges Verfahren einen minimalen Spannbaum eines bewerteten ungerichteten
Graphen.
12
Der Algorithmus geht zunächst von einem beliebigen Startpunkt aus, wobei alle angrenzenden Kanten untersucht werden. Er untersucht alle möglichen Pfade, die sich
von diesem Startpunkt zu anderen Knotenpunkten finden lassen und nimmt dann
den günstigsten. Dann untersucht er alle möglichen Pfade von beiden Knotenpunkten und sucht wiederum den günstigsten. Der Algorithmus führt hierbei n-1 Iterationen aus, wobei n die Anzahl der Knoten des Graphen ist.
4.3.2 Algorithmus im Pseudocode
Gegeben sei ein zusammenhängender, ungerichteter Graph G mit Knotenmenge
V = 1,...,n und Gewichtsfunktion w : E
(über Adjazenzlisten Av).
Als Eingabe erhält der Algorithmus von Prim den Graphen G mit seiner entsprechenden Gewichtsfunktion w. Die Ausgabe ist der minimale Spannbaum T von G.
Prozedur PRIM(G,w;T)
(1) w(1)
, S
,T
;
(2) for i = 2 to n do g(i)
od;
(3) while S V do
(4)
wähle ein i S\V, für das g(i) minimal ist,
und setze S S i ;
(5)
(6)
(7)
(8)
(9)
(10) od
if i 1 then T T e ; fi
for e Ai E(S,V\S) do
v sei Endpunkt von e in V\S;
if g(v) > w(e) then g(v) w(e) und e(v)
od
e fi
4.3.3 Beispiel zur Vorgehensweise
Zu Demonstration der Vorgehensweise des Prim-Algorithmus soll das in Abschnitt
4.2.3 angeführte Beispiel nochmals betrachtet werden. Hier sind ebenfall alle Kanten,
die den späteren Minimalbaum bilden rot gefärbt.
13
1.
Ausgangsgraph
2.
Der Algorithmus startet bei Knoten 0. Er untersucht die angrenzenden Kanten (0,1) und (0,3).
Dabei stellt er fest, dass die
Kante (0,1) die kleinere Gewichtung (35 < 40) und nimmt daher
diese in den Baum mit auf.
3.
Jetzt
werden
die
angrenzenden
Kanten der Knoten 0 und 1 betrachtet. Hierbei ist die Kante
(1,2) die kleinste (10 < 35 <
40). Diese wird nun in den Baum
mit aufgenommen und daher rot
markiert.
4.
Hier werden nun die Kanten (0,3),
(1,3), (2,3) und (2,4) betrachtet. (2,3) ist mit einer Gewichtung von 20 die kleinste und wird
somit rot gefärbt.
5.
Als letztes wird die Kante (3,4)
aufgenommen. Der erzeugte Spannbaum ist somit fertig und mit dem
vom Kruskal - Algorithmus erzeugten Baum identisch
14
4.3.4 Laufzeitanalyse
Der Algorithmus, wie oben beschrieben, bestimmt einen minimal erzeugenden Baum
in Zeit O(|V|2).
Die while Schleife in Schritt 3 wird dabei |V| - mal durchlaufen. Bei jeder Iteration
sind die notwendigen Vergleiche in Schritt 4 in maximal |V|-|S| Schritten möglich,
woraus eine Zeitkomplexität von O(|V|2) resultiert.
Durch Verwendung besserer Datenstrukturen (z.B. bei Verwendung von FibonacciHeaps als Speicher) kommt man mit einer Zeitkomplexität von O(| V | log | V | | E |)
aus.
4.4 Der Algorithmus von Boruvka
4.4.1 Beschreibung und Verfahren
Schließlich sei noch ein dritter Algorithmus zur Ermittlung eines minimalen Spannbaums eines gewichteten, ungerichteten Graphen erwähnt, der Algorithmus von Boruvka. Dieser stammt aus dem Jahre 1926 und ist aus Kruskals und Prims Algorithmus hervorgegangen. Er behandelt den Spezialfall, dass die Kantengewichte paarweise verschieden sind.
Der Algorithmus betrachtet anfangs jeden Knoten als Baum bzw. isolierte Komponente. In jeder Iteration sucht sich jeder Knoten die Kante mit dem niedrigsten Wert,
welche die aktuelle Komponente mit einer anderen Komponente verbindet. Diese
Kante wird dann in den minimalen Spannbaum aufgenommen.
Dabei werden Kanten so hinzugenommen, dass stets zwei Komponenten immer nur
durch eine Kante verbunden werden und auftretende Kreise aufgelöst werden. Dieser Schritt wird solange wiederholt, bis nur noch eine Komponente existiert, die dann
einen minimalen Spannbaum des Ausgangsgraphen bildet.
4.4.2 Algorithmus im Pseudocode
Gegeben sei ein zusammenhängender, ungerichteter Graph G mit Knotenmenge
, wobei verschiedene Kanten stets verV = 1,...,n und Gewichtsfunktion w : E
schiedenes Gewicht haben.
Als Eingabe erhält der Algorithmus von Prim den Graphen G mit seiner entsprechenden Gewichtsfunktion w. Die Ausgabe ist der minimale Spannbaum T von G.
15
Prozedur BORUVKA(G,w;T)
(1) for i = 1 to n do Vi {i} od;
(2) T
; M
V1,...,Vn ;
(3) while |T| < n-1 do
(4)
for U M do
(5)
finde eine Kante e = uv mit u U ,
v U und w(e) < w(e )
für alle Kanten e = u v mit v' U und v' U ;
(6)
finde die Komponente U , die v enthält
(7)
T T e ;
(8)
od
(9)
for U M do v sei Endpunkt von e in V\S;
(10)
MERGE (U,U )
(11)
od
(12) od
4.4.3 Beispiel zur Vorgehensweise
Wie bereits in den vorherigen Beispielen soll hier ebenfalls wieder derselbe Ausgangsgraph genommen werden.
1.
Ausgangsgraph
2.
Der Algorithmus startet, nimmt in
der ersten Iteration jeden Knoten
unter die Lupe und ermittelt zu
jedem die günstigste Kante.
Die günstigste Kante von Knoten 0
ist (0,1) ist w(0,1) = 35, von
Knoten 1 und 2 jeweils die Kante
(1,2). Knoten 1 und 2 haben also
jeweils
die
Kante
(1,2)
mit
w(1,2)=10 als günstigste Kante
gemeinsam. Diese wird in den minimalen Baum mit aufgenommen.
16
3.
Als nächstes untersucht der Algorithmus alle ausgehenden Kanten
von Knoten 3 und 4, stellt dabei
fest, dass die Kante (3,4) mit
w(3,4)=15 die günstigste beider
Knoten ist. Daher werden Knoten 3
und 4 zu einer Komponenten vereinigt.
4.
Vor
der
nächsten
Iteration
existieren
bereits
die
Komponenten (0), (1,2) und (3,4).
Diese
werden
nun
über
die
möglichst
günstigste
Kante
miteinander
verbunden.
Diese
Kante ist (2,3) mit w(2,3)=20. Es
ist
somit
die
Komponente
(1,2,3,4) entstanden.
5.
Im letzten Schritt wird die günstigsten Kanten der Komponenten
(0) und (1,2,3,4) ermittelt. Diese ist die Kante (0,1) mit
w(0,1)=35. Diese Kante wird in
den minimalen Spannbaum aufgenommen. Der minimale Baum wurde somit generiert.
4.4.4 Laufzeitanalyse
Der Algorithmus von Boruvka bestimmt einen minimal aufspannenden Baum mit
Zeitkomplexität O(| V 2 | log | V |) .
Die Suche nach der Kante mit dem geringsten Gewicht, die mit jeder Komponente
inzident ist, benötigt O(V 2 ) Vergleiche. Die Anzahl der Komponenten reduziert sich
dabei in jeder Iteration um den Faktor zwei, die Anzahl der Zusammenhangskomponenten wird also mindestens halbiert. Folglich sind O(log | V |) Iterationen nötig, um
den minimalen spannenden Baum zu finden.
Es ergibt sich somit eine Laufzeit von O(| V 2 | log | V |) .
17
Quellenverzeichnis
[1] Meinel, Christoph: Mathematische Grundlagen der Informatik, B.G. Teubner Verlag (2000)
ISBN 3 - 519 - 02949 - 9
[2] Getferd, Florian: Minimal aufspannenden Bäume
www.mathematik.uni-kl.de/~krumke/Teaching/SS2004/proseminar/Data/minspan_getfert.pdf
[3] Seeliger, André.: Algorithmen für minimal aufspannende Bäume
www.inf.hs-zigr.de/~wagenkn/ TI/Komplexitaet/ReferateSS00/seeliger.pdf
[4] Augustin, Daniel.: Graphen
www.vameo.de/uni/tutorium2/graphen.pdf
18