Graphen

Algorithmen und Datenstrukturen 2
Prof. Dr. C. Stamm, B. Scheuner christoph.stamm@fhnw.ch Tel.: 056 462 47 44
1 Einführung in Graphen
Ein Graph ist eine Menge von Knoten, welche durch Kanten verbunden sind. Bis jetzt haben Sie eine
spezielle Teilmenge der Graphen die Bäume kennen gelernt. Es gibt jedoch noch viele andere Arten
von Graphen. Graphen dienen ganz allgemein der Veranschaulichung von Zusammenhängen zwischen
verschiedenen Objekten. Dabei werden die Objekte meistens als Knoten und die Zusammenhänge
als Kanten dargestellt.
Ein ganz offensichtliches Beispiel ist das Internet. Es
besteht aus Endgeräten und Routern (Knoten) und aus
Netzwerk-Verbindungen (Kanten) dazwischen. Ein Problem
im Internet ist das Auffinden einer möglichst
schnellen Verbindung zwischen zwei Endgeräten. Üblicherweise
gibt es zwischen zwei Knoten immer mehr als
nur eine Verbindung. Aber welche dieser Verbindungen
?
ist nun die kürzeste oder die schnellste
Das nebenstehende Liniennetz eines Verkehrsbetriebes
ist auch ein Graph. An jeder Haltestelle können Sie sich
ein Bild dieses Graphen ansehen. Hier fragen sich die
Benutzer, welches der schnellste oder billigste Weg von
einer Haltestelle zur nächsten ist, oder auf welcher
ssen.
Route sie am wenigsten umsteigen mü
Man kann aber noch ganz andere Probleme als Graphen
darstellen. Z.B. kann das Finden einer besten (z.B.
kürzesten, einfachsten, schnellsten) Besichtigungstour
einer Stadt mit vielen Sehenswürdigkeiten als Graphenproblem
interpretiert werden. Jede Sehenswürdigkeit
wird dabei als Knoten dargestellt. Zwei Knoten sind
genau dann mit einer Kante verbunden, wenn die beiden
Sehenswürdigkeiten über einen direkten Weg verbunden
sind. Nun möchten Sie z.B. eine Tour finden, bei der Sie
alle Sehenswürdigkeiten besichtigen können und dabei
so wenig wie möglich Kilometer zurücklegen müssen.
Sie sehen, dass Graphen in unserer modernen Welt sehr
weit verbreitet sind. Sehr viele Situationen lassen sich in einem Graph veranschaulichen; meist mit
dem Ziel, Probleme zu lösen. Das Lösen dieser Probleme ist Gegenstand der Graphentheorie. Als
erstes werden wir nun definieren, was ein Graph ist, und welche Eigenschaften er hat. Danach werden
wir einige bekannte Algorithmen betrachten.
In Wikipedia 1 finden Sie ein Glossar der Graphentheorie mit ca. 250 Begriffen. Ein Teil dieser Begriffe
kennen Sie schon von den Bäumen und aus dem Fach Diskrete Mathematik.
1.1 Definitionen
Graph: Ein Graph besteht aus einer Knotenmenge V (vertices) und einer Kantenmenge E (edges).
Dabei gilt:
(i) |V| = n > 0
(ii) E = {(u, v) | u, v ∈ V} wobei u und v nicht verschieden sein müssen. Eine Kante ist also ein
Paar von Knoten. Falls u = v gilt, dann sprechen wir von einer Schleife oder Schlinge, also
einer Kante, welche einen Knoten mit sich selber verbindet.
|E| = m ≥ 0
Notation: V = {1, 2, ..., n} und E = {(1,2), (3,2), ..., (2,4)}
Knoten: Der Grad eines Knoten in einem Graphen entspricht der Menge der Kanten, welche den
Knoten als (einen) Anfangs- bzw. Endpunkt haben. Der Grad wird angegeben als deg(v). Eine
1 http://de.wikipedia.org/wiki/Glossar_Graphentheorie
1

Kante ist zu ihren Anfangs- und Endknoten inzident. Alle Knoten, mit denen ein Knoten durch eine
Kante verbunden ist, heissen adjazente Knoten. Diese adjazenten Knoten werden meist auch als
Nachbarn bezeichnet.
Kanten: Eine Kante verbindet zwei Knoten miteinander. Dabei kann sie eine Richtung haben (gerichtet),
oder aber auch ungerichtet sein. Wenn sie eine Richtung hat, wird sie als Pfeil gezeichnet
und als Paar von Knoten (u, v) symbolisiert, wobei u der Startknoten und v der Zielknoten ist. Eine
ungerichtete Kante wird als Verbindungslinie gezeichnet und als Menge {u, v} symbolisiert.
Neben der Richtung kann eine Kante auch noch ein Gewicht haben. Solche Kanten heissen gewichtete
Kanten. Gewichte stellen zum Beispiel die Entfernung zweier Knoten oder die Bandbreite
einer Internetleitung dar.
Sind zwei Knoten durch mehrere direkte Kanten verbunden, wird diese Gruppe als Mehrfachkante
zusammengefasst.
Ist ein Knoten mit sich selber durch eine Kante verbunden, wird diese Kante als Schlinge bezeichnet.
(Für den Grad eines Knoten wird diese Kante zweimal gezählt.)
Zusammenhängende Graphen: Ein Graph ist zusammenhängend, wenn von jedem Knoten jeder
andere Knoten über Kanten erreicht werden kann. Ist ein Graph nicht zusammenhängend, besteht
er aus mehreren Komponenten. Das Tramnetz einer Stadt ist üblicherweise ein zusammenhängender
Graph. Alle Tramnetze der Schweiz gemeinsam betrachtet, sind jedoch ein nicht zusammenhängender
Graph.
2
Mehrfachkante
3
0
3
Schlinge
1 2
3
Baum: Ein Baum ist ein spezieller zusammenhängender Graph. Er zeichnet sich dadurch aus, dass
er keine Kreise und somit auch keine Schlingen enthält (siehe Unterkapitel Kreise).
1.2 Einfache Graphen
Ein einfacher Graph ist ein ungerichteter Graph ohne Mehrfachkanten und ohne Schlingen. In einfachen
Graphen und auch in allen anderen ungerichteten Graphen können folgende Aussagen gemacht
werden:
• Die Summe aller Knotengrade ist gerade, sie entspricht dem Zweifachen der Anzahl Kanten m.
∑ v in V deg(v) = 2⋅m
• Die Anzahl der Knoten mit ungeradem Knotengrad ist gerade.
Beweis: Die Summe aller Knotengrade ist gerade. Die Summe aller geraden Knotengrade ist gerade.
Eine gerade Zahl minus eine gerade Zahl muss wieder gerade sein. Somit ist die Summe aller
ungeraden Grade wieder gerade. Diese Summe kann nun nur gerade sein, wenn es eine gerade
Anzahl von ungeraden Graden gibt.
Formal: ∑ v in V deg(v) = ∑ v in V deg gerade (v) + ∑ v in V deg ungerade (v) = 2 m
∑ v in V deg gerade (v) ist gerade, weil die Summe von geraden Zahlen immer gerade ist.
∑ v in V deg ungerade (v) muss auch gerade sein, weil die Summe der beiden gerade ist.
Nehmen wir nun an, dass wir eine ungerade Anzahl ungerader Grade haben. Dann können
wir immer Paare (mit gerader Summe) bilden, bis auf einen Grad. Dass diese Summe nie gerade
sein kann ist einleuchtend.
1.2.1 Vollständige Graphen (K n )
K 2
K 3 K 4
K 5
Ein vollständiger Graph ist ein einfacher Graph. Er hat aber die zusätzliche Eigenschaft, dass von
jedem Knoten aus alle andern Knoten direkt mit einer Kante verbunden sind. Solche Graphen können
für die Darstellung eines Tourniers verwendet werden, bei dem jedes Team gegen jedes andere Team
spielen muss.
2

1.2.2 Kreise (C n )
Ein Kreis ist ein einfacher Graph, bei dem alle Knoten den
Grad 2 haben. Von jedem Knoten kommt man auf zwei Wegen
zu jedem anderen Knoten.
1.2.3 Bipartite Graphen
Ein einfacher Graph heisst bipartit, wenn die Knotenmenge in zwei disjunkte Teilmengen aufgeteilt
werden kann und wenn alle Kanten nur Verbindungen zwischen den beiden Teilmengen herstellen. Es
gibt also keine Kanten zwischen zwei Knoten aus der gleichen Teilmenge.
Ein bipartiter Graph heisst vollständig, wenn jeder Knoten aus der einen Teilmenge mit allen Knoten
aus der andern Teilmenge verbunden ist. Wir bezeichnen einen vollständigen bipartiten Graph mit
(K a,b ).
Solche Graphen können zum Beispiel bei einer Partnerschaftsvermittlung gezeichnet werden. Jeder
Mann wird mit einer potentiellen Partnerin verbunden und umgekehrt.
K 3,4 K 4,1
1.2.4 Hyperwürfel
Eine etwas spezielle Art eines Graphen ist der Hyperwürfel. Dieser Graph ist wiederum ein einfacher
Graph. Seine Knoten haben jedoch ganz bestimmte Namen. Ein Hyperwürfel der Dimension d hat die
Knotenmenge, welche aus allen binären Folgen der Länge d besteht. Formal heisst dies: V= { {0,1} d }.
Eine Kante verbindet immer genau dann zwei Knoten, wenn sich deren Binärfolge in nur einer Stelle
unterscheiden. Z.B. werden die zwei Knoten mit den Binärfolgen 1011 und 1001 miteinander verbunden.
Solche Hyperwürfel werden zum Beispiel in der Codierungstheorie verwendet.
1.2.5 Planare Graphen
Planare Graphen sind einfache Graphen, welche so gezeichnet werden können, dass sich keine zwei
Kanten überschneiden. Über planare Graphen lassen sich sehr viele Aussagen machen. Zwei davon
werden hier erläutert. Um diese Aussagen jedoch zu verstehen, muss erst noch ein neuer Begriff
eingeführt werden:
Gebiet oder Fläche: Ein Gebiet ist eine zusammenhängende Fläche, welche von mindestens drei
Kanten begrenzt wird.
1. Bäume sind planar.
Idee: Durch ihre spezielle Struktur können alle Bäume so gezeichnet werden, dass sich keine zwei
Kanten überschneiden.
2. Eulersche Polyederformel
Sei G ein planarer, zusammenhängender, einfacher Graph mit n Knoten, m Kanten und f Gebieten.
Dann gilt: n – m + f = 2.
Beweis: Aus 1 ist bekannt, dass Bäume planar sind. In jedem Graphen kann ein Baum (Spannbaum)
aufgespannt werden, der alle Knoten beinhaltet.
Ein Baum mit n Knoten hat m = n – 1 Kanten. Es existiert nur ein Gebiet, f = 1. Daraus folgt:
n – (n – 1) + 1 = 2.
Nun werden die restlichen Kanten des Graphen sukzessive hinzugefügt. Dabei fällt auf, dass bei
jeder Kante die hinzugefügt wird, ein neues Gebiet erzeugt wird.
Die beiden Bilder zeigen die zwei Möglichkeiten.
Entweder wird vom umgebenden Gebiet
ein Teilgebiet abgetrennt oder ein inneres
Gebiet wird geteilt. Auf diese Weise werden die
fehlenden k Kanten hinzugefügt.
n – (n – 1 + k) + 1 + k = n – n +1 – k +1 + k = 2
3

3. Das Verhältnis von Gebieten zu Kanten: 3f ≤ 2m
Beweis: Ein Gebiet wird von mindestens drei Kanten begrenzt. Eine Kante begrenzt immer zwei
Gebiete. 3f bezeichnet alle Randkanten. Dabei ist aber jede Kante doppelt gezählt.
4. Kanten und Regionen in planaren Graphen
Für jeden einfachen planaren Graphen G = (V,E) mit |V| ≥ 3 gilt:
• m ≤ 3n – 6
• f ≤ 2n – 4
Beweis: n – m + f = 2 und 3f ≤ 2m sind gegeben. Aus der Polyederformel folgt: f = 2 – n + m. Setzen
wir diesen Wert für f in (3f ≤ 2m) ein erhalten wir: 3(2 – n + m) ≤ 2m. Daraus folgt:
6 – 3n + 3m ≤ 2m ⇒ 6 – 3n + m ≤ 0 ⇒ m ≤ 3n – 6.
Die zweite Aussage lässt sich analog dazu beweisen (Hausaufgabe).
5. K 5 und K 3,3 sind nicht planar.
K 5 oder K 3,3 sind die beiden kleinsten nicht planaren Graphen, was direkt aus dem Satz von Kuratowski
2 folgt. Der Satz von Kuratowski sagt: „Ein endlicher Graph ist genau dann planar, wenn er
keinen Teilgraphen enthält, der durch Unterteilung von K 5 oder K 3,3 entstanden ist. Unterteilung bedeutet
hier das beliebig oft wiederholbare (auch nullmalige) Einfügen von neuen Knoten auf Kanten.
Mit Teilgraph ist hier ein Graph gemeint, der aus dem ursprünglichen Graphen durch Entfernen von
Knoten bzw. Kanten entsteht.“ Somit erlaubt der Satz von Kuratowski zu entscheiden, ob ein Graph
planar ist oder nicht.
Ein anderer Beweis, dass K 5 nicht planar ist, folgt aus den Forderungen aus Punkt 4.
Beweis für K 5 : Dieser Graph besitzt n = 5 Knoten und 10 Kanten. In (m ≤ 3n – 6) ergibt dies
10 ≤ 15 – 6 = 9 (stimmt also nicht)
1.3 Gerichtete Graphen (Digraphen)
Im Unterschied zu den allgemeinen Graphen besitzen die Kanten gerichteter Graphen eine Richtung.
Das bedeutet, dass eine Kante zwischen zwei Knoten nur in einer Richtung durchlaufen werden darf.
Gerichtete Graphen finden ihre Anwendung in ganz verschiedenen Gebieten. In einem Projektplan
werden die Aktivitäten mit einer gerichteten Kante verbunden um anzuzeigen, wie der zeitliche Ablauf
sein muss. In einer Strassenkarte werden Einbahnstrassen mit einer Richtung versehen.
Eingangsgrad: Der Eingangsgrad (Indegree) eines Knoten entspricht der Anzahl gerichteter
Kanten, die in den Knoten hineinführen: indeg(v)
Ausgangsgrad: Der Ausgangsgrad (Outdegree) eines Knoten entspricht der Anzahl gerichteten
Kanten, die aus dem Knoten hinausführen: outdeg(v)
Die Summe der Eingangsgrade aller Knoten ist gleich der Summe der Ausgangsgrade aller Knoten.
∑ indeg(v) = ∑ outdeg(v)
2 z.B. http://de.wikipedia.org/wiki/Satz_von_Kuratowski
4

1.4 Lernkontrolle
1.4.1 Grapheneigenschaften
Hier sind einige Graphen abgebildet. Geben Sie für jeden Graphen die Grade der Knoten an. Versuchen
Sie dann so viele Eigenschaften wie möglich festzuhalten. Mit Eigenschaften sind hier gemeint:
• Zu welcher Gruppe von Graphen gehört der Graph? Z.B. Bäume, Kreise, vollständig bipartite
Graphen, einfacher Graph, etc.
• Ist der Graph zusammenhängend?
• Etc.
a) b) c)
d)
e)
f)
1.4.2 Summe der Knotengrade
Im Kapitel über einfache Graphen wurde gesagt, dass es immer eine gerade Anzahl von Knoten mit
ungeradem Grad geben muss. Wie sieht dies für die Anzahl der Knoten mit geradem Grad aus?
1.4.3 Planare Graphen
Lassen sich die die untenstehenden Graphen planar zeichnen? Be- oder widerlegen Sie die Planarität
mit den Formeln aus dem Kapitel über planare Graphen. Zeichnen Sie die planaren Graphen planar.
Schreiben Sie auch dazu, was die Graphen darstellen.
a) b)
c) d)
1.4.4 Kurzaufgaben
a) Wie viele Kanten hat der K 5 ?
b) Wie viele Kanten hat der K n ?
c) Wie viele Kanten hat der K 3,3 ?
d) Wie viele Kanten hat der K a,b ?
e) Wie viele Kanten hat der C 4 ?
f) Wie viele Kanten hat der C n ?
g) Zeichnen Sie für die folgende Situation einen Graphen, der die Situation widergibt: Sie laden 5
Freunde ein. Jeder Gast kennt zwei andere Gäste. Zeichnen Sie einen zusammenhängenden
Graphen.
h) Kann ein Graph mit 11 Knoten und 30 Kanten planar sein?
i) Kann ein Graph mit 5 Knoten und 6 Gebieten planar sein?
j) Kann ein Graph mit 5 Knoten, 10 Kanten und 8 Gebieten planar sein?
5

2 Speicherung von Graphen
Nach der Einführung kennen Sie die grundlegende Struktur von Graphen. In vielen Computerprogrammen
wird mit Graphen gearbeitet, z.B. Navigation, Routenplanung im Abfuhrwesen, Internet
Routing Protokoll. Alle diese Programme speichern in irgendeiner Form einen oder mehrere verschiedene
Graphen. Oft werden diese Graphen nicht nur im Hauptspeicher sondern auch auf dem Externspeicher
gehalten.
Die Art der Speicherung der Graphen kann auf die Effizienz der auszuführenden Algorithmen einen
Einfluss haben. Das ist eigentlich nichts Neues, wie Sie schon längst bei anderen Datenstrukturen
gesehen haben. Aus diesem Grund ist es wichtig, Graphen speicher- und laufzeiteffizient abzuspeichern.
Im Folgenden lernen Sie vier unterschiedliche Arten der Speicherung kennen.
2.1 Adjazenzmatrix
Der Beispielgraph ist der Graph G=(V,E) mit V={1,2,3,4,5} und E= {(1,3), (1,3), (3,4), (2,3), (2,5), (5,5)}
1
3
4
2
5
1 2 3 4 5
1 0 0 2 0 0
2 0 0 1 0 1
3 0 0 0 1 0
4 0 0 0 0 0
5 0 0 0 0 1
In einer Adjazenzmatrix werden adjazente Knotenpaare gespeichert. Es wird vermerkt, welche Knoten
durch eine Kante miteinander verbunden sind.
Die Adjazenzmatrix ist eine Matrix der Grösse n × n, wobei n die Anzahl der Knoten bezeichnet. Sind
zwei Knoten (u und v) mit einer gerichteten Kante verbunden wird in der Adjazenzmatrix in der u-ten
Zeile und der v-ten Spalte eine 1 eingetragen. Sind die beiden Knoten mit mehr als einer Kante verbunden,
wird die Anzahl der Kanten eingetragen. Für u und v gilt 1 ≤ u ≤ n, 1 ≤ v ≤ n.
Im Beispiel ist ein Digraph mit seiner Adjazenzmatrix dargestellt. Es ist erkennbar, dass Mehrfachkanten
zusammengezählt werden. Treten Schlingen auf, sind diese in der Diagonalen der Matrix ersichtlich.
Besteht die Diagonale aus lauter Nullen, ist der Graph schlingenfrei.
In ungerichteten Graphen ist die Matrix symmetrisch, weil sowohl (u, v) = 1 als auch (v, u) = 1 eingetragen
wird. Selbstverständlich lässt sich in diesem Fall die Speicherung leicht optimieren, indem nur
eine Dreiecksmatrix gespeichert wird.
Wenn der Graph gewichtet ist, dann wird das Gewicht der Kante in die Zelle eingetragen. Bei gewichteten
Graphen ist es unüblich, dass Mehrfachkanten auftreten (je nach Problem müsste dieser Umstand
anders behandelt werden). Man kann in einer Adjazenzmatrix nicht unterscheiden, ob die Kanten
gewichtet sind oder ob Mehrfachkanten aufgetreten sind.
Bemerkung: Bei dieser Art der Speicherung mit einem herkömmlichen Array werden die Knoten nur
implizit in Form des Array-Index gespeichert. Alle weiteren Eigenschaften von Knoten müssen separat
gespeichert werden.
2.2 Inzidenzmatrix
Der Beispielgraph ist der Graph G = (V, E) mit V = {1, 2, 3, 4, 5} und E = {{1,3}, {1,3}, {3,4}, {2,3}, {2,5},
{5}}
2
1
3
1
3
4
4
2
5
6
5
1 2 3 4 5 6
1 1 1 0 0 0 0
2 0 0 0 1 1 0
3 1 1 1 1 0 0
4 0 0 1 0 0 0
5 0 0 0 0 1 1
In der Inzidenzmatrix wird eingetragen, welche Kanten zu welchen Knoten inzident sind.
Die Inzidenzmatrix ist eine (n × m)-Matrix. Dabei werden nicht nur die Knoten nummeriert, sondern
auch die Kanten. Gehört eine Kante e mit Index j zu einem Knoten v, wird in der v-ten Zeile und der j-
6

ten Spalte eine 1 eingetragen. Ansonsten wird eine 0 eingetragen. Für v und j gelten 1 ≤ v ≤ n, 1 ≤ j ≤
m.
Im Beispiel ist eine Inzidenzmatrix für einen ungerichteten Graphen gezeigt. Für gerichtete Graphen
kann die Darstellung nicht einfach übernommen werden. Mann muss definieren können, ob ein inzidenter
Knoten der Ursprung oder das Ziel ist. Man könnte z.B. für Ursprung eine 1 eintragen und für
Ziel eine -1.
Gewichte der Kanten können in der Inzidenzmatrix berücksichtigt werden indem der Wert des Gewichts
in der Matrix eingetragen wird.
Bemerkung: Bei dieser Art der Speicherung werden Knoten und Kanten nur implizit in Form ihrer
Indizes erfasst. Zusätzliche Informationen zu Kanten und Knoten müssen deshalb in einer separaten
Struktur gespeichert werden.
2.3 Adjazenzlisten
Der Beispielgraph G = (V, E) ist gerichtet aber ungewichtet.
Es sei: G = (V, E) mit V = {1, 2, ..., 9} und E = {(1,2),
(1,3), (1,7), (4,6), (5,4), (6,1), (6,5), (6,6), (7,5), (9,8)}
Wie bei der Adjazenzmatrix werden bei dieser Speicherung
die Verbindungen zwischen zwei Knoten in den
Vordergrund gestellt. Es wird also gespeichert, welcher
Knoten mit welchem anderen Knoten benachbart ist.
Die Grundlage der Speicherung ist ein Knoten-Array.
Dieses Array hat so viele Felder, wie es Knoten gibt.
Jedem Knoten wird eine Position im Array zugeteilt. Im
Knoten-Array werden mindestens die Anfangszeiger auf
verkettete Listen gespeichert. In diesen Listen sind die
Knoten gespeichert, zu welchen eine direkte Verbindung
durch eine Kante besteht. Die Kante (u, v) aus dem Graph
führt zu einem Eintrag in der Liste an der Stelle u im
Array.
Diese Speicherung benötigt Ө(n + m) Speicherplatz. Adjazenzlisten unterstützen viele Operationen,
z.B. das Verfolgen von gerichteten Kanten in Graphen. Andere Operationen dagegen werden nur
schlecht unterstützt, insbesondere das Hinzufügen und Entfernen von Knoten.
2.4 Speicherung mit doppelt verketteten Listen
Der Beispielgraph ist derselbe
wie vorhin.
Bei dieser Speicherung werden
die Knoten und die Kanten als
Objekte behandelt. Es wird
ihnen also zugestanden, mehr
Information als nur den Namen
zu enthalten.
Die Basis bildet eine doppelt
verkettete Liste, welche die
Knotenobjekte enthält. Jedes
Knotenobjekt speichert dann
eine Liste mit den von ihm
ausgehenden Kanten-Objekten.
Auch diese Liste ist doppelt
verkettet.
Ein Kantenobjekt enthält drei
Referenzen. Zwei Referenzen
werden für die doppelt verkettete
Kantenliste benötigt. Die
dritte Referenz zeigt auf den
Knoten, auf den die gerichtete Kante zeigt. Zusätzlich können im Kantenobjekt noch weitere Informationen
wie z.B. das Gewicht der Kante gespeichert werden.
7

2.5 Lernkontrolle
2
1
2
3
1
4
3
4
5
5
2.5.1 Adjazenzmatrix
a) Geben Sie die Adjazenzmatrix für die beiden Graphen an.
b) Bei welchem Graphen ist der Speicherplatz besser ausgenutzt?
c) Denken Sie dass der Speicherplatz generell gut ausgenützt ist?
d) Gibt es Graphen, für die diese Speicherung gut, bzw. sehr schlecht ist?
2.5.2 Inzidenzmatrix
a) Geben Sie die Inzidenzmatrix für die beiden Graphen an.
b) Bei welchem Graphen ist der Speicherplatz besser ausgenutzt?
c) Denken Sie dass der Speicherplatz generell gut ausgenützt ist?
d) Gibt es Graphen, für die diese Speicherung gut, bzw. sehr schlecht ist?
2.5.3 Adjazenzlisten
Speichern Sie den oben rechts stehenden Graphen mit Hilfe von Adjazenzlisten ab.
8

3 Graphenalgorithmen
Es gibt sehr viele Probleme, welche sich im Zusammenhang mit Graphen stellen. Sie werden hier nur
einen ganz kleinen Teil dieser Probleme und deren Lösungsansätze kennen lernen.
3.1 Topologisches Sortieren
Eine topologische Sortierung basiert auf einer vergleichenden Relation. In einem gerichteten Graphen
besteht durch die Kantenrichtung eine solche vergleichende Relation zwischen je zwei benachbarten
Knoten. Die Kantenrichtung kann dabei gelesen werden wie zum Beispiel: „grösser als“, „folgt auf“
oder „ist Nachfolger von“. In ungerichteten Graphen besteht diese vergleichende Relation nicht und
daher kann keine topologische Sortierung erreicht werden.
Beispiel: Wir müssen einen Projektplan erstellen. Als erstes stellen wir fest, welche Aktivitäten zu
erledigen sind: „Analyse“, „Implementierung“, „Einkauf der Hardware“, „Test“, „Installation der Hardware“,
„Installation der Software“. Es ist klar, dass diese Aktivitäten eine zeitliche Abhängigkeit haben.
Wir müssen beispielsweise zuerst die Hardware kaufen, bevor wir sie installieren können.
Folgender Projektplan könnte nun erstellt werden:
Einkauf
Hardware
Installation
Hardware
Analyse
Implementierung
Test
Installation
Software
Wir sehen hier die zeitliche Abhängigkeit (Relation „kommt nach“). Wenn wir dieses Projekt nun
alleine durchführen müssen, können wir nicht so parallel arbeiten, wie das hier dargestellt ist. Wir
müssen eine sequenzielle (topologisch sortierte) Abfolge haben. Davon gibt es mehrere. Hier drei
Beispiele:
Analyse → Einkauf Hardware → Installation Hardware → Implementierung → Test → Installation Software
Analyse → Einkauf Hardware → Implementierung → Installation Hardware → Test → Installation Software
Analyse → Implementierung → Test → Einkauf Hardware → Installation Hardware → Installation Software
Eine topologische Sortierung eines Digraphen ist also eine vollständige Ordnung der Knoten, die mit
der durch die gerichteten Kanten ausgedrückten partiellen Ordnung verträglich ist.
3.1.1 Zyklenfreiheit
Ein Zyklus oder Kreis ist eine Folge von Kanten bei der Anfangs- und Endpunkt dieselben sind. Eine
Schlinge ist der kleinstmögliche Zyklus mit genau einem Knoten.
Nicht für alle Digraphen kann eine topologische Sortierung erzeugt werden. Die zentrale Eigenschaft
von topologisch sortierbaren Digraphen ist, dass sie keine Zyklen enthalten, also zyklenfrei sind.
In manchen Problemstellungen ist es sehr wichtig, dass die Graphen zyklenfrei sind. Beim Projektplan
darf es nicht sein, dass zwei Vorgänge je voneinander abhängen. Auch in Computerprogrammen ist
es oft nicht erlaubt, dass zyklische Abhängigkeiten bestehen: Wenn Klasse C1 von C2 abhängt, C2
von C3 abhängt und C3 von C1 abhängt, dann besteht ein zyklische Abhängigkeit.
Satz: Jeder zyklenfreie Graph hat eine topologische Sortierung.
3.1.2 Algorithmus
Die Idee des Algorithmus ist es, mit Knoten zu arbeiten, welche keine eingehenden Kanten haben,
d.h. die indeg(v) = 0 besitzen. Diese Knoten können nicht zu einem Zyklus gehören, da sie von keinem
anderen Knoten erreicht werden können. Es ist sofort einleuchtend, dass es in einem topologisch
sortierbaren Graphen mindestens einen Knoten v mit indeg(v) = 0 geben muss, weil es sonst keinen
ersten Knoten in der topologischen Sortierung geben würde. Dieser Knoten wird markiert und bildet
den Anfang der topologischen Sortierung. Alle markierten Knoten werden konzeptionell der Reihe
nach aus dem Graphen entfernt. Dadurch erniedrigt sich der Eingangsgrad anderer Knoten und es
gibt wieder einen oder mehrere neue Knoten mit indeg(v) = 0.
9

Input: Ein gerichteter Graph G. Alle Knoten kennen ihren Eingangsgrad.
Output: Eine topologische Sortierung von G oder die Information, dass es keine solche Sortierung
gibt.
L := { v ∈ V | indeg(v) == 0 }.
for (i := 1..n) do
if (L == {}) then
es gibt keine Sortierung Exit
endif
entferne den ersten Knoten u aus L und gebe ihn mit i aus
forall (Kanten e inzident zu u) do
v := Zielknoten von e
indeg(v) := indeg(v) – 1
if (indeg(v) == 0) then
füge v in L ein
endif
entferne e
endforall
entferne u
endfor
Dieser Pseudocode liefert eine topologische Sortierung eines Graphen wenn dieser zyklenfrei ist. Die
Laufzeit dieses Algorithmus beträgt O(n + m). Die äussere for-Schleife wird für jeden Knoten einmal
durchlaufen, also n mal. Die innere forall-Schleife geht für den Knoten u all seine ausgehenden,
inzidenten Kanten durch. Im Ganzen werden in allen forall-Schleifen alle Kanten einmal besucht.
Beispiel
1 2
3
2
3
3
4
5 6
4
5 6 4 5 6
3
4 6 4
6
6
Die markierten Knoten sind die Knoten mit indeg(v) = 0. In jedem Schritt wird ein Knoten dieser Art
aus dem Graphen entfernt. Die resultierende topologische Sortierung ist:
1 → 2 → 5 → 3 → 4 → 6
3.2 Durchlaufen von Graphen
Wie schon bei den Bäumen besteht auch hier der Bedarf, alle Knoten in einer geordneten Weise zu
besuchen und eventuell auszugeben. Gerade im Zusammenhang mit der Speicherung eines Graphen
auf dem Externspeicher (Serialisierung) ist es wichtig, alle Knoten zu besuchen und die Knotenobjekte
und inzidenten Kantenobjekte abzuspeichern.
Wiederum gibt es zwei Strategien mit denen alle Knoten besucht werden können: Die eine Strategie
ist die Tiefensuche (DFS = depth first search), die andere ist die Breitensuche (BFS = breadth first
search). Beide Strategien durchlaufen alle Knoten und alle Kanten, und haben sogar dieselbe Laufzeit.
10

3.2.1 Tiefensuche (DFS)
Bei der DFS-Strategie wird der Graph zunächst „in die Tiefe gehend durchsucht“. Die DFS-Strategie
ist eine Verallgemeinerung des Preorder-Durchlaufprinzips bei Binärbäumen. Das Prinzip ist das
folgende:
• Kanten werden ausgehend von dem zuletzt entdeckten Knoten
v, der mit noch unerforschten Kanten inzident ist, erforscht. w
• Erreicht man von v aus einen noch nicht erforschten Knoten w,
so verfährt man mit w genauso wie mit v.
• Wenn alle mit w inzidenten Kanten erforscht sind, erfolgt ein
Backtracking zu v.
Es gibt viele verschiedene Arten, wie die DFS-Strategie implementiert werden kann. Die folgende ist
also nur eine von vielen.
v
DFS mit drei Farben
Bei dieser Methode gibt es drei Arten von Knoten (weiss, grau, schwarz). Am Anfang ist jeder Knoten
weiss. Das bedeutet, dass er noch nicht entdeckt worden ist. Sobald ein Knoten entdeckt worden ist,
wird er grau. Wenn ein Knoten komplett abgearbeitet ist, wird er schwarz gefärbt. Dies ist der Fall,
wenn er das Backtracking zum Vorgängerknoten einleitet.
Des Weiteren wird für jeden Knoten noch abgespeichert, wer sein Vorgänger ist. D.h., von welchem
Knoten aus er entdeckt worden ist. Der Vorgänger wird in einem Array α gespeichert. Selbstverständlich
wäre es auch möglich, den Vorgänger direkt im Knoten zu speichern.
DFS (Graph G)
forall (v in V) do
farbe[v]:= weiss
α[v]:= null
endforall
forall (v in V) do
\\ so werden alle Zusammenhangskomponenten gefunden
if (farbe[v] == weiss) then
DFS-Visit(v)
endif
endforall
DFS-Visit(v)
farbe[v]:= grau
forall (w adjazent zu v) do
if (farbe[w] == weiss) then
α[w]:= v
DFS-Visit(w)
endif
endforall
farbe[v]:= schwarz
Durch dieses Verfahren werden alle Zusammenhangskomponenten gefunden. Jeder Knoten und jede
Kante werden einmal besucht. Am Ende enthält α die Informationen eines Spannbaums für den Graphen,
falls dieser zusammenhängend ist.
Laufzeitanalyse: Die Methode DFS(G) benötigt offensichtlich O(n) Schleifendurchläufe. Die Methode
DSF-Visit betrachtet für den Knoten v alle inzidenten, ausgehenden Kanten. Also dauern alle for-
Schleifen von DFS-Visit zusammen ∑ v∈V outdeg(v) = m. Somit ergibt sich eine Laufzeit von O(n + m)
11

Beispiel Tiefensuche
1 2
3 1 2 3
1
2 3
4 5 6
4 5 6
4
5 6
1 2
3 1 2
3 1 2 3
4 5 6
4 5 6
4
5 6
1 2
3 1 2 3
1
2 3
4 5 6
4 5 6
4 5 6
1 2
3 1 2 3
1 2 3
4 5 6
4 5 6
4
5 6
Als erstes wird in diesem Beispiel die Tiefensuche von Knoten 1 aus bis zum Knoten 6 gemacht.
Danach sind alle Knoten ausser Knoten 4 abgearbeitet. Als letztes Knoten wird noch Knoten 4 gefunden
und abgearbeitet.
3.2.2 Topologische Sortierung mittels DFS
Aus dem Algorithmus für die Tiefensuche kann ein zweiter Algorithmus für die topologische Sortierung
von zyklenfreien Graphen gewonnen werden:
DFS-Topological-Sort
Counter := n
rufe DFS(G) auf {
sobald ein Knoten schwarz gefärbt wird, setze nummer[v] := counter;
counter--
}
3.2.3 Breitensuche (BFS)
Der Algorithmus für die Breitensuche lautet wie folgt:
1. Für einen Knoten werden die noch nicht besuchten Nachbarknoten gesucht.
2. Jeder Nachbarknoten wird ans Ende einer Warteschlange eingefügt.
3. Solange die Warteschlange nicht leer ist, wähle den nächsten Knoten und beginne wieder bei 1.
Nachfolgend sehen Sie den Algorithmus in Pseudocode. Der Knoten s bezeichnet dabei den Startknoten
der Breitensuche. Q ist die Warteschlange (Queue).
BFS(Graph G, Knoten s)
forall (v in V) do
v.gefunden := false
// alle Knoten unentdeckt
endforall
s.gefunden := true
Q = {s}
while (Q nicht leer) do
entferne das vorderste Element u aus Q
forall (v in der Nachbarschaft von u) do // Alle Knoten die von u aus mit einer
// Kante erreicht werden können
12

if (v.gefunden == false) then
v.gefunden := true
füge v in Q ein
endif
endforall
endwhile
Dieser Algorithmus benötigt O(n + m) Zeit (wie DFS). Die while-Schleife wird so lange ausgeführt,
bis es keine unentdeckten Knoten mehr gibt (also n mal). Für jeden Knoten wird die Nachbarschaft
betrachtet. Dies sind so viele adjazente Knoten, wie der Knoten inzidente Kanten besitzt. Im Ganzen
wird die forall-Schleife also m-mal ausgeführt.
3.3 Kürzeste Pfade
Problem 1: Finde den kürzesten Pfad zwischen zwei Knoten.
Beispiel: Im Liniennetz der SBB möchten Sie den kürzesten Weg zwischen Ihrem Wohnort und
Brugg-Windisch finden, damit Sie nicht zu viel Zeit für Ihren Schulweg verlieren.
Problem 2: Finde alle kürzesten Pfade zwischen einem Knoten s und allen anderen Knoten des
Graphen.
Beispiel: Sie wollen herausfinden, wer aus Ihrer Klasse den kürzesten Schulweg hat.
Problem 3: Finde für jedes Knotenpaar des Graphen den kürzesten Pfad.
Beispiel: Sie erhalten einen Plan mit allen Standorten der FHNW. Nun dürfen Sie sich Ihr Schulgebäude
selber aussuchen. Sie suchen dasjenige mit der geringsten Entfernung zu Ihrem
Wohnort.
Die beiden Algorithmen, die in diesem Kapitel vorgestellt werden, lösen beide Problem 2. Die Algorithmen
sind nach ihren Erfindern benannt. Der berühmteste Algorithmus wurde 1959 von E.W.
Dijkstra vorgeschlagen. Vor ihm entwickelten R. Bellman(1956) und L. Ford(1958) unabhängig voneinander
denselben Algorithmus. Sowohl der Algorithmus von Dijkstra als auch der von Bellman und
Ford beschäftigen sich mit kürzesten Pfaden zwischen einem Knoten und allen anderen Knoten im
Graphen, dieses Problem wird auch als single source shortest path-Problem bezeichnet. Ausgehend
von einer Quelle (source) werden die kürzesten Pfade zu allen anderen Knoten im Graphen berechnet.
Was aber unterscheidet diese beiden Algorithmen, wenn sie doch dasselbe Ziel haben?
Beide Algorithmen funktionieren für gewichtete Graphen (gerichtet und ungerichtet) mit positiven
Kantenwerten. Der Algorithmus von Bellman und Ford kann zusätzlich noch mit gerichteten Graphen
arbeiten, deren Kantengewichte negativ sein dürfen.
3.3.1 Einleitung, Begriffe
Die hier definierten Begriffe sind recht intuitiv. Trotzdem müssen sie definiert werden, um Missverständnissen
vorzubeugen.
Pfad:
Ein Pfad ist eine endliche Folge P = (v 0 , e 1 , v 1 , ... , e k , v k ) mit k ≥ 0 mit v i aus
V und e i = (v i-1 , v i ) aus E. In einem Graph ohne Mehrfachkanten ist ein Pfad
alleine durch die Folge von benachbarten Knoten definiert.
Gewichtsfunktion: Die Gewichtsfunktion weist jeder Kante ein Gewicht zu. Diese Funktion wird
meist mit w (weight) bezeichnet. w(e) = Gewicht der Kante e.
Länge eines Pfades: Die Länge eines Pfades in einem gewichteten Graphen G = (V, E) mit Gewichtsfunktion
w ist bestimmt durch:
wP ( ) = ∑ we (
i
)
k
i=
1
Das ist die Summe der Kantengewichte der verwendeten
Kanten.
Distanz, Abstand: Der Abstand zweier Knoten u, v ist der kürzeste Pfad zwischen den beiden
Knoten. Bezeichnet wird dieser Abstand mit dist(u, v). Kann v von u aus
nicht erreicht werden ist der Abstand unendlich. Ein Knoten hat zu sich selber
den Abstand 0.
Weitere Voraussetzung: Der Graph, auf dem die Berechnung kürzester Pfade durchgeführt wird, ist
ein einfacher Graph, er enthält also keine Schlingen oder Mehrfachkanten.
13

Lemma: Sei s ein ausgezeichneter Knoten. Dann gilt: dist(s, v) ≤ dist(s, u) + w(u, v) für alle u, v in V.
Beweis: dist(s, v) ist der Wert des kürzesten Pfades zwischen s und v. Wird dabei die Kante {u, v} für
die Berechnung benutzt, so ist dist(s, u) + w(u, v) = dist(s, v). Wenn sie nicht benutzt wird, kann
dist(s, v) nicht grösser sein als dist(s, u) + w(u, v), weil ansonsten nicht der kürzeste Pfad gefunden
worden ist.
3.3.2 Allgemeine Methoden
Die beiden Algorithmen zur Berechnung der kürzesten Pfade verwenden die gleiche Initialisierung
init(Graph G, Knoten s) und dieselbe Methode test(…). Der Graph G kann gerichtet oder
ungerichtet sein. Der Knoten s ist der Startknoten von dem aus die kürzesten Pfade berechnet werden.
Die Werte d[v] enthalten den Wert des momentan kürzesten Pfades von s nach v. Diese Werte
sind dabei obere Schranken für dist(s, v). Am Ende der Algorithmen enthält d[v] den Wert des kürzesten
Pfades von s nach v.
init(Graph G, Knoten s)
forall (v in V) do
d[v] := ∞
// α[v]:= null //enthält den Nachbarknoten über den der kürzeste Pfad geht
endforall
d[s]:= 0 // s hat zu sich selber Abstand 0
Die Methode test(u, v) testet, ob eine gegebene Kante (u, v) den momentanen kürzesten Pfad
von s nach v abkürzen kann. Es wird dabei getestet, ob die Summe aus der Distanz der Kante (u, v)
und der Länge des Pfades von s nach u kleiner ist als die bisherige Länge des Pfades von s nach v.
boolean test(u,v)
if (d[v] > d[u] + w(u, v)) then
d[v] := d[u] + w(u, v);
// α[v] := u //enthält den Nachbarknoten über den der kürzeste Pfad geht
endif
Die Verweise auf den Knoten, von dem aus der eine Knoten erreicht worden ist, werden in dieser
Situation noch nicht gebraucht.
3.4 Der Algorithmus von Dijkstra
Dieser Algorithmus ist ein Greedy-Algorithmus. Greedy-Algorithmen (gierige Algorithmen oder Raffkealgorithmen)
bilden in der Informatik eine spezielle Klasse von Algorithmen. Sie zeichnen sich dadurch
aus, dass sie immer denjenigen Folgezustand auswählen, der zum Zeitpunkt der Wahl den grössten
Gewinn bzw. das beste Ergebnis verspricht. Bei Greedy-Algorithmen gibt es kein Backtracking. Eine
Lösung, die einmal als fix gekennzeichnet worden ist, wird im weiteren Verlauf nicht mehr verändert.
Dieser Algorithmus ist sehr ähnlich zum BFS-Algorithmus. Der BFS liefert für den Fall, in dem alle
Gewichte dieselben sind, eine Lösung für dieses Problem.
3.4.1 Prinzip und Pseudocode
Der Algorithmus von Dijkstra 3 arbeitet mit einer „Wellenfront“-Strategie. Für alle Knoten hinter der
Front ist der endgültige Distanzwert bereits ermittelt worden. Wir nennen diese Knoten permanent und
speichern sie in PERM ab. Für diese Knoten v gilt also: dist(s, v) = d[v]. Die Knoten vor der Front sind
noch nicht bearbeitet worden. Für alle Knoten auf der Front ist die Berechnung in Gange. Diese Knoten
werden in einer Prioritätswarteschlange PQ gespeichert. Die Prioritäten entsprechen den momentanen
Abständen zum Startknoten.
Anfangszustand: Am Anfang ist die Menge der permanenten Knoten leer. Die Menge der Knoten auf
der Front enthält nur den Startknoten s.
3 http://de.wikipedia.org/wiki/Algorithmus_von_Dijkstra
14

• Nimm einen Knoten u aus PQ, welcher den kleinsten Abstand zu s hat.
• Für alle Nachbarknoten v von u überprüfe mittels test(u, v) die Distanz. Wenn nötig wird diese
Distanz aktualisiert. Ist der Nachbarknoten v schon in PQ, wird seine Priorität dort aktualisiert. Ist
er noch nicht in dieser Menge, wird er mit dem aktuellen Wert der Distanz in diese Menge eingefügt.
• Nimm den Knoten u in die Menge der permanenten Knoten auf.
Pseudocode
Gegeben ist ein gewichteter Graph G mit nicht negativen Knotengewichten w und ein Startknoten s.
Dijkstra (G =(V, E), w, s)
init(G, s)
PERM := {}
// Menge der permanent markierten Knoten
PQ := Prioritätswarteschlange // z.B. Min-Heap
PQ.insert(s, d[s]) // füge s mit Prio d[s] = 0 in PQ ein
while(!PQ.isEmpty()) do // es wurden noch nicht alle Distanzen definitiv gesetzt
u := PQ.removeMin() // u ist ein Knoten mit der kleinsten Distanz
forall(v benachbart zu u) do // Alle Knoten die von u aus mit einer Kante
// erreicht werden können
if (d[v] == ∞) then
PQ.insert(v, d[v])
endif
if (test(u, v)) then // Teste ob dieser Pfad kürzer ist.
// Wenn ja, wird in Test(u,v) d[v] heruntergestzt.
PQ.updatePrio(v, d[v]) // setze die Priorität von v in PQ auf d[v]
endif
endforall
PERM.add(u)
// füge u in die Menge PERM ein
endwhile
Bemerkung
Die Distanzwerte können auch in den Knoten selber gespeichert werden. Um zu markieren, ob ein
Knoten schon als permanent markiert worden ist, kann man dies auch im Knoten selber speichern.
3.4.2 Laufzeitanalyse
In jedem Durchlauf der while-Schleife wird genau ein Knoten in die Menge PERM eingefügt. Das
Einfügen in eine ungeordnete Menge kann in O(1) gemacht werden. Da n Knoten vorhanden sind,
resultiert für das Einfügen die Zeitkomplexität O(n).
Das Minimum in der Prioritätswarteschlange muss n mal gesucht werden, da jeder Knoten einmal das
Minimum ist. Wie schnell das Minimum aus der Prioritätswarteschlange geholt und entfernt werden
kann, hängt von der Realisierung der Prioritätswarteschlange ab. Auch die Zeit, die für das Einfügen
und das Aktualisieren des Schlüssels benötigt wird, hängt von der Prioritätswarteschlange ab. Jeder
Knoten wird einmal in die Prioritätswarteschlange eingefügt. Der Wert muss höchstens m mal verändert
werden. Generell sieht die Laufzeit also so aus:
T = O(n) + n·T min aus PQ extrahieren + n·T einfügen in PQ + m·T aktualisieren in PQ
Nehmen wir nun an, dass die Prioritätswarteschlange durch einen binären Min-Heap realisiert worden
ist. Dann wird die gesamte Laufzeit zu:
T = O(n) + n·O (log n) + n·O(log n) + m·O(log n)) = O(n log n + m log n)
T = O ((n + m) log n)
3.4.3 Problem bei negativen Gewichten
Wie schon an früherer Stelle angedeutet, setzt der Algorithmus von Dijkstra nicht negative Kantengewichte
voraus. Die folgenden Bilder zeigen ein Beispiel, bei dem mit dem Algorithmus von Dijkstra
Probleme auftreten. Nachdem die Distanz zum oberen Knoten auf 1 gesetzt und dieser Knoten in die
Menge PERM aufgenommen wurde, wird er als Nachbar vom Knoten rechts unten noch einmal in der
Prioritätswarteschlange PQ erwartet, obwohl er in PQ gar nicht mehr enthalten ist.
15

1
∞
1
1
1
1
0 - 4 0 - 4 0 -4
2
2
2
∞
2
2
3.5 Der Algorithmus von Bellman und Ford
Der Algorithmus von Bellman und Ford, der hier erklärt wird, kann auch mit negativen Gewichten
umgehen (wenn der Graph gerichtet ist). Wenn negative Gewichte zugelassen sind, tritt ein grundsätzliches
Problem auf: es kann ein Kreis negativer Länge von s aus erreichbar sein und damit
dist(s, v)= –∞ für alle Knoten v gelten, die von s aus erreichbar sind. Denn dieser Kreis kann unendlich
viele Male durchlaufen werden und vermindert den Wert des Pfades bei jedem
Durchlaufen.
Ein ungerichteter Graph enthält immer Zyklen, ausser es handelt sich um einen Baum.
Wenn nun eine Kante negatives Gewicht hat, ist schon ein Kreis negativer Länge
vorhanden.
Dieser Algorithmus ist kein Greedy-Algorithmus. Die Werte der Abstände können sich
bis zum Schluss verändern. Natürlich werden aber auch hier Zwischenwerte gespeichert und aktualisiert.
3.5.1 Prinzip und Pseudocode
• Es gibt n Phasen, wobei in der ersten Phase initialisiert wird.
• In jeder weiteren Phase wird jede Kante mit test(u, v) überprüft und d[v] aktualisiert.
• Am Ende enthält das Array d[v] für alle Knoten v die Distanz zwischen s und v.
Bellman-Ford(G = (V, E), w, s)
init(G,s)
for (k := 1..n-1) do
forall ((u,v) in E) do
test(u, v)
endforall
endfor
-3
-3
-3
Die genaue Vorgehensweise wollen wir anhand des oben stehenden Graphen illustrieren. Dabei ist es
zentral, dass wir eine Kantenreihenfolge festlegen, in der alle Kanten des Graphen besucht werden.
Obwohl der Algorithmus für alle möglichen Kantenreihenfolgen funktioniert, hat die Wahl Einfluss
darauf, wie früh die kürzesten Distanzen entdeckt werden. Mit gewissen Reihenfolgen werden die
korrekten Distanzen erst in der letzten Iteration gefunden, während mit anderen Kantenreihenfolgen
die kürzesten Distanzen bereits in der ersten Iteration gefunden werden.
Für unser Beispiel wählen wir die folgende Kantenreihenfolge: (A,C), (B,C), (B,D), (s,A), (C,D), (A,B).
Phasen k d[s] d[C] d[C] d[D] d[A] d[D] d[B]
0 (init) 0 ∞ ∞ ∞ ∞ ∞ ∞
1 3 3 – 1 = 2
2 3 + 2 = 5 2 + 2 = 4 2 + 8 = 10 4 + 3 = 7
3, 4, 5 0 4 4 7 3 7 2
3.5.2 Laufzeitanalyse
Die Laufzeit dieses Algorithmus ist, im Gegensatz zum Algorithmus von Dijkstra, von keiner Datenstruktur
abhängig. Die for-Schleife wird (n – 1)-mal durchlaufen. Bei jedem Durchlauf werden alle m
Kanten geprüft. Also ist die Laufzeit O(n·m).
Falls ein Kreis negativer Länge auftritt, ist die Laufzeit für die Berechnung unendlich gross. Dass die
Schleife nur n mal ausgeführt wird, verhindert eine endlose Laufzeit beim Algorithmus.
16

3.6 Lernkontrolle
3.6.1 Topologische Sortierung
a) Kann ein ungerichteter Graph topologisch sortiert werden?
b) Geben Sie für den folgenden Graphen eine topologische Sortierung an.
1
4
6
2
3 5 7
c) Zeichnen Sie noch zwei Kanten ein, welche die topologische Sortierung nicht beeinträchtigen.
3.6.2 Durchlaufen von Graphen
Zeichnen Sie im folgenden Graphen die verschiedenen Schritte einer a) Tiefensuche und b) Breitensuche
ein. Startknoten ist der Knoten 1. Geben Sie auch an, in welcher Reihenfolge die Knoten gefunden
werden.
1
4
6
2
3
5 7
3.6.3 Kürzeste Pfade
a) Sie haben gesehen, dass die Laufzeit des Dijkstra-Algorithmus O((n + m) log n) ist. Rechnen Sie
nun aus, wie die Laufzeit wäre, wenn anstatt der Prioritätswarteschlange eine sortierte Liste verwendet
würde.
b) Sie erhalten einen Graphen und sollen nun herausfinden, ob er eine Kante mit negativem Gewicht
enthält. Schreiben Sie in Pseudocode eine entsprechende Testmethode. Geben Sie zudem die
Laufzeit Ihres Algorithmus an.
c) Bestimmen Sie eine möglichst scharfe untere Grenze der Laufzeit für einen Algorithmus zur
Überprüfung von Kanten mit negativem Gewicht.
17

4 Spannbäume
Spannbäume sind Bäume die aus Kanten eines Graphen bestehen. Sie wissen, dass ein Baum mit n
Knoten genau n-1 Kanten enthält. Für einen Spannbaum werden also n – 1 Kanten aus der Menge
der Kanten ausgesucht, so dass ein zusammenhängender Graph entsteht. In diesem Graphen gibt es
zwischen zwei Knoten genau einen Weg gibt.
Wie ein Spannbaum berechnet wird, wissen Sie im Prinzip schon. Die Suchwege bei Breiten- und
Tiefensuche bilden einen Spannbaum. Im Code von BFS und DFS ist das Berechnen eines Spannbaumes
schon „eingebaut“. Speichert jeder Knoten den adjazenten Knoten, von dem er entdeckt
wurde, dann entspricht dies dem Speichern des Vaters im Spannbaum.
Das Beispiel zeigt einen Spannbaum, der bei der Breitensuche vom grauen Knoten aus berechnet
wurde.
Ein Spannbaum kann auch als Gerüst eines Graphen gesehen werden. Spannbäume gibt es nur in
zusammenhängenden Graphen. (Damit ein Graph zusammenhängend ist, muss er deshalb mindestens
n-1 Kanten haben.)
Übungsaufgaben
Geben Sie für den folgenden Graphen einen möglichen Spannbaum an.
Versuchen Sie im folgenden Graphen einen Spannbaum zu finden, dessen Kanten möglichst kurz
sind.
4.1 Minimale Spannbäume
In der Praxis braucht man meist nicht irgendeinen Spannbaum, sondern ist auf der Suche nach einem
minimalen Spannbaum. Minimale Spannbäume werden an den verschiedensten Orten eingesetzt:
Telekommunikationsfirmen versuchen ein möglichst kurzes Hauptnetz zu haben. Das spart Materialund
Unterhaltskosten. Es muss dabei sichergestellt werden, dass alle Ortschaften am Netz angeschlossen
sind. Vertriebsfirmen möchten ihre Verteillager so legen, dass die Wege zwischen den
einzelnen Lagern möglichst kurz sind.
18

4.2 Formale Definitionen
Spannbaum:
Ein Spannbaum ST (= Spanning Tree) eines Graphen G = (V, E) besteht
aus n – 1 Kanten der Menge E. Diese Kanten bilden einen zusammenhängenden
Graphen, der alle Knoten aus V enthält.
Minimaler Spannbaum: Ein minimaler Spannbaum MST (= Minimum Spanning Tree) ist ein Spanbaum,
bei dem die Summe der Kantengewichte minimal ist.
(Es kann in einem Graphen mehr als einen minimalen Spannbaum geben.)
4.3 Algorithmus von Prim
Der Algorithmus von Prim, auch Prim-Dijkstra-Algorithmus genannt, funktioniert analog zum Dijkstra-
Algorithmus. Der einzige Unterschied liegt darin, dass der Abstand zum Spannbaum und nicht der
Abstand zum Startknoten als Priorität (für die Prioritätswarteschlange) verwendet wird.
Der Abstand eines Knoten zum Spannbaum ist gleich dem kleinsten Gewicht einer Kante, die den
Knoten mit einem Knoten des Spannbaums verbindet.
4
7 1
8
Im Beispiel hat der graue Knoten vier inzidente Kanten, die ihn mit Knoten aus dem bisherigen
Spannbaum verbinden. Die Kante mit dem geringsten Gewicht hat das Gewicht w(e) = 1. Somit hat
der graue Knoten den Abstand 1 zum Spannbaum.
Abstand von v zum minimalen Spannbaum MST:
dist(v, MST) = min { w(e) | e = { v, u } ∈ E und v, u ∈ V}
Ist der Knoten v zu keinem Knoten des Spannbaums adjazent, ist die Distanz unendlich.
4.3.1 Prinzip
Vor der Implementierung des Prim-Algorithmus wird hier das Prinzip vorgestellt. Als erstes wird die
Startphase beschrieben. Danach wird gesagt, wie der Spannbaum in jedem Schritt um eine Kante
wächst. Als letztes wird noch die Endbedingung genannt.
Start: Als Ausgangspunkt wird ein beliebiger Knoten genommen. Dieser ist zu Beginn der einzige
Knoten im Spannbaum. Der Spannbaum enthält noch keine Kante.
Wachsen: Es wird der Knoten gesucht, der den kleinsten Abstand vom Spannbaum hat. Dieser
Knoten darf aber nicht schon im Spannbaum enthalten sein.
Der Knoten wird dann über die minimale Kante mit dem Spannbaum verbunden und in die
Menge der Knoten des Spannbaums aufgenommen.
Ende: Wenn alle Knoten im Spannbaum enthalten sind, dann ist die Berechnung zu Ende.
4.3.2 Beispiel
Gegeben ist ein Graph mit nebenstehender Adjazenzmatrix.
Die Werte in den Feldern geben die
Kantengewichte an.
s 1 2 3 4 5 6
s 0 2 0 5 7 0 0
1 2 0 8 6 0 3 0
2 0 8 0 0 0 2 4
3 5 6 0 0 1 0 5
4 7 0 0 1 0 0 1
5 0 3 2 0 0 0 2
6 0 0 4 5 1 2 0
19

In diesem Beispiel wird ein Spannbaum ausgehend vom Knoten s berechnet. Für jeden Schritt werden
die folgenden Informationen angegeben. Ein Bild zeigt den momentanen minimalen Spannbaum (linke
Spalte). Der Knoten, der als nächstes in den Spannbaum aufgenommen wird, die Queue und die
Menge der Knoten, die im Spannbaum sind, werden in der mittleren Spalte angegeben. In der Spalte
ganz rechts werden die Abstände der Knoten zum aktuellen Spannbaum angegeben.
Queue: {s}
s 1 2 3 4 5 6
MST: { }
0 ∞ ∞ ∞ ∞ ∞ ∞
s
1 2
3
5
Knoten: s
Queue: {1,3,4}
MST: { }
s 1 2 3 4 5 6
0 2 ∞ 5 7 ∞ ∞
4
6
s
1 2
3
5
Knoten: 1
Queue: {5, 3, 4, 2}
MST: {s}
s 1 2 3 4 5 6
0 0 8 5 7 3 ∞
4
6
s
1 2
3
5
Knoten: 5
Queue: {2, 6, 3, 4}
MST: {s, 1} s 1 2 3 4 5 6
0 0 2 5 7 0 2
4
6
s
1 2
3
5
Knoten: 2
Queue: {6, 3, 4}
MST: {s, 1, 5} s 1 2 3 4 5 6
0 0 0 5 7 0 2
4
6
s
1 2
3
5
Knoten: 6
Queue: {4, 3}
MST: {s, 1, 5, 2} s 1 2 3 4 5 6
0 0 0 5 1 0 0
4
6
s
1 2
3
5
Knoten: 4
Queue: {4}
MST: {s, 1, 5, 2, 6 } s 1 2 3 4 5 6
0 0 0 1 0 0 0
4
6
s
1 2
3
5
Knoten: 3
Queue: { }
MST: {s, 1, 5, 2, 6, 4} s 1 2 3 4 5 6
0 0 0 0 0 0 0
4
6
20

Übungsaufgaben
a) Zeichnen Sie den Graphen, der zu der nachfolgend gegebenen Adjazenzmatrix (links) gehört.
Erzeugen Sie dann den minimalen Spannbaum für diesen Graphen. Füllen Sie dabei die rechte
Tabelle der Gewichte aus (rechts). Geben Sie in dieser Tabelle in der Spalte ganz links an, welches
der aktuelle Knoten ist (analog zu den vorherigen Beispielen).
b) Geben Sie die Menge der Kanten an, die im minimalen Spannbaum enthalten sind. Z.B. {s, 3}
c) Welches Gewicht hat der hier erzeugte minimale Spannbaum.
d) Hätte in einem Schritt auch eine andere Kante (bzw. ein anderer Knoten) in den MST aufgenommen
werden können?
s 1 2 3 4 5 6
s 0 1 0 10 0 0 0
1 1 0 2 0 0 7 0
2 0 2 0 0 8 5 0
3 10 0 0 0 2 0 0
4 0 0 8 2 0 3 0
5 0 7 5 0 3 0 4
6 0 0 0 0 0 4 0
s
s 1 2 3 4 5 6
0 ∞ ∞ ∞ ∞ ∞ ∞
4.3.3 Implementierung
Für die Implementierung des Algorithmus von Prim können Methoden analog zu denen des Dijkstra-
Algorithmus verwendet werden. Diese müssen jedoch etwas abgeändert werden. Zuerst werden die
abgeänderten Hilfsmethoden danach die Hauptmethode beschrieben.
Hilfsmethoden
Die beiden Hilfsmethoden init(…) und test(…) müssen nur wenig angepasst werden. Das zentrale
Element, welches ändert, ist d[v]. Dieser Wert entspricht nun dem Abstand vom Spannbaum.
init(Graph G, Knoten s)
forall (v in V) do
d[v] := ∞ // minimaler Abstand zum Spannbaum
α[v] := null // enthält den Nachbarknoten, über den der kürzeste Weg geht
endforall
d[s] := 0
// s ist der erste Knoten des Spannbaums und hat deshalb den
// Abstand 0 vom Spannbaum
Die Methode init(…) initialisiert für jeden Knoten den Abstand vom Spannbaum. Am Anfang haben
alle Knoten bis auf den Startknoten den Abstand unendlich.
Die Methode test(…) wird aufgerufen, wenn eine neue Kante (und somit auch ein neuer Knoten u) in
den MST aufgenommen wird. Die Methode wird dabei verwendet, um zu testen, ob die Nachbarn v
des neuen Knoten u über die inzidenten Kanten von u schneller erreicht werden können als über
Kanten inzident zu den anderen Knoten des MST.
boolean test(e := {u,v})
if (w(e) < d[v]) then // Wenn die aktuelle Kante e geringeres Gewicht hat,
// als das aktuelle Minimum
d[v] := w(e); // wird der Wert des Minimus auf das Gewicht der Kante e gesetzt
α[v] := u;
endif
In dieser Variante wird bei einem erfolgreichen Test für den Knoten v der Knoten u als derjenige
Knoten gespeichert, über den v am schnellsten erreicht wird. Man könnte aber auch die Kante speichern,
über die der Knoten v mit dem geringsten Gewicht erreicht wird. Das Ziel beider Methoden ist
es, dass am Ende des Algorithmus nachvollziehbar ist, welche Kanten den MST bilden.
21

Hauptmethode
Die Hauptmethode benötigt die Hilfsmengen MST und queue. Wie schon erwähnt, ist die Priorität der
Knoten in der Prioritätswarteschlange gleich dem Abstand vom Spannbaum und nicht gleich dem
Abstand vom Startknoten s.
Vorarbeiten: Mit der Methode init(…) wird der Anfangszustand der Abstände initialisiert. Alle
Knoten haben einen unendlichen Abstand von s. Nur s hat Abstand 0.
Eine Prioritätswarteschlange PQ und eine Menge zur Speicherung der Spannbaumknoten
MST wird erzeugt.
Schleife: Solange noch nicht alle Koten im Spannbaum aufgenommen sind, wird die Schleife
ausgeführt.
1. Entnehme den Knoten u mit der geringsten Distanz zum Spannbaum aus der
Prioritätsschlange PQ.
2. Füge den Knoten in die Menge der Knoten des Spannbaums ein (MST).
3. Überprüfe mit test(…), ob Nachbarknoten v von u über u eine geringere Distanz
zum Spannbaum haben.
4. Verändere die Prioritäten der Nachbarn entsprechend dem Ergebnis.
prim (G :=(V,E), Gewichtsfunktion w, Startknoten s)
init(G, s)
MST := {}
PQ := Prioritärsschlange
PQ.insert(s, d[s])
while (|MST| < n) do
u := PQ.removeMin()
MST.insert(u)
forall (Nachbarn v von u) do
if (d[v] == ∞) then
PQ.insert(v, d[v])
endif
if (test({u,v}) then
PQ.updatePrio(v, d[v])
endif
endforall
endwhile
22