Zusammenfassung - S-Inf

Zusammenfassung 

Datenstrukturen & Algorithmen 

M. Leonard Haufs 

Sommersemester 2012

Wichtige Hinweise: 

Letzte Bearbeitung: Sonntag, 9. Dezember 2012 

Ihr dürft die Zusammenfassung selbstverständlich gerne nutzen. 

Ich habe nur eine Bedingung. Wenn ihr Fehler im Dokument findet, schreibt sie mir bitte 

an folgende Adresse, damit ich die Zusammenfassung verbessern kann: 

martin.leonard.haufs@rwth-aachen.de 

Viele der Abbildungen dieser Zusammenfassung sind folgender Vorlesung entnommen: 

Datenstrukturen und Algorithmen 

Prof. Dr. Joost-Pieter Katoen 

(RWTH Aachen, Sommersemester 2012)

Inhaltsverzeichnis 

1 Komplexitätsklassen 1 

2 Rekursionsgleichungen 2 

1 Rekursionsbäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 

2 Substitutionsmethode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 

3 Mastertheorem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 

3 Datenstrukturen 5 

1 Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 

2 Bäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 

2.1 Binärbäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 

2.2 Binäre Suchbäume . . . . . . . . . . . . . . . . . . . . . . . . . . 7 

2.3 Rot-Schwarz-Bäume . . . . . . . . . . . . . . . . . . . . . . . . . 9 

3 Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 

4 Flüsse 15 

1 Allgemeine Flusseigenschaften . . . . . . . . . . . . . . . . . . . . . . . . 15 

1.1 Flussnetzwerke . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 

1.2 Fluss in einem Flussnetzwerk . . . . . . . . . . . . . . . . . . . . 15 

1.3 Flüsse zwischen Knotenmengen . . . . . . . . . . . . . . . . . . . 16 

2 Ford-Fulkerson-Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 

5 Algorithmenprinzipien 17 

1 Divide & conquer - Teilen und Beherrschen . . . . . . . . . . . . . . . . . 17 

2 Greedy-Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 

3 Dynamische Programmierung . . . . . . . . . . . . . . . . . . . . . . . . 17 

3.1 Rucksackproblem . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 

3.2 Longest Common Subsequence (LCS) . . . . . . . . . . . . . . . . 19 

6 Sortieralgorithmen 21 

1 Einfache Sortieralgorithmen . . . . . . . . . . . . . . . . . . . . . . . . . 21 

1.1 Insertionsort - Sortieren durch einfügen . . . . . . . . . . . . . . . 21 

1.2 Selectionsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 

i

Inhaltsverzeichnis 

2 Höhere Sortieralgorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . 22 

2.1 Heapsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 

2.2 Countingsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 

2.3 Mergesort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 

2.4 Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 

2.5 Dutch National Flag- Problem . . . . . . . . . . . . . . . . . . . . 27 

3 Gesamtübersicht über Sortieralgorithmen . . . . . . . . . . . . . . . . . . 29 

7 Graphenalgorithmen 30 

1 Graphensuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 

1.1 Tiefensuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 

1.2 Breitensuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 

2 Sharir’s Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 

3 Prims Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 

4 Single Source Shortest Path (SSSP) . . . . . . . . . . . . . . . . . . . . . 35 

4.1 Dijkstra-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . 35 

4.2 Bellman-Ford-Algorithmus . . . . . . . . . . . . . . . . . . . . . . 36 

5 Topologische Sortierung . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 

6 All Pairs Shortest Paths . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 

6.1 Floyd-Warshall Algorithmus . . . . . . . . . . . . . . . . . . . . . 39 

7 Algorithmen auf Flussnetzwerken . . . . . . . . . . . . . . . . . . . . . . 40 

7.1 Ford-Fulkerson-Methode - Maximaler Fluss . . . . . . . . . . . . . 40 

7.2 Min-cut-max-flow . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 

8 Hashing 42 

1 Hashfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 

2 Geschlossenes Hashing . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 

3 Offenes Hashing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 

9 Algorithmische Geometrie 47 

1 Mathematische Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . 47 

2 Graham-Scan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 

ii

1 Komplexitätsklassen 

O(f) 

g ∈ O(f) ⇔ ∃c > 0, n0 : ∀n ≥ n0 : 0 ≤ g(n) ≤ c · f(n) 

Alternative Definition: 

Ω(f) 

g ∈ O(f) ⇔ lim sup 

n→∞ 

g(n) 

f(n) 

= c ≥ 0, c = ∞ 

g ∈ Ω(f) ⇔ ∃c > 0, n0 : ∀n ≥ n0 : c · f(n) ≤ g(n) 


Θ(f) 

g ∈ Ω(f) ⇔ lim inf 

n→∞ 

g(n) 

f(n) 

= c > 0 

g ∈ Θ(f) ⇔ ∃c1, c2 > 0, n0 : ∀n ≥ n0 : c1 · f(n) ≤ g(n) ≤ c2 · f(n) 


o(f) 

ω(f) 

g(n) 

g ∈ Θ(f) ⇔ lim 

n→∞ f(n) 

= c, 0 < c < ∞ 

g ∈ o(f) ⇔ ∀c > 0, n0 : ∀n ≥ n0 : 0 ≤ g(n) ≤ c < f(n) 

g ∈ ω(f) ⇔ ∀c > 0, n0 : ∀n ≥ n0 : f(n) < g(n) 

1

a) T (n) = 23T (b n 

23c) + 42n. 

Die Koeffizienten des Mastertheorems sind: b = 23, c = 23 und somit ist E = log23 23 = 1 und f (n) = 

42n 2 ⇥(nE ). Der 2. Fall des Mastertheorem liefert dann: 

2 Rekursionsgleichungen 

1 Rekursionsbäume 

Allgemeines Prinzip: 

Mithilfe von Rekursionsbäumen lässt sich die Lösung einer Rekursionsgleichung erraten, 

indem die Aufteilung in Teilprobleme iterativ dargestellt wird. 

Beispiel: T (n) = 2T ( n 

anwendbar da keiner der drei Fälle anwendbar ist: 

• n log2 n/2 O(n1 ✏ ) 

• n log2 n/2 ⇥(n1 ) 

• n log2 n/2 ⌦(n1+✏ ) 

denn n log2 n ist asymptotisch aber nicht polynomial größer als n. 

2 ) + n · log 2 n, T (0) = 1 

T (n) 2 ⇥(n· log n) 

b) T (n) =9T ( n 

3 ) + 27n 

Die Koeffizienten des Mastertheorems sind: b =9, c =3und somit ist E = log39 =2.Daf (n) = 27n 2 

O(n2 1 ) wenden wir den 1. Fall des Mastertheorem an und erhalten: 

c) T (n) =2T ( n 

T (n) 2 ⇥(n 2 ) 

2 )+n log2 n 

Es gilt b =2, c =2. Somit ist E = log2 2=1und f (n) =n log2 n. Hier ist das Mastertheorem nicht 

Wir betrachten den Rekursionsbaum: 

log 2 n 

T (n/9) 

n/18 + 3 

T (n/2) 

n/2 · log 2 n/2 

T (n/9) 

n/18 + 3 

T (n) 

n · log 2 n 

T (n/9) 

n/18 + 3 

T (n/2) 

n/2 · log 2 n/2 

T (n/9) 

n/18 + 3 

T (0)T (0)T (0)T (0)T (0)T (0) T (0)T (0)T (0)T (0)T (0)T (0) 

2 log 2 n = n 

aus dem Rekursionsbaum lesen wir eine Komplexität von: 

n log 2 n 

2 · n/2log 2 n/2 

4 · n/4log 2 n/4 

log2 n X 

T (n) = (2 i · n 

2i log log2 n 

log 

n X 

2 n X 

2 )=n·( log 

2i 2 n log2 2 i )=n(log 2 log2 n · (log2 n 1) 

2 n 

) 2 ⇥(n·log 

2 

2 log2 n 

T (n) = 2 

2 n) 

i · n 

 

n 

· log2 

2i 2i 

+ 2 log2n+1 

log2 n 

= 2 i 

n 

· log2 

2i 

+ 2 · n 

i=0 

i=0 

i=0 

Die Rekursionsgleichung leitet sich wie folgt her: 

Wir nutzen die Substitutionsmethode um die Vermutung zu beweisen: 

h 

(Rekursive Kosten auf Ebene i) + Gesamtkosten der Blätter(= c · b h+1 ) 

i=0 

mit Verästelungsgrad b. 

6 

Bei der Bestimmung der Höhe h ist folgendes zu beachten: 

i=0 

- Ist der Basisfall T(0), so ist die Höhe um 1 erhöht, da zusätzlich die Elemente der 

Ebene T(0) betrachtet werden. 

2 

i=0

Typische Höhen: 

- T (n) = b · T ( n 

c ) 

→ h = logcn 

KAPITEL 2. REKURSIONSGLEICHUNGEN 

- T (n) = b · T (n − c), c ∈ {1, 2} 

→ h = n 

c 

- T (n) = b · T ( √ n) 

→ h = log 2 log 2 n 

2 Substitutionsmethode 

Allgemeines Vorgehen: 

- Lösung ’raten’ (z.B. Rekursionsbaum) 

- Betrachte die jeweilige Definition des betrachteten Falls (O, Ω,, Θ, o, ω) 

- Setze die geratene Lösung in den rekursiven Teil (T (n)) der Rekursionsgleichung 

ein und beweise entsprechend der Definition des betrachteten Falls. 

- Teile durch Umformen den Term in 2 Teile auf: 

- Einem Teil, der einer Konstanten multipliziert mit der beweisenden Schranke 

entspricht und 

- Einem Restterm, durch Abschätzen über die Konstante die Definition des 

Falls bestärkt. 

- Gegebenenfalls muss durch Variablentransformation die Rekursionsgleichung zunächst 

vereinfacht werden. 

- Häufigste Transformationen: 

- n = 2 m ⇔ m = log2n 

- T (2 m ) = S(m) 

Beispiel: 

Bestimme die exakte Lösung der Rekursionsgleichung 

T (n) = 3√ n + 3 mit T (2) = 2. 

3

zu b) 

, T (n) = 16n 3 + 12n 

3 

)+4n +3 ,T (n) = 48n 

2 

KAPITEL 2. REKURSIONSGLEICHUNGEN 

T (n) =T ( 3p n)+3 |Variablentransformation m = log 2 n 

, T (2 m )=T (2 m 

3 )+3 | Umbenennung T (2 m )=S(m) 

, S(m) =S( m 

)+3 

3 

| Lösung bekannter Rekursionsgleichung: S(m) =S(m 

3 )+3 

, S(m) =3· log3 m + S(1) | da S(1) = T (2) = 2 (Anfangsbedingung) 

, S(m) =3· log 3 m +2 | m = log 2 n 

, T (n) =3· log 3 log 2 n +2 

3 Mastertheorem 

T (n) = b · T ( n 

) + f(n) 

c 

mit b ≤ 1 und c > 1 

Anzahl der Blätter im Rekursionsbaum: 

n E mit E = log(b) 

log(c) = log c b 

1. f(n) ∈ O(n E−ɛ ) (für ein ɛ > 0) 

→ T (n) ∈ Θ(n E ) 

2. f(n) ∈ Θ(n E ) 

→ T (n) ∈ Θ(n E · log(n)) 

3. f(n) ∈ Ω(nE+ɛ ) (für ein ɛ > 0) und 

) ≤ d · f(n) (für d < 1, n hinreichend groß) 

b · f( n 

c 

→ T (n) ∈ Θ(f(n)) 

Grenzen des Mastertheorems: 

Das Mastertheoren ist nicht anwendbar, wenn 

- die Funktion f(n) negativ ist. 

- b oder c /∈ N >0 . 

- der Unterschied von n E und f(n) nicht polynomiell ist. 

2 

4 

3 

2 

q.e.d.

leinsten 

öchsten 

hfolgerelement 

rückwärts 

einen weiteren 

er Liste 

25 

tail 

25/39 

27/39 

3 Datenstrukturen 

1 Listen 

Liste I In(Forts.) Vorlesung 8 (Heapsort) werden wir eine weitere Implementierung 

kennenlernen. 

I Element minimum(List l) gibt das Element mit dem kleinsten 

Schlüssel zurück. 

ú 

Beinhaltet das Verschieben aller Elemente „rechts“ von k. 

† I Element maximum(List l) gibt das Element mit dem höchsten 

Mittels binärer Suche. 

Schlüssel zurück. 

Joost-Pieter Katoen Datenstrukturen und Algorithmen 21/39 

I Element successor(List l, Element x) gibt das Nachfolgerelement 

von Element x zurück. 

Elementare Datenstrukturen Verkettete Listen 

I Element predecessor(List l, Element x) gibt das 

Vorgängerelement von Element x zurück. 

Einfach verkettete Listen 

Einfach verkettete Liste 

Eine einfach verkettete Liste ist eine rekursive, dynamische Datenstruktur. 


I Elemente bestehend aus Schlüssel k sowie Zeiger auf ein 

nachfolgendes Element 



Listen umdrehen 

Einfach 

Doppelt 

verkettete 

verkettete 

Listen 

Listen 

I Listen können dynamisch erweitert werden 

I head zeigt auf das erste Element der Liste 

Doppelt 1 void reverse(List verkettete Liste l) { 

2 last = l.head; next 

Eine 3 head doppelt pos = last.next; verkettete 48 Liste kann 34 sowohl vorwärts 2 als auch rückwärts 25 

4 durchlaufen last.next werden. = null; Sie implementiert den ADT Liste. 

I6 Elemente while(pos besitzen != null){ neben Schlüssel und Nachfolgender last pos tmp 

einen weiteren 

7 Zeiger tmp auf = pos.next; das vorherige Element. 

8 pos.next = last; 

I9 Zusätzlicher last = pos; Zeiger tail zeigt auf das letzte Element der Liste 

10 pos = tmp; 

Doppelt verkettete Listen 

Laufzeiten 


11 } 

next 

48 34 2 25 

prev 

13 l.head = last; 

14 } 

head tail 




Laufzeiten 

Implementierung 

Operation einfach verkette Liste doppelt verkettete Liste 

insert(L,x) ⇥(1) ⇥(1) 

remove(L,x) ⇥(n) ⇥(1) 

search(L,k) ⇥(n) ⇥(n) 

minimum(L) ⇥(n) ⇥(n) 

maximum(L) ⇥(n) ⇥(n) 

search(L,k) ⇥(n) ⇥(n) 

minimum(L) ⇥(n) ⇥(n) 

maximum(L) ⇥(n) ⇥(n) 

successor(L,x) ⇥(1) ⇥(1) 

predecessor(L,x) ⇥(n) ⇥(1) 

I Suchen eines Schlüssels erfordert einen Durchlauf der gesamten Liste. 

Gibt es andere Möglichkeiten, die Daten zu organisieren? 


5 

14void Binäre rev 

2 last Trav = 

3 pos = 

4 last.n 

6 while( 

7 tmp = 

Joost-Pieter 8 pos.n Katoe 

9 last 

10 pos = 

Elementare 

11 } Datens 

Listen ( 

13 l.head 

14 } 

Liste 

Eine Liste 

Reihenfolg 

Joost-Pieter Katoen 

I void 

Elementare Datenstruk 

der L 

Laufzeite 

I void 

Liste. 

I Eleme 

Operation 

überg 

insert(L, gibt. 

remove(L, 

search(L, 

minimum(L 

maximum(L 

search(L, 

minimum(L 

maximum(L 

successor 

predecess 

Joost-Pieter Katoe 

I Suchen 

Gibt es 

Joost-Pieter Katoen

29/39 

(V , E) 

en (edges) 

l. 

ot). 

2. 

31/39 

2 Bäume 

Linkes Kind 

von A 

2.1 Binärbäume 

Allgemeiner Aufbau 

Vater/Mutter A 

von B und C 

Schlüssel 

12 

KAPITEL 3. DATENSTRUKTUREN 

B 

6 

left 

Ein Binärbaum ist ein gerichteter, zykelfreier Graph mit Knoten (nodes, allgemein: ver- 

Elementare Datenstrukturen Binäre Bäume 

tices) V und gerichteten Kanten (edges). 

right 

C 

225 

Rechtes Kind 

von A 


Binärbäume – Begri e(I) 

Höhe des Binärbaums = 3 

6 

34 

23 40 

102 

innerer 

Knoten 

225 

103 1056 

Blatt 

Wurzel 

Ebene 0 

Ebene 1 

Ebene 2 

Ebene 3 


Begriffsklärung Binärbäume 

- Es gibt genau einen ausgezeichneten Knoten, die Wurzel (root). 

- Alle Kanten zeigen von der Wurzel weg. 

- Diese Kanten sind Zeiger. Jedes Element bekommt zwei dieser Zeiger (left und 

right) zu den nachfolgenden Elementen. 

- Der Ausgangsgrad jedes Knotens ist höchstens 2. 

- Der Eingangsgrad eines Knoten ist 1, bzw. 0 (bei der Wurzel). 

- Sonderfall: Baum mit V = E = ∅. 

- Ein Knoten mit leerem linken und rechten Teilbaum heißt Blatt (leaf). 

- Die Tiefe (auch: Ebene) eines Knotens ist sein Abstand, d. h. die Pfadlänge, von 

der Wurzel. 

- Die Höhe eines Baumes ist die maximale Tiefe seiner Blätter. 

6

Allgemeine Eigenschaften 

- Ebene d hat höchstens 2 d Knoten. 


- Mit Höhe h kann ein Binärbaum maximal 2 h+1 − 1 Knoten enthalten. 

- Mit n Knoten hat ein Binärbaum mindestens die Höhe h = ⌈log 2 n + 1⌉ − 1 

Traversierungen 

Eine Traversierung ist ein Baumdurchlauf mit folgenden Eigenschaften: 

1. Die Traversierung beginnt und endet an der Wurzel. 

2. Die Traversierung folgt den Kanten des Baumes. Jede Kante wird genau zweimal 

durchlaufen: Einmal von oben nach unten und danach von unten nach oben. 

3. Die Teilbäume eines Knotens werden in festgelegter Reihenfolge (zuerst linker, 

dann rechter Teilbaum) besucht. 

4. Unterschiede bestehen darin, bei welchem Durchlauf man den Knoten selbst (bzw. 

das dort gespeicherte Element) „besucht“. 

(Die Arraydarstellung einer Traversierung nennt man Linearisierung) 

Es gibt 3 verschiedene Formen der Traversierung: 

- Inorder-Traversierung: “Scannen von links nach rechts” 

Zuerst linken Teilbaum, dann Wurzel, dann rechten Teilbaum ausgeben. 

- Preorder-Traversierung: “Wie Einfügereihenfolge” 

Zuerst Wurzel, dann linken, dann rechten Teilbaum ausgeben. 

- Postorder: “Soweit wie möglich runter” 

Zuerst linken, dann rechten Teilbaum, dann Wurzel ausgeben. 

2.2 Binäre Suchbäume 

Allgemeine Definition 

Ein binärer Suchbaum (BST) ist ein Binärbaum, der Elemente mit Schlüsseln enthält, 

wobei der Schlüssel jedes Knotens 

- mindestens so groß ist, wie jeder Schlüssel im linken Teilbaum und 

- höchstens so groß ist, wie jeder Schlüssel im rechten Teilbaum. 

Führt man auf einem binären Suchbaum eine Inordertraversierung durch, so erhält man 

mit einer Laufzeit von Θ(n) die Schlüssel als Linearisierung in sortierter Reihenfolge. 

7

Operationen auf Binären Suchbäumen 

Suchen 

Traversiere (durchsuche) den Baum: 


- Falls der gesuchte Schlüssel gleich dem aktuell betrachteten Schlüssel ist: 

Suche beenden 

- Falls der gesuchte Schlüssel kleiner als der aktuell betrachtete Schlüssel ist: 

Durchlaufe den linken Teilbaum (linkes Kind ist neuer betrachtete Schlüssel) 

- Falls der gesuchte Schlüssel größer als der aktuell betrachtete Schlüssel ist: 

Durchlaufe den rechten Teilbaum (rechtes Kind ist neuer betrachtete Schlüssel) 

Komplexität: Θ(h) 

Einfügen 

1. Suche einen geeigneten freien Platz: 

Wie bei der regulären Suche, außer dass, selbst bei gefundenem Schlüssel, 

weiter abgestiegen wird, bis ein Knoten ohne entsprechendes Kind erreicht 

ist. 

2. Hänge den neuen Knoten an: 

Verbinde den neuen Knoten mit dem gefundenen Vaterknoten. 

Komplexität: Θ(h) (wegen der notwendigen Suche) 

Nachfolger finden 

Es gibt 2 mögliche Fälle: 

1. Der rechte Teilbaum existiert: 

→ Der Nachfolger ist der linkeste Knoten (das Minimum) im rechten Teilbaum. 

2. Der rechte Teilbaum existiert nicht 

→ Der Nachfolger ist der jüngste Vorfahre, dessen linker Teilbaum den Ausgangsknoten 

enthält. 


8

Einfügen von n (unterschiedliche) Schlüssel in zufälliger Reihenfolge in 

einem anfangs leeren Baum entsteht. 

Annahme: jede der KAPITEL n! möglichen 3. DATENSTRUKTUREN 

Einfügungsordnungen hat die gleiche 

Wahrscheinlichkeit. 

Löschen 

Drei mögliche Fälle: 

Theorem (ohne Beweis) 

1. Knoten hat keine Kinder: Lösche den Knoten 

Die erwartete Höhe eines zufällig erzeugten BSTs mit n Elementen ist 

O(log n). 

2. Knoten hat ein Kind: Schneide den Knoten aus. Verbinde also den Vater- und den 

Kindknoten direkt miteinander. 

3. Knoten hat zwei Kinder: 

Fazit: Im Schnitt verhält sich eine binäre Suchbaum wie ein (fast) 

- Finde den Nachfolger. 

balancierte Suchbaum. 

- Lösche den Nachfolger aus dem Baum. 

- Ersetze den Knoten durch dessen Nachfolger. 



Binäre Suchbäume Rotationen 

Links- und Rechtsrotationen 

leftRotate – Konzept und Beispiel 

Beispiel 

A 

Komplexität: Θ(1) 

1 

2 

15 

2.3 Rot-Schwarz-Bäume 

5 

Allgemeine Eigenschaften 

3 12 

10 14 

13 

leftRotate(1) 

rightRotate(2) 

B C 

A B 

20 

leftRotate(5) 

Ein binärer Suchbaum, dessen Knoten jeweils zusätzlich eine Farbe haben, hat die Rot- 

Schwarz-Eigenschaft, falls folgende Bedingungen erfüllt sind: 

17 31 

1. Jeder Knoten ist entweder rot oder schwarz. 

2. Die Wurzel ist schwarz. 

3. Jedes (externe) Blatt ist schwarz. 

5 

3 10 


4. Ein roter Knoten hat nur schwarze Kinder. 

5. Für jeden Knoten enthalten alle Pfade, die an diesem Knoten starten und in einem 

Blatt des Teilbaumes dieses Knotens enden, die gleiche Anzahl schwarzer Knoten. 

9 

12 

1 

14 

13 

15 

2 

C 

17 

20 

31

e 

9/31 

Einfügen von Schlüssel k in einen RBT – Strategie 

Einfügen 

Zum Einfügen inKAPITEL einen RBT3. gehen DATENSTRUKTUREN 

wir zunächst wie beim BST vor: 

I Finde einen geeigneten, freien Platz. 

Die Schwarzhöhe I Hänge bh(x) deneines neuenKnotens Knoten an. x ist die Anzahl schwarzer Knoten bis zu einem 

(externen) EsBlatt, bleibtxdie ausgenommen. Frage nach derDie Farbe: Schwarzhöhe bh(t) eines RBT t ist die Schwarz- 

Höhe seinerIWurzel. Färben wir den neuen Knoten schwarz, dannverletzenwirinder 

Regel die Schwarz-Höhen-Bedingung. 

ElementareIEigenschaften Färben wir ihn aber rot, dann könnten wir eine Verletzung der 

Ein Rot-Schwarzbaum Farbbedingungen t mit Schwarzhöhe bekommen (die h = Wurzel bh(t) hat: ist schwarz, rote Knoten 

Rot-Schwarz haben Bäume keine roten Kinder). 

Rot-Schwarz-Bäume 

– Mindestens ∆ Wir 2h färben − 1 den innere Knoten Knoten. rot – ein Schwarz-Höhen-Verletzung wäre 

Einfügen schwieriger in zu einen behandeln. RBT – Algorithmus 

– Höchstens I4h Rot − 1ist innere sozusagen Knoten. eine lokale Eigenschaft, schwarz eine globale. 

I 

– Ein Rot-Schwarz-Baum Behebe daher immit letzten n inneren SchrittKnoten die Farbverletzung. hat höchstens die Höhe 2·log(n+1). 


Operationen auf Rot-Schwarzbäumen 

1Rot-Schwarz Bäume Rot-Schwarz-Bäume 

Einfügen 

void rbtIns(Tree t, Node node) { // Füge node in den Baum t ein 

2 bstIns(t, node); // Einfügen wie beim BST 

3Einfügen node.left – = Was null; kann passieren? (1) 

4 node.right = null; 

5 node.color = RED; // eingefügter Knoten immer zunächst rot 

6 // stelle Rot-Schwarz-Eigenschaft c 

c 

node node ggf. wieder her 

7 rbtInsFix(t, node); 

8 } 

c 

node 

node 

I Der neu eingefügte Knoten ist immer rot. 

I Ist die Farbe des Vaterknotens c schwarz (z. B. die Wurzel), haben 

- Jeder neu eingefügte Knoten ist rot. 

wir kein Problem. 

- Ist derIVaterknoten Ist c aber rot, c schwarz, dann liegt eine ist der Rot-Rot-Verletzung Einfügevorgangvor, abgeschlossen. die wir 

behandeln müssen. 

- Ist Rot-Schwarz derIVaterknoten Bäume 

Die unteren Fälle c rot, lassen so muss sichdie analog Rot-Rot-Verletzung Rot-Schwarz-Bäume 

(symmetrisch) zubehoben den oberen werden. 

Es gibt 3lösen, mögliche daherFälle: betrachten wir nur die beiden oberen Situationen. 

Einfügen – Was kann passieren? (2) 

Joost-Pieter Fall Katoen 1: Onkelknoten e ist rot Datenstrukturen und Algorithmen 11/31 

Wir müssen nun Großvater d und Onkel e mit berücksichtigen: 


d 

c e 

c 

d 

c e 

I Der Großvater des eingefügten Knotens war schwarz, denneshandelte 

sich vor dem Einfügen um einen korrekten RBT. 

- Umfärben von c und e auf schwarz und d auf rot 

Fall 1 

Ist e rot, dann können wir durch Umfärben von c und e auf schwarz sowie 

d auf rot die Rot-Schwarz-Eigenschaft 10 

lokal wieder herstellen. 

I Zwei Ebenen weiter oben könnte nun aber eine Rot-Rot-Verletzung 

vorliegen, die nach dem selben Schema iterativ aufgelöst werden kann. 

I Ist d allerdings die Wurzel, dannfärbenwirsieeinfachwieder 

schwarz. Dadurch erhöht sich die Schwarzhöhe des Baumes um 1. 

Einfüg 

1 void r 

2 bstI 

3 node 

4 node 

5 node 

6 // s 

7 rbtI 

8 } 

Joost-Pieter Kat 

Rot-Schwarz Bäu 

Einfüg 

Wir müs 

I Der 

sich 

Fall 1 

Ist e rot, 

d auf rot 

I Zwe 

vorl 

I Ist d 

schw 

Joost-Pieter Kat

3: 

zieren. 

ch dadurch 

Kind, das 

ten Bild) 

=x + 1 

x 

e 

x 

ng zu 

lich am 

ültigen 

rt. 

13/31 

14/31 


- Löse evtl. höher liegende Rot-Rot-Verletzung iterativ auf. 

- ist d die Wurzel, so wird d wieder schwarz gefärbt. 

Rot-Schwarz Bäume Rot-Schwarz-Bäume 


Fall 2: Onkelknoten e ist schwarz, neuer Knoten liegt innen 

Ist der Onkel e dagegen schwarz, dann erhalten wir Fall 2 und 3: 

d 

c e 

d 

c e 

Fall 2 Fall 3 

- Überführe 

Fall 2 

zu Fall 3 durch Rotation um Vater c nach außen. 


Fall 3: Onkelknoten Dieser Fall lässt e, neuer sichKnoten durch Linksrotation liegt außen um c auf Fall 3 reduzieren. 


Fall 3 

I Die Schwarz-Höhe des linken Teilbaumes von d ändert sich dadurch 

nicht. bh(·) =x + 1 

bh(·) =??? 

I Der bisherige x Vaterknoten xc 

wird dabei zum x + 1linken, 

roten Kind, das 

eine Rot-Rot-Verletzung ≠æ mit dem neuen Vater d (c im rechten Bild) 

hat, die wir mit Fall 3 beheben können. x 

x 

c e 

x x 


Fall 3 

d 

I Rot-Schwarz Bäume Rot-Schwarz-Bäume 

Zunächst rotieren wir um d nach rechts, wobei wir die 

- Rotation in Richtung e um Großvaterknoten d. 

Schwarz-Höhen im Auge behalten. 


- d rot I Um färben. die Schwarz-Höhen der Kinder von c wieder in Einklang zu 

- c schwarz bringen, färben. färben wir d rot. Da dessen linkes Kind ursprünglich am 

bh(·) =x + 1 

roten c hing, ist das soweit unproblematisch. 

d 

c 

Komplexität: Θ(log n) 

x 

x 

≠æ 

c e 

x x 

x 

3 Graphen 



Definitionen 

Einfügen in einen RBT – Algorithmus Teil 2 

bh(·) =x + 1 

I 

Ein gerichteter Graph G ist Zunächst ein Paar rotieren (V, E) wir mit um d nach rechts, wobei wir die 

Schwarz-Höhen im Auge behalten. 

- einer Menge 1 // Behebe Knoten Ieventuelle Um (vertices) die Schwarz-Höhen Rot-Rot-Verletzung V und der Kinder mit Vater von c wieder in Einklang zu 

2 void rbtInsFix(Tree t, Node node) { 

bringen, färben wir d rot. Da dessen linkes Kind ursprünglich am 

- einer Menge 3 // solange (geordneter) noch eine Paare Rot-Rot-Verletzung von Knoten E ⊆besteht V xV , die (gerichtete) Kanten 

4 while (node.parent.color roten c hing, ist== das RED) soweit { unproblematisch. 

(edges) genannt werden. 

5 if (node.parent 

I 

== node.parent.parent.left) { 

Färben wir nun c schwarz, dann haben wir wieder einen gültigen 

6 // der von uns betrachtete Fall 

- Falls E7 eine Menge leftAdjust(t, ungeordneter RBT. Die node); Schwarzhöhe Paare ist, des heißt Gesamtbaumes G ungerichtet. ist unverändert. 

8 // möglicherweise wurde node = node.parent.parent gesetzt 

9 } else { 

10 // der dazu symmetrischer Fall 

11 rightAdjust(t, node); 

12 } 

13 } 

14 t.root.color = BLACK; // Wurzel bleibt schwarz 

Ein Teilgraph (subgraph) Joost-Pieter eines Katoen Graphen G = (V , E ) ist Datenstrukturen ein Graphund G Algorithmen 14/31 

′ = (V ′ , E ′ ) mit: 

15 } 

11 


c 

e 

x 

d 

e 

x

- V ′ ⊆ V und E ′ ⊆ E. 


– Ist V ′ ⊂ V und E ′ ⊂ E, so heißt G’ echter Teilgraph. 

A B 

- Transponierter Graph: In GT Elementare Graphenalgorithmen I Graphen 

ist die Richtung der Kanten von G umgedreht. 

Terminologie bei Graphen (III) 

A B 

D 

A B 

D 

E 

Grapheigenschaften 

C 

F 

Teilgraph 

E Vollständiger (und symmetrischer) Digraph 

- Der Graph auf vier GKnoten heißt symmetrisch, wenn aus (v, w) ∈ E folgt (w, v) ∈ E. 


Elementare Graphenalgorithmen I Graphen 

Terminologie bei Graphen (III) 

D 

A B 

D 

E 

E 

C 

F 

Teilgraph 

Vollständiger (und symmetrischer) Digraph 

auf vier Knoten 

Terminologie bei Graphen 


- Der Graph G ist vollständig, wenn jedes Paar von Knoten mit einer Kante verbunden 

ist. 

- Knoten w ist adjazent zu Knoten v, wenn (v, w) ∈ E. 

- Transponiert man G, so erhält man G T = (V, E ′ ) mit (v, w) ∈ E ′ gdw. (w, v) ∈ E. 

- Ein Weg von Knoten v nach w ist eine Folge von Kanten (vi, vi+1) : v0v1v2...vk−1vk, 

so dass v0 = v und vk = w 

- Ein Weg, bei dem alle Kanten verschieden sind, heißt Pfad. 

- Länge eines Pfades (Weges) ist die Anzahl der durchlaufenen Kanten. 

- Knoten w heißt erreichbar von v, wenn es einen Pfad von v nach w gibt. 

- Ein Zyklus ist ein nicht-leerer Weg bei dem der Startknoten auch Endknoten ist. 

- Ein Zyklus der Form vv heißt Schleife (loop, self-cycle). 

- Ein Graph ist azyklisch, wenn er keine Zyklen hat. 

12


Pfade undKAPITEL Zyklen (II) 3. DATENSTRUKTUREN 

A B C 

D 

Zyklus 

E 

F 

Schleife 

Beispiele für Wege: AABEDB B E D und B und CFFCwären F F, hier Beispiele für für Wege. Pfade: E D B und C F 

Für ungerichtete Graphen G gilt: 

EDBund CF sind Pfade. 


- Ein Graph G heißt zusammenhängend, wenn jeder Knoten von jedem anderen 

Knoten aus erreichbar ist. 

- Eine Zusammenhangskomponente von G ist ein maximaler zusammenhängender 

Teilgraph von G. 

- In einer Ansammlung von Graphen heißt ein Graph maximal, wenn er von 

keinem anderen dieser Graphen ein echter Teilgraph ist. 

Für gerichtete Graphen G gilt: 

- G heißt stark zusammenhängend, wenn jeder Knoten von jedem anderen aus erreichbar 

ist. 

- G heißt schwach zusammenhängend, wenn der zugehörige ungerichtete Graph (wenn 

alle Kanten ungerichtet gemacht worden sind) zusammenhängend ist. 

- Eine starke Zusammenhangskomponente von G ist ein maximaler stark zusammenhängender 

Teilgraph von G. 


Ein nicht Starke verbundener Zusammenhangskomponenten 

Graph kann eindeutig in verschiedene Zusammenhangskomponenten 

aufgeteilt werden. 

Zusammenhangskomponenten 

Zusammenhangskomponenten 

Ein nicht-zusammenhängender Digraph, aufgeteilt in seine maximalen 

zusammenhängenden Teilgraphen. 

13 

Joost-Pieter Katoen Datenstrukturen und Algorithmen 16/36


Darstellung als Adjazenzmatrix und Adjazenzliste 

Die Adjazenzmatrix-Darstellung eines Graphen ist durch eine nxn Matrix A gegeben, 

wobei A(i, j) = 1, wenn (vi, vj) ∈ E, sonst 0. 

- Wenn G ungerichtet ist, ergibt sich eine symmetrische Adjazenzmatrix A (d.h. 

A = A T ). Dann muss nur die Hälfte der Datenmenge gespeichert werden. 

→ Platzbedarf: Θ(n 2 ) 

Bei der Darstellung als Array von Adjazenzlisten gibt es ein durch die Nummer des 

Knoten indiziertes Array, das jeweils verkettete Listen (Adjazenzlisten) enthält. 

- Der i-te Arrayeintrag enthält alle Kanten von G, die von vi „ausgehen“. 

- Ist G ungerichtet, dann werden Kanten doppelt gespeichert. 

- Kanten, die in G nicht vorkommen, benötigen keinen Speicherplatz. 

→Elementare Platzbedarf: Graphenalgorithmen Θ(n I + m) 

Graphen 

Darstellung eines gerichteten Graphen 

A B C 

D 

E 

S 

W 

U 

F 

0 1 0 1 0 0 

0 0 0 0 1 0 

0 0 0 0 1 1 

0 1 0 0 0 0 

0 0 0 1 0 0 

0 0 0 0 0 1 

Adjazenzmatrix 

T 

X 

V 

A 

B 

C 

D 

E 

F 

B D 

E 

F E 

B 

D 

F 

Adjazenzliste 


Abbildung 3.1: Beispiel für die Darstellung als Adjazenzmatrix und Adjazenzliste 

14

4 Flüsse 

1 Allgemeine Flusseigenschaften 

1.1 Flussnetzwerke 

Ein Flussnetzwerk ist ein gerichteter Graph, dessen Kanten die Zusatzinformation der 

Kapazität tragen (Kanten sind wie Wasserrohre).s, t ∈ V (Quelle s, Senke t) sind ausgezeichnete 

Knoten des Netzwerkes. 

– An der Quelle wird produziert 

– An der Senke wird verbraucht 

– Kapazität = maximale Durchsatzrate 

1.2 Fluss in einem Flussnetzwerk 

Ein Fluss f hat folgende Eigenschaften: 

Beschränkung: Für v ∈ V gilt: f(u, v) ≤ c(u, v). 

Ein Fluss f ist also immer maximal so groß wie die Kapazität c. 

Asymmetrie: Für v ∈ V gilt: f(u, v) = −f(v, u) 

Wird die Flussrichtung umgekehrt, so ändert sich das Vorzeichen des Flusses. 

Flusserhaltung: Für u ∈ V − {s, t} gilt: Σv∈V f(u, v) = 0 

Was in einen inneren Knoten, der weder Quelle noch Senke ist, hineinfließt 

kommt auch wieder heraus. 

– f(u,v) ist der Fluss vom Knoten u zum Knoten v. 

– Der Wert |f| eines Flusses f ist der Gesamtfluss aus der Quelle s: 

|f| = 

f(s, V ) 

v∈V 

– Ein maximaler Fluss ist einen Fluss mit maximalem Wert für ein Flussnetzwerk. 

15

ken geben. 

“ in ein 

n geben. 

in ein 

4 

) 

4 

) 

metrie. 

etrie. 

21/42 

21/42 

23/42 

23/42 

Maximaler Fluss Flussnetzwerke 

Flüsse zwischen Knotenmengen 

KAPITEL 4. FLÜSSE 

Notationen 

f (x, Y ) = ÿ 

f (x, y) für Y V 


1.3 Flüsse Flüsse zwischen Knotenmengen 

Notationen 

yœY 

f (x, Y ) = ÿ 

f (x, y) für Y V 

yœY 

f (X, y) = ÿ 

f (X, y) = 

f (x, y) für X V 

ÿ 

f (x, y) für X V 

xœX 

f (X, Y ) = ÿ ÿ 

f (x, y) für X, Y V 

xœX yœY 

xœX 

f (X, Y ) = ÿ 

Eigenschaften von Flüssen zwischen ÿ Mengen 

f (x, y) für X, Y V 

Falls f ein Fluss für Flussnetzwerk xœX yœY G =(V , E, c) ist, dann gilt: 

1. f (X, X) =0 für X V 

Eigenschaften 2. f (X, Y von )=≠f Flüssen (Y , X) zwischen Mengen für X, Y V 

Falls 3. f (X einfiFluss Y , Z) für =f Flussnetzwerk (X, Z)+f (Y , G Z) =(V für, E, X, c) Y , ist, Z dann V : Xgilt: fl Y = ? 

1. 4. f (Z, f X(X, fi Y X) )=f =0(Z, X)+f (Z, Y ) für für X, XY , Z V 

V : X fl Y = ? 

2. f (X, Y )=≠f (Y , X) für X, Y V 

3. f (X fi Y , Z) =f (X, Z)+f (Y , Z) für X, Y , Z V : X fl Y = ? 

4. f (Z, X fi Y )=f (Z, X)+f (Z, Y ) für X, Y , Z V : X fl Y = ? 


2 Ford-Fulkerson-Methode 


Eingehender Fluss in der Senke 

Joost-Pieter Katoen Datenstrukturen und Algorithmen 

Prinzip 

Wie groß ist der an der Senke eingehende Fluss? 

– Überführe Maximaler Flussden Graphen in ein Flussnetzwerk. 

Flussnetzwerke 

Aufgrund der Flusserhaltung in alle Zwischenknoten ist zu erwarten, dass 

– Suche er dem 

Eingehender einen austretenden beliebigenFluss Fluss Pfadan inzwischen der Quelle 

der Senke sentspricht: und t heraus. 

22/42 

– Wie Bestimme groß ist der diean minimale der Senke f Kapazität (s, eingehende V )=f (V (maximalen , t) Fluss? Durchfluss) dieses Pfades. 

– Aufgrund Beweis: Bestimme der die Flusserhaltung Flusserhöhung, in alleindem Zwischenknoten der Flussist entlang zu erwarten, des Pfades dass gleich der 

erKapazität dem austretenden der Kante Fluss mit an der minimalen Quelle entspricht: Kapazität gesetzt wird. 

f (s, V )=f (V , V ) ≠ f (V ≠ {s}, V ) | Eigenschaft 3 

– Bilde das Restnetzwerk, indem der Durchfluss als umgekehrte Kanten einge- 

= ≠f (V ≠ {s}, f V (s, ) V )=f (V , t) | Eigenschaft 1 

zeichnet wird (eventuell existierende Gegenpfade werden verrechnet). 

= f (V , V ≠ {s}) | Eigenschaft 2 

Beweis: 

– Fahre solange fort, = f neue (V , t)+f Pfade (V , zu V ≠ suchen, {s, t}) bis es keine | Eigenschaft augmentierende 4 (den Fluss 

weiter vergrößernde) f (s, V )=f = f (V Pfade , , t). V ) ≠mehr f (V ≠ gibt, {s}, V d.h. ) die |Flusserhaltung 

Senke | Eigenschaft noch von3 der Quelle aus 

erreichbar ist. 

= ≠f (V ≠ {s}, V ) | Eigenschaft 1 

→ Der Maximale Fluss = f (V ist, Vdie≠ Summe {s}) aller Flusserhöhungen. | Eigenschaft 2 

Joost-Pieter Katoen = f (V , t)+f (V , V ≠ Datenstrukturen {s, t}) und Algorithmen | Eigenschaft 4 24/42 

= f (V , t). |Flusserhaltung 


16

5 Algorithmenprinzipien 

1 Divide & conquer - Teilen und Beherrschen 

Das Prinzip hinter Divide & conquer- Algorithmen ist, dass sie ein Problem in kleinere 

Teilprobleme teilen, die zwar dem ursprünglichen Problem ähneln, jedoch eine kleinere 

Größe besitzen. Die Teilprobleme werden dabei rekursiv gelöst. Anschließend werden die 

Lösungen der Teilprobleme dann kombiniert, um daraus die Lösung des Ursprungsproblems 

zu erhalten. Das Paradigma umfasst drei Schritte: 

- Teile das Problem in eine Anzahl von Teilproblemen auf. 

- Beherrsche die Teilprobleme durch rekursives Lösen. Hinreichend kleine Teilprobleme 

werden direkt gelöst. 

- Verbinde die Lösungen der Teilprobleme zur Lösung des Ausgangsproblems. 

2 Greedy-Algorithmen 

Greedy(‘gierige’) Algorithmen sind dadurch gekennzeichnet, dass sie in jedem Schritt 

eine kuzfristig optimale Lösung wählen. Diese Lösungsfindung sollte eine möglichst geringe 

Komplexität haben. Nachdem eine Wahl für eine Lösung getroffen wurde ist diese 

nicht mehr rückgängig zu machen. 

Die Lösungsstrategie eines Greedy-Algorithmus’ ist optimal, wenn sie sich aus optimalen 

Teilproblemen zusammensetzt, die unabhängig von anderen Teillösungen sind. 

3 Dynamische Programmierung 

Dynamische Programmierungs-Probleme sind Optimierungsprobleme, also Probleme, für 

die es verschiedene Lösungsmöglichkeiten mit einer Minimierung von Kosten oder einer 

Maximierung eines Wertes gibt. Damit Dynamische Programmierung möglich ist, muss 

die optimale Lösung aus sich überlappenden Teilproblemen bestehen, die sich rekursiv 

aufeinander beziehen. 

17

Allgemeines Vorgehen 

KAPITEL 5. ALGORITHMENPRINZIPIEN 

1. Stelle die Rekursionsgleichung (top-down) für den Wert der Lösung auf. 

– Dabei sind folgende Punkte zu klären: 

– Festlegung der Basisfälle 

– Unterscheidung zwischen Maximierungs- und Minimierungsproblem. 

– Festlegung der Abbruchbedingungen 

2. Löse die Rekursionsgleichung bottom-up. 

3. Bestimme aus dem Wert der Lösung die Argumente der Lösung. 

4. Rekonstruiere die Lösung. 

– dies geschieht durch aufstellen einer Lösungstabelle, die entsprechend der Rekursionsgleichung 

ausgefüllt wird. 

3.1 Rucksackproblem 

Gegeben sei ein Rucksack, mit maximaler Tragkraft M, sowie n Gegenstände, die sowohl 

ein Gewicht als auch einen Wert haben. Nehme möglichst viel Wert mit, ohne den 

Dynamische Programmierung Anwendungen 

Rucksack zu überladen. 

Das Rucksackproblem – Rekursionsgleichung (II) 

Rekursionsgleichung 

Sei also C[i, j] der maximale Wert des Rucksacks mit Tragkraft j, wenn 

Sei also C[i, j] der manmaximale nur die Gegenstände Wert des { 0, ..., Rucksacks i ≠ 1 } berücksichtigt. mit Tragkraft j, wenn nur die Gegenstände 

0, ..., i − 1 berücksichtigt werden. 

Es ergibt sich folgende Rekursionsgleichung: 

Y 

_] max(C[i≠1, j], ci≠1 + C[i≠1, j≠wi≠1]) 

C[i, j] = ≠Œ für j < 0 

_[ 0 für i = 0, j > 0 

I Dann ist cmax = C[n, M]. 

1 // Eingabe : 

I Diese Rekursionsgleichung lösen wir nun bottom-up, indem wir die 

Gewichte Rucksäcke w[ mit i ] allen , Werte möglichenc Gewichten [ i ] , Tragkraft { 0, ..., M } berechnen, M 

int knapDP( int w[ wenn n ] wir , int jeweilsc einen [ n ] weiteren , int Gegenstand n , int hinzunehmen. M) { 

3 int C[ n+1,M+1]; // Array i n i t i a l i s i e r e n 

5 

for ( int j = 0 ; j

O en ist noch KAPITEL die Frage, 5. welche ALGORITHMENPRINZIPIEN 

Gegenstände (S G) nun eigentlich 

mitgenommen werden müssen, um cmax zu erreichen. 

13 return C[ n ,M] ; 

} 

Beispiel 

Das Rucksackproblem – Rekonstruktion 

Beispiel 

w[] = { 2, 12, 1, 1, 4 }, c[] = { 2, 4, 2, 1, 10 }, M = 15 

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 

1 0 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 

2 0 0 2 2 2 2 2 2 2 2 2 2 4 4 6 6 

3 0 2 2 4 4 4 4 4 4 4 4 4 4 6 6 8 

4 0 2 3 4 5 5 5 5 5 5 5 5 5 6 7 8 

5 0 2 3 4 10 12 13 14 15 15 15 15 15 15 15 15 


3.2 Longest Common Subsequence (LCS) 

Sei A = (a1, ..., am) eine Sequenz. Die Sequenz Aik = (ai1, ..., aik) ist eine Teilsequenz 

von A wobei i1 < i2 < ... < ik und ij ∈ 1, ..., m. 

Dynamische Programmierung Anwendungen 

Beispiel: bca ist eine gemeinsame Teilsequenz von A = abcbdab und B = bdcaba. 

Longest Common Subsequence – 

Rekursionsgleichung Rekursiongleichung 

Hier lässt sich die Rekursiongleichung für den Wert, also die Länge der LCS aufstellen: 

L[i, j] = |LCS(Ai, Wir können Bj)| wieder die Rekursiongleichung für den Wert, also die Länge 

der LCS aufstellen: L[i, j] = |LCS(Ai, Bj)| 

Y 

_] 

0 für i = 0 oder j = 0 

L[i, j] = L[i ≠ 1, j ≠ 1]+1 

_[ 

max(L[i, j ≠ 1], L[i ≠ 1, j]) 

falls ai = bj, i, j > 0 

falls ai ”= bj, i, j > 0 

I Das lässt sich direkt als Algorithmus umsetzen (Hausaufgabe). 

2 

I Dessen Laufzeit ist O(|A|·|B|), ebenso seine Platzkomplexität. 

int l c s ( int seq1 [ ] , int l1 , int seq2 [ ] , int l 2 ) { 

I Ähnlich dem Rucksackproblem lässt sich dann die LCS rekonstruieren. 

int L [ l 1 +1, l 2 +1]; 

for ( int i = 0 ; i i= l 1 ; i++) 

4 L [ i , 0 ] = 0 ; 

for ( int j = 0 ; j i= l 2 ; j++) 

6 L [ 0 , j ] = 0 ; 


8 for ( int i = 1 ; i i= l 1 ; i++) { 

for ( int j = 1 ; j i= l 2 ; j++) { 

10 i f ( seq1 [ i ] == seq2 [ j ] ) { 

L [ i , j ] = L [ i − 1 , j − 1 ] + 1 ; 

12 } else i f (L [ i − 1 , j ] > L [ i , j − 1 ] ) { 

19

L [ i , j ] = L [ i − 1 , j ] ; 

14 } else { 

L [ i , j ] = L [ i , j − 1 ] ; 

16 } 

} 

18 return L [ l1 , l 2 ] ; 

} 

KAPITEL 5. ALGORITHMENPRINZIPIEN 

20

6 Sortieralgorithmen 

1 Einfache Sortieralgorithmen 

Sortieren Sortieren durch Einfügen 

1.1 Insertionsort - Sortieren durch einfügen 

Prinzip: 

Sortieren durch Einfügen – Insertionsort 

0 12 17 17 19 8 25 3 6 69 26 4 2 13 34 41 

bereits sortiert noch unsortiert 

als Nächstes einzusortieren 

- Beginne beim zweiten Element. 

I Durchlaufen des (unsortierten) Arrays von links nach rechts. 

- Der unsortierte Bereich des Arrays wird von links nach rechts durchlaufen. 

- Gehe zun ersten bisher noch nicht berücksichtigten Element. 

- Suche die richtige Position für das Element im bereits sortierten Arrayabschnitt. 

- Füge das Element an die richtige Stelle ein. 

- Verschiebe alle bereits sortierten Elemente Rechts vom eingefügten Element um 1 

nach rechts. 

⇒ Wiederhole solange, bis das Ende des Arays erreicht ist. 


1 void i n s e r t i o n S o r t ( n ){ 

for ( i = 1 ; i < n ; i ++){ 

3 i f (E[ i ] < E[ i −1]){ 

int temp = E[ i ] ; 

5 for ( j = i ; j >0 && E[ j −1] > temp ; j −−){ 

E[ j ] = E[ j −1]; 

7 } 

E[ j ] = temp ; 

9 } 

} 

11 } 

21

1.2 Selectionsort 

Prinzip: 

KAPITEL 6. SORTIERALGORITHMEN 

1. Setze Pointer i auf das erste Element. 

2. Suche kleinstes Element rechts von i und speichere die Position dieses Elementes 

als m. 

3. Vertausche i. Element mit dem Wert des Elementes an Position m. 

Setze i um eins hoch. 

⇒ Wiederhole 2./3. bis Ende des Arrays erreicht. 

1 void s e l e c t i o n S o r t ( Array E) { 

int i , j ,m; 

3 for ( i = 0 ; i < E. length ; i++) { 

m = i ; 

5 for ( j = i + 1 ; j < E. length ; j++) { 

i f (E[ j ]


- Finde das Maximum der Werte A[i] und seiner Kinder 

- Is A[i] bereits das größte Element, dann ist der gesamte Teilbaum auch 

ein Heap. 

void buildHeap ( int E [ ] ) { 

- Sonst: Tausche A[i] mit dem größten Element und führe Heapify erneut 

in diesem Unterbaum aus. 

2 for ( int i = E. length / 2 − 1 ; i >= 0 ; i −−) { 

h e a p i f y (E, E. length , i ) ; 

4 } 

} 

6 

8 void heapSort ( int [ ] E) { 

buildHeap (E ) ; 

10 for ( int i = E. length − 1 ; i > 0 ; i −−) { 

swap (E [ 0 ] , E[ i ] ) ; 

12 h e a p i f y (E, i , 0 ) ; 

} 

14 } 

16 void h e a p i f y ( int [ ] E, int n , int pos ) { 

int next = 2 ∗ pos + 1 ; 

18 while ( next < n ) { 

( next + 1 < n && E[ next + 1 ] > E[ next ] ) { 

20 next = next + 1 ; 

} 

22 i f (E[ pos ] > E[ next ] ) { 

break ; 

24 } 

swap (E[ pos ] , E[ next ] ) ; 

26 pos = next ; 

next = 2 ∗ pos + 1 ; 

28 } 

} 

23

2.2 Countingsort 

Prinzip: 


Beispiel für Heapsort mit Eingabearray E = [12, 6, 8, 3, 4, 0, 2] 

- Zunächst ein Histogramm- Hilfsarray erstellen, in dem die Häufigkeit jeder Zahl 

gespeichert wird. 

- Positionsarray erstellen, in dem von links nach rechts die Werte des Histogramm- 

Arrays aufaddiert werden. 

Beispiel: 

Histogramm: 2 0 0 1 2 1 

Positionen: 2 2+0 2+0 2+1 3+2 5+1 

- Ausgabearray von hinten nach vorne erstellen, indem die neue Position der Zahl 

X im Eingabearray der Wert an Position (X − 1) des Positionsarrays ist. 

- Der Wert des Positionsarrays wird anschließend um 1 verringert. 

24

Beispiel: 

Eingabe: 6 8 0 3 5 4 0 4 


0 1 2 3 4 5 6 7 8 

Histogramm: 2 0 0 1 2 1 1 0 1 

Positionen 2 2 2 3 5 6 7 7 8 

Ausgabearray Positionsarray 

0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 8 

4 2 2 2 3 4 6 7 7 8 

0 4 1 2 2 3 4 6 7 7 8 

0 4 4 1 2 2 3 3 6 7 7 8 

0 4 4 5 1 2 2 3 3 5 7 7 8 

0 3 4 4 5 1 2 2 2 3 5 7 7 8 

0 0 3 4 4 5 0 2 2 2 3 5 7 7 8 

0 0 3 4 4 5 8 0 2 2 2 3 5 7 7 7 

0 0 3 4 4 5 6 8 0 2 2 2 3 5 7 6 7 

1 int [ n ] countingSort ( int [ ] E, int n , int k ){ 

int [ ] histogram = new int [ k ] ; // Direkte A d r e s s i e r u n g s t a b e l l e 

3 for ( int i = 0 ; i < 0 ; i ++){ 

histogramm [E[ i ]]++; // Zä h l e Hä u f i g k e i t 

5 } 

for ( int i = 1 ; i < k ; i ++){ // Berechne P o s i t i o n 

7 histogramm [ i ] = histogram [ i ] + histogram [ i − 1 ] ; 

} 

9 // Berechne P o s i t i o n 

int e r g e b n i s [ n ] ; 

11 for ( int i = n − 1 ; i >= 0 ; i −−){ 

// l ä u f t nur s t a b i l , wenn r ückwä r t s gez ä h l t wird . 

13 histogram [E[ i ]] − −; 

r e s u l t [ histogram [E[ i ] ] ] = E[ i ] ; 

15 } 

return r e s u l t ; 

17 } 

2.3 Mergesort 

Prinzip: 

- Teile das Zahlenarray in zwei (möglichst) gleichgroße Hälften auf. 

- Beherrsche: Sortiere die Teile durch rekursives Mergesort-aufrufen. 

- Verbinde je zwei bereits sortierte Teilsequenzen zu einen einzigen sortierten Array. 

25


1 // Aufruf : mergeSort (E, 0 , E. length −1); 

void mergeSort ( Array E, int l i n k s , int r e c h t s ){ 

3 i f ( l e f t < r i g h t ) { 

int mid = ( l e f t + r i g h t ) / 2 ; // f i n d e Mitte 

5 mergeSort (E, l e f t , mid ) ; // s o r t i e r e l i n k e H a e l f t e 

mergeSort (E, mid + 1 , r i g h t ) ; // s o r t i e r e r e c h t e H a e l f t e 

7 // Verschmelzen der s o r t i e r t e n H aelften 

merge (E, l e f t , mid , r i g h t ) ; 

9 } 

} 

11 

void merge ( int E [ ] , int l e f t , int mid , int r i g h t ) { 

13 int a = l e f t , 

b = mid + 1 ; 

15 int Eold [ ] = E; 

for ( int l e f t = 0 ; l e f t mid ) { // Wir wissen ( Widerspruch ) : b r i g h t | | Eold [ a ] Pivot” und “ungeprüft”. 

26

Quicksort Quicksort 


Quicksort – Strategie 

41 26 17 25 19 17 8 3 6 69 12 4 2 13 34 0 

Pivot 

Partitionierung 

8 3 6 12 4 2 13 0 17 41 26 17 69 25 19 34 

< Pivot > Pivot 

- Solange das zusätzliche Element “< Pivot” ist, schicke die linke Grenze nach rechts. 

- Solange das zusätzliche Element “>= Pivot” ist, schiebe die rechte Grenze nach 

links. 

- Tausche das links gefundene mit dem rechts gefundenen. 

⇒ Fahre fort, bis sich die Grenzen treffen. 


1 void quickSort ( int E [ ] , int l e f t , int r i g h t ) { 

i f ( l e f t < r i g h t ) { 

3 int i = p a r t i t i o n (E, l e f t , r i g h t ) ; 

// i i s t P o s i t i o n des Pivotelementes 

5 quickSort (E, l e f t , i − 1 ) ; // s o r t i e r e den l i n k e n T e i l 

quickSort (E, i + 1 , r i g h t ) ; // s o r t i e r e den rechten T e i l 

7 } 

} 

9 

int p a r t i t i o n ( int E [ ] , int l e f t , int r i g h t ) { 

11 // Wä h l e e i n f a c h e s Pivotelement 

int ppos = r i g h t , pivot = E[ ppos ] ; 

13 while ( true ) { 

// B i l i n e a r e Suche 

15 while ( l e f t < r i g h t && E[ l e f t ] < pivot ) l e f t ++; 

while ( l e f t < r i g h t && E[ r i g h t ] >= pivot ) r i g h t −−; 

17 i f ( l e f t >= r i g h t ) { 

break ; 

19 } 

swap (E[ l e f t ] , E[ r i g h t ] ) ; 

21 } 

swap (E[ l e f t ] , E[ ppos ] ) ; 

23 return l e f t ; // gib neue P i v o t p o s i t i o n a l s Splitpunkt zurück 

} 

2.5 Dutch National Flag- Problem 

Prinzip: Jedes Feld eines Arrays kann drei mögliche Werte haben: Rot, Weiß oder Blau. 

27


- Teile das Array in vier Regionen auf: 

1. 0 

Sortieren Sortieren - Einführung 

Dutch National 2. u 

3. b ≤ i ≤ n 

1 void DutchNationalFlag(Color E[], int n) { 

2 

3 

int r = 0, b = n + 1; // rote und blaue Regionen sind leer 

int -u Es = 1; gibt // 3weiße Zeiger: Region ist leer, die unbekannte == E 

4 

5 

while (u < b) { 

if (E[u] - r: == Rote rot) { Region 

6 

7 

swap(E[r - b: + Blaue 1], E[u]); Region 

r = r + 1; // vergrößere die rote Region 

- u: Unbekannte Region 

8 u = u + 1; // verkleinere die unbekannte Region 

9 } 

10 if (E[u] == weiss) { 

11 u = u + 1; 

12 } 

13 if (E[u] == blau) { 

14 swap(E[b - 1], E[u]); 

15 b = b - 1; // vergrößere die blaue Region 

16 } 

17 

18 } 

} 

r u 

b 

Zeigerstartposition beim Dutch National Flag- Problem 

- Steht u auf einem roten Feld, wird E[u] mit E[r + 1] vertauscht und der rote 

Bereich vergrößert und der unbekannte Bereich um 1 verringert (r++, u++) 

- Steht u auf einem weißen Feld, wird der unbekannte Bereich um 1 verkleinert 

(u++) 


- Steht u auf einem blauen Feld, wird E[u] mit E[b−1] vertauscht. Der blaue Bereich 

erhöht sich um 1. (b–, u bleibt gleich!) 

⇒ Der Algorithmus terminiert, wenn u = b. 

In jedem Schritt wird entweder u erhöht, oder b verringert. 

void DutchNationalFlag ( Color E [ ] , int n ) { 

2 int r = 0 , b = n + 1 ; // r o t e und blaue Regionen sind l e e r 

int u = 1 ; // wei ß e Region i s t l e e r , d i e unbekannte == E 

4 while ( u 

i f (E[ u ] == r o t ) { 

6 swap (E[ r + 1 ] , E[ u ] ) ; 

r = r +1; // vergr ö ß e r e d i e r o t e Region 

8 u = u + 1 ; // v e r k l e i n e r e d i e unbekannte Region 

} 

10 i f (E[ u ] == w e i s s ) { 

u = u + 1 ; 

12 } 

i f (E[ u ] == blau ) { 

14 swap (E[ b − 1 ] , E[ u ] ) ; 

b = b−1; // v ergr ö ß e r e d i e blaue Region 

16 } 

} 

18 } 

28


3 Gesamtübersicht über Sortieralgorithmen 

Laufzeitkomplexität 

Algorithmus Worst case Average case Speicher Stabilität 

Insertionsort Θ(n 2 ) Θ(n 2 ) in-place stabil 

Selectionsort Θ(n 2 ) Θ(n 2 ) in-place nicht stabil (*) 

Quicksort Θ(n 2 ) Θ(n log n) Θ(log n) nicht stabil(*) 

Mergesort Θ(n log n) Θ(n log n) Θ(n) stabil 

Heapsort Θ(n log n) Θ(n log n) in-place nicht stabil 

Countingsort 1 Θ(n + k) Θ(n + k) O(n + k) stabil 

Dutch National Flag Θ(n) Θ(n) in place nicht stabil 

(*): Vorlesungsversion ist nicht stabil, es existiert jedoch auch eine stabile Version. 

29

7 Graphenalgorithmen 

1 Graphensuche 

1.1 Tiefensuche 

(Tiefensuche: Depth-First Search, DFS) 

Prinzip: 

– Alle Knoten als ’nicht gefunden’ markieren. 

– Aktuellen Knoten als ’gefunden’ markieren. 

– Jede Kante mit ’gefundenem’ Nachfolger: 

– Erforsche Kante, besuche Nachfolger und forsche von dort aus weiter bis es 

nicht mehr weiter geht. 

– Für jede Kante mit gefundenem Nachfolger: 

– Kante überprüfen ohne den Knoten selbst zu besuchen. 

– Knoten als ’abgeschlossen’ markieren. 

⇒ Man erhält die Menge der vom Startknoten aus erreichbaren Knoten. 

30

Elementare Graphenalgorithmen I Graphendurchlauf 

Tiefensuche – Beispiel (I) 

A 

F 

A 

KAPITEL 7. GRAPHENALGORITHMEN 

B 

C 

Beginn der Tiefensuche Erforsche einen Knoten 

B 

D 

E 

D 

F C E 

F C E 

Erforsche einen Knoten 

Sackgasse! 

Backtracke und erforsche den nächsten Knoten 


A 

D 

A 

D 

Tiefensuche – Beispiel (II) 

G 

G 

F 

C 

E 

F 

C 

E 

Nächster Zustand wurde bereits gefunden 



Nächster Zustand wurde bereits gefunden 

Backtracke Datenstrukturen und erforsche und Algorithmen den nächsten Knoten 

29/36 

Elementare Graphenalgorithmen I B 

Graphendurchlauf B 

G 

Tiefensuche – Beispiel (III) 

F 

C 

E 

D ist eine Sackgasse 


A 

B 

D 

F 

C 

E 

F 

C 

E 

CwurdebereitsgefundenErforsche 

den nächsten Knoten 

Backtracke Cwurdebereitsgefunden 

und erforsche den nächsten Knoten 

Erforsche den nächsten Knoten 


A 

F 

A 

A 

F 

A 

B 

C 

B 

D 

D 

E 

G 

G 

G 


A 

F 

A 

A 

A 

A 

F 

B 

C 

B 

B 

F 

C 

E 

B ist eine Sackgasse 



B 

B 

G 

G 


F 

C 

E 

F 

Tiefensuche – Implementierung 

B 

C 

D 

E 

D 

Beide nächsten Knoten wurden bereits gefunden Fertig! 

G 

1 void BeidedfsRec(List nächsten Knoten adjList[n], wurden Beispiel bereits fürint eine gefunden n, Tiefensuche int start, Fertig! int &color[n]) { 

2 color[start] = GRAY; 

3 foreach (next in adjList[start]) 31 

{ 

4 if (color[next] == WHITE) { 

5 dfsSRec(adjList, n, next, color); 

6 } 

7 } 

8 color[start] = BLACK; 

9 } 

A 

F 

A 

B 

C 

C 

B 

B 

C 

D 

E 

D 

D 

E 

D 

E 

D 

G 

G 

G 

G 

G 

D 

D 

E 

G 

G


void dfsSearch ( L i s t a d j L i s t [ n ] , int n , int s t a r t ){ 

2 int c o l o r [ n ] ; 

for ( int i = 0 ; i < n ; i ++){ // Farbarray i n i t i a l i s i e r e n 

4 c o l o r [ i ] = WHITE; 

} 

6 dfsRec ( a d j L i s t , n , s t a r t , c o l o r ) ; 

} 

8 

void dfsRec ( L i s t a d j L i s t [ n ] , int s t a r t , int &c o l o r [ n ] ) { 

10 c o l o r [ s t a r t ] = GRAY; // Aktuell b e t r a c h t e t e n Knoten grau f ä rben 

f o r e a c h ( next in a d j l i s t [ s t a r t ] ) { 

12 i f ( c o l o r [ next ] == WHITE) 

dfsRec ( a d j L i s t , n , next , c o l o r ) ; 

14 } 

c o l o r [ s t a r t ] = BLACK; // Gefundenen Startknoten schwarz f ä rben 

16 } 

1.2 Breitensuche 

Prinzip: 

– Alle Knoten als ’nicht gefunden’ markieren 

– Aktuell betrachteten Knoten als ’gefunden’ markieren 

– Jede Kante mit ’nicht gefundenem’ Nachfolger: 

– Gleichzeitig von allen diesen Knoten aus weiter suchen 

→ Kein Backtracking 

⇒ Man erhält die Menge aller Knoten, die vom Stratknoten aus erreichbar ist. 

32


Breitensuche – Beispiel 

A 

F 

A 

F 


B 

C 

Beginn der Breitensuche 

B 

C 

Erforsche alle folgenden nicht-gefundenen Knoten 

D 

E 

D 

E 

G 

G 

A 

F 

Erforsche alle folgenden nicht-gefundenen Knoten 

Beispiel für eine Breitensuche 

A 

F 

B 

C 

B 

C 

Fertig! 


void bfsSearch ( l i s t a d j l i s t ( n ) , int n , int s t a r t ){ 

2 int c o l o r [ ] ; 

Elementare Queue Graphenalgorithmen wait ; // I Warteschlange i n i tGraphendurchlauf i a l i s i e r e n 

4 // A l l e Knoten a l s ’ n i c h t gefunden ’ markieren 

for ( int i = 0 ; i < n ; i++) 

Eigenschaften der Breitensuche 

6 c o l o r [ i ] = WHITE; 

c o l o r [ s t a r t ] = GRAY; // Startknoten a l s ’ gefunden ’ markieren 

8 wait . enqueue ( s t a r t ) // Startknoten auf Warteschlange s e t z e n 

I Knoten werden in der Reihenfolge mit zunehmenden Abstand vom 

While Startknoten ( ! Wait . isempty aus besucht. ( ) ) { 

I Nachdem alle Knoten mit Abstand d verarbeitet wurden, werden die 

mit d + 1 angegangen. 

I Die Suche c o l o r [w] terminiert, = GRAY; wenn in Abstand d keine Knoten auftreten. 

10 int v = wait . dequeue ( ) ) ; //Knoten a l s b e a r b e i t e t von queue nehmen 

f o r e a c h (w in a d j l i s t [ v ] ) { // Die Nachfolgerknoten von v betrachten 

12 i f c o l o r [w] == WHITE { 

14 wait . enqueue (w) ; // Nachfolgerknoten a l s nä c h s t e Startknoten 

I Die Tiefe } des Knotens v im Breitensuchbaum ist seine kürzeste 

Kantendistanz zum Startknoten. 

16 } 

} 

I Die zu verarbeitenden Knoten werden als FIFO-Queue (first-in 

first-out) organisiert. 

18 c o l o r [ v ] = BLACK; // Gefundenen Knoten a l s ’ a b g e s c h l o s s e n ’ markieren 

} 

I Es gibt eine einzige „Verarbeitungsmöglichkeit“ für v, nämlich,wenn 

es aus der Queue entnommen wird. 

2 Sharir’s Algorithmus 

Theorem (Komplexität der Breitensuche) 

Sharir’s Algorithmus findet starke Zusammenhangskomponenten. 

Die Zeitkomplexität ist O(|V | + |E|), derPlatzbedarf⇥(|V |). 

33 


D 

E 

D 

E 

G 

G

7 } 

9 void dfsSearch(List KAPITEL adjL[n], 7. GRAPHENALGORITHMEN 

int n, int start, int &color[n]) { 

10 color[start] = GRAY; 

11 foreach (next in adjL[start]) { 

Prinzip 

12 if (color[next] == WHITE) { 

13 – Tiefensuche dfsSearch(adjL, auf Graph n, next, color); 

14 } 

– Alle Knoten, die ’abgeschlossen’ sind, also gefunden wurden, auf einem Stack 

15 } 

speichern. 

16 color[start] = BLACK; // Schliesse ab 

17 } – Graph transponieren und auf diesem transponierten Graphen eine weitere Tiefensuche 

durchführen. Dabei in der Reihenfolge die Knoten besuchen, in der sie auf 

dem Stapel stehen. 

– Leiter speichern. Leiter sind Knoten, die als erste bei der 2. Tiefensuche ’entdeckt’ 

wurden. 


⇒ Die starken Zusammenhangskomponenten sind die im stapel zwischen zwei Leitern. 

Elementare Graphenalgorithmen II Starke Zusammenhangskomponenten 

Sharir’s Beispiel: Algorithmus – Beispiel 

A 

F 

Ursprünglicher Digraph Transponierter Graph 

E 

G AFB 

D C 

B 

C 

Stack am Ende der Phase 1 

Zeitkomplexität 

D 

E 

G 

A 

F 

A 

F 

B 

C 

B 

C 

In Phase 2 gefundene starke Komponenten 


Sharir’s Algorithmus hat eine Zeitkomplexität von Θ(|V | + |E|). 

Seine Speicherkomplexität beträgt: Θ(|V |). 

3 Prims Algorithmus 

Der Algorithmus findet minimale Spannbäume. 

34 

D 

E 

D 

E 

G 

G

Prinzip 


– Bei beliebigen Knoten beginnen, Wert dieses Knotens auf 0, den der anderen auf 

∞ setzen. 

– Günstigste Kante bestimmen (→ Greedy- Algorithmus), Werte der angrenzenden 

Knoten updaten, wenn Kantengewicht kleiner als der Wert ist. 

– Bei günstigem Knoten fortfahren, bis keine weiteren Randknoten mehr verfügbar 

sind. 

– Bei gleichem Gewicht wird in alphabetischer Reihenfolge vorgegangen. 

4 Single Source Shortest Path (SSSP) 

4.1 Dijkstra-Algorithmus 

Dijkstra ermittelt die kürzesten Wege vom Startknoten zu allen anderen Knoten des 

Graphen. 

Hier sind (im Gegensatz zu Bellman Ford) ausschließlich nicht negative Kantengewichte 

zugelassen. 

– Initialisiere alle Knoten mit ∞ 

– Aktualisiere ausgehend vom aktuell betrachteten Knoten alle Knoten, die mit diesem 

verknüpft sind, wenn die Summe aus aktuellem Knoten und der Kante geringer 

Lehrstuhl für Informatik 2 

Datenstrukturen und Algorithmen SoSe 2012 

ist 2als der Wert des Zielknotens. Betrachte den aktuellen Knoten zukünftig nicht 

Modellierung und Verifikation von Software 

Musterlösung - Übung 11 

mehr. 

– Fahre mit dem Knoten mit minimalem Wert fort. 

→ Greedy-Algorithmus 

⇒ Führe diese Schritte in einer (großen) Tabelle aus (siehe Beispiel). 

Beispiel 

Die einzige starke Zusammenhangskomponente ist der gesamte (vollständige) Graph. Ihr Gesamtgewicht ist 

3. Somit würde das Verfahren des Studenten FALSE ausgeben. Es gibt jedoch einen Zyklus mit negativem 

Gewicht von A nach B und zurück. 

34 

9 

A B C 

1 

32 

13 

11 

D E F 

12 

5 

7 

2 

3 

10 

G H I 

Schritt 0 1 2 3 4 5 6 7 8 

Knoten A D G H E I F B C 

D[A] 

D[B] 

0 

34 

X 

33 

X 

33 

X 

33 35 

X 

33 

X 

33 

X 

25 

X 

25 

X 

X 

D[C] 1 1 1 1 1 1 35 34 34 

D[D] 1 1 X X X X X X X 

D[E] 1 1 1 10 10 X X X X 

D[F ] 1 1 1 1 21 21 21 X X 

D[G] 1 6 6 X X X X X X 

D[H] 1 8 8 8 X X X X X 

D[I] 1 1 1 18 16 16 X X X 

4 

6 

14 

8

G 

3 

H 

10 

I 


Schritt 0 1 2 3 4 5 6 7 8 

Knoten A D G H E I F B C 

D[A] 0 X X X X X X X X 

D[B] 34 33 33 33 33 33 25 25 X 

D[C] 1 1 1 1 1 1 35 34 34 

D[D] 1 1 X X X X X X X 

D[E] 1 1 1 10 10 X X X X 

D[F ] 1 1 1 1 21 21 21 X X 

D[G] 1 6 6 X X X X X X 

D[H] 1 8 8 8 X X X X X 

D[I] 1 1 1 18 16 16 X X X 

4.2 Bellman-Ford-Algorithmus 

D[H] 

D[I] 

Bellman Ford bestimmt den Kürzesten Pfad von einem Startknoten zu allen anderen 

b) Knoten Beweisen nach Sie dem die Korrektheit SSSP (single des Dijkstra sourceAlgorithmus, shortest path)- d.h. zeigen Prinzip. Sie, dass dieser Algorithmus für einen 

Wichtigster Graphen G den Unterschied kürzesten Abstand zu Dijkstra vom Startknoten ist, dass er s zuauch jedemmit anderen negativen von s erreichbaren Kantengewichten Knoten in G 

umgehen berechnet. kann. Sie dürfen dazu das Theorem aus Vorlesung 17, Folie 19 nutzen. 

c) Beweisen oder widerlegen Sie die folgenden Aussagen für einen gewichteten, zusammenhängenden, unge- 

Prinzip richteten Graphen G: 

i) Der vom Dijkstra Algorithmus berechnete SSSP-Baum ist ein Spannbaum. 

1. Initialisiere alle Knoten mit ∞ 

ii) Der vom Dijkstra Algorithmus berechnete SSSP-Baum ist ein minimaler Spannbaum. 

2. Initialisiere den Startknoten mit 0 

3. Aktualisiere die Kosten aller direkt durch Kanten erreichbaren Knoten, wenn durch 

3 

die Summe des Ursrungsknotens und der Kosten der Kante ein geringerer Wert 

erzielt wird, als der Zielknoten bislang hatte. 

4. Wiederhole 3), bis sich die Kosten nicht mehr ändern. 

→ Breche ab, wenn ein negativer Zyklus vorliegt. Dies ist der Fall, wenn nach (Knotenanzahl 

- 1)- Wiederholungen noch Verbesserungen möglich sind. 

⇒ Führe diese Schritte in einer Tabelle aus (siehe Beispiel). 

36

Aufgabe 1 (Bellman-Ford KAPITEL Algorithmus): 7. GRAPHENALGORITHMEN (5 + 6 + 3 = 14 Punkte) 

a) Bestimmen Sie für den Startknoten A die Längen der kürzesten Wege zu jedem Knoten im unten gegebenen 

Graphen G1 mit Hilfe des Bellman-Ford Algorithmus. Dabei sei die Reihenfolge der Knoten gegeben durch 

Beispiel die alphabetische Sortierung (A, B, C, . . . ). Geben Sie für jeden Knoten K die Kosten an, die dem Knoten 

während der Berechnun zugewiesen werden. Z.B. im Format K : 1, 10, 7, 6, 3. Geben Sie außerdem an, 

ob der Algorithmus einen Zyklus Gewicht erkennt. 

A 

D 

2 

7 

3 

5 

B 

E 

8 

-4 

1 1 

6 

C 

F 

1/A 1/B 1/E 1/F 2/B 2/F 

A: 1 0 A: 1, 0 

B: 1 7 6 B: 1, 7, 6 

C: 1 15 4 3 C: 1, 15, 4, 3 

D: 1 2 D: 1, 2 

E: 1 5 E: 1, 5 

F: 1 3 2 F: 1, 3, 2 

Der Graph enthält keinen Zyklus mit negativem Gewicht. 

b) Passen Sie die Implementierung von haben (Vorlesung 

17, Folie 13), so an, dass der kürzeste Pfad zwischen zwei Knoten i und j ausgegeben (nicht zurückgegeben!) 

wird. Sie dürfen davon ausgehen, dass der übergebene Graph keine negativen Zykel besitzt. 

5 Topologische Sortierung 

g 

Ihre Funktion soll die folgende Signatur haben: 

Topologische Sortierung void bellFord(List bezeichnetadjLst[n], eine Reihenfolge int n, intvon i, int Dingen, j) bei der vorgegebene 

Abhängigkeiten erfüllt sind. Anstehende Tätigkeiten einer Person 

etwa unterliegen einer Halbordnung: es existieren Bedingungen wie „Tätigkeit 

A muss vor Tätigkeit B erledigt werden“. Eine Reihenfolge, welche alle 

void ausgabe(String text) 

Bedingungen erfüllt, nennt man topologische Sortierung der Menge anstehender 

Tätigkeiten. Eine Topologische Sortierung ist nur möglich, wenn es 

keinen Zyklus gibt, d.h. wenn keine gegenseitigen Abhängigkeiten vorliegen. 

Zur Ausgabe können Sie annehmen, dass eine Funktion ausgabe mit folgender Signatur existiert: 

Außerdem können Sie annehmen, dass int-Werte automatisch nach String konvertiert werden können. 

c) Einem Studenten gefällt die Laufzeit des Bellman-Ford Algorithmus nicht und er schlägt das folgende 

alternative Verfahren vor, um Zyklen mit negativem Gesamtgewicht zu erkennen: 

Wir benutzen Sharirs Algorithmus, um alle starken Zusammenhangskomponenten zu finden. Dies kostet 

O(|V | + |E|). Da |E| 2 O(|V | 2 ) sind die Kosten damit in O(|V | + |V | 2 )=O(|V | 2 ). Für jede starke Zusammenhangskomponente 

berechnen wir dann die Summe der Gewichte ihrer Kanten. Dies kostet insgesamt 

O(|E|) und ist also wiederum in O(|V | 2 Prinzip: 

– Stelle die Abhängigkeiten als Graph dar. 

). Ist eine dieser Summen negativ, geben wir TRUE aus, sonst 

FALSE. – Die gerichteten Kanten zeigen jeweils zum Knoten, von dem der 

Wo liegt der Fehler, den der Student begangen hat? 

Ausgangsknoten abhängig ist 

– Sortiere die Knoten nach ihrer Abhängigkeiten so dass rechts diejenigen 

Knoten stehen, von denen nichts abhängt und links diejenigen Knoten 

stehen, die keine eigenen Abhängigkeiten haben 

– Versehe alle Knoten mit den jeweiligen Kosten. 

1 

⇒ Der Kritische Pfad ist der Pfad mit den maximalen Kosten (betrachtet 

von links nach rechts). 

Der kritische Pfad ist eine Folge von Aufgaben v0. . . vk, sodass 

- v0 keine Abhängigkeiten hat 

- vi abhängig von vi−1 ist, wobei est(vi) = eft(vi−1) (Keine Verzögerung!) 

est: earliest starting-time 

37

Beispiel 


eft: earliest finish-time 

- eft(vk) das Maximum über alle Aufgaben ergibt. 

Arbeitsschritt Abkürzung Dauer Abhängig von 

Vorlesung V 1 F 

Folien F 4 L 

Lehrstoff L 1 - 

Globalübung G 1 A, M 

Musterlösung M 2 A 

Aufgaben A 3 L 

Blatt B 1 A 

Tutorenbesprechung T 1 A, M 

L 

1 

F 

4 

V 

1 

A 

3 

Darstellung der Abhängigkeiten als gerichteter Graph und als Topologische Sortierung 

mit kritischem Pfad. 

– Vollständige Tiefensuche, bei der zusätzlich ein Array ’kritische Länge’ 

und ’earliest finish-time’ übergeben wird. 

– Nach der Abfrage der Knotenfarbe wird jedes mal folgende Abfrage 

durchgeführt: 

1 i f ( e f t [ next ] >= e s t ){ 

e s t = e f t [ next ] 

3 critDep [ s t a r t ] = next ; 

38 

M 

2 

G 

1 

B 

1 

T

d 

rithmen 17/22 

d 

, k≠1} 

Rekursionsgleichung: 

für k = 0 

für k > 0 

[i,j] = d (·) 

ij . 

j 

rithmen 19/22 


I Die Funktion W ordnet Kanten ein Gewicht zu. 

I } Negative Gewichte sind zugelassen, aber keine Zyklen mit negativem 

Gewicht. 

– Bevor Ider Nicht Knoten vorhandene schwarz Kanten gefärbt haben Gewicht wird, wird W (·, ·) =Œ. 

e f t [ s t a r t ] = e s t + duration [ s t a r t ] 

Problem (All-Pairs Shortest Path) 

durchgeführt. 

6 All EPairs zientere Version: Shortest Floyd’s Algorithmus. Paths 

Betrachtet wird die Länge des Pfades jedes Knotens mit jedem anderen Kno- 


ten. Hier sind negative Kantengewichte, jedoch keine negativen Zyklen zugelassen. 

Der Algorithmus von Floyd – Idee 

6.1 Floyd-Warshall Algorithmus 35 

Prinzip 

All-Pairs Shortest Path Der Algorithmus von Floyd 

All-Pairs Shortest Paths 

Wir betrachten gewichtete Digraphen G =(V , E, W ). 

Berechne für jedes Paar i, j die Länge D[i,j] des kürzesten Pfades. 

Naive Lösung: lasse ein SSSP-Algorithmus (z. B. Bellman-Ford) |V | mal 

laufen. Dies führt zu einer Worst-Case Zeitkomplexität O(|V | 4 ). 

All-Pairs Shortest Path Der Algorithmus von Floyd 

i j 

25 

Verbessert sich die Pfadlänge, wenn der Weg über Zwischenknoten führt? 

{1, ..., k≠1} 

– Floyd-Warshall ist eine klassischek Aufgabe der Dynamischen Programmierung: 

10 

{1, ..., k≠1} 

I Vorgehen wie bei Warshall, jedoch mit folgender Rekursionsgleichung: 

d (k) 

ij = 

Y 

] 

[ 

W (i, j) für k = 0 

1 

min d (k≠1) 

ij , d (k≠1) 

ik + d (k≠1) 

2 

kj für k > 0 

1 

‚ t (k≠1) 

ik · t (k≠1) 

2 

kj ) 

(statt: t (k≠1) 

ij 

I Auch hier arbeiten wir direkt im Ausgabearray: D[i,j] = d (·) 

ij . 


39

Beispiel 

• Namen und Matrikelnummern der Studenten sowie die Nummer der Übungsgruppe sind auf jedes Blatt der 

Abgabe zu schreiben. Heften bzw. tackern Sie die Blätter! 


Aufgabe 1 (Floyd-Algorithmus): (8 Punkte) 

Bestimmen Sie für den folgenden Graphen die Werte der kürzesten Pfade zwischen allen Paaren von Knoten. 

Nutzen Sie hierzu den Algorithmus von Floyd. Geben Sie das Distanzarray vor dem Aufruf, sowie nach jeder 

Iteration an. 

Die Knotenreihenfolge sei mit A, B, C, D, E fest vorgegeben. 

A B C D E 

A 0 7 1 3 1 

B 8 0 9 1 1 

C 5 1 0 1 2 

D 6 1 3 0 4 

E 1 9 1 7 0 

A B C D E 

A 0 7 16 3 8 

B 8 0 9 11 1 

C 5 12 0 8 2 

D 6 13 3 0 4 

E 17 9 18 7 0 

8 

A 

B 

7 

5 

9 

3 

6 

C 

1 

9 

A B C D E 

A 0 7 1 3 1 

B 8 0 9 11 1 

C 5 12 0 8 2 

D 6 13 3 0 4 

E 1 9 1 7 0 

A B C D E 

A 0 7 6 3 7 

B 8 0 9 11 1 

C 5 12 0 8 2 

D 6 13 3 0 4 

E 13 9 10 7 0 

7 Algorithmen auf Flussnetzwerken 

1 

3 

2 

7 

D 

E 

4 

A B C D E 

A 0 7 16 3 8 

B 8 0 9 11 1 

C 5 12 0 8 2 

D 6 13 3 0 4 

E 17 9 18 7 0 

A B C D E 

A 0 7 6 3 7 

B 8 0 9 8 1 

C 5 11 0 8 2 

D 6 13 3 0 4 

E 13 9 10 7 0 

7.1 Ford-Fulkerson-Methode - Maximaler Fluss 

Prinzip 

– Überführe den Graphen in ein Flussnetzwerk. 

– Suche einen beliebigen Pfad zwischen s und t heraus. 

– Bestimme die minimale Kapazität (maximalen Durchfluss) dieses 

Pfades. 

– Bestimme die Flusserhöhung, indem der Fluss entlang des Pfades 

gleich der Kapazität der Kante mit der minimalen Kapazität gesetzt 

wird. 

– Bilde das Restnetzwerk, indem der Durchfluss als umgekehrte Kanten 

eingezeichnet wird (eventuell existierende Gegenpfade werden 

verrechnet). 

40 

.


Maximaler Fluss Ford-Fulkerson-Methode 

Schnitte in Flussnetzwerken 

Definition 

– Fahre solange fort, neue Pfade zu suchen, bis es keine augmentierende 

(den Fluss weiter vergrößernde) Pfade mehr gibt, d.h. die Senke noch 

von der Quelle aus erreichbar ist. 

→ Der Maximale Fluss ist die Summe aller Flusserhöhungen. 

Ein Schnitt (S, T ) in einem Flussnetzwerk G =(V , E, c) ist eine Partition 

S fi T = V , S fl T = ? mit s œ S und t œ T . 

7.2 Min-cut-max-flow 

Datenstrukturen und Algorithmen (Folie 366, Seite 62 im Skript) 

I Wenn f ein Fluss in G ist, dann ist f (S, T ) der Fluss über (S, T ). 

Ein Schnitt (S, T) in einem Flussnetzwerk G = (V, E, c) ist eine Partition 

S ∪Schnitte T = V, S ∩inT = Netzwerken 

∅ mit s ∈ S und t ∈ T . Die Knoten werden also in zwei 

Gruppen aufgeteilt: Eine, die die Senke- und eine, welche die Quelle enthält. 

I Die Kapazität von (S, T ) ist c(S, T ). 

I Ein minimaler Schnitt ist ein Schnitt mit minimaler Kapazität. 

11/16 

s 

8/13 

v1 v1 

10 1/4 

v2 v2 

12/12 

4/9 

11/14 

v3 v3 

v4 v4 

7/7 

15/20 

4/4 

Der Fluß über 

(Schnitt 

(S, T 

(S 

)ist19. 

= /s, v1, v2/, T = /t, v3, v4/) hier 26) 


Die Kapazität von (S, T )ist26. 

Max-flow Min-cut Theorem 

Ist f ein Fluss im Flussnetzwerk G, dann sind äquivalent (gleichbedeutend): 

– f ist ein maximaler Fluss. 

– In Gf gibt es keinen augmentierenden Pfad. 

– |f| = c(S, T ) für einen Schnitt (S, T ), d.h. der Schnitt (S, T ) ist minimal. 

Daraus folgt: 

→ Die Kapazität eines minimalen Schnittes ist gleich dem Wert eines maximalen 

Flusses. (Kapazität des minimalen Schnittes entspricht dem 

maximalen Flusses) 

→ Falls die Ford–Fulkerson–Methode terminiert, berechnet sie einen maximalen 

Fluss. 

41 

t

8 Hashing 

Allgemeines Prinzip 

Das Ziel von Hashing ist es, einen großen Schlüsselraum auf einen kleineren 

Bereich von ganzen Zahlen abzubilden. Dabei soll möglichst unwahrscheinlich 

sein, dass zwei Schlüssel auf die selbe Zahl abgebildet werden. Eine Hashfunktion 

bildet einen Schlüssel auf einen Index der Hashtabelle T ab: 

h : U → {0, 1, ..., m − 1} für Tabellengröße m und |U| = n. 

Wir sagen, dass h(k) der Hashwert des Schlüssels k ist. Das Auftreten von 

Hashing I Grundlagen des Hashings 

h ′ (k) für k = k ′ nennt man Kollision. 

Hashing (II) 

Schlüsselmenge 

k2 

k4 

K 

benutzte Schlüssel 

U 

k3 

k1 

k5 

Hashfunktion 

0 

Hashtabelle 

h(k1) 

h(k2) =h(k3) 

h(k5) 

h(k4) 

m ≠ 1 

Kollision 

I Wie finden wir Hashfunktionen, die einfach auszurechnen sind und 

Kollisionen minimieren? 

I Wie behandeln wir dennoch auftretende Kollisionen? 

1 Hashfunktionen 


Hashing I Grundlagen des Hashings 

Eine Hashfunktion bildet einen Schlüssel auf einen Index (eine ganze Zahl) 

ab. Kollisionen: Das Geburtstagsparadoxon (II) 

Gute Hashfunktionen 

Auf Hashing angewendet bedeutet das: 

I Die Wahrscheinlichkeit keiner Kollision nach k Einfügevorgängen in 

einer m-elementigen Tabelle ist: 

Eine gute Hashfunktion ist charakterisiert durch folgende Eigenschaften: 

I Dieses Produkt geht gegen 0. 

k≠1 

m m ≠ 1 m ≠ k + 1 Ÿ m ≠ i 

· · ...· = 

m m m 

m 

i=0 

42 

I Etwa bei m = 365 ist die Wahrscheinlichkeit für k > 50 praktisch 0. 

Hashing I 

Kollisionen: Das 

Das liegt am 

Unsere 

wir so 

Geburtstagsparadox 

I Die Wahrscheinli 

Geburtstag hat is 

I Fragt man 23 Pe 

23 

365 ¥ 0,063. 

I Sind aber 23 Per 

den selben Gebur 


Hashing I 

1 

Kollisionen: Das 

Wahrscheinlichkeit 

keiner Kollision 

1.0 

0.8 

0.6 

0.4 

0.2

– Effizient 

– Geringer Speicheraufwand 

– Einfach zu berechnen 

KAPITEL 8. HASHING 

– Eingabewerte müssen nur einmal ausgelesen werden 

– Ähnliche Schlüssel sollten zu unterschiedlichen und breit verteilten Hashwerten 

führen. 

– Die Hashfunktion sollte surjektiv sein, d.h möglichst jeder Hashwert 

sollte genutzt werden. 

– Dabei sollte alle Indizes in etwa die gleiche Häufigkeit besitzen. 

Es gibt verschiedene Methoden, um eine gute Hashfunktion zu erhalten: 

– Divisionsmethode: Hashfunktion: h(k) = k mod m 

– Dabei sollte m möglichst eine Primzahl sein und nicht zu nahe an 

einer Zweierpotenz liegen. 

– Multiplikationsmethode: Hashfunktion: h(k) = ⌊m(k · c mod 1)⌋ 

für 0 < c < 1 

k·c mod 1 ist hierbei der Nachkommateil von k·c, d.h. k·c−⌊k·c⌋. 

– Universelles Hashing: Löst das Problem, dass es immer eine ungünstige 

Sequenz von Schlüsseln geben kann, sodass alle Schlüssel auf einen 

Hashwert abgebildet werden. 

– Dazu wird beim universellen Hashing eine zufällige Hashfunktion 

aus einem Pool H von Hashfunktionen ausgewählt. 

– Eine Menge H der Hashfunktionen wird als universell betrachtet, 

wenn mit einer zufällig aus H ausgewählten Hashfunktion die Wahrscheinlichkeit 

für eine Kollision zwischen den Schlüsseln k und l 

nicht größer als die Wahrscheinlichkeit 1 

m 

einer Kollision ist, wenn 

h(k) und h(l) zufällig und unabhängig aus der Menge {0, 1, ..., m − 

1} gewählt wurden. 

– Für universelles Hashing ist die erwartete Länge der Liste T [k] 

- gleich α, wenn k nicht in T enthalten ist. 

- gleich 1 + α, wenn k in T enthalten ist. 

2 Geschlossenes Hashing 

Beim geschlossenen Hashing, auch Kollisionsauflösung durch Verkettung genannt, 

werden alle Schlüssel, die zum gleichen Hashwert führen, innerhalb 

einer verketteten Liste gespeichert, auf die ein Arrayeintrag verweist: 

43

men 19/35 

I) 

chlüsselk in der 

ang der Liste 

iste T[h(e.key)]. 

men 21/35 

Kollisionsauflösung durch Verkettung (I) 

Idee 


Alle Schlüssel, die zum gleichen Hash führen, werden in einer 

verketteten Liste gespeichert. [Luhn 1953] 

k2 

k4 

K 

U 

k1 

k7 

k3 k6 

k5 

0 

k1 

k2 

k3 

k6 k7 k5 

k4 

m ≠ 1 

Idee der Kollisionsauflösung durch Verkettung 


Hashing I Verkettung 

Komplexität Kollisionsauflösung durch Verkettung (III) 

– Im Worst-Case Komplexität haben alle Schlüssel den selben Hashwert. Suchen und 

Löschen hat die selbe Worst-Case Komplexität wie bei Listen: W (n) = 

Θ(n). 

Angenommen, die Berechnung von h(k) ist recht e zient, etwa ⇥(1). 

Die Komplexität ist: 

Suche: Proportional zur Länge der Liste T [h(k)]. 

– Im Average-Case jedoch beträgt die Laufzeit zum (erfolgreichen und 

erfolglosen) Einfügen: Suchen Konstant A(n) (ohne= Überprüfung, Θ(1 + α). ob das Element schon 

vorhanden ist). 

α ist hierbei der Füllgrad der Hashtabelle: α = 

Löschen: Proportional zur Länge der Liste T [h(k)]. 

n (n: Anzahl der einge- 

m 

gebenen Schlüssel, m: Größe der Hashtabelle) 

I Im Worst-Case haben alle Schüssel den selben Hashwert. 

I Suche und Löschen hat dann die selbe Worst-Case Komplexität wie 

Listen: ⇥(n). 

3 Offenes Hashing 

I Im Average-Case ist Hashing mit Verkettung aber dennoch e zient! 

Allgemeines Prinzip: 


Beim offenen Hashing, auch Hashing mit offener Adressierung genannt, werden 

alle Schlüssel direkt auf eine einzige Hashtabelle abgebildet. Dabei können 

höchstens n Schlüssel gespeichert werden: 

α(n, m) = n 

m 

≤ 1 

Einfügen eines Schlüssels k 

– Sondiere die Positionen der Hashtabelle, bis ein leerer Slot gefunden 

wird 

– Die zu überprüfenden Positionen werden mittels einer Sondierungsfunktion 

in Abhängigkeit des Schlüssels k bestimmt. 

44


Die Hashfunktion hängt also sowohl vom Schlüssel k, als auch 

von der Nummer der Sondierung i ab. 

Sondierungsfunktionen 

Sondierungsfunktionen ordnen einen Schlüssel k auf eine Position der Hashtabelle 

zu. Dazu wird bei jeder fehlgeschlagenen Zuordnung eines Schlüssels 

dessen Zähler i um 1 hochgesetzt und die Sondierungsfunktion mit diesen 

modifizierten Parametern erneut aufgerufen. 

– Lineares Sondieren: h(k, i) = (h ′ (k) + i) mod m (für i < m) 

mit: k: Schlüssel 

i: Sondierungsschritt 

h’: Hashfunktion 

– Die Verschiebung der nachfolgende Sondierungen ist linear von i 

abhängig, die erste Sondierung bestimmt bereits die gesamte Sequenz. 

→ Es können insgesamt m verschiedene Sequenzen erzeugt werden. 

– Quadratisches Sondieren: h(k, i) = (H ′ (k) + c1 · i + c2 · i 2 ) mod m 

(für i < m) 

mit: k: Schlüssel 

i: Sondierungsschritt 

h’: Hashfunktion 

Konstanten c1, c2 = 0 

– Die Verschiebung der nachfolgende Sondierungen ist quadratisch 

von i abhängig, die erste Sondierung bestimmt auch hier bereits die 

gesamte Sequenz. 

→ Bei geeignet gewähltem c1, c2 können auch hier insgesamt m 

verschiedene Sequenzen erzeugt werden. 

→ Clustering (Aneinanderreihung), welches bei linearem Sondieren 

auftritt wird jedoch vermieden. Jedoch tritt sekundäres 

Clustering immer noch auf: 

Beispiel: h(k, 0) = h(k ′ , 0) verursacht h(k, i) = h(k ′ , i) (für 

alle i) 

– Doppeltes Hashing: h(k, i) = (h1(k) + i · h2(k)) mod m (für i < 

m) 

mit: h1, h2: Übliche Hashfunktionen. 

45

0/1 

2/1 

h1(k) =k mod 11 

h2(k) =1 + k mod 10 

h(k, i) =(h1(k)+i · h2(k)) mod 11 



- Die Verschiebung der nachfolgenden Sondierungen ist von h2(k) 

abhängig. Die erste Sondierung bestimmt also nicht die gesamte 

Sequenz. 

Hashing II O ene Adressierung 

→ Dies führt zu einer besseren Verteilung der Schlüssel in der 

Hashtabelle. Dies kommt gleichverteiltem Hashing nahe. 

Praktische E zienz von Doppeltem Hashing 

I Hashtabelle- mit Sind538 h2 und 051 mEinträgen relativ prim (Endfüllgrad (Teilerfremd), 99,95%) wird99,8 die% -> gesamte 358 

I Mittlere Anzahl Hashtabelle Kollisionen abgesucht. ÷ pro Einfügen in die Hashtabelle: 

÷ 

14 

12 

10 

8 

6 

4 

2 

0 

Lineares Sondieren 

Quadratisches Sondieren 

Doppeltes Hashing 

0 10 20 30 40 50 60 70 80 90 100 

Füllgrad der Hashtabelle (in %) 


Vergleich der drei Sondierungsmethoden 

Datenstrukturen und Algorithmen 23/1 

Komplexität 

Average-Case: 

– Die erfolgreiche Suche benötigt O 

1 1 · ln α 1−α 

– Die erfolglose Suche benötigt O( 1 

1−α ) 

Löschen eines Schlüssels k 

Problematik 

Im Gegensatz zum Geschlossenen Hashing kann ein zu löschender Schlüssel 

hier nicht einfach gelöscht (durch null ersetzt) werden, da ansonsten das 

beim Einfügen geschehene Sondieren nicht berücksichtigt wird. 

Daher muss hier statt einem Löschen (ersetzen mit null) der Schlüssel durch 

einen speziellen Wert DELETED ersetzt werden. 

46

26/33 

9 Algorithmische Geometrie 

Algorithmische Geometrie Algorithmische Geometrie 

Winkelbestimmung 1 Mathematische(III) Grundlagen 

Problem 

Winkelbestimmung mit Determinanten 

Gegeben der Streckenzug (p, q, r). Wirdbeiqnach links oder rechts 

abgebogen? Gegeben der Oder: Streckenzug Ist der Winkel (p, q, r): ]pqr > 180 oder < 180 ? 

p 

pq 

q 

qr 

r 

]pqr = 180 +– 

I Wir verwenden wieder die Determinante. 

I Dazu berechnen wir ˛a = ˛dpq = q ≠ p und ˛b = ˛ – 

dqr = r ≠ q. 

−→ a = −→ dpq = q − p und −→ b = −→ dpr = r − q 

I det(˛a, ˛b) > 0, fallsderKnicknachlinks geht (]pqr > 180 – Linksdrehung, wenn det( 

, – > 0). 

−→ a , −→ b ) > 0 

– Rechtsdrehung, wenn det( −→ a , −→ b ) < 0 

I Wenn r auf (der Verlängerung von) pq liegt, dann ist det(˛a, ˛ b)=0 

(]pqr = 0 oder = 180 – Wenn det( 

). 

−→ a , −→ b ) = 0 liegt r auf der Verlängerung von pq. (∡pqr = 0◦ oder 180◦ ) 


Algorithmische Geometrie Algorithmische Geometrie 

Schnitt zweier Strecken 

Problem 

Algorithmische Geometrie Konvexe Hülle 

Polygone 

Polygone 

Gegeben zwei Strecken pq und rs. Schneidensichdiese? 

einfach 

r 

p 

I Wir sind nicht an der Position des Schnittpunktes interessiert. 

I Idee: Wir testen, ob die Endpunkte r und s auf verschiedenen Seiten 

s 

q 

x2 

nicht einfach nicht konvex konvex, einfach 

Ein Polygon heißt einfach, wennessichnichtselbstschneidet. 

konvex 

47 

Ein Polygon heißt konvex, wenn jede Verbindung (Konvexkombination) 

zweier Punkte des Polygons nie außerhalb des Polygons liegt. 


– 

˛ b 

˛a 

x1


Konvexe Hülle 

KAPITEL 9. ALGORITHMISCHE GEOMETRIE 




p5 

p12 

p10 

p11 

p6 

p0 

p1 

p4 

Die konvexe Hülle einer Menge Q von Punkten ist das kleinste konvexe Po- 

Die konvexe Hülle einer Menge Q von Punkten ist das kleinste konvexe 

lygon P, für das sich jeder Punkt in Q entweder auf dem Rand von P oder in 

Polygon P, fürdassichjederPunktinQentwederaufdemRand von P 

seinem Inneren befindet. Hilfreich ist hierbei die Vorstellung der Punktemen- 

oder in seinem Inneren befindet. 

ge als Nägel auf einem Brett, um die außen ein Gummiband gespannt wird. 

Die konvexe Hülle hat dann die Form, die durch das straffe Gummiband 

I 

gebildet 

Betrachte 

wird, das 

jeden 

alle 

Punkt 

Nägel umschließt. 

als Nagel, der aus einem Brett herausragt. 

I Die konvexe Hülle hat dann die Form, die durch ein stra es 

Gummiband gebildet wird, das alle Nägel umschließt. 

2 Graham-Scan 


Der Graham-Scan gibt die konvexe Hülle einer Menge Q von Punkten in 

einem zweidimensionalen Raum aus. 

Prinzip 

1. Suche den Startpunkt, der auf jeden Fall auf der Hülle liegt. 

– Konvention: Gewählt wird der Punkt mit der niedrigsten x2- Koordinate. 

Haben mehrere Punkte die gleiche x2-Koordinate, so GIBT 

zusätzlich die geringste x1-Koordinate den Ausschlag 

2. Von Punkt diesem ausgehend sortiere die Punkte nach zunehmendem 

(Polar-) Winkel zur x1- Achse (entspricht einer rotierenden Sweepline): 

– Dies geschieht mittels Determinantenberechnung: Die Determinanten 

der Strecken vom Startpunkt zum betrachteten Punkt und 

der x1-Achse werden berechnet. Die Reihenfolge der Determinanten 

gibt die Polarwinkelreihenfolge an. 

48 

p8 

p2 

p3 

p7 

p9

lle 

Beispiel 

p8 

p2 

p3 

p7 

p9 

ren und Algorithmen 30/33 

lle 

Beispiel 

p5 

p4 

p2 

p1 

p3 

ren und Algorithmen 30/33 

KAPITEL 9. ALGORITHMISCHE GEOMETRIE 


Konvexe Hülle – Graham-Scan – Beispiel 

p0 

p9 

p8 

p7 


p6 

3. Die ersten Algorithmische drei Geometrie Punkte werden nun Konvexe auf Hülle einen Stapel gelegt (und somit 

als ’auf Konvexe der konvexen Hülle – Hülle Graham-Scan liegend’ betrachtet). – Beispiel 

4. Die weiteren Punkte werden p9 einzeln auf ihren Winkel zu den beiden 

Vorgängerpunkten auf dem Stapel überprüft: 

– Die Winkelüberprüfung geschieht mittels Determinante: 

p6 

p10 

p5 

p7 

det(stack.top − (stack.top − 1), NeuesElement − stack.top) 

p8 

→ Es p12 wird also p11die 

Determinante von (oberstem Stackelement abzüglich 

zweitoberstem Stackelement) und (neu hinzukommendem 

Element abzüglich oberstem Stackelement) berechnet. 

– Hier sind zwei Fälle möglich: 

p0 

a) Ist die berechnete Determinante ≤ 0, knickt die Verbindungs- 

strecke der drei Punkte bei Stack.top nach rechts ab. Das oberste 

Stapelelement wird entfernt, da es sich nicht auf der Hülle, 

sondern im inneren des Polygons befindet. 


– Das neu hinzukommende Element wird nun erneut mit den 

restlichen auf dem Stack befindlichen Elementen überprüft. 

b) Ist die berechnete Determinante > 0, knickt die Verbindungsstrecke 

der drei Punkte bei Stack.top nach links ab. Das neu 

hinzukommende Element wird oben auf den bestehenden Stapel 

gelegt. 

49 

p5 

p4 

p4 

p2 

p2 

p1 

p1 

p3 

p3

2 

Joost-Pieter Katoen KAPITEL Datenstrukturen und 9. Algorithmen ALGORITHMISCHE 30/33 GEOMETRIE 

Joost-Pieter Katoen Datenstrukturen und Algorithmen 


p0 

p9 

p8 

p7 


p6 

p5 

p4 

p2 

p1 

p3 

Joos uren und Algorithmen 

Rot: p7 wird aus konvexer Hülle entfernt, Grün: p8 wird anschließend überprüft. 

Beispiel 

Konvexe Hülle für folgende Punkte in einem Zweidimensionalen Koordinatensystem: 

Datenstrukturen und Algorithmen SoSe 2012, Fragestunde 29.08.2012 

(1, 0); (4, 1); (4, 3); (3, 3); (2, 2); (1, 4); (0, 2) 

Lösung 

Knoten Vektoren und Determinante Stack 

(3, 3) 

(4, 3) 

(4, 1) 

(2, 2) 

(3, 3) 

(4, 3) 

(1, 4) 

(2, 2) 

(3, 3) 

(1, 4) 

(3, 3) 

(4, 3) 

✓ 

0 

det( 

2 

✓ 

1 

det( 

0 

✓ 

1 

det( 

1 

✓ 

1 

det( 

0 

◆ ✓ 

1 

, 

0 

◆ ✓ 

1 

, 

1 

◆ ✓ 

1 

, 

2 

◆ ✓ 

2 

, 

1 

p0 

p9 

p8 

p7 

◆ 

)=0+2=2> 0 (3, 3) 

(4, 3) 

(4, 1) 

(1, 0) 

◆ 

)=1 0=1> 0 

p6 

p5 

p4 

p2 

p1 

p3 

(2, 2) 

(3, 3) 

(4, 3) 

(4, 1) 

(1, 0) 

◆ 

)= 2 1= 3 apple 0 (3, 3) 

(4, 3) 

(4, 1) 

(1, 0) 

50 

◆ 

)= 1 0= 1 apple 0 

(4, 3) 

(4, 1) 

lle 

p5 

p4 

p2 

p1 

p

(2, 2) 

✓ ◆ ✓ ◆ 

KAPITEL 9. ALGORITHMISCHE 1 1 GEOMETRIE 

(3, 3) det( , )=1 0=1> 0 

0 1 

(1, 4) 

(2, 2) 

(3, 3) 

✓ 

1 

det( 

1 

◆ ✓ 

1 

, 

2 

(2, 2) 

(3, 3) 

(4, 3) 

Knoten Vektoren und Determinante Stack 

(1, 4) 

(3, 3) 

(4, 3) 

(1, 4) 

(4, 3) 

(4, 1) 

(0, 2) 

(1, 4) 

(4, 3) 

✓ 

1 

det( 

0 

✓ 

0 

det( 

2 

✓ 

3 

det( 

1 

◆ ✓ 

2 

, 

1 

◆ ✓ 

3 

, 

1 

◆ ✓ 

1 

, 

2 

51 

◆ 

)= 2 1= 3 apple 0 (3, 3) 

(4, 3) 

(4, 1) 

(1, 0) 

◆ 

)= 1 0= 1 apple 0 

(4, 3) 

(4, 1) 

(1, 0) 

◆ 

)=0+6=6> 0 (1, 4) 

(4, 3) 

(4, 1) 

(1, 0) 

4 

◆ 

)=6+1=7> 0 

(0, 2) 

(1, 4) 

(4, 3) 

(4, 1) 

(1, 0)

Zusammenfassung - S-Inf

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?