DuA Alle

Datenstrukturen und
Algorithmen
SS 2011 SS 2011
Prof. Dr. Christian Scheideler
Organisatorisches
Vorlesung:
Di 11:15 - 12:45 Hrsaal C1
Fr 11:15 - 12:45 Hrsaal C1
Zentralbung: Zentralbung:
Fr 13:00 13:45 Hrsaal C1
Beginn: nchste Woche
bungen:
Beginn: nchste Woche
DuA - Kapitel 1 2 SS 2011
Organisatorisches
bungsgruppen:
Anmeldung ber PAUL
bungsgruppenzeiten: siehe Kurswebseite
http://www.cs.uni-paderborn.de/fachgebiete/fg-ti/lehre0/ss2011/dua0.html
erreichbar ber Theorie verteilter Systeme LehreDuA erreichbar ber Theorie verteilter Systeme LehreDuA
Problem: bung 9 (Mi 9-11) wird auf Do 16-18 verschoben, da
sonst kein Raum zur Verfgung steht
Koordinator der bungsgruppen:
Martina Hllmann
(Ansprechpartner fr bungs-
spezifische Fragen)
Organisatorisches
bungen:
Jede Woche Freitag neues bungsblatt auf der
Vorlesungswebseite (nicht PAUL!)
1. Blatt an diesem Freitag
Abgabe: nchsten Freitag bis 11:15 Uhr, D3-Flur Abgabe: nchsten Freitag bis 11:15 Uhr, D3-Flur
versptete Abgaben werden nicht bercksichtigt!
Gruppengre: 2-4 Personen
Vorstellung einer Musterlsung in der Zentralbung
Bonuspunkte:
>50% der bungspunkte: 1/3 Note
zweimal Vorrechnen in der bung: 1/3 Note
Organisatorisches
Klausur:
Eine Korrelation mit den bungsaufgaben ist zu erwarten
Es gab in der Vergangenheit einen direkten Zusammen-
hang zwischen bungsteilnahme/abgabe und gutem
Abschneiden bei Klausuren Abschneiden bei Klausuren
Hilfsmittel: handbeschriebenes DIN A4-Blatt
Sprechzeiten:
Do 16:00 17:00 (Raum F2.326; Frstenallee)
Fragen/Anmerkungen zunchst an den eigenen Tutor
Organisatorisches
Literatur:
Cormen, Leiserson, Rivest, Stein:
Introduction to Algorithms, 3rd ed.
MIT Press/McGraw-Hill MIT Press/McGraw-Hill
ISBN 0-262-53305-8
Weitere Literatur siehe Webseite
Inhaltsangabe:
Einleitung, Motivation
Pseudocode, Invarianten, Laufzeitanalyse
Gro-O-Notation
Inkrementelle Algorithmen: Insertion-Sort
Divide & Conquer Algorithmen: Merge-Sort,
Grundlagen
Divide & Conquer Algorithmen: Merge-Sort,
Quick-Sort und Varianten
Rekursionsgleichungen: Master-Theorem
Algorithmen mit Datenstrukturen: Heaps,
Heap-Sort
Untere Schranke fr Vergleichssortierer
Counting-Sort
Sortieralgorithmen
ADTs und Datenstrukturen: Stacks, Queues,
Listen, Bume
Hashtabellen
Binre Suchbume, AVL Bume
Elementare Graphalgorithmen:
Tiefen- und Breitensuche
Zusammenhangskomponenten
Krzeste Wege: Algorithmus von Dijkstra
Minimale Spannbume: Algorithmus von Prim
Datenstrukturen
Graphalgorithmen
Minimale Spannbume: Algorithmus von Prim
und Kruskal
Gierige Algorithmen: Scheduling
Dynamische Programmierung:
Rucksack-Problem
Amortisierte Laufzeitanalyse
Optimale Suchbume
Entwurfsmethoden
1. Einfhrung
Wie passt Datenstrukturen und Algorithmen ins
Informatikstudium?
Was ist ein Algorithmus?
Was ist eine Datenstruktur?
Nach welchen Kriterien beurteilen wir Algorithmen? Nach welchen Kriterien beurteilen wir Algorithmen?
Wie beschreiben wir Algorithmen?
Warum betrachten wir effiziente Algorithmen?
Ein paar einfhrende Beispiele
Softwareentwicklung
Problem
Modellierung
Entwicklung von
Algorithmus/Datenstruktur
Implementierung
DuA + Info-Studium
DuA
Modellierung
Beschreibung von Problemen
Grenzen von
Algorithmen
Umsetzung
durch Programme DuA
Berechenbarkeit,
formale Sprachen
und
Komplexitt
Algorithmen durch Programme
Programmierung,
Softwareentwurf,
Softwarepraktikum
Beispielprobleme
Wie findet ein Navigationssystem gute Verbindungen
zwischen zwei Orten? Wie werden im Internet
Informationen geroutet?
Wie berechnet ein Unternehmen eine mglichst gute
Aufteilung seiner Ressourcen, um seinen Gewinn zu
maximieren? maximieren?
Wie werden etwa in Google Informationen schnell
gefunden?
Wie werden Gleichungssysteme der Form Ax=b
gelst?
Probleme, Algorithmen, Ziele
Ziel der Vorlesung ist es
1. Wichtige Probleme, Algorithmen und
Datenstrukturen kennen zu lernen.
2. Wichtige Algorithmentechniken und
Entwurfsmethoden kennen und anwenden
zu lernen. zu lernen.
3. Wichtige Analysemethoden kennen und
anwenden zu lernen.
4. Das Zusammenspiel von Datenstrukturen
und Algorithmen zu verstehen.
Definition 1.1: Ein Algorithmus ist eine eindeutige
Beschreibung eines Verfahrens zur Lsung einer
bestimmten Klasse von Problemen.
Genauer: Ein Algorithmus ist eine Menge von Regeln
fr ein Verfahren, um aus gewissen Eingabegren
bestimmte Ausgabegren herzuleiten. Dabei muss
1. Das Verfahren in einem endlichen Text beschreibbar
sein.
2. Jeder Schritt des Verfahrens auch tatschlich
ausfhrbar sein.
3. Der Ablauf des Verfahrens zu jedem Zeitpunkt
eindeutig definiert sein.
Anschaulich:
Eingabe
Algorithmus Algorithmus
Ausgabe
Beispiel Sortieren
) b , , b , (b Umordnung sortierte
) a , , a , (a Folge jeder zu das n, Verfahre : orithmus Sortieralg
. b b b dass so ge, Eingabefol
der ) b , , b , (b Umordnung : Sortieren bei Ausgabe
). a , , a , (a Zahlen n von Folge : Sortieren bei Eingabe
n 2 1
n 2 1
n 2 1
n 2 1
K
K
L
K
K

48,51,59) (26,31,41, : Ausgabe
26,51,48) (31,41,59, : Eingabe
berechnet.
n 2 1
K
Definition 1.2: Eine Datenstruktur ist eine bestimmte Art,
Daten im Speicher eines Computers so anzuordnen,
dass Operationen wie z.B. Suchen, Einfgen, Lschen
einfach zu realisieren sind.
Einfache Beispiele: Einfache Beispiele:
Listen
Arrays
Datenstrukturen und Algorithmen sind eng verbunden:
Gute Datenstrukturen sind hufig unerlsslich fr gute
Algorithmen.
Anschaulich:
Datenstruktur
Operation 1
Operation 2 Datenstruktur Operation 2
Operation 3
Beispiele
Wrterbuch
Filesystem
Speicherverwaltung
Straenkarte
DuA - Kapitel 1
Textdatei im Editor
3D-Szene
19 SS 2011
Kriterien fr Algorithmen
Algorithmen mssen korrekt sein.
Bentigen Korrektheitsbeweise.
Algorithmen sollen zeit- und speichereffizient sein.
Bentigen Analysemethoden fr Zeit- und
Speicherbedarf.
Analyse basiert nicht auf empirischen Untersuchungen,
sondern auf mathematischen Analysen. Nutzen hierfr
Pseudocode und Basisoperationen.
Algorithmenentwurf
Zum Entwurf eines Algorithmus gehren
1. Beschreibung des Algorithmus
2. Korrektheitsbeweis
3. Zeit- bzw. Speicherbedarfsanalyse. 3. Zeit- bzw. Speicherbedarfsanalyse.
Beschreibung von Algorithmen
Zunchst informelles (mathematisches) Verfahren zur
Lsung.
Dann Przisierung durch Pseudocode.
Keine Beschreibung durch Programmcode in Java Keine Beschreibung durch Programmcode in Java
oder C, C++ (das ist Teil der Umsetzung durch ein
Programm).
Pseudocode:
Schleifen (for, while, repeat)
Bedingtes Verzweigen (if then else)
(Unter-)Programmaufruf/bergabe (return)
Zuweisung durch
Beschreibung von Algorithmen
Zuweisung durch
Kommentar durch
Daten als Objekte mit einzelnen Feldern oder
Eigenschaften (z.B. length(A) Lnge des Arrays A)
Blockstruktur durch Einrckung
> >> >
Algorithmenentwurf
Warum mathematische Korrektheitsbeweise?
Fehler knnen fatale Auswirkungen haben
(Steuerungssoftware in Flugzeugen, Autos, AKWs)
Fehler knnen selten auftreten
(Austesten funktioniert nicht)
Der teuerste algorithmische Fehler? Der teuerste algorithmische Fehler?
Pentium bug ( $500 Mio.)
Enormer Imageschaden
Trat relativ selten auf
Algorithmenentwurf
$480 Mio. entgangener Gewinn
Die Berechnung von
z = x- (x/y)y
sollte z=0 ergeben.
Der fehlerhafte
Pentium-Prozessor Pentium-Prozessor
berechnete statt dessen
mit den Werten
x=4195835 und
y=3145727
den Wert z=256
Wozu gute Algorithmen?
Computer werden zwar immer schneller und Speicher
immer grer und billiger, aber
Geschwindigkeit und Speicher werden immer
begrenzt sein.
Daher muss mit den Ressourcen Zeit und Speicher Daher muss mit den Ressourcen Zeit und Speicher
geschickt umgegangen werden.
Auerdem werden in Anwendungen immer grere
Datenmengen verarbeitet. Diese wachsen schneller
als Geschwindigkeit oder Speicher von Computern.
Effekt guter Algorithmen - Sortieren
: A Computer
n. Vergleiche
n c mit Zahlen n Sortiert
: Sort - Insertion
2
1
: B Computer
en. Vergleich nlog(n) c
mit Zahlen n Sortiert
: Sort - Merge
2
Sek. 2000
10
) (10 2
A bentigt Dann
. 10 n 2, c
e/Sek. Vergleich 10
: A Computer
9
2 6
6
1
9
=
= =
Sek. 100
10
) )log(10 (10 50
B bentigt Dann
. 10 n 50, c
e/Sek. Vergleich 10
: B Computer
7
6 6
6
2
7
= =
Ganzzahlige Arithmetik
Einfhrung in effiziente Algorithmen am
Beispiel ganzzahliger Arithmetik
bersicht:
Notation
DuA - Kapitel 1
Notation
Arithmetik auf groen Zahlen
Addition
Multiplikation
Kreisberechnung
28 SS 2011
Ganzzahlige Arithmetik:
Ganze Zahl: Ziffernfolge zur Basis B
Zur Basis B: Ziffern aus [B] = {0,,B-1}
Zahl a=(a
n-1
a
0
)
B
zur Basis B hat den Wert
i=0
n-1
a
i
B
i
Notation
DuA - Kapitel 1
Wichtige Beispiele:
B=2: Binrzahlen ( (101)
2
= 12
2
+ 12
0
= 5 )
B=10: Dezimalzahlen
B=16: Hexadezimalzahlen ( (A)
16
= 10 )
Ziffern: {0,,9} {A,B,C,D,E,F}
29 SS 2011
Elementare arithmetische Operationen:
Seien a,b,c,x,y [B].
(x y)
B
a+b+c
(x y)
B
ab
Beispiele fr B=10:
Notation
DuA - Kapitel 1
Beispiele fr B=10:
(12)
10
= 5+6+1
(42)
10
= 67
Basis B klar: lassen wir weg
30 SS 2011
Gegeben: zwei Zahlen a=(a
n-1
a
0
) und
b=(b
n-1
b
0
)
Gesucht: s=(s
n
s
0
) mit s=a+b
Schulmethode:
a a a
Addition
DuA - Kapitel 1
a
n-1
a
1
a
0
b
n-1
b
1
b
0
c
n
c
n-1
c
1
c
0
{0,1}
s
n
s
n-1
s
1
s
0
bertrag
31 SS 2011
Es gilt:
c
0
= 0
(c
i+1
s
i
) = a
i
+b
i
+c
i
fr alle i0
s
n
= c
n
Algorithmus:
Addition
DuA - Kapitel 1
Algorithmus:
c0
for i0 to n-1 do
(c s
i
)a
i
+b
i
+c
s
n
c
Elementaroperation
for to do - Schleife
32 SS 2011
Satz 1.3: Die Addition zweier Zahlen der
Lnge n bentigt hchstens n Elementar-
additionen
Addition
DuA - Kapitel 1
Beobachtung: Jede Addition n-stelliger
Zahlen a und b bentigt mindestens n
Elementaradditionen, d.h. unser Algo ist
optimal.
33 SS 2011
Gegeben: zwei Zahlen a=(a
n-1
a
0
) und
b=(b
n-1
b
0
)
Gesucht: s=(s
2n-1
s
0
) mit s=a b
Multiplikation
DuA - Kapitel 1
Schulmethode:
berechne a b
j
fr alle j0
addiere Ergebnisse versetzt zusammen
34 SS 2011
(a
n-1
a
0
) b
j
c
n-1
c
n-2
c
0
0
+ d
n-1
d
1
d
0
e
n
e
n-1
e
1
e
0
p
n
p
n-1
p
1
p
0
Algorithmus:
(c
i
d
i
) = a
i
b
j
bertrag
Multiplikation
DuA - Kapitel 1
Algorithmus:
e0; c
-1
0
for i0 to n-1 do
(c
i
d
i
)a
i
b
j
; (e p
i
)c
i-1
+d
i
+e
p
n
c
n-1
+e
35 SS 2011
Lemma 1.4: Wir knnen eine Zahl der Lnge
n mit einer Ziffer in 2n primitiven Operatio-
nen multiplizieren.
Multiplikation
DuA - Kapitel 1
Sei p
j
= a b
j
mit p
j
= (p
j,n
p
j,0
).
Dann mssen wir noch
p =
j=0
n-1
p
j
B
j
berechnen.
36 SS 2011
Bildlich: p
0,n
p
0,2
p
0,1
p
0,0
+ p
1,n
p
1,n-1
p
1,1
p
1,0

+ p . p p
Multiplikation
DuA - Kapitel 1
+ p
n-1,n
. p
n-1,1
p
n-1,0
p
2n-1
... p
2
p
1
p
0
37 SS 2011
Algorithmus:
p0
for j0 to n-1 do
pp + (ab
j
) B
j
Lemma 1.4
Satz 1.3
Multiplikation
DuA - Kapitel 1
Anzahl Elementaroperationen maximal
2n wegen Satz 1.3, insgesamt 2n
2
2n wegen Lemma 1.4, insgesamt 2n
2
Also insgesamt max. 4n
2
Elementaroperationen
38 SS 2011
Mit einer besseren Abschtzung fr die
Additionen kann gezeigt werden:
Satz 1.5: Die Schulmethode multipliziert
Multiplikation
DuA - Kapitel 1
Satz 1.5: Die Schulmethode multipliziert
zwei Zahlen der Lnge n mit hchstens
3n
2
+n primitiven Operationen.
Knnen wir besser werden?
39 SS 2011
Rekursive Version der Schulmethode:
Gegeben: zwei n-stellige Zahlen a, b zur
Basis B, n gerade
Sei a=a
1
B
k
+a
0
und b=b
1
B
k
+b
0
mit k=n/2
Multiplikation
DuA - Kapitel 1
Dann gilt:
a b = (a
1
B
k
+a
0
) (b
1
B
k
+b
0
)
= a
1
b
1
B
2k
+ (a
1
b
0
+ a
0
b
1
)B
k
+ a
0
b
0
4 rekursive Aufrufe zur Multiplikation n/2-stelliger Zahlen
40 SS 2011
Annahme: |a|=|b|=n=2
c
fr ein c
Algorithmus Produkt(a,b):
if |a|=|b|=1 then return ab
return - Anweisung
Multiplikation
DuA - Kapitel 1
else
k|a|/2
return Produkt(a
1
,b
1
) B
2k
+ (Produkt(a
1
,b
0
)
+ Produkt(a
0
,b
1
))B
k
+ Produkt(a
0
,b
0
)
if then else - Anweisung
41 SS 2011
Anzahl Elementaroperationen ( , +):
1 n=1
4T(n/2)+3(2n) n>1
T(n) =
{
Multiplikation
DuA - Kapitel 1
4T(n/2)+3(2n) n>1
Daraus ergibt sich T(n) < 7n
2
+ 6n
Beweis: durch Induktion
42 SS 2011
Karatsubas Idee:
a b = (a
1
B
k
+a
0
) (b
1
B
k
+b
0
)
= a
1
b
1
B
2k
+ (a
1
b
0
+ a
0
b
1
)B
k
+ a
0
b
0
= a
1
b
1
B
2k
+ ((a
1
+a
0
)(b
1
+b
0
)
(a b +a b ))B
k
+ a b
Multiplikation
DuA - Kapitel 1
(a
1
b
1
+a
0
b
0
))B
k
+ a
0
b
0
Nur noch drei rekursive Aufrufe fr
a
1
b
1
, a
0
b
0
, (a
1
+a
0
)(b
1
+b
0
)
43 SS 2011
Algorithmus Karatsuba(a,b):
if |a|=|b|=1 then return ab
else
k |a|/2
p Karatsuba(a ,b )
Multiplikation
DuA - Kapitel 1
p
1
Karatsuba(a
1
,b
1
)
p
2
Karatsuba(a
1
+a
0
,b
1
+b
0
)
p
3
Karatsuba(a
0
,b
0
)
return p
1
B
2k
+ (p
2
-(p
1
+p
3
))B
k
+ p
3
44 SS 2011
Anzahl Elementaroperationen:
1 n=1
3T(n/2+1)+6(2n) n>1
Daraus ergibt sich T(n) ~ n
log 3
= n
1,58
T(n) =
{
Multiplikation
DuA - Kapitel 1
Daraus ergibt sich T(n) ~ n
log 3
= n
1,58
Problem: Karatsuba erst fr n>1.000.000 besser
als Schulmethode
Bester Algo fr Multiplikation: O(n log n loglog n)
45 SS 2011
Wie zeichne ich schnell Kreise im Computer?
Kreiszeichnen
Naiver Ansatz: verwende sin und cos
Fr =0...2:
y=R sin( )
Kreiszeichnen
DuA - Kapitel 1

x=R cos( )
R -R
47 SS 2011
plot(x,y): setze Punkt bei Position (x,y)
Algorithmus Kreis1:
for i0 to n-1 do
plot(Rcos(2i/n), Rsin(2i/n))
Kreiszeichnen
DuA - Kapitel 1
plot(Rcos(2i/n), Rsin(2i/n))
Kreisumfang: U=2R. Bei Pixelbreite von 1
Lngeneinheit reicht dann n=7R.
Problem: sin, cos, , / teuer!
48 SS 2011
Besserer Ansatz:
x
2
+y
2
=R
2
, also y=+/- R
2
-x
2
Algorithmus Kreis2:
y0 0
for x -R to R do
y
y0
y1
Kreiszeichnen
DuA - Kapitel 1
for x -R to R do
y1 sqrt(RR-xx)
for yy0 to y1 do
plot(x,y); plot(x,-y)
y0y1
x
y
-R R
49 SS 2011
Noch besser: Ausnutzung von Spiegelungen
R
(x,y) (-x,y)
(y,-x)
(y,x)
zu berechnen
Kreiszeichnen
DuA - Kapitel 1
(y,-x)
(-y,-x)
(-x,-y) (x,-y)
(y,x)
(-y,x)
50 SS 2011
Aber: Algo verwendet immer noch Wurzel
Kommen wir mit ,+,- aus?
Kreiszeichnen
DuA - Kapitel 1
innerhalb von Kreis?
ja: xx+1
nein: xx+1; yy-1
zeichne nur mit innerhalb
51 SS 2011
Mittelpunkt des ersten sei (x,y)=(0,R)
Position seines : (0,R-1/2) (1x1-Quadrat)
Test, ob (x,y) innerhalb Kreis:
teste, ob F(x,y)=x
2
+y
2
-R
2
< 0 ist
Kreiszeichnen
DuA - Kapitel 1
Also Test, ob mit Mittelpunkt (1,R) noch
innerhalb von Kreis ist: F(1,R-1/2)<0?
Es gilt: F(x+1,y) = F(x,y)+2x+1
F(x+1,y-1) = F(x,y)+2x-2y+2
52 SS 2011
(x,y)(0,R)
F1-R
{eigentlich F(1,R-1/2)=5/4-R, aber 1-R gleiche Ausgabe}
plot(0,R); plot(R,0); plot(0,-R); plot(-R,0)
while (x<y) do
if (F<0) then { bei (x+1,y) hat innerhalb Kreis?}
FF+2x+1 { ja: zu Punkt (x+1,y) }
Bresenham Algorithmus
DuA - Kapitel 1
xx+1
else
FF+2x-2y+2 {nein: zu Punkt (x+1,y-1) }
xx+1
yy-1
plot(x,y); plot(y,x); plot(-x,y); plot(y,-x)
plot(x,-y); plot(-y,x); plot(-x,-y); plot(-y,-x)
53 SS 2011
(x,y)(0,R)
F1-R
{eigentlich F(1,R-1/2)=5/4-R, aber 1-R gleiche Ausgabe}
while (x<y) do
while do - Schleife
Bresenham Algorithmus
xx+1
else
FF+2x-2y+2 { nein: zu Punkt (x+1,y-1) }
xx+1
yy-1
(x,y)(0,R)
F1-R
while (x<y) do
xx+1
FF+2x-1 { ja: zu Punkt (x+1,y) }
Besserer Bresenham Algorithmus
DuA - Kapitel 1
FF+2x-1 { ja: zu Punkt (x+1,y) }
else
FF+2(x-y) { nein: zu Punkt (x+1,y-1) }
yy-1
2 : in Maschinencode sehr schnell (Linksshift der Bits)
55 SS 2011
Beispiele:
Arithmetik auf groen Zahlen
Beispiel fr asymptotische Verbesserung
(klassische Algorithmik)
Kreisberechnung
Beispiel fr Verbesserung der Konstanten
Zusammenfassung
DuA - Kapitel 1
Beispiel fr Verbesserung der Konstanten
(Algorithm Engineering)
Ideal: Anwendung beider Strategien, obwohl
hier Fokus auf klassischer Algorithmik
56 SS 2011
2. Grundlagen
Beschreibung von Algorithmen durch Pseudocode.
Korrektheit von Algorithmen durch Invarianten.
Laufzeitverhalten beschreiben durch O-Notation.
SS 2011 1 DuA - Kapitel 2
Pseudocode
Schleifen (for, while, repeat)
Bedingtes Verzweigen (if then else)
(Unter-)Programmaufruf/bergabe (return)
Zuweisung durch
>
SS 2011 2
Kommentar durch
Daten als Objekte mit einzelnen Feldern oder
Eigenschaften (z.B. length(A) Lnge des Arrays A)
Blockstruktur durch Einrckung
>
DuA - Kapitel 2
Beispiel Minimum-Suche
Folge jeder zu das n, Verfahre : orithmus Minimumalg
1 Indizes alle
fr dass so , Index : Suche - Minimum bei Ausgabe

Zahlen n von Folge : Suche - Minimum bei Eingabe
2 1
. n j
a a i
). ,a , ,a (a
j i
n
K

SS 2011 3
4 : Ausgabe
26,51,48) (31,41,59, : Eingabe
berechnet. Elements
kleinsten eines Index
Folge jeder zu das n, Verfahre : orithmus Minimumalg
2 1
) ,a , ,a (a
n
K
DuA - Kapitel 2
Min-Search in Pseudocode
[ ]
min A j A
A length j
min
A
] [ ] [ 3
to 2 2
1 1
) Search( - Min
then
if do
for
<
SS 2011 4
min
j min
5
4
return
then
DuA - Kapitel 2
Min-Search
[ ]
min A j A
A length j
min
A
] [ ] [ 3
to 2 2
1 1
) Search( - Min
then
if do
for
<
SS 2011 5
min
j min
5
4
return
then
26,51,48) (31,41,59, : Eingabe
DuA - Kapitel 2
Min-Search
> Zuweisung
[ ]
min A j A
A length j
min
A
] [ ] [ 3
to 2 2
1 1
) Search( - Min
then
if do
for
<
SS 2011 6
min = 1
min
j min
5
4
return
then
26,51,48) (31,41,59, : Eingabe
DuA - Kapitel 2
Min-Search
Schleife
[ ]
min A j A
A length j
min
A
] [ ] [ 3
to 2 2
1 1
) Search( - Min
then
if do
for
<
SS 2011 7
min = 1, j = 2
min
j min
5
4
return
then
26,51,48) (31,41,59, : Eingabe
DuA - Kapitel 2
Min-Search
Verzweigung
[ ]
min A j A
A length j
min
A
] [ ] [ 3
to 2 2
1 1
) Search( - Min
then
if do
for
<
SS 2011 8
Verzweigung
min = 1, j = 2, A[2] < A[1] ? Nein
min
j min
5
4
return
then
26,51,48) (31,41,59, : Eingabe
DuA - Kapitel 2
Min-Search
Schleife
[ ]
min A j A
A length j
min
A
] [ ] [ 3
to 2 2
1 1
) Search( - Min
then
if do
for
<
SS 2011 9
min = 1, j = 3
min
j min
5
4
return
then
26,51,48) (31,41,59, : Eingabe
DuA - Kapitel 2
Min-Search
Verzweigung
[ ]
min A j A
A length j
min
A
] [ ] [ 3
to 2 2
1 1
) Search( - Min
then
if do
for
<
SS 2011 10
Verzweigung
min = 1, j = 3, A[3] < A[1] ? Nein
min
j min
5
4
return
then
26,51,48) (31,41,59, : Eingabe
DuA - Kapitel 2
Min-Search
Schleife
[ ]
min A j A
A length j
min
A
] [ ] [ 3
to 2 2
1 1
) Search( - Min
then
if do
for
<
SS 2011 11
min = 1, j = 4
min
j min
5
4
return
then
26,51,48) (31,41,59, : Eingabe
DuA - Kapitel 2
Min-Search
Verzweigung
Zuweisung
[ ]
min A j A
A length j
min
A
] [ ] [ 3
to 2 2
1 1
) Search( - Min
then
if do
for
<
SS 2011 12
Verzweigung
min = 1, j = 4, A[4] < A[1] ? Ja min = 4
> Zuweisung
min
j min
5
4
return
then
26,51,48) (31,41,59, : Eingabe
DuA - Kapitel 2
Min-Search
Schleife
[ ]
min A j A
A length j
min
A
] [ ] [ 3
to 2 2
1 1
) Search( - Min
then
if do
for
<
SS 2011 13
min = 4, j = 5
min
j min
5
4
return
then
26,51,48) (31,41,59, : Eingabe
DuA - Kapitel 2
Min-Search
Verzweigung
[ ]
min A j A
A length j
min
A
] [ ] [ 3
to 2 2
1 1
) Search( - Min
then
if do
for
<
SS 2011 14
Verzweigung
min = 4, j = 5, A[5] < A[4] ? Nein
min
j min
5
4
return
then
26,51,48) (31,41,59, : Eingabe
DuA - Kapitel 2
Min-Search
Schleife
[ ]
min A j A
A length j
min
A
] [ ] [ 3
to 2 2
1 1
) Search( - Min
then
if do
for
<
SS 2011 15
min = 4, j = 6 = length[A]
min
j min
5
4
return
then
26,51,48) (31,41,59, : Eingabe
DuA - Kapitel 2
Min-Search
Verzweigung
[ ]
min A j A
A length j
min
A
] [ ] [ 3
to 2 2
1 1
) Search( - Min
then
if do
for
<
SS 2011 16
Verzweigung
min = 4, j = 6, A[6] < A[4] ? Nein
min
j min
5
4
return
then
26,51,48) (31,41,59, : Eingabe
DuA - Kapitel 2
Min-Search
[ ]
min A j A
A length j
min
A
] [ ] [ 3
to 2 2
1 1
) Search( - Min
then
if do
for
<
SS 2011 17
min = 4
> Ausgabe
min
j min
5
4
return
then
26,51,48) (31,41,59, : Eingabe
DuA - Kapitel 2
Invarianten
Definition 2.1 Eine (Schleifen-)Invariante ist eine
Eigenschaft eines Algorithmus, die vor und nach
jedem Durchlaufen einer Schleife erhalten bleibt.
Invarianten dienen dazu, die Korrektheit von
SS 2011 18
Invarianten dienen dazu, die Korrektheit von
Algorithmen zu beweisen.
Sie werden in der Vorlesung immer wieder auftauchen
und spielen eine groe Rolle.
DuA - Kapitel 2
Invarianten und Korrektheit
Invariante und Korrektheit von Algorithmen wird
bewiesen, indem gezeigt wird, dass
Die Invarianten vor dem ersten Schleifendurchlauf
erfllt ist (Initialisierung).
SS 2011 19
Die Eigenschaft bei jedem Schleifendurchlauf erhalten
bleibt (Erhaltung).
Die Invariante nach Beendigung der Schleife etwas
ber die Ausgabe des Algorithmus aussagt,
Algorithmus korrekt ist (Terminierung).
DuA - Kapitel 2
Invariante bei Min-Search
Invariante: Vor Schleifendurchlauf mit Index j ist A[min]
kleinstes Element in A[1..j-1].
Initialisierung: Der kleinste Index fr die Schleife ist
j=2. Davor ist A[min]=A[1].
Erhaltung: if-Abfrage mit then in Zeilen 3 und 4 ersetzt
SS 2011 20
Erhaltung: if-Abfrage mit then in Zeilen 3 und 4 ersetzt
korrekt Minimum, wenn zustzlich A[j] betrachtet
wird.
Terminierung: Vor Durchlauf mit j=n+1 (und damit beim
Abbruch der Schleife) ist A[min] das Minimum der Zahlen
in A[1..n].
DuA - Kapitel 2
Invariante bei Min-Search
Min-Search(A) { sei n=length[A] }
1 min1
{ A[min] = A[1] }
2 for j2 to length[A]
{ A[min] = min{ A[i] | 1ij-1} }
3 if A[j] < A[min] then
{ A[min] = min{ A[i] | 1ij-1} A[j] < A[min] }
Schleifeninvariante
4 minj
{ A[min] = min{ A[i] | 1ij }
{ sonst: A[min] = min{ A[i] | 1ij-1} A[j] A[min] }
A[min] = min{ A[i] | 1ij } }
{ A[min] = min{ A[i] | 1ij} }
{ A[min] = min{ A[i] | 1ij-1} j = n+1 }
A[min] = min{ A[i] | 1in} }
5 return min
Abbruchbedingung
Laufzeitanalyse und Rechenmodell
Fr eine przise mathematische Laufzeitanalyse bentigen
wir ein Rechenmodell, das definiert
Welche Basisoperationen zulssig sind.
Welche Datentypen es gibt.
Wie Daten gespeichert werden.
Wie viel Zeit Operationen auf bestimmten Daten
bentigen.
SS 2011 22
bentigen.
Formal ist ein solches
Rechenmodell gegeben
durch die Random
Access Maschine (RAM).
DuA - Kapitel 2
Speicher
Basisoperationen Kosten
Definition 2.2: Als Basisoperationen bezeichnen wir
Arithmetische Operationen Addition, Multiplikation,
Division, Ab-, Aufrunden.
Datenverwaltung Laden, Speichern, Kopieren.
Kontrolloperationen Verzweigungen, Programm-
aufrufe, Wertbergaben.
SS 2011 23
Kosten: Zur Vereinfachung nehmen wir an, dass jede
dieser Operationen bei allen Operanden gleich viel Zeit
bentigt (d.h. 1 Zeiteinheit).
In weiterfhrenden Veranstaltungen werden Sie andere
und hufig realistischere Kostenmodelle kennen lernen.
DuA - Kapitel 2
Definition 2.3: Die Laufzeit T(I) eines Algorithmus A bei
Eingabe I ist definiert als die Anzahl von Basisoperationen,
die Algorithmus A zur Berechnung der Lsung bei
Eingabe I bentigt.
Definition 2.4: Die (worst-case) Laufzeit eines Algorithmus A
ist eine Funktion T:, wobei
Eingabegre - Laufzeit
SS 2011 24
ist eine Funktion T:, wobei
T(n) = max{T(I): I hat Eingabegre n}
DuA - Kapitel 2
Laufzeit angegeben als Funktion der Gre der Eingabe.
Eingabegre abhngig vom Problem definiert.
Eingabegre Minimumssuche = Gre des Arrays.
Laufzeit bei Minimumsuche: A Array, fr das Minimum
bestimmt werden soll.
Eingabegre Laufzeit (2)
SS 2011 25
bestimmt werden soll.
T(A ):= Anzahl der Operationen, die zur Bestimmung
des Minimums in A bentigt werden.
Satz 2.5: Algorithmus Min-Search hat Laufzeit T(n) an+b
fr Konstanten a,b.
DuA - Kapitel 2
Minimum-Suche
[ ]
min 4
1 ] min [ ] [ 3
to 2 2
1 1 min 1
mal Kosten Search(A) - Min
4
3
2
1
<
t c j
n c A j A
n c A length j
c
then
if do
for
SS 2011 26
. 1 gilt Es
chsel. Mimimumswe der Anzahl die ist Hierbei
1 min 5
min 4
5
4

n t
t
c
t c j
return
then
DuA - Kapitel 2
O-Notation
+
. 0
gilt alle fr dass so
Konstanten existieren Es
Funktionen von Menge folgende die mit wir
bezeichnen Dann Funktion. eine Sei :
0
0
) n ( cg ) n ( f
n n
, n , c>0
: ) n ( f : )) n ( g
)) n ( g
: g 2.6. Definition
(
(
O
O

SS 2011 27
O(g(n)) formalisiert: Die Funktion f(n) wchst
asymptotisch nicht schneller als g(n).
Statt f(n) O(g(n)) in der Regel f(n) = O(g(n))

. 0 ) n ( cg ) n ( f
DuA - Kapitel 2
Illustration von O(g(n))
SS 2011 28
g(x)=x
2
f(x)=100x
g(x)=x
2
f(x)=200x
DuA - Kapitel 2
-Notation
Definition 2.7:
+
0
bezeichnen Dann Funktion. eine Sei
0
0
). n ( f ) n ( cg
n n
, n , c>0
: ) n ( f : )) n ( g
)) n ( g
: g
(
(

SS 2011 29
(g(n)) formalisiert: Die Funktion f(n) wchst
asymptotisch mindestens so schnell wie g(n).
Statt f(n) (g(n)) in der Regel f(n) = (g(n))

0 ). n ( f ) n ( cg
DuA - Kapitel 2
-Notation
Definition 2.8:
+
. 0
bezeichnen Dann Funktion. eine Sei
2 1
0
0 2 1
) n ( g c ) n ( f ) n ( g c
n n
, n , c , c >0
: ) n ( f : )) n ( g
)) n ( g
: g
(
(

SS 2011 30
(g(n)) formalisiert: Die Funktion f(n) wchst
asymptotisch genau so schnell g(n).
Statt f(n) (g(n)) in der Regel f(n)= (g(n))

. 0
2 1
) n ( g c ) n ( f ) n ( g c
DuA - Kapitel 2
Illustration von (g(n))
f(n)
) n ( g c
1
) n ( g c
2
o-Notation
+
. 0
Konstanten
alle Fr
bezeichnen Dann Funktion. eine Sei :
0
0
) n ( cg ) n ( f
n n
, n existiert
c>0
: ) n ( f : )) n ( g
)) n ( g
: g 2.9. Definition
(
(
o
o

SS 2011 32
o(g(n)) formalisiert: Die Funktion f(n) wchst
asymptotisch weniger schnell als g(n).
Analog zu (g(n)): (g(n)) ist die Menge aller
Funktionen, die asymptotisch schneller steigen als g(n).

. 0 ) n ( cg ) n ( f
DuA - Kapitel 2
: Existenzquantor (es existiert)
: Allquantor (fr alle)
Kalkle fr asymptotisches Verhalten:
O(g(n))={ f(n) | c>0 n
0
>0 nn
0
: f(n) cg(n) }
(g(n))={ f(n) | c>0 n
0
>0 nn
0
: f(n) cg(n) }
bersicht ber Kalkle

(g(n))={ f(n) | c>0 n
0
>0 nn
0
: f(n) cg(n) }
(g(n)) = O(g(n)) (g(n))
o(g(n))={ f(n) | c>0 n
0
>0 nn
0
: f(n) cg(n) }
(g(n))={ f(n) | c>0 n
0
>0 nn
0
: f(n) cg(n) }
Nur Funktionen f(n) (bzw. g(n)) mit N>0 n>N: f(n)>0 !
Diese sollen schlielich Zeit-/Speicherschranken sein.
x
n
: lim
n
(sup
mn
x
m
) (sup: Maximum)
x
n
: lim
n
(inf
mn
x
m
) (inf: Minimum)
Alternative Schreibweise fr Kalkle:
O(g(n))={ f(n) | c>0 f(n)/g(n) c }
bersicht ber Kalkle

lim sup
n
lim sup
n
lim inf
n
O(g(n))={ f(n) | c>0 f(n)/g(n) c }
(g(n))={ f(n) | c>0 f(n)/g(n) c }
(g(n)) = O(g(n)) (g(n))
o(g(n))={ f(n) | f(n)/g(n) = 0 }
(g(n))={ f(n) | g(n)/f(n) = 0 }
SS 2011 34
n
lim inf
n
lim sup
n
lim inf
n
DuA - Kapitel 2
O-Notation als Platzhalter fr eine Funktion:
statt g(n)O(f(n)) schreiben wir gewhnlich
g(n) = O(f(n))
Fr f(n)+g(n) mit g(n)=o(h(n)) schreiben wir
auch f(n)+g(n) = f(n)+o(h(n))
Statt O(f(n))O(g(n)) schreiben wir auch
Regeln fr Kalkle
Statt O(f(n))O(g(n)) schreiben wir auch
O(f(n)) = O(g(n))
Beispiel: n
3
+n = n
3
+ o(n
3
) = (1+o(1))n
3
= O(n
3
)
O-Notationsgleichungen sollten nur von links nach
rechts verstanden werden!
Regeln fr Kalkle
O- und - bzw. o- und -Kalkl sind komplementr
zueinander, d.h.:
f(n) = O(g(n)) g(n) = (f(n))
f(n) = (g(n)) g(n) = O(f(n))
SS 2011 36
f(n) = o(g(n)) g(n) = (f(n))
f(n) = (g(n)) g(n) = o(f(n))
Beweis: folgt aus Definition der Kalkle
DuA - Kapitel 2
Regeln fr Kalkle - Reflexivitt
O-, - und -Kalkl sind reflexiv, d.h.:
f(n) = O(f(n))
f(n) = (f(n))
f(n) = (f(n))
SS 2011 37
f(n) = (f(n))
-Kalkl ist symmetrisch, d.h.
f(n) = (g(n)) genau dann, wenn g(n) = (f(n)).
DuA - Kapitel 2
Regeln fr Kalkle - Transitivitt
Satz 2.10: Das O-, - und -Kalkl sind transitiv, d.h.:
Aus f(n)= O(g(n)) und g(n)= O(h(n)) folgt f(n)= O(h(n)).
Aus f(n)= (g(n)) und g(n)= (h(n)) folgt f(n)= (h(n)).
SS 2011 38
Aus f(n)= (g(n)) und g(n)= (h(n)) folgt f(n)= (h(n)).
Beweis:
ber Definition der Kalkle.
Transitivitt gilt auch fr o- und -Kalkl.
DuA - Kapitel 2
Beweis: (Punkt 1)
f(n) = O(g(n)) es gibt c, n
0
, so dass
f (n) cg(n) fr alle n > n
0
.
g(n) = O(h(n)) es gibt c, n
0
, so dass
SS 2011 39
g(n) ch(n) fr alle n > n
0
.
Sei n
0
= max{n
0
, n
0
} und c = cc. Dann gilt fr n > n
0
:
f (n) c g(n) c c h(n) = c h(n).
DuA - Kapitel 2
Beweis: (Punkt 2)
f(n) = (g(n)) es gibt c, n
0
, so dass
f (n) cg(n) fr alle n > n
0
.
g(n) = (h(n)) es gibt c, n
0
, so dass
SS 2011 40
g(n) ch(n) fr alle n > n
0
.
Sei n
0
= max{n
0
, n
0
} und c = cc. Dann gilt fr n > n
0
:
f (n) c g(n) c c h(n) = c h(n).
DuA - Kapitel 2
Beweis: (Punkt 3)
f(n) = (g(n)) f(n) = O(g(n)) und f(n) = (g(n))
g(n) = (h(n)) g(n) = O(h(n)) und g(n) = (h(n))
f(n) = O(g(n)) und g(n) = O(h(n)) impliziert
f(n) = O(h(n))
SS 2011 41
f(n) = O(h(n))
f(n) = (g(n)) und g(n) = (h(n)) impliziert
f(n) = (h(n))
f (n) = (h(n)).
DuA - Kapitel 2
Satz 2.11: Sei p(n) =
i=0
k
a
i
n
i
mit a
k
>0. Dann ist
p(n) = (n
k
).
Beweis:
Zu zeigen: p(n) = O(n
k
) und p(n) = (n
k
).
p(n) = O(n
k
) : Fr n>1 gilt
p(n)
i=0
k
|a
i
| n
i
n
k
i=0
k
|a
i
|
Regeln fr Kalkle
SS 2011 42
p(n)
i=0
|a
i
| n n
i=0
|a
i
|
Also ist Definition von O() mit c=
i=0
k
|a
i
| und n
0
=1 erfllt.
p(n) = (n
k
) : Fr n>2kA/a
k
mit A=max
i
|a
i
| gilt
p(n) a
k
n
k
-
i=0
k-1
An
i
a
k
n
k
kA n
k-1
a
k
n
k
/2
Also ist Definition von () mit c=a
k
/2 und n
0
=2kA/a
k
erfllt.
DuA - Kapitel 2
Satz 2.12:
Seien f
1
(n) = O(g
1
(n)) und f
2
(n)=O(g
2
(n)).
Dann gilt:
(a) f
1
(n)+f
2
(n) = O(g
1
(n)+g
2
(n))
(b) f
1
(n) f
2
(n) = O(g
1
(n) g
2
(n))
Ausdrcke auch korrekt fr , o, und .
Regeln fr Kalkle
Ausdrcke auch korrekt fr , o, und .
Beweis: folgt aus Definition des O-Kalkls.
Beispiel: ist f(n)=O(g(n)), dann ist auch
f(n)
k
=O(g(n)
k
) fr alle k
Satz 2.13:
(a) cf(n) = (f(n)) fr jede Konstante c>0
(b) O(f(n))+O(g(n)) = O(f(n)+g(n))
(c) O(f(n))O(g(n)) = O(f(n)g(n))
(d) O(f(n)+g(n)) = O(f(n)) falls g(n)=O(f(n))
Regeln fr Kalkle
(d) O(f(n)+g(n)) = O(f(n)) falls g(n)=O(f(n))
Ausdrcke auch korrekt fr statt O.
Vorsicht bei induktiver Anwendung von (d)!
Behauptung:
i=1
n
i = O(n)
Beweis: Sei f(n) = n+f(n-1) und f(1)=1.
Induktionsanfang: f(1)=O(1).
Induktionsschluss: f(n-1)=O(n-1) gezeigt.
Dann gilt:
Regeln fr Kalkle
Dann gilt:
f(n) = n + f(n-1) = n + O(n-1) = O(n)
Also ist f(n) =
i=1
n
i = O(n) natrlich falsch!
Also Vorsicht mit (d) in Induktionsbeweisen!
Satz 2.14: Seien f und g stetig und
differenzierbar. Dann gilt:
(a) Falls f(n) = O(g(n)), dann auch f(n)=O(g(n))
(b) Falls f(n) = (g(n)), dann auch f(n)=(g(n))
Regeln fr Kalkle
(c) Falls f(n) = o(g(n)), dann auch f(n)=o(g(n))
(d) Falls f(n) = (g(n)), dann auch f(n)=(g(n))
Der Umkehrschluss gilt im Allg. nicht!
Regeln fr Kalkle
Satz 2.15: Sei ( ) . alle fr 1 mit n n f : f
+
R N Weiter sei
l k l , k mit 0 . Dann gilt

1. ( ) ( ) ( )
k l
n f n f O = .

2. ( ) ( ) ( )
l k
n f n f = .

SS 2011 47

Satz 2.16: Seien 0 > k , beliebig. Dann gilt

1. ( ) ( )
n n
k
O = log .

2. ( ) ( )
k
n log n = .

DuA - Kapitel 2
Beweis Satz 2.16
Beweis Satz 2.16 (2)
Beweis Satz 2.16 (3)
Berechnung der worst-case Laufzeit:
T(I) sei worst-case Laufzeit fr Instruktion I
T(el. Zuweisung) = O(1), T(el. Vergleich) = O(1)
T(return x) = O(1)
T(I;I) = T(I) + T(I)
T(if C then I else I) = T(C) + max{T(I),T(I)}
Laufzeitanalyse mithilfe des O-Kalkls
SS 2011 DuA - Kapitel 2 51
T(if C then I else I) = T(C) + max{T(I),T(I)}
T(for i:=a to b do I) =
i=a
b
T(I)
T(repeat I until C) =
i=1
k
(T(C)+T(I))
(k: Anzahl Iterationen)
T(while C do I) =
i=1
k
(T(C)+T(I))
Gegeben: Zahl x
Algorithmus Signum(x):
if x<0 then return -1
if x>0 then return 1
T(x<0) = O(1)
T(return -1) = O(1)
Wir wissen:
Beispiel: Vorzeichenausgabe
return 0
T(return -1) = O(1)
T(if B then I) =
O(T(B)+ T(I))
Also ist T(if x<0 then return -1) = O(1+1) = O(1)
Satz 2.12(d)
Gegeben: Zahl x
Algorithmus Signum(x):
if x<0 then return -1
O(1)
O(1)
Beispiel: Vorzeichenausgabe
Satz 2.12(b)
return 0
O(1)
O(1)
Gesamtlaufzeit: O(1+1+1)=O(1)
Satz 2.12(d)
Satz 2.12(b)
Gegeben: Zahlenfolge in A[1],,A[n]
Algorithmus Minimum(A):
min A[1]
for i2 to n do
O(1)
i=1
n
T(I)
Beispiel: Minimumsuche
for i2 to n do
if A[i]<min then min:=A[i]
return min
i=1
T(I)
O(1)
O(1)
Laufzeit: O(1 +(
i=1
n
1) + 1) = O(n)
Satz 2.12(b),(d)
Gegeben: Zahl x und sortiertes Array A[1],,A[n]
Algorithmus BinreSuche(A,x):
l1; rn
while l < r do
m(r+l) div 2
O(1)
i=1
k
T(I)
O(1)
Beispiel: Binre Suche
if A[m] = x then return m

if A[m] < x then lm+1
else rm-1
return l
O(1)
O(1)
O(1)
O(1)
O(1)
O(
i=1
k
1) = O(k)
Gegeben: Zahl x und sortiertes Array A[1],,A[n]
Algorithmus BinreSuche(A,x):
l1; rn
while l < r do
m(r+l) div 2
O(
i=1
k
1) = O(k)
s
i
= (r-l+1) in Iteration i
Was ist k ?? Zeuge
Beispiel: Binre Suche
if A[m] = x then return m

if A[m] < x then lm+1
else rm-1
return l
s
i
= (r-l+1) in Iteration i
s
1
= n, s
i+1
s
i
/2
s
i
< 1: fertig
Also ist k log n + 1
(x,y)(0,R)
F1-R
while x<y do
xx+1
if F<0 then
FF+2x - 1
O(1)
O(1)
O(1)
i=1
k
T(I)
alles
Beispiel: Bresenham Algorithmus
FF+2x - 1
else
FF+2(x-y)
yy-1
plot(x,-y); plot(-y,x); plot(-y,x); plot(-x,-y)
O(1)
O(
i=1
k
1) = O(k)
alles
Zeuge:
(x,y) = y-x
(x,y)(0,R)
F1-R
while x<y do
xx+1
if F<0 then
FF+2x - 1
Monotonie: verringert sich
um 1 pro while-Runde
Beschrnktheit: while-Bed.
FF+2x - 1
else
FF+2(x-y)
yy-1
Zeuge:
(x,y) = y-x
(x,y)(0,R)
F1-R
while x<y do
xx+1
if F<0 then
FF+2x - 1
Anzahl Runden:
0
(x,y) = R, (x,y)>0
maximal R Runden
FF+2x - 1
else
FF+2(x-y)
yy-1
Gegeben: natrliche Zahl n
Algorithmus Fakultt(n):
if n=1 then return 1
else return n Fakultt(n-1)
O(1)
O(1) + ??
Beispiel: Fakultt
Laufzeit:
T(n): Laufzeit von Fakultt(n)
T(n) = T(n-1) + O(1), T(1) = O(1)
Anwendung auf Laufzeiten
O-Notation erlaubt uns, Konstanten zu ignorieren.
Wollen uns auf asymptotische Laufzeit konzentrieren.
Werden in Zukunft Laufzeiten immer mit Hilfe von O-,
-,-Notation angeben.
SS 2011 61
-,-Notation angeben.
DuA - Kapitel 2
3. Inkrementelle Algorithmen
Definition 3.1: Bei einem inkrementellen Algorithmus wird
sukzessive die Teillsung fr die ersten i Objekte aus
der bereits bekannten Teillsung fr die ersten i-1
Objekte berechnet, i=1,,n.
Beispiel Min-Search:
SS 2011 1
Objekte sind Eintrge des Eingabearrays.
Teilproblem bestehend aus ersten i Objekten
bedeutet Minimum im Teilarray A[1..i] bestimmen.
DuA - Kapitel 3
Sortieren und inkrementelle Algorithmen
) a , , a , (a Folge jeder zu das n, Verfahre : orithmus Sortieralg
. b b b dass so ge, Eingabefol
der ) b , , b , (b Umordnung : Sortieren bei Ausgabe
). a , , a , (a Zahlen n von Folge : Sortieren bei Eingabe
n 2 1
n 2 1
n 2 1
n 2 1
K
K
L
K
K

SS 2011 2
48,51,59) (26,31,41, : Ausgabe
26,51,48) (31,41,59, : Eingabe
berechnet.
n 2 1
K
DuA - Kapitel 3
Insertion-Sort
j A key
) A ( length j
) A (
] [ 2
2 1
Sort - Insertion
do
to for
Idee: Sukzessive wird eine Sortierung der Teilarrays
A[1..i], 1i length(A) berechnet.
SS 2011 3
key i A
i i
i A i A
key i A i
j i
.j j
j A key
+

+
> >

] 1 [ 8
1 7
] [ ] 1 [ 6
] [ and 0 5
1 4
ein 1] A[1. Folge sortierte die in ] A[ Fge 3
] [ 2
do
while
do
. >
DuA - Kapitel 3
Insertion Sort
InsertionSort(Array A)
1. for j 2 to length(A) do
2. key A[j]
3. i j-1
4. while i>0 and A[i]>key do
4
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 3 14 7 6 18 19
SS 2011 DuA - Kapitel 3
Insertion Sort
InsertionSort(Array A) Eingabegre n
1. for j 2 to length(A) do (length(A)=n)
2. key A[j]
3. i j-1
5
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 3 14 7 6 18 19
Insertion Sort
2. key A[j]
3. i j-1
6
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 3 14 7 6 18 19
1
n
Insertion Sort
2. key A[j]
3. i j-1
7
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 3 14 7 6 18 19
j
1
n
Insertion Sort
2. key A[j]
3. i j-1
8
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 3 14 7 6 18 19
1
n j
key
Insertion Sort
2. key A[j]
3. i j-1
9
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 3 14 7 6 18 19
i
n j
key
Insertion Sort
2. key A[j]
3. i j-1
10
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 3 14 7 6 18 19
i
n j
key
Insertion Sort
2. key A[j]
3. i j-1
11
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 3 14 7 6 18 19
i
n j
key
Insertion Sort
2. key A[j]
3. i j-1
12
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 3 14 7 6 18 19
1
n j
Insertion Sort
2. key A[j]
3. i j-1
13
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 3 14 7 6 18 19
1
n j
key
Insertion Sort
2. key A[j]
3. i j-1
14
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 3 14 7 6 18 19
1
n j
key=3
i
Insertion Sort
2. key A[j]
3. i j-1
15
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 3 14 7 6 18 19
1
n j
i
key=3
Insertion Sort
2. key A[j]
3. i j-1
16
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 15 14 7 6 18 19
1
n j
i
key=3
Insertion Sort
2. key A[j]
3. i j-1
17
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 15 14 7 6 18 19
i
n j
key=3
Insertion Sort
2. key A[j]
3. i j-1
18
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 15 15 14 7 6 18 19
i
n j
key=3
Insertion Sort
2. key A[j]
3. i j-1
19
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 8 15 14 7 6 18 19
i
n j
key=3
Insertion Sort
2. key A[j]
3. i j-1
20
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 8 15 14 7 6 18 19
1
n j
key=3
i
Insertion Sort
2. key A[j]
3. i j-1
21
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
8 8 15 14 7 6 18 19
1
n j
key=3
i
Insertion Sort
2. key A[j]
3. i j-1
22
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
3 8 15 14 7 6 18 19
1
n j
key=3
Insertion Sort
2. key A[j]
3. i j-1
23
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
3 8 15 14 7 6 18 19
1
n j
Sortiert
Insertion Sort
2. key A[j]
3. i j-1
24
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
3 8 15 14 7 6 18 19
1
n j
Sortiert
key
Insertion Sort
2. key A[j]
3. i j-1
25
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Beispiel:
3 8 15 14 7 6 18 19
1
n j
Sortiert
key=14
Insertion Sort
2. key A[j]
3. i j-1 verschiebe alle
4. while i>0 and A[i]>key do A[1,..,j-1], die grer als
26
5. A[i+1] A[i] key sind eine Stelle
6. i i-1 nach rechts
7. A[i+1] key
Beispiel:
3 8 15 14 7 6 18 19
1
n j
Sortiert
key=14
j-1
Insertion Sort
2. key A[j]
27
7. A[i+1] key
Beispiel:
3 8 15 14 7 6 18 19
1
n j
Sortiert
key=14
j-1
Insertion Sort
2. key A[j]
28
7. A[i+1] key
Beispiel:
3 8 15 15 7 6 18 19
1
n j
Sortiert
key=14
j-1 i
Insertion Sort
2. key A[j]
29
7. A[i+1] key
Beispiel:
3 8 15 15 7 6 18 19
1
n j
key=14
i+1 i
Insertion Sort
2. key A[j]
30
7. A[i+1] key Speichere key in Lcke
Beispiel:
3 8 15 15 7 6 18 19
1
n j
key=14
i+1 i
Insertion Sort
2. key A[j]
31
Beispiel:
3 8 14 15 7 6 18 19
1
n j
key=14
i+1 i
Insertion Sort
2. key A[j]
32
Beispiel:
3 8 14 15 7 6 18 19
1
n j
Sortiert
Insertion Sort
2. key A[j]
33
Beispiel:
3 8 14 15 7 6 18 19
1
n j
Sortiert
key=7
Insertion Sort
2. key A[j]
34
Beispiel:
3 8 14 15 7 6 18 19
1
n j
Sortiert
key=7
Insertion Sort
2. key A[j]
35
Beispiel:
3 8 8 14 15 6 18 19
1
n j
key=7
Insertion Sort
2. key A[j]
36
Beispiel:
3 8 8 14 15 6 18 19
1
n j
key=7
Insertion Sort
2. key A[j]
37
Beispiel:
3 7 8 14 15 6 18 19
1
n j
key=7
Insertion Sort
2. key A[j]
38
Beispiel:
3 7 8 14 15 6 18 19
1
n j
Sortiert
Insertion Sort
2. key A[j]
39
Beispiel:
3 7 8 14 15 6 18 19
1
n
key=6
j
Sortiert
Insertion Sort
2. key A[j]
40
Beispiel:
3 7 8 14 15 6 18 19
1
n j
key=6
Insertion Sort
2. key A[j]
41
Beispiel:
3 7 7 8 14 15 18 19
1
n j
key=6
Insertion Sort
2. key A[j]
42
Beispiel:
3 7 7 8 14 15 18 19
1
n j
key=6
Insertion Sort
2. key A[j]
43
Beispiel:
3 6 7 8 14 15 18 19
1
n j
key=6
Insertion Sort
2. key A[j]
44
Beispiel:
3 6 7 8 14 15 18 19
1
n j
Sortiert
Insertion Sort
2. key A[j]
45
Beispiel:
3 6 7 8 14 15 18 19
1
n j
Insertion Sort
2. key A[j]
46
Beispiel:
3 6 7 8 14 15 18 19
1
n
Sortiert
Insertion Sort
2. key A[j]
47
Beispiel:
3 6 7 8 14 15 18 19
1
n
Sortiert
Invariante bei Insertion-Sort
Invariante: Vor Durchlauf der for-Schleife (Zeilen 1-8) fr
Index j gilt, dass A[1..j-1] die j-1 Eingabezahlen in
sortierter Reihenfolge enthlt.
Initialisierung: j=2 und A[1] ist sortiert, da es nur eine
Zahl enthlt.
SS 2011 48
Zahl enthlt.
Erhaltung: while-Schleife (Zeilen 5-7) zusammen mit
Zeile 8 sortiert A[j] korrekt ein.
Terminierung: Vor Durchlauf mit j=length(A)+1 ist
A[1. . length(A)] sortiert.
DuA - Kapitel 3
Satz 3.2
Insertion-Sort sortiert eine Folge von n Zahlen aufsteigend.
Beweis:
Wir zeigen, dass die Schleifeninvariante erfllt ist
Da die Schleife mit j=n+1 terminiert, folgt aus der
Invariante die Korrektheit des Algorithmus
SS 2011 49
Invariante die Korrektheit des Algorithmus
Induktionsanfang (j=2):
A[1] ist sortiert
Induktionsannahme(I.A.):
Invariante gilt fr j=n
DuA - Kapitel 3
Induktionsschritt (nn+1):
Betrachte Durchlauf mit j=n
Insertionsort merkt sich A[n] in Variable key
Sei 1kn-1 der kleinste Index mit A[k]>key oder
k=n, falls ein solcher nicht existiert
Der Algorithmus verschiebt A[k,..,n-1] nach A[k+1,..,n]
Dann wird A[k] auf den Wert key gesetzt
SS 2011 50
Dann wird A[k] auf den Wert key gesetzt
Danach gilt:
(1) A[1]A[2]A[k-1] nach I.A.
(2) A[k-1] A[k] A[k+1] nach Ablauf der Schleife
(3) A[k+1] A[k+2] A[n] nach I.A.
Aus (1)-(3) folgt die Behauptung fr n
Formale Analyse (nchste Seite): Bezug auf Eingabe (a
1
,,a
n
)
DuA - Kapitel 3
Insertion-Sort(A)
1 for j2 to length(A) do
{ INV1: A[1j-1] = (a
1
a
j-1
): A[1] A[j-1] }
2 keyA[j]
{ INV1 key=a
j
}
3 ij-1
4 while i>0 and A[i]>key do
{ INV2: [ A[1i,i+2j]=(a
1
a
j-1
): A[1] A[i]A[i+2] A[j] key=a
j
]
key<A[i] i>0 }
5 A[i+1]A[i]
Invariante 1
Invariante 2
heit: ist Permutation von
SS 2011 51
5 A[i+1]A[i]
{ A[1i-1,i+1j]=(a
1
a
j-1
): A[1]A[i-1]A[i+1]A[j] key=a
j
key<A[i+1] i>0 }
6 ii-1
{ (a): i=0 INV2 key<A[i+2]
A[2j]=(a
1
a
j-1
): A[2] A[j] key=a
j
key<A[2]
(b): A[i]key INV2 key<A[i+2] i>0
7 A[i+1]key
{ A[1j]=(a
1
a
j
): A[1] A[j] }
{ A[1j-1] = (a
1
a
j-1
): A[1] A[j-1] j=n+1 A[1j]=(a
1
a
n
): A[1]A[n] }
Abbruchbedingung
Abbruchbedingungen
DuA - Kapitel 3
Insertion-Sort Analyse (1)
[ ]
[ ]
[ ] [ ]
and 0 5
1 c 1 4
. von Einfgen 3
1 c ] [ key do 2
c length(A) to 2 j for 1
times cost Sort( - Insertion
2
5
4
2
1
t c key i A i
n- j i
j A
n- j A
n
) A
n
j
j
> >

=
while
>
SS 2011 52
[ ] [ ]
[ ] 1 1 8
1 1 7
1 1 6
8
2
7
2
6
2
n- c key i A
) (t c i i
) (t c i A i A

n
j
j
n
j
j
+

+
=
=
=
do
Hierbei ist
j
t j die Anzahl der Durchlufe der Abfrage
in Zeile 5.
DuA - Kapitel 3
Insertion-Sort Analyse (2)
Satz 3.3. Insertion-Sort besitzt worst case Laufzeit ( )
2
n .

Zum Beweis wird gezeigt:

der Eingaben allen bei Sort - Insertion
von Laufzeit die dass so , ein gibt Es 1
2
c .
SS 2011 53
besitzt.
Laufzeit mindestens Sort - Insertion
der bei existiert Gre der Eingabe
eine alle fr dass so , ein gibt Es 2.
ist. hchstens immer Gre
der Eingaben allen bei Sort - Insertion
2
1
1
2
2
n c
I
c
n c
n
n
n
n

DuA - Kapitel 3
4. Divide & Conquer Merge-Sort
Definition 4.1: Divide&Conquer (Teile&Erobere) ist eine auf
Rekursion beruhende Algorithmentechnik.
Eine Divide&Conquer-Algorithmus lst ein Problem in 3
Schritten:
Teile ein Problem in mehrere Unterprobleme.
SS 2011 1
Teile ein Problem in mehrere Unterprobleme.
Erobere jedes einzelne Unterproblem durch rekursive
Lsung. Ausnahme sind kleine Unterprobleme, diese
werden direkt gelst.
Kombiniere die Lsungen der Teilprobleme zu einer
Gesamtlsung.
DuA - Kapitel 4
Divide&Conquer und Sortieren
Teile ein Problem in
Unterprobleme.
Erobere jedes
einzelne Teilproblem,
Teile eine n-elementige
Teilfolge auf in zwei
Teilfolgen mit jeweils
etwa n/2 Elementen.
Sortiere die beiden
Teilfolgen rekursiv.
SS 2011 2
einzelne Teilproblem,
durch rekursive
Lsung.
Kombiniere die
Lsungen zu einer
Gesamtlsung.
Teilfolgen rekursiv.
Mische die sortierten
Teilfolgen zu einer
sortierten Gesamtfolge.
DuA - Kapitel 4
Merge-Sort
( )
( )

( )
/ r p q
r p
r , p , A
2 2
1
Sort - Merge
+
<
then
if
Merge-Sort ist eine mgliche Umsetzung des
Divide&Conquer-Prinzips auf das Sortierproblem.
SS 2011 3
( )

( )
( )
( ) r , q , p , A
r , q , A
q , p , A
/ r p q
Merge 5
1 Sort - Merge 4
Sort - Merge 3
2 2
+
+ then
Merge ist Algorithmus zum Mischen zweier sortierter
Teilfolgen
Aufruf zu Beginn mit Merge-Sort(A,1,length(A)).
DuA - Kapitel 4
Illustration von Merge-Sort (1)
5 2 4 7 1 3 2 6
5 2 4 7 1 3 2 6
SS 2011 4
5 2 4 7 1 3 2 6
5 2 4 7 1 3 2 6
DuA - Kapitel 4
Illustration von Merge-Sort (2)
1 2 2 3 4 5 6 7
2 4 5 7 1 2 3 6
SS 2011 5
2 5 4 7 1 3 2 6
5 2 4 7 1 3 2 6
DuA - Kapitel 4
Kombination von Teilfolgen - Merge
( )
[ ] [ ]
[ ] [ ]
[ ] [ ]
[ ]
[ ] 1 9
1 8
do 7
to 1 for 6
1 do 5
to 1 for 4
1 .. 1 , 1 1 Arrays Erzeuge 3
2
1 1
Merge
1
2
1
2 1
2
1
+
+
+
+ +

+
n R
n L
j q A j R
n j
i p A i L
n i
n R n .. L
q r n
p q n
r , q , p , A
>
SS 2011 6
[ ]
[ ] [ ]
[ ] [ ]
[ ] [ ]
1 17
else 16
1 15
then 14
if do 13
to for 12
1 11
1 10
1 9
2
1
+
+
j j
j R k A
i i
i L k A
j R i L
r p k
j
i
n R
DuA - Kapitel 4
Illustration von Merge
2 3 1 5
1 3 1 5
2 3
2 3
1 5
1 5
A L R
SS 2011 7
1 2 1 5
1 2 3 5
1 2 3 5
2 3
2 3
2 3
1 5
1 5
1 5
DuA - Kapitel 4
Korrektheit von Merge - Sort
Zeigen Korrektheit von Merge-Sort (d.h. A[p,,r] sortiert)
mit vollstndiger Induktion ber Gre des Eingabearrays A.
Zeigen hierzu:
1. Ist r-p0, dann ist Merge-Sort korrekt.
(Induktionsverankerung)
2. Ist Merge-Sort fr alle p,r mit r-pn korrekt, dann
ist Merge-Sort auch fr alle p,r mit r-pn+1 korrekt.
SS 2011 8
ist Merge-Sort auch fr alle p,r mit r-pn+1 korrekt.
(Induktionsschluss)
zu 1.
zu 2. Folgt, wenn Merge aus sortierten Teilarrays
A[p,,q], A[q+1,,r] sortiertes Array A[p,,r]
berechnet.
DuA - Kapitel 4
Korrektheit von Merge - Sort
Merge-Sort(A,p,r)
1 if p<r then
{ I.A.: Merge-Sort(A,p,r) korrekt r-p< r-p,
d.h. A[p..r]=(a
p
,,a
r
): A[p] A[r] }
2 q (p+r)/2
3 Merge-Sort(A,p,q)
{ I.A. q-p < r-p
A[p..q]=(a
p
,,a
q
): A[p] A[q] }
Induktionsannahme
SS 2011 9
A[p..q]=(a
p
,,a
q
): A[p] A[q] }
4 Merge-Sort(A,q+1,r)
{I.A. r-(q+1) < r-p A[p..q]=(a
p
,,a
q
): A[p] A[q]
A[p..q]=(a
p
,,a
q
): A[p] A[q]
A[q+1..r]=(a
q+1
,,a
r
): A[q+1] A[r] }
5 Merge(A,p,q,r)
{ A[p..r]=(a
p
,,a
r
): A[p] A[r] }
{ sonst: A[p..r]=(a
p
,,a
r
): A[p] A[r] trivialerweise wahr }
{A[p..r]=(a
p
,,a
r
): A[p] A[r] }
zu zeigen!
ohne I.A., also Basisfall
DuA - Kapitel 4
Korrektheit von Merge - Invariante
Lemma 4.2: Erhlt Algorithmus Merge als Eingabe ein
Teilarray A[p,,r], so dass die beiden Teilarrays
A[p,,q] und A[q+1,,r] sortiert sind, so ist
nach Durchfhrung von Merge das Teilarray A[p,,r]
ebenfalls sortiert.
SS 2011 10
Invariante: Vor Durchlauf der Schleife in Zeilen 12 -17 mit
Index k enthlt das Array A[p..k-1] die k-p kleinsten Zahlen
aus den Arrays L und R in sortierter Reihenfolge.
Auerdem sind L[i] und R[j] jeweils die kleinsten noch nicht
einsortierten Elemente in den Arrays L bzw. R.
DuA - Kapitel 4
Korrektheit von Merge 3 Schritte
Initialisierung: Vor Durchlauf mit k=p ist das Array
A[p..k-1] leer. Daher ist die Invariante trivialerweise erfllt.
Erhaltung:
A[l] L[i],R[j], fr alle l < k, da A[p..k-1] die k-p kleinsten
Elemente aus den Arrays L und R enthlt.
Sei o.B.d.A. L[i] R[j]. Dann ist L[i] das kleinste noch nicht
SS 2011 11
Sei o.B.d.A. L[i] R[j]. Dann ist L[i] das kleinste noch nicht
einsortierte Element. Nach Ausfhrung der Zeilen 14-15
enthlt A[p..k] die k-p+1 kleinsten Elemente. Zusammen mit
Erhhung der Zhler i,k garantiert dies die Erhaltung der
Invariante.
Terminierung: Nach Ende der Schleife enthlt A[p..r] die
r-p+1 kleinsten Elemente und ist sortiert. Also sind dann alle
Elemente sortiert.
DuA - Kapitel 4
Korrektheit von Merge Formal
Merge(A,p,q,r)
1 n
1
q-p+1
2 n
2
r-q
3 for i1 to n
1
do
4 L[i]A[p+i-1]
5 for j1 to n
2
do
6 R[j]A[q+j]
7 L[n
1
+1]
8 R[n
2
+1]
9 i1;j1
{ S: (L[1.. n
1
],R[1.. n
2
])= (a
p
,,a
r
): L[1] L[n
1
+1] R[1] R[n
2
+1]) }
{ S: (L[1.. n
1
],R[1.. n
2
])= (a
p
,,a
r
): L[1] L[n
1
+1] R[1] R[n
2
+1]) }
10 for kp to r do
{ INV(k): [ A[p..k-1]=(L[1..i-1],R[1..j-1]): A[p] A[k-1]min{L[i],R[j]} S ] }
11 if L[i]R[j] then
{ L[i]R[j] INV(k) }
12 A[k]L[i]; ii+1
{ A[p..k]=(L[1..i-1],R[1..j-1]): A[p] A[k]min{L[i],R[j]} S }
13 else
{ L[i]>R[j] INV(k) }
14 A[k]R[j]; jj+1
{ A[p..k]=(L[1..i-1],R[1..j-1]): A[p] A[k]min{L[i],R[j]} S }
{ INV(k-1) k=r+1 A[p..r]=(a
p
,,a
r
): A[p] A[r] }
Laufzeit von Merge
Lemma 4.3: Ist die Eingabe von Merge ein Teilarray der
Gre n, so ist die Laufzeit von Merge (n).
( )
[ ] [ ]
[ ] [ ]
[ ] 1 7
do 6
to 1 for 5
1 do 4
to 1 for 3
2
1 1
, , , Merge
2
1
2
1
+
+

+
n L
j q A j R
n j
i p A i L
n i
q r n
p q n
r q p A
Cost Zeit
c
1
1
c
2
1
c
3
n
1
+1
c
4
n
1
c
5
n
2
+1
c
6
n
2
c 1
SS 2011 13
[ ] [ ]
[ ]
[ ]
[ ] [ ]
[ ] [ ]
[ ] [ ]
1 16
else 15
1 14
then 13
if do 12
to for 11
1 10
1 9
1 8
1 7
do 6
2
1
+
+
+
+
j j
j R k A
i i
i L k A
j R i L
r p k
j
i
n R
n L
j q A j R
6 2
c
7
1
c
8
1
c
9
1
c
10
1
c
11
r-p+2
c
12
r-p+1
c
13
t
1
c
14
t
1
c
15
t
2
c
16
t
2
t
1
+t
2
=r-p+1
DuA - Kapitel 4
Laufzeit von D&C-Algorithmen
) n ( T := Gesamtlaufzeit bei Eingabegre n.

a := Anzahl der Teilprobleme durch Teilung.

n/b := Gre der Teilprobleme.

D(n) := Zeit fr Teilungsschritt.

SS 2011 14

C(n) := Zeit fr Kombinationsschritt.

Fr n u wird Algorithmus mit Laufzeit c benutzt.

Dann gilt:
( )
( ) ( ) ( )
+ +
sonst
falls
n C n D b / n aT
u n c
n T
DuA - Kapitel 4
Laufzeit von Merge-Sort (1)
. b , a , u 2 2 1 = =

( ) ( ) ( ) ( ) n n C , n D = = 1 (Lemma 4.3).

Sei c so gewhlt, dass eine Zahl in Zeit c sortiert
werden kann und ( ) ( ) cn n C n D + gilt.

SS 2011 15

Lemma 4.4: Fr die Laufzeit T(n) von Merge-Sort gilt:

( )
( )
sonst 2 2
1 falls
cn / n T
n c
n T
DuA - Kapitel 4
T(n) cn
T(n/2) T(n/2)
cn
cn/2 cn/2
SS 2011 16
T(n/4) T(n/4) T(n/4) T(n/4)
DuA - Kapitel 4
cn
cn/2
cn/4 cn/4
cn/2
cn/4 cn/4
cn
cn
cn
SS 2011 17
c
M
c
M
c
M
c
M
L
c
M
c
M
c
M
c
M
L
Zusammen: cn log(n)+cn
log(n)
cn
n
DuA - Kapitel 4
Satz 4.5: Merge-Sort besitzt Laufzeit ( ) ( ) n nlog .

Zum Beweis wird gezeigt:

der Eingaben allen bei Sort - Merge
von Laufzeit die dass so , ein gibt Es 1
2
c .
SS 2011 18
( )
( ) besitzt. log
Laufzeit mindestens Sort - Merge
der bei existiert Gre der Eingabe
eine alle fr dass so , ein gibt Es 2.
ist. log hchstens immer Gre
der Eingaben allen bei Sort - Merge
1
1
2
n n c
I
c
n n c
n
n
n
n

DuA - Kapitel 4
Eingabegre n
Laufzeit 10 100 1,000 10,000 100,000
n 100 10,000 1,000,000 100,000,000 10,000,000,000
n log n 33 664 9,965 132,877 166,096
SS 2011 19
Beobachtung:
n wchst viel strker als n log n
Selbst bei groen Konst. wre MergeSort schnell besser
Konstanten spielen kaum eine Rolle
-Notation ist entscheidend fr groe n
DuA - Kapitel 4
Average-Case Laufzeit
Average-case Laufzeit:
Betrachten alle Permutationen dern Eingabezahlen.
Berechnen fr jede Permutation Laufzeit des
Algorithmus bei dieser Permutation.
Average-case Laufzeit ist dann der Durchschnitt ber all
diese Laufzeiten.
Definition 4.6: Eine Permutation ist eine bijektive Ab-
bildung einer endlichen Menge auf sich selbst.

Alternativ: Eine Permutation ist eine Anordnung der
Elemente einer endlichen Menge in einer geordneten
Folge.

SS 2011 20
diese Laufzeiten.
DuA - Kapitel 4
Lemma 4.7: Zu einer n-elementigen Menge gibt es
genau ( ) n n ! n = 1 3 2 1 L Permutationen.

Beweis: Induktion ber n.
(I.A.) n=1 klar.
(I.V.) Der Satz gilt fr n.
(I.S.) n+1: An letzter Stelle steht die i-te Zahl. Es gibt n!
SS 2011 21
(I.S.) n+1: An letzter Stelle steht die i-te Zahl. Es gibt n!
unterschiedliche Anordnungen der restlichen n Zahlen.
Da i jeden Wert zwischen 1 und n+1 annehmen kann,
gibt es (n+1) n! = (n+1)! Anordnungen der n+1 Zahlen.

Beispiel: { } 2,3,6 Menge

( ) ( ) ( ) ( )
( ) ( ). , , , , ,
, , , , , , , , , , , ,
2 3 6 3 2 6
2 6 3 6 2 3 3 6 2 6 3 2 : nen Permutatio

DuA - Kapitel 4
Wahrscheinlichkeitstheorie
Definition 4.8 (Wahrscheinlichkeitsraum):
Ein Wahrscheinlichkeitsraum S ist Menge von
Elementarereignissen. Ein Elementarereignis kann als
der Ausgang eines (Zufalls)experiments betrachtet
werden.
Beispiel:
SS 2011 22
Beispiel:
Mnzwurf mit zwei unterscheidbaren Mnzen
Ergebnis eines Mnzwurfs knnen wir als Zeichenkette
der Lnge 2 ber {K,Z} (Kopf, Zahl) darstellen
Wahrscheinlichkeitsraum ist S={KK,KZ,ZK,ZZ}
Elementarereignisse sind also die mglichen Ausgnge
des Mnzwurfs
DuA - Kapitel 4
Definition 4.9 (Ereignis):
Ein Ereignis ist eine Untermenge eines Wahrscheinlichkeits-
raums. (Diese Definition ist etwas vereinfacht, aber fr
unsere Zwecke ausreichend)
SS 2011 23
Beispiel:
{KK, KZ, ZK} ist das Ereignis, dass bei unserem Mnzwurf
mindestens eine Mnze Kopf zeigt
DuA - Kapitel 4
Definition 4.10(Wahrscheinlichkeitsverteilung)
Eine Wahrscheinlichkeitsverteilung Pr[] auf einem
Wahrscheinlichkeitsraum S ist eine Abbildung der
Ereignisse von S in die reellen Zahlen, die folgende Axiome
erfllt:
1. Pr[A] 0 fr jedes Ereignis A
SS 2011 24
1. Pr[A] 0 fr jedes Ereignis A
2. Pr[S]=1
3. Pr[AB] = Pr[A]+Pr[B] fr alle Ereignisse A,B mit AB=
Pr[A] bezeichnet die Wahrscheinlichkeit von Ereignis A
DuA - Kapitel 4
Beispiel:
Bei einem fairen Mnzwurf haben wir Pr[A] = 1/4 fr
jedes Elementarereignis A[KK,KZ,ZK,ZZ]
Die Wahrscheinlichkeit fr das Ereignis [KK,KZ,ZK]
(mindestens eine Mnze zeigt Kopf) ist
SS 2011 25
Pr[{KK,KZ,ZK}] = Pr[KK] + Pr[KZ] + Pr[ZK] =
Bemerkung:
Eine Verteilung, bei der jedes Elementarereignis aus S
dieselbe Wahrscheinlichkeit hat, nennen wir auch
Gleichverteilung ber S.
DuA - Kapitel 4
Abhngigkeiten:
Was passiert, wenn man schon etwas ber den Ausgang
eines Zufallsexperiments wei?
Frage:
SS 2011 26
Frage:
Jemand hat beobachtet, dass der Ausgang des
Mnzwurfs mit zwei Mnzen mindestens einmal Kopf
zeigt. Wie gro ist die Wahrscheinlichkeit fr zweimal
Kopf?
DuA - Kapitel 4
Definition 4.11 (bedingte Wahrscheinlichkeit):
Die bedingte Wahrscheinlichkeit eines Ereignisses A unter
der Voraussetzung, dass Ereignis B auftritt ist
Pr[A | B] = Pr[AB] / Pr[B],
wenn Pr[B]0 ist.
SS 2011 27
wenn Pr[B]0 ist.
DuA - Kapitel 4
Beispiel:
Jemand beobachtet den Ausgang unseres
Mnzwurfexperiments und sagt uns, dass es mindestens
einmal Zahl gibt
Was ist die Wahrscheinlichkeit fr zweimal Zahl
SS 2011 28
Was ist die Wahrscheinlichkeit fr zweimal Zahl
(Ereignis A) unter dieser Beobachtung (Ereignis B)?
Pr[A|B] = (1/4) /(3/4) =1/3
DuA - Kapitel 4
Definition 4.12 (Zufallsvariable):
Eine Zufallsvariable X ist eine Funktion von einem
Wahrscheinlichkeitsraum in die reellen Zahlen.
SS 2011 29
Bemerkung:
Eine Zufallsvariable liefert uns zu jedem Ausgang eines
Zufallsexperiments einen Wert
DuA - Kapitel 4
Beispiel:
Wurf zweier Mnzen
Sei X Zufallsvariable fr die Anzahl Mnzen, die Zahl
zeigen
X(KK)=0, X(KZ)=1, X(ZK)=1, X(ZZ)=2
SS 2011 30
X(KK)=0, X(KZ)=1, X(ZK)=1, X(ZZ)=2
DuA - Kapitel 4
Fr Zufallsvariable X und reelle Zahl x knnen wir das
Ereignis X=x definieren als {sS:X(s)=x}. Damit gilt:
Pr[X=x] = Pr[{sS:X(s)=x}]
Beispiel:
SS 2011 31
Beispiel:
Was ist die Wahrscheinlichkeit, dass wir bei zwei
Mnzwrfen genau einen Kopf erhalten?
Pr[X=1] = Pr[{KZ, ZK}] = Pr[KZ]+Pr[ZK] =
(bei derselben Definition von X wie auf der letzten Folie)
DuA - Kapitel 4
Definition 4.13 (Erwartungswert):
Der Erwartungwert einer Zufallsvariable ist definiert als
E[X] = x Pr[X=x]
SS 2011 32
Interpretation:
Der Erwartungswert gibt den durchschnittlichen Wert
der Zufallsvariable an, wobei die Wahrscheinlichkeiten
der Ereignisse bercksichtigt werden
DuA - Kapitel 4
Beispiel:
Erwartete Anzahl Kopf bei 2 Mnzwrfen
E[X] = 0 Pr[X=0] + 1 Pr[X=1] + 2 Pr[X=2]
= 0 + + 2
= 1
SS 2011 33
= 1
DuA - Kapitel 4
Linearitt des Erwartungswerts:
E[X + Y] = E[X] + E[Y]
Bemerkung:
Eine der wichtigsten Formeln im Bereich randomisierte
Algorithmen
SS 2011 34
Algorithmen
Anwendung:
Man kann komplizierte Zufallsvariable oft als Summe
einfacher Zufallsvariablen schreiben und dann den
Erwartungswert der einfachen Zufallsvariablen
bestimmen
DuA - Kapitel 4
Beispiel:
Sei X die Wrfelsumme von n Wrfeln.
Wir wollen E[X] bestimmen.
Dazu fhren wir die Zufallsvariable X
i
ein, die die
Augenzahl von Wrfel i angibt.
Fr E[X
i
] gilt bei einem perfekten Wrfel:
SS 2011 35
E[X
i
] = 1/6(1+2++6) = 7/2
Da X=X
1
+X
2
++X
n
ist, folgt aufgrund der Linearitt des
Erwartungswerts:
E[X] = E[X
1
+X
2
++X
n
] = E[X
1
]+E[X
2
]++E[X
n
]
= 7n/2 .
DuA - Kapitel 4
Average-case Laufzeit:
Wir betrachten alle Permutationen der n Eingabezahlen.
Wir berechnen fr jede Permutation Laufzeit des
Algorithmus bei dieser Permutation.
SS 2011 36
diese Laufzeiten.
Average-case Laufzeit ist die erwartete Laufzeit einer
zufllig und gleichverteilt gewhlten Permutation aus
der Menge aller Permutationen der n Eingabezahlen.
DuA - Kapitel 4
Average-Case Insertion-Sort
Satz 4.14: Insertion-Sort besitzt average-case Laufzeit
(n
2
).

Beweis: Wir zeigen, mit Wahrscheinlichkeit 1/2 hat man
mindestens n
2
/16 Vergleiche (Annahme: n ist gerade).
Sei L
n/2
die Menge der n/2 kleinsten Zahlen
Sei U
n/2
die Menge der n/2 grten Zahlen
SS 2011 37
Sei U
n/2
die Menge der n/2 grten Zahlen
A
i
: Ereignis, dass in einer zuflligen Permutation der n
Zahlen genau i Elemente aus U
n/2
in der ersten Hlfte
der Permutation platziert sind.
B
i
: Ereignis, dass in einer zuflligen Permutation der n
Zahlen genau i Elemente aus L
n/2
in der ersten Hlfte
der Permutation platziert sind.

DuA - Kapitel 4
Average-Case Insertion-Sort
Pr[U
n/4 i n/2
A
i
] =
n/4 i n/2
Pr[A
i
]
Pr[A
i
] = Pr[B
i
] Pr[A
i
] = Pr[A
n/2-i
]
5 2 4 7 1 3 2 6
1 2 2 3 4 5 6 7 L
n/2
U
n/2
Ereignis A
3
SS 2011 38

0 i n/2
Pr[A
i
] = 1

n/4 i n/2
Pr[A
i
] = 1-
0 i < n/4
Pr[A
i
] = Pr[A
n/4
] + 1-
n/4 i n/2
Pr[A
i
]
2
n/4 i n/2
Pr[A
i
] = 1 + Pr[A
n/4
] > 1
n/4 i n/2
Pr[A
i
] >
Mit Wahrscheinlichkeit 1/2 befindet sich mindestens die Hlfte
von U
n/2
in der ersten Hlfte und mindestens die Hlfte von
L
n/2
in der zweiten Hlfte einer zuflligen Permutation.

DuA - Kapitel 4
2. key A[j]
3. i j-1
5. A[i+1] A[i]
Sei j n/2 und A[j] in L
n/2
Dann wird die while-Schleife
Mit Wahrscheinlichkeit
gibt es mindestens n/4
Elemente A[j] in L
n/2
mit
j n/2
SS 2011 39
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
Dann wird die while-Schleife
mindestens n/4 mal
durchlaufen.
n
2
/16 Vergleiche
Im Durchschnitt produziert Insertion-Sort >n
2
/32 Vergleiche
DuA - Kapitel 4
5. Rekursionen
Laufzeiten insbesondere von Divide&Conquer
Algorithmen werden hufig durch Rekursionsgleichungen
beschrieben.
Werden eine allgemeine Methode kennenlernen, um solche
Gleichungen zu lsen, die Rekursionsbaum-Methode.
Diese Methode kann verfeinert werden, um das Master
Theorem fr Rekursionsgleichungen zu beweisen.
Satz 5.1: Fr positive Konstanten a,b,c mit
n=b
k
fr eine natrliche Zahl k sei
Dann gilt
T(n) c falls n=1
T(n) aT(n/b) + cn falls n>1
Master-Theorem (Einfache Version)
Dann gilt
T(n) = (n) falls a<b
T(n) = (n log
b
n) falls a=b
T(n) = (n
log
b
a
) falls a>b
Beweis:
Betrachte abgewickelten
Laufzeitbaum.
Daraus folgt:
T(n)
i=0
k
a
i
(cn/b
i
)
cn
i=0
k
(a/b)
i
Master-Theorem
cn
a
cn/b cn/b
a ..
T(n):
cn
i=0
(a/b)
Einsetzung der Flle
ergibt das Theorem
(verwende fr ab
i=0
k
z
i
= )
cn/b
2
cn/b
2
. . . . . . . . . . . . . . . . . .
c
c
. . . . . . . . . . .
z
i+1
-1
z-1
Rekursionsbaum fr T(n)=aT(n/b)+f(n)
( )L
2
b / n f ( )
2
b / n f ( )
2
b / n f ( )L
2
b / n f ( )
2
b / n f ( )
2
b / n f ( )L
2
b / n f ( )
2
b / n f ( )
2
b / n f
( ) b / n f ( ) L b / n f ( ) b / n f
( (( ( ) )) )
n f
a
a a a
( ) n
b
log
( )L
2
b / n f ( )
2
b / n f ( )
2
b / n f ( )L
2
b / n f ( )
2
b / n f ( )
2
b / n f ( )L
2
b / n f ( )
2
b / n f ( )
2
b / n f
L
a
L
a
L
a
L
a
L
a
L
a
L
a
L
a
L
a
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) n
b
log
( ) a
b
n
log
Rekursionsbaum und Summation
( )L
2
b / n f ( )
2
b / n f ( )
2
b / n f ( )L
2
b / n f ( )
2
b / n f ( )
2
b / n f ( )L
2
b / n f ( )
2
b / n f ( )
2
b / n f
( ) b / n f ( ) L b / n f ( ) b / n f
a
a a a
a a a a a a a a a
( ) n
b
log
( ) n f ( ) n f
( ) b / n f a
( )
2 2
b / n f a
L
a
L
a
L
a
L
a
L
a
L
a
L
a
L
a
L
a
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) 1

M
( ) a
b
n
log
( )
( )
a
b
n
log
( )
( )
( )
( )
j
n
j
j a
b / n f a n
b
b
=
+
1 log
0
log
: Insgesamt
Lsen durch Rekursionsbume - Beispiel
Betrachten ( )

( )
0
1
1 4 3
2
>
=
> +
= c ,
n , c
n , cn / n T
n T .

Erhalten durch Ignorieren der Abrundung und mit
Rekursionsbaum

( )
( )
( ) 3 log 2
1 log
2 2
16
3
16
3
4
4
cn cn cn cn n T
n
+
|
\
|
+ + + =
L

( )
( )
( )
( )
( )
( )
( )
( )
2 3 log 2
log
3 log 2
1 log
0

1 3/16
1 3/16

16
3

16 16
4
4
4
4
n cn cn
cn cn
cn cn cn cn n T
n
i
n
i
O = +
=
+
|
\
|
=
+
|
\
+ + + =
=
L
.

Das (allgemeine) Master-Theorem

Satz 5.2 (Master Theorem):
( )
( )
( ) ( ) ( )
(
( ) n T
n/b n/b n/b
. n f n/b aT n T
n T
n f a,b
+ =
t abgeschtz aen folgenderm kann Dann werden.

ersetzt oder durch auch kann Hierbei

gleichung Rekursions die durch definiert sei
und Funktion eine sei , Konstanten 1 Seien

( )
( )
( )
( ) ( )
( )
( )
( )
( )
( ) ( )
( )
( ) ( )
( )
( )
( ) ( ) ( )
( ) ( ) ( ). n f n T
n c
n cf n/b af n n f .
. n n n T n n f .
. n n T n n f
n T
a
a a
a a
b
b b
b b
=
<
> =
= =
= > =
+

gilt dann , und 1 Konstante eine fr
ist und 0, fr Ist 3
log gilt dann , Ist 2
gilt dann 0, fr Ist 1.
werden.
t abgeschtz aen folgenderm kann Dann werden.
log
log log
log log
O
O O

6. Divide & Conquer Quicksort
Quicksort ist wie Merge-Sort ein auf dem
Divide&Conquer-Prinzip beruhender
Sortieralgorithmus.

Von Quicksort existieren unterschiedliche
Varianten, von denen einige in der Praxis
besonders effizient sind.

SS 2010 1

Die worst-case Laufzeit von Quicksort ist ( )
2
n .

Die durchschnittliche Laufzeit ist jedoch ( ) ( ) n nlog .

Eine randomisierte Version von Quicksort besitzt
erwartete Laufzeit ( ) ( ) n nlog .

Datenstrukturen und Algorithmen
Quicksort - Idee
Eingabe: Ein zu sortierendes Teilarray [ ] r p A K .

Teilungsschritt: Berechne einen Index r q p , q und
vertausche die Reihenfolge der Elemente
in [ ] r p A K , so dass die Elemente in [ ] 1 q p A K nicht
grer und die Elemente in [ ] r q A K 1 + nicht kleiner
sind als [ ] q A .
SS 2010 2
sind als [ ] q A .

Eroberungsschritt: Sortiere rekursiv die beiden Teilarrays
[ ] 1 q p A K und [ ] r q A K 1 + .

Kombinationsschritt: Entfllt, da nach Eroberungsschritt
das Array [ ] r p A K bereits sortiert ist.

Quicksort - Pseudocode
( )
( )
( )
( ) ,r A,q
A,p,q-
A,p,r q
r p
A,p,r
1 Quicksort 4.
1 Quicksort 3.
Partition 2.
1.
Quicksort
+
<
then
if

SS 2010 3

Aufruf, um Array A zu sortieren: [ ] ( ) A ,length A,1 Quicksort
Partition - Pseudocode
( )
[ ]
[ ]
1 5.
4.
1 3.
1 2.
1.
Partition
+
i i
x j A
r- p j
p- i
r A x
A,p,r
then
if do
to for
SS 2010 4
[ ] [ ]
[ ] [ ]
1 8.
1 7.
6.
1 5.
+
+
+
i
r A i A
j A i A
i i
return
then

Illustration von Partition (1)
2 8 7 1 3 5 6 4
r
p,j i
2 8 7 1 3 5 6 4
r
p,i j
( )
[ ]
[ ]
1 5.
4.
1 3.
1 2.
1.
Partition
+
i i
x j A
r- p j
p- i
r A x
A,p,r
then
if do
to for
SS 2010 5
2 8 7 1 3 5 6 4
r
p,i j
2 8 7 1 3 5 6 4
r
p,i j
[ ] [ ]
[ ] [ ]
1 8.
1 7.
6.
1 5.
+
+
+
i
r A i A
j A i A
i i
return
then
Illustration von Partition (2)
2 1 7 8 3 5 6 4
r p j i
2 1 3 8 7 5 6 4
r p j i
2 1 3 8 7 5 6 4
j i p r
( )
[ ]
[ ]
1 5.
4.
1 3.
1 2.
1.
Partition
+
i i
x j A
r- p j
p- i
r A x
A,p,r
then
if do
to for
SS 2010 6
2 1 3 8 7 5 6 4
2 1 3 8 7 5 6 4
i p r
2 1 3 4 7 5 6 8
i p r
[ ] [ ]
[ ] [ ]
1 8.
1 7.
6.
1 5.
+
+
+
i
r A i A
j A i A
i i
return
then
Korrektheit von Partition - Invariante
Invariante: Vor Durchlauf der Schleife in Zeilen 3-6 mit
Index j gilt fr jeden Index k:

1. Falls
i k p
, dann ist [ ] x k A .

2. Falls 1 1 + j k i , dann ist [ ] x k A > .

SS 2010 7

3. Falls r k = , dann ist [ ] x k A = .

r p i
x
x
> x
Verhltnis unbekannt
j
Korrektheit von Partition (1)
Initialisierung: Vor dem ersten Schleifendurchlauf gilt
1 = p i und p j = . Daher gibt es in diesem Fall keine
Indizes zwischen p und i (1.Bedingung) bzw. zwischen
1 + i und 1 j (2.Bedingung). Die erste Zeile sorgt
dafr, dass die 3.Bedingung ebenfalls erfllt ist.

Erhaltung: Unterscheiden zwei Flle

SS 2010 8

1. [ ] x j A >
2. [ ] x j A .

1. Fall: Nur j wird erhht. Damit wird dann 2.Bedingung
auch fr k=j erfllt.

Erhaltung 1.Fall
r p i
>x x
x
> x
j
r p i j
SS 2010 9
r p i
x
x
> x
j

2. Fall [ ] x j A : Element [ ] j A kommt an Position i. Da
[ ] x j A ist 1.Bedingung weiter erfllt.
Fr neues [ ] 1 j A gilt nach
Voraussetzung [ ] x j A > 1 . Damit ist
2. Bedingung erfllt auch.

SS 2010 10

Erhaltung 2.Fall
r p i
x x
x
> x
j
SS 2010 11
r p i
x
x
> x
j
Terminierung: Es gilt j=r und alle Elemente des Arrays
wurden mit x verglichen. Zeile 9 stellt nun
sicher, dass x zwischen die Elemente
echt kleiner als x und die Element echt
grer als x plaziert wird. Damit gengt
die von Partition berechnete Aufteilung
immer den Anforderungen von Quicksort.
SS 2010 12
immer den Anforderungen von Quicksort.

( )
[ ]
[ ]
1 5.
4.
1 3.
1 2.
1.
Partition
+
i i
x j A
r- p j
p- i
r A x
A,p,r
then
if do
to for
Laufzeit von Partition
Pro Zeile konstante
Zeit.
Schleife Zeilen 3-6 wird
SS 2010 13
[ ] [ ]
[ ] [ ]
1 8.
1 7.
6.
1 5.
+
+
+
i
r A i A
j A i A
i i
return
then

Satz 6.1: Partition hat Laufzeit (n) bei Eingabe eines
Teilarrays mit n Elementen.
Schleife Zeilen 3-6 wird
n=r-p-mal durchlaufen.
Quicksort Analyse
Satz 6.2: Es gibt ein c>0, so dass fr alle n und alle Ein-
gaben der Gre n Quicksort mindestens Laufzeit
cnlog(n) besitzt.

Satz 6.3: Quicksort besitzt worst-case Laufzeit ( )
2
n .

Satz 6.4: Quicksort besitzt average-case Laufzeit
( ) ( ) n nlog O .
SS 2010 14
( ) ( ) n nlog O .

Average-case Laufzeit: Betrachten alle Permutationen der
n Eingabezahlen. Berechnen fr jede Permutation
Laufzeit von Quicksort bei dieser Permutation.
Average-case Laufzeit ist dann der Durchschnitt ber
all diese Laufzeiten.

Quicksort Analyse
SS 2010 15 Datenstrukturen und Algorithmen
Quicksort Analyse
=
=
=
Wir nehmen vereinfacht Gleichheit an (worst case).
=
=
Quicksort Analyse
Wir wissen
i=2
n
1/i ln(n). Also gilt

Schlechte Eingaben fr Quicksort knnen ver-
mieden werden durch Randomisierung, d.h.
der Algorithmus wirft gelegentlich eine Mnze,
um sein weiteres Vorgehen zu bestimmen.

Worst-case Laufzeit bei ungnstigen Mnz-
wrfen immer noch ( )
2
n .

Randomisiertes Quicksort (1)

Es gibt keine schlechten Eingaben. Dies sind
Eingaben, bei denen Quicksort bei allen
Mnzwrfen Laufzeit ( )
2
n besitzt.

Laufzeit ist in diesem Modell erwartete Laufzeit,
wobei Erwartungswert ber Mnzwrfe
genommen wird. Erwartete Laufzeit ist ( ) ( ) n nlog .
( )
( )
[ ] [ ]
( ) A,p,r
i A r A
p,r i
A,p,r
Partition 3.
2.
Random 1.
Partition - Randomized
return
SS 2010 19
[ ] [ ]
( ) ( ) .
p r
i p,r
r p i
1
1
Random Pr
: alle fr gilt Dabei whlt. r p
aus Wert einen zufllig die Funktion, eine Random ist Hierbei
+
= =
K K
( )
( )
( )
( ) ,r A,q
A,p,q-
A,p,r q
r p
A,p,r
1 Quicksort - Randomized 4.
1 Quicksort - Randomized 3.
Partition - Randomized 2.
1.
Quicksort - Randomized
+
<
then
if

SS 2010 20

Satz 6.5: Die erwartete Laufzeit von Randomized-
Quicksort ist ( ) ( ) n nlog . Dabei ist der Erwartungswert
ber die Zufallsexperimente in Partition - Randomized
genommen.


Verbesserung der Gte von Aufteilungen, indem
nicht ein festes Element zur Aufteilung benutzt
wird, sondern z.B. das mittlere von drei Elementen
Zur Aufteilung benutzt wird.

Knnen etwa drei zufllige Elemente whlen oder
[ ] [ ] [ ] ( )

2 mit / r p : q r A , q A , p A + = .
Median-Quicksort (1)
[ ] [ ] [ ] ( )

2 mit / r p : q r A , q A , p A + = .

Beide Varianten in der Praxis erfolgreich. Aber nur
zufllige Variante kann gut analysiert werden:
( ) ( ) n nlog erwartete Laufzeit.


( )
[ ] [ ] [ ] [ ]
[ ] [ ] [ ] [ ]
k
j
j A k A j A i A
i
i A k A j A i A
k j, i, A,
5.
4.
) ( ) ( 3.
2.
) ( ) ( 1.
Median
return else
return then
if else
return then
if

SS 2010 22

( )
( )

( )
[ ] [ ]
( ) A,p,r
i A r A
,r / r p p, i
A,p,r
Partition 3.
2.
2 Median 1.
Partition - Median
return
+
( )
( )
( )
( ) ,r A,q
A,p,q-
A,p,r q
r p
A,p,r
1 Quicksort - Median 4.
1 Quicksort - Median 3.
Partition - Median 2.
1.
Quicksort - Median
+
<
then
if


7. Heapsort
Werden sehen, wie wir durch geschicktes Organsieren
von Daten effiziente Algorithmen entwerfen knnen.
Genauer werden wir immer wieder bentigte
Operationen durch Datenstrukturen untersttzen.
Heapsort: Heap (Familie der Priority Queues)
Heapsort: Heap (Familie der Priority Queues)
Werden im Laufe des Semesters viel mehr ber
Datenstrukturen und ihren Zusammenhang mit
effizienten Algorithmen lernen.
M: Menge von Elementen
Jedes Element e identifiziert ber key(e).
Operationen:
insert(M,e): M:=M{e}
Priority Queue
min(M): gib eM mit minimalem key(e) aus

deleteMin(M): wie M.min, aber zustzlich
M:=M{e}, fr e mit minimalem key(e)
Idee: organisiere Daten im binren Baum
Bewahre zwei Invarianten:
Form-Invariante:vollst.
Binrbaum bis auf
unterste Ebene
Priority Queue als Heap
unterste Ebene
Heap-Invariante:
e
1
e
2
e
3
key(e
1
)min{key(e
2
),key(e
3
)}
Beispiel:
4
8 5
Heapvariante
Heap
11 9 12 18
15 17
Forminvariante
Realisierung eines Binrbaums als Feld:
e
1
e
2
e
3
Heap
e
4
e
5
e
6
e
7
e
8
e
9
e
1
e
2
e
3
e
4
e
5
e
6
e
7
e
8
e
9
e
3
A: Array [1..N] of Element (Nn, n=#Elemente)
e
1
e
2
e
3
e
4
e
5
e
6
e
7
e
8
e
9
e
3
Heap
A: Array [1..N] of Element (Nn, n=#Elemente)
Kinder von e in A[i]: in A[2i], A[2i+1]
Form-Invariante: A[1],,A[n] besetzt
Heap-Invariante:
key(A[i])min{key(A[2i]),key(A[2i+1])}
Definition 7.1: Ein Heap ber einem Array A ist das
Array A der Gre N zusammen mit einem Para-
meter n:=heap-size[A]N und drei Funktionen
Parent, Left, Right: {1,,n}{1,..,n}
Dabei gilt:

Heap
1. 1nN
2. Parent(i)=i/2 fr alle i{1,..,n}
3. Left(i)=2i fr alle i{1,,n}
4. Right(i)=2i+1 fr alle i{1,,n}
Die Elemente A[1],,A[n] heien Heapelemente.
Definition 7.2: Ein Heap heit
1. max-Heap, wenn fr alle i{2,,n} gilt
key(A[Parent(i)]) key(A[i])
2. min-Heap, wenn fr alle i{2,,n} gilt
key(A[Parent(i)]) key(A[i])
Heap
Bemerkungen:
key(A[Parent(i)]) key(A[i]) ist quivalent zu
key(A[i])min{key(A[Left(i)]),key(A[Right(i)])}
Wir werden uns zunchst mit dem min-Heap
beschftigen und diesen einfach Heap nennen.
insert(A,e):
e
1
e
2
e
3
e
4
e
5
e
6
e
7
e
8
e
9
e
3
e
10
Heap
insert(A,e):
Form-Invariante: nn+1; A[n]e
Heap-Invariante: vertausche e mit Vater
bis key(A[Parent(k)])key(e) fr e in A[k]
oder e in A[1]
Insert(A,e):
n n+1; A[n] e
HeapifyUp(A,n)
HeapifyUp(A,i):
while i>1 and key(A[Parent(i)])>key(A[i]) do
Insert Operation
A[i] A[Parent(i)]
i Parent(i)
Fr Analyse: wir nehmen vereinfachend an,
dass key(A[i]) = A[i].
3
5 8
10 9 12 15
3
5 8
10 9 12 15
Insert Operation
11 18
Invariante: A[k] ist minimal fr Teilbaum von A[k]
: Knoten, die Invariante eventuell verletzen
11 18 4
3
5 8
10 9 12 15
3
5 8
10 4 12 15
Insert Operation
11 18 4 11 18 9
3
5 8
10 4 12 15
3
4 8
10 5 12 15
Insert Operation
11 18 9 11 18 9
3
4 8
10 5 12 15
3
4 8
10 5 12 15
Insert Operation
11 18 9 11 18 9
Insert Operation
P(i): Menge aller Vorgnger von A[i] (d.h. A[i/2],
A[i/4] usw. bis A[1])
T(i): Menge aller Elemente im Teilbaum mit Wurzel
A[i] (d.h. A[2i], A[2i+1], A[2(2i)], A[2(2i+1)],)
Schleifeninvariante:
j{1,,n}\P(i): A[j]=min{ A[k] | kT(j) }
j{1,,n}\{i}: A[j]=min{ A[k] | k T(j)\{i} }
j{1,,n}\{i}: A[j]=min{ A[k] | k T(j)\{i} }
i i
Heap OK
auer fr
P(i)
Heap OK
bei Auslas-
sung von i
Insert Operation
j{1,,n}\P(i): A[j]=min{ A[k] | kT(j) }
j{1,,n}\{i}: A[j]=min{ A[k] | k T(j)\{i} }
Initialisierung: zu Beginn ist i=n und damit Invariante
trivialerweise wahr.
Erhaltung:
A[i/2]>A[i]: (2): A[i/2]min{ A[k] | k T(i/2)\{i} }
(1)
(2)
A[i/2]>A[i]: (2): A[i/2]min{ A[k] | k T(i/2)\{i} }
d.h. nach Vertauschung von A[i] und A[i/2] ist
Invariante wieder wahr
Terminierung: am Ende ist i=1 oder A[i/2]A[i].
i=1: Heapeigenschaft folgt aus (1)
A[i/2]A[i]: Heapeigenschaft folgt mit (1) und (2)
Insert Operation
Laufzeit:
Insert(A,e):
n n+1; A[n] e O(1)
HeapifyUp(A,n)
HeapifyUp(A,i):
j=1
k
(T(B)+T(I))
A[i] A[Parent(i)] O(1)
A[i] A[Parent(i)] O(1)
i Parent(i) O(1)
Problem: was ist k?
Verwende Potenzialfunktion (j) = log i
Anfang: (1) = log n
Fr alle j: (j+1) (j) -1
Ende sptestens wenn (j) 0
O(k)
Also ist k log n +1
deleteMin(A):
Form-Invariante: A[1]A[n]; nn-1
e
1
e
2
e
3
e
4
e
5
e
6
e
7
e
8
e
9
e
3
deleteMin Operation

Heap-Invariante: starte mit e in A[1].
Vertausche e mit Kind mit min Schlssel
bis A[k]min{A[Left(k)],A[Right(k)]} fr
Position k von e oder e in Blatt
DeleteMin(A):
eA[1]; A[1]A[n]; nn-1
HeapifyDown(A,1)
return e
HeapifyDown(A,i):
while Left(i)<=n do
if Right(i)>n then mLeft(i) // m: Pos. des min. Kindes
Laufzeit: O(log n)
(ber Potenzialmethode)
deleteMin Operation
if Right(i)>n then mLeft(i) // m: Pos. des min. Kindes
else
if key(A[Left(i)])<key(A[Right(i)]) then mLeft(i)
else mRight(i)
if key(A[i])<=key(A[m]) then return // Heap-Inv gilt
A[i] A[m]; im
3
5 8
10 9 12 15
5 8
10 9 12 15
18
deleteMin Operation
11 18 11
5 8
10 9 12 15
5
8
10 9 12 15
18
18
deleteMin Operation
11 11
5
8
10 9 12 15
5
8
10
9
12 15 18
18
deleteMin Operation
11 11
deleteMin Operation
T(i): Menge aller Elemente im Teilbaum mit Wurzel
A[i] (d.h. A[2i], A[2i+1], A[2(2i)], A[2(2i+1)],)
j{1,,n}\{i}: A[j]=min{ A[k] | k T(j) }
Heap OK
i
Heap OK
bis auf i
deleteMin Operation
j{1,,n}\{i}: A[j]=min{ A[k] | k T(j) }
Initialisierung: zu Beginn ist i=1 und damit Invariante
trivialerweise wahr.
Erhaltung:
o.B.d.A. sei A[2i]=min{A[2i],A[2i+1]}
A[i]>A[2i]: dann ist A[2i]min{ A[k] | k T(i) }
A[i]>A[2i]: dann ist A[2i]min{ A[k] | k T(i) }
d.h. nach Vertauschung von A[i] und A[2i] ist
Invariante wieder wahr
Terminierung: am Ende ist i>n/2 oder A[i]min{A[2i],A[2i+1]}.
i>n/2: Heapeigenschaft folgt, da A[i] Blatt ist
A[i]min{A[2i],A[2i+1]}: Heapeigenschaft folgt aus Inv.
BuildHeap(A): baue mit Elementen in A einen Heap auf.
Naive Implementierung ber n insert(A,e)-Operationen:
Laufzeit O(n log n)
Bessere Implementierung:
BuildHeap(A):
Aufbau eines Heaps
BuildHeap(A):
nheap-size[A]
for in/2 downto 1 do
HeapifyDown(A,i)
Aufwand (mit k=log n):
O(
1l<k
2
l
(k-l)) = O(2
k
j0
j/2
j
) = O(n)
Aufbau eines Heaps:
Jedes Blatt ist ein Heap
Baue Heap von unten nach oben mit HeapifyDown auf
3 7 10 12 2 4
1
1 2 3 4 5 6
Aufbau eines Heaps
26
BuildHeap(A)
1. n heap-size[A]
2. for i n/2 downto 1 do
3. HeapifyDown(A,i)
3
7 10
12 2 4
1
2 3
4 5
6
3 7 10 12 2 4
1
1 2 3 4 5 6
Aufbau eines Heaps
Aufbau eines Heaps:
27
3
7 10
12 2 4
1
2 3
4 5
6
BuildHeap(A)
1. n heap-size[A]
3. HeapifyDown(A,i)
3 7 10 12 2 4
1
1 2 3 4 5 6
i
Aufbau eines Heaps
Aufbau eines Heaps:
28
3
7 10
12 2 4
1
2 3
4 5
6
BuildHeap(A)
1. n heap-size[A]
3. HeapifyDown(A,i)
3 7 4 12 2 10
1
1 2 3 4 5 6
i
Aufbau eines Heaps
Aufbau eines Heaps:
29
3
7 4
12 2 10
1
2 3
4 5
6
BuildHeap(A)
1. n heap-size[A]
3. HeapifyDown(A,i)
3 7 4 12 2 10
1
1 2 3 4 5 6
i
Aufbau eines Heaps
Aufbau eines Heaps:
30
3
7 4
12 2 10
1
2 3
4 5
6
BuildHeap(A)
1. n heap-size[A]
3. HeapifyDown(A,i)
3 2 4 12 7 10
1
1 2 3 4 5 6
i
Aufbau eines Heaps
Aufbau eines Heaps:
31
3
2 4
12 7 10
1
2 3
4 5
6
BuildHeap(A)
1. n heap-size[A]
3. HeapifyDown(A,i)
3 2 4 12 7 10
1
1 2 3 4 5 6
i
Aufbau eines Heaps
Aufbau eines Heaps:
32
3
2 4
12 7 10
1
2 3
4 5
6
BuildHeap(A)
1. n heap-size[A]
3. HeapifyDown(A,i)
2 3 4 12 7 10
1
1 2 3 4 5 6
i
Aufbau eines Heaps
Aufbau eines Heaps:
33
2
3 4
12 7 10
1
2 3
4 5
6
BuildHeap(A)
1. n heap-size[A]
3. HeapifyDown(A,i)
2 3 4 12 7 10
1
1 2 3 4 5 6
Aufbau eines Heaps
Aufbau eines Heaps:
34
2
3 4
12 7 10
1
2 3
4 5
6
BuildHeap(A)
1. n heap-size[A]
3. HeapifyDown(A,i)
HeapifyDown(A,i) fr i=n/2 runter bis 1:
Inv.
Aufbau eines Heaps
Invariante: j>i: A[j] min. fr Teilbaum von A[j]
Inv.
verletzt
Laufzeiten:
BuildHeap(A): O(n)
insert(A,e): O(log n)
min(A): O(1)
deleteMin(A): O(log n)
Heap
deleteMin(A): O(log n)
max-Heap anwendbar in Sortierverfahren
Heapsort
Heapsort
Eingabe: Array A
Ausgabe: Zahlen in A in aufsteigender Reihenfolge sortiert.
Heapsort(A):
Build-Max-Heap(A) // wie BuildHeap, aber fr max-Heap
for in downto 2 do
for in downto 2 do
A[1]A[i]
nn-1
HeapifyDown(A,1) // anpassen an max-Heap
Illustration von Heapsort
1
16
14 10
8 7
4 2 1
9
3
2
3
4 5
6
7
8 9
10
1
1
14 10
8 7
4 2 16
9
3
2
3
4 5
6
7
8 9
10
1
14
8 10
4 7
1 2 16
9
3
2
3
4 5
6
7
8 9
14 10 8 7 9 3 2 4 1 16
14 8 10 4 7 9 3 2 1 16
1 1
1
8 10
4 7
14 2 16
9
3
2
3
4 5
6
7
8 9
10
14
8 10
4 7
1 2 16
9
3
2
3
4 5
6
7
8 9
10 8 9 4 7 9 3 2 14 16
1
10
8 9
4 7
14 2 16
1
3
2
3
4 5
6
7
8 9
10
14 8 10 4 7 9 3 2 1 16
1 1
2
8 9
4 7
14 10 16
1
3
2
3
4 5
6
7
8 9
10
10
8 9
4 7
14 2 16
1
3
2
3
4 5
6
7
8 9
9 8 3 4 7 1 2 10 14 16
1
9
8 3
4 7
14 10 16
1
2
2
3
4 5
6
7
8 9
10
10 8 9 4 7 9 3 2 14 16
1 1
2
8 3
4 7
14 10 16
1
9
2
3
4 5
6
7
8 9
10
9
8 3
4 7
14 10 16
1
2
2
3
4 5
6
7
8 9
9 8 3 4 7 1 2 10 14 16
1
8
7 3
4 2
14 10 16
1
9
2
3
4 5
6
7
8 9
10
10 8 9 4 7 9 3 2 14 16
Laufzeit von Heapsort
Satz 7.3: Heapsort besitzt Laufzeit ( ) ( ) n nlog O .

Beweisskizze:

1. Aufruf von Build-Max-Heap: ( ) n O .

2. for-Schleife (n-1)-mal durchlaufen.
2. for-Schleife (n-1)-mal durchlaufen.

3. Pro Durchlauf Laufzeit ( ) ( ) n log O (HeapifyDown).
8. Untere Schranken fr Sortieren
Alle bislang betrachteten Sortieralgorithmen hatten
(worst-case) Laufzeit (nlog(n)).
Werden nun gemeinsame Eigenschaften dieser
Algorithmen untersuchen.
Fassen gemeinsame Eigenschaften in Modell des
Fassen gemeinsame Eigenschaften in Modell des
Vergleichssortierers zusammen.
Zeigen dann, dass jeder Vergleichssortierer Laufzeit
(nlog(n)) besitzt.
Laufzeit von Sortieralgorithmen

Laufzeit
worst-case average-case
A
l
g
o
r
i
t
h
m
u
s

Insertion-
Sort
( )
2
n ( )
2
n
Merge-
Sort
( ) ( ) n log n ( ) ( ) n log n
A
l
g
o
r
i
t
h
m
u
s
Sort
( ) ( ) n log n ( ) ( ) n log n
Quick-
sort
( )
2
n
( ) ( ) n log n
Heap-
sort
( ) ( ) n log n
-

Vergleichssortierer
Definition 8.1: Ein Vergleichssortierer ist ein Algorithmus,
der zu jeder beliebigen Eingabefolge ( )
n
a , , a , a K
2 1
von
Zahlen eine Permutation berechnet, so dass

( ) ( ) ( ) n
a a a

L
2 1
. Dabei benutzt ein
Vergleichssortierer auer den durch den Pseudocode
definierten Kontrolloperationen nur die
Vergleichsoperationen . , , , , , > < =


Bemerkungen:
1. Wir nehmen an, dass Eingabezahlen immer
paarweise verschieden sind. Bentigen daher
= nicht.
2. Knnen uns auf den Vergleich einschrnken.
Andere Vergleichen sind hierzu quivalent.
Definition 8.2: Ein Entscheidungsbaum ber n Zahlen ist
ein binrer Baum, bei dem

1. Jeder innere Knoten mit n j , i , j : i 1 gelabelt
ist.
2. Jedes Blatt mit einer Permutation { } n , 1, auf K
gelabelt ist.
Entscheidungsbume
gelabelt ist.

Entscheidungsbume und Sortieren
Mit Entscheidungsbumen knnen Vergleichssortierer
modelliert werden. Hierzu

1. wird bei Eingabe ( )
n
a , , a K
1
ein Pfad von der
Wurzel des Baums zu einem Blatt des Baums
durchlaufen.
2. wird an einem inneren Knoten gelabelt mit j : i
die Kante zum linken Kind genommen, falls
die Kante zum linken Kind genommen, falls

j i
a a , sonst wird die Kante zum rechten Kind
genommen.
3. wird die Permutation des Blatts am Ende des
Pfades ausgegeben.

Zu einem Vergleichssortierer gibt es fr jede Eingabe-
gre n einen Entscheidungsbaum.
2. key A[j]
3. i j-1
Entscheidungsbaum fr Insertion-Sort
5. A[i+1] A[i]
6. i i-1
7. A[i+1] key
1:2
2:3 1:3
1:3
(1,2,3)
2:3
(2,1,3)

>
>
>
>
(1,3,2) (3,1,2) (3,2,1) (2,3,1)

>
>
5 8 6 : Eingabe
3 2 1
= = = a , a , a
for j 2 to length(A) do
key A[j]
i j 1
while i > 0 and A[i] > key do
A[i+1] A[i]
i i 1
A[i+1] key
a
1
:
a
2
i
j
a
2
a
3
key = a
2
a
1
key A[j]
i j 1
A[i+1] A[i]
i i 1
A[i+1] key
a
1
:
a
2
a
:
a
i
j
a
2
a
3
key = a
3
a
1
a
2
:
a
3
key A[j]
i j 1
A[i+1] A[i]
i i 1
A[i+1] key
a
1
:
a
2
a
:
a
i
j
a
2
a
3
key = a
3
a
1
a
2
:
a
3
a ,
1 2
a ,
3
a
key A[j]
i j 1
A[i+1] A[i]
i i 1
A[i+1] key
a
1
:
a
2
a
:
a
i
j
a
2
a
3
key = a
3
a
1
a
2
:
a
3
a ,
1 2
a ,
3
a
key A[j]
i j 1
A[i+1] A[i]
i i 1
A[i+1] key
a
1
:
a
2
a
:
a
i
j
a
2
a
3
key = a
3
a
1
a
2
:
a
3
a
1
:
a
3
>
a ,
1 2
a ,
3
a
key A[j]
i j 1
A[i+1] A[i]
i i 1
A[i+1] key
a
1
:
a
2
a
:
a
>
a
:
a
i j
a
2
a
3
key = a
3
a
1
a ,
1 3
a ,
2
a
a
2
:
a
3
a
1
:
a
3
>
a ,
1 2
a ,
3
a
a ,
3 1
a ,
2
a
a ,
2 3
a ,
1
a
a
1
:
a
3
a
2
:
a
3
>
a ,
2 1
a ,
3
a
a ,
3 2
a ,
1
a
> >
Lemma 8.3: Fr Eingaben der Gre n hat ein
Entscheidungsbaum fr einen Vergleichssortierer
mindestens n! Bltter.

Beweis: Wir zeigen, jede Permutation muss in einem der
Bltter vorkommen.
Annahme: eine bestimmte Permutation ((1), , (n))
kommt nicht vor.
kommt nicht vor.
Wir betrachten die Eingabe (a
1
, ,a
n
) mit a
(1)
< < a
(n)
.
Sei eine beliebige Permutation. Dann gibt es ein j, so dass
(j) (j) (sei o.B.d.A. a
(j)
> a
(j)
).
In der Ausgabe (nach ) wre a
(j)
nicht an der richtigen
Position; somit wre die Folge nicht sortiert.
Lemma 8.4: ( ) ( ) ( ). n n ! n log log =

Beweis:
n! = 12n > ( n/2+1) n > (n/2)
n/2

n! = 12n < n
n

n/2 n
(n/2) log(n/2) = log((n/2)
n/2
) < log(n!) < log(n
n
) = nlog(n)
(n/2) log(n/2) = (n/2) (log(n)-1) > (n/4) log(n) fr alle n>4

Satz 8.5: Die von einem Vergleichssortierer bei Eingabe-
gre n bentigte Anzahl von Vergleichen ist
( ) ( ). n nlog

Beweis: Ein binrer Baum mit N Blttern hat Hhe
mindestens log(N).
Annahme: Es gibt einen Baum der Hhe log(N)-1
(Anzahl der Ebenen ist log(N)).
(Anzahl der Ebenen ist log(N)).
Ebene i hat hchstens 2
i
Elemente
Der Baum hat hchstens 2
log(N)-1
< N Bltter.

Korollar 8.6: Die von Merge-Sort und Heapsort bentigte
Laufzeit von ( ) ( ) n nlog ist asymptotisch optimal.

9. Sortieren in linarer Zeit
Es gibt Algorithmen, die die (nlog(n)) untere Schranke
fr Vergleichssortierer schlagen. Diese Algorithmen
haben Laufzeit O(n).
Diese Algorithmen benutzen neben Vergleichen und
Kontrolloperationen noch andere Operationen, z.B.
arithmetische Operationen auf den zu sortierenden Zahlen.
Auerdem werden noch Annahmen ber die zu
sortierenden Zahlen getroffen, um die Laufzeit von O(n)
zu zeigen und die Korrektheit der Algorithmen zu
beweisen.
Zu diesen Algorithmen gehren Counting-Sort,
Bucket-Sort und Radix-Sort.
Sortieren durch Abzhlen (1)
Annahme: Es gibt ein dem Algorithmus Counting-Sort
bekannter Parameter k, so dass fr die Eingabefolge
( )
n
a , , a K
1
gilt:

n i k a
i
1 alle fr 0 .

Algorithmusidee:

1. Fr alle bestimme Anzahl der
1. Fr alle k i , i 0 bestimme Anzahl
i
C der
i a a
j j
mit .
2. Kopiere i a a
j j
= mit in Felder [ ] [ ]
i i
C B , , C B K 1
1
+

eines Arrays B mit length[B]=n. Dabei gilt
0
1
=
C .

Es gilt:
1
i i
C C ist die Anzahl der i a a
j j
= mit .
Sortieren durch Abzhlen (2)
1
a
2
a
3
a
4
a

1 n
a
n
a
A
1
.
1
0
C
1
1
+
i
C
i
C
k
C
i a a
j j
= mit
0 mit =
j j
a a
B
Counting-Sort
( )
[ ]
[ ]
[ ] [ ] [ ] [ ]
[ ] . Wert mit in te der Elemen Anzahl enthlt . 5
1 4.
1 . 3
0 2.
0 . 1
Sort - Counting
+
i A i C
j A C j A C
A length j
i C
k i
A,B,k
do
to for
do
to for

>
[ ]
[ ] [ ] [ ]
[ ]
[ ]
[ ] [ ] [ ] [ ]
[ ] [ ] [ ] [ ] 1 . 11
B . 10
1 . 9
. Wert mit in te der Elemen Anzahl enthlt . 8
1 7.
1 6.

j A C j A C
j A j A C
A length j
i A i C
i C i C i C
k i
i A i C
do
downto for
do
to for

>
>
Illustration fr Counting-Sort (1)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
0
2
0
3
0
4
0
5
0
0
C
(nach Zeilen 3-4)
0 0 0 0 0 0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
0
2
0
3
0
4
0
5
0
0
C
(nach Zeilen 3-4)
0 0 0 0 0 0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
1
2
0
3
0
4
0
5
0
0
C
(nach Zeilen 3-4)
0 1 0 0 0 0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
1
2
0
3
0
4
0
5
0
0
C
(nach Zeilen 3-4)
0 1 0 0 0 0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
1
2
0
3
0
4
1
5
0
0
C
(nach Zeilen 3-4)
0 1 0 0 1 0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
1
2
0
3
0
4
1
5
0
0
C
(nach Zeilen 3-4)
0 1 0 0 1 0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
1
2
1
3
0
4
1
5
0
0
C
(nach Zeilen 3-4)
0 1 1 0 1 0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
1
2
1
3
0
4
1
5
0
0
C
(nach Zeilen 3-4)
0 1 1 0 1 0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
1
2
1
3
0
4
1
5
1
0
C
(nach Zeilen 3-4)
0 1 1 0 1 1
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
1
2
1
3
0
4
1
5
1
0
C
(nach Zeilen 3-4)
0 1 1 0 1 1
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
2
2
1
3
0
4
1
5
1
0
C
(nach Zeilen 3-4)
0 2 1 0 1 1
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
2
2
1
3
0
4
1
5
1
0
C
(nach Zeilen 3-4)
0 2 1 0 1 1
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
2
2
2
3
0
4
1
5
1
0
C
(nach Zeilen 3-4)
0 2 2 0 1 1
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
2
2
2
3
0
4
1
5
1
0
C
(nach Zeilen 3-4)
0 2 2 0 1 1
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
2
2
2
3
0
4
1
5
2
0
C
(nach Zeilen 3-4)
0 2 2 0 1 2
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
2
2
2
3
0
4
1
5
2
0
C
(nach Zeilen 3-4)
0 2 2 0 1 2
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
2
2
3
3
0
4
1
5
2
0
C
(nach Zeilen 3-4)
0 2 3 0 1 2
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
2
2
3
3
0
4
1
5
2
0
C
(nach Zeilen 3-4)
0 2 3 0 1 2
0
1
2
2
3
3
0
4
1
5
2
0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
2
2
3
3
0
4
1
5
2
0
C
(nach Zeilen 3-4)
0 2 3 0 1 2
2
1
2
2
3
3
0
4
1
5
2
0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
2
2
3
3
0
4
1
5
2
0
C
(nach Zeilen 3-4)
0 2 3 0 1 2
2
1
4
2
3
3
0
4
1
5
2
0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
2
2
3
3
0
4
1
5
2
0
C
(nach Zeilen 3-4)
0 2 3 0 1 2
2
1
4
2
7
3
0
4
1
5
2
0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
2
2
3
3
0
4
1
5
2
0
C
(nach Zeilen 3-4)
0 2 3 0 1 2
2
1
4
2
7
3
7
4
1
5
2
0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
2
2
3
3
0
4
1
5
2
0
C
(nach Zeilen 3-4)
0 2 3 0 1 2
2
1
4
2
7
3
7
4
8
5
2
0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
0
1
2
2
3
3
0
4
1
5
2
0
C
(nach Zeilen 3-4)
0 2 3 0 1 2
2
1
4
2
7
3
7
4
8
5
2
0
C
(nach Zeilen 6-7)
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
2
1
4
2
7
3
7
4
8
5
2
0
B
1 2 3 4 5 6 7 8
1 2 3 4 5 0
C 2
1
4
2
7
3
7
4
8
5
2
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
2
1
4
2
7
3
7
4
8
5
2
0
B
1 2 3 4 5 6 7 8
1 2 3 4 5 0
C 2
1
4
2
7
3
7
4
8
5
2
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
2
1
4
2
7
3
7
4
8
5
2
0
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
C 2
1
4
2
6
3
7
4
8
5
2
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
2
1
4
2
6
3
7
4
8
5
2
0
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
C 2
1
4
2
6
3
7
4
8
5
2
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
C
2
1
4
2
6
3
7
4
8
5
2
0
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
0
C 2
1
4
2
6
3
7
4
8
5
1
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
0
C 2
1
4
2
6
3
7
4
8
5
1
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
0 3
C 2
1
4
2
5
3
7
4
8
5
1
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
0 3
C 2
1
4
2
5
3
7
4
8
5
1
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
0 2 3
C 2
1
3
2
5
3
7
4
8
5
1
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
0 2 3
C 2
1
3
2
5
3
7
4
8
5
1
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
0 2 3 0
C 2
1
3
2
5
3
7
4
8
5
0
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
0 2 3 0
C 2
1
3
2
5
3
7
4
8
5
0
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
0 2 3 0 3
C 2
1
3
2
4
3
7
4
8
5
0
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
0 2 3 0 3
C 2
1
3
2
4
3
7
4
8
5
0
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
0 2 3 0 3 5
C 2
1
3
2
4
3
7
4
7
5
0
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
0 2 3 0 3 5
C 2
1
3
2
4
3
7
4
7
5
0
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
0 2 3 0 3 5 2
C 2
1
2
2
4
3
7
4
7
5
0
0
A
2
1
5
2
3
3
0
4
2
5
3
6
0
7
3
8
B
1 2 3 4 5 6
3
7 8
1 2 3 4 5 0
0 2 3 0 3 5 2
C 2
1
2
2
4
3
7
4
7
5
0
0
Analyse von Counting-Sort (1)
( )
[ ]
[ ]
[ ] [ ] [ ] [ ]
[ ]
[ ] [ ] [ ]
[ ] . Wert mit in te der Elemen Anzahl enthlt . 8
1 7.
1 6.
1 4.
1 . 3
0 2.
0 . 1
Sort - Counting
i A i C
i C i C i C
k i
i A i C
j A C j A C
A length j
i C
k i
A,B,k
do
to for
do
to for
do
to for

>
>
[ ]
[ ]
[ ] [ ] [ ] [ ]
[ ] [ ] [ ] [ ] 1 . 11
B . 10
1 . 9

j A C j A C
j A j A C
A length j
i A i C
do
downto for
>
Zeilen 1-2, 6-7: jeweils O(k)
Zeilen 3-4, 9-11: jeweils O(n)
Analyse von Counting-Sort (2)
Satz 9.1: Counting-Sort besitzt Laufzeit O(n+k).
Korollar 9.2: Gilt k= O(n), so besitzt Counting-Sort
Laufzeit O(n).
10. Elementare Datenstrukturen
Definition 10.1: Eine Datenstruktur ist gegeben durch eine
Menge von Objekten sowie einer Menge von Opera-
tionen auf diesen Objekten.
Operation 1
5 2
3
Operation 2
Operation 3
1
7
3
8
10. Elementare Datenstrukturen
Definition 10.1: Eine Datenstruktur ist gegeben durch eine
Menge von Objekten sowie einer Menge von Opera-
tionen auf diesen Objekten.
Definition 10.2:
1. Werden auf einer Menge von Objekten die
Operationen Einfgen, Entfernen und Suchen
betrachtet, so spricht man von einem Wrterbuch
betrachtet, so spricht man von einem Wrterbuch
(engl. Dictionary).
2. Werden auf einer Menge von Objekten die
Operationen Einfgen, Entfernen und Suchen des
Maximums (Minimums) betrachtet, so spricht man
von einer Warteschlange (engl. Priority Queue).
Datenstrukturen
Ein grundlegendes Datenbank-Problem
Speicherung von Datenstzen
Beispiel:
Kundendaten (Name, Adresse, Wohnort, Kundennummer,
offene Rechnungen, offene Bestellungen,)
offene Rechnungen, offene Bestellungen,)
Anforderungen:
Schneller Zugriff
Einfgen neuer Datenstze
Lschen bestehender Datenstze
Datenstrukturen
Zugriff auf Daten:
Jedes Objekt hat einen Schlssel
Eingabe des Schlssels liefert Datensatz
Schlssel sind vergleichbar (es gibt totale Ordnung der
Schlssel)
Beispiel:
Kundendaten (Name, Adresse, Kundennummer)
Schlssel: Name
Totale Ordnung: Lexikographische Ordnung
Datenstrukturen
Zugriff auf Daten:
Jedes Objekt hat einen Schlssel
Eingabe des Schlssels liefert Datensatz
Schlssel sind vergleichbar (es gibt totale Ordnung der
Schlssel)
Beispiel:
Kundendaten (Name, Adresse, Kundennummer)
Schlssel: Kundennummer
Totale Ordnung:
Elementare Operationen
Insert(S,x): Fge Objekt x in Menge S ein.
Search(S,k): Finde Objekt x mit Schlssel k. Falls kein
solches Objekt vorhanden Ausgabe NIL
Remove(S,x): Entferne Objekt x aus Menge S.
Minimum(S): Finde Objekt mit minimalem Schlssel in
S (es muss eine Ordnung auf Schlsseln existieren).
Maximum(S): Finde Objekt mit maximalem Schlssel in
S (es muss eine Ordnung auf Schlsseln existieren).
Unsere erste Datenstruktur:
Array A[1,,max]
Integer n, 1 n max
n bezeichnet Anzahl Elemente in Datenstruktur
Datenstrukturen
7
13 7 11 6 4 nil nil nil
n
A
Insert(s)
1. if n=max then return Fehler: Kein Platz in Datenstruktur
2. else
3. n n+1
4. A[n] s
Datenstrukturen
8
4. A[n] s
13 7 11 6 4 nil nil nil
n
A
Insert(s)
2. else
3. n n+1
4. A[n] s
Datenstrukturen
9
4. A[n] s
13 7 11 6 4 nil nil nil
n
A
Insert(2)
Insert(s)
2. else
3. n n+1
4. A[n] s
Datenstrukturen
10
4. A[n] s
13 7 11 6 4 nil nil nil
n
A
Insert(2)
Insert(s)
2. else
3. n n+1
4. A[n] s
Datenstrukturen
11
4. A[n] s
13 7 11 6 4 nil nil nil
n
A
Insert(2)
Insert(s)
2. else
3. n n+1
4. A[n] s
Datenstrukturen
12
4. A[n] s
13 7 11 6 4 2 nil nil
n
A
Insert(2)
Insert(s)
2. else
3. n n+1
4. A[n] s
Datenstrukturen
SS 2011 13
4. A[n] s
Laufzeit: (1)
13 7 11 6 4 2 nil nil
n
A
DuA - Kapitel 10 13
Search(x)
1. for i 1 to n do
3. if A[i] = x then return i
4. return nil
Datenstrukturen
14
13 7 11 6 4 2 nil nil
n
A
Search(x)
1. for i 1 to n do
4. return nil
Datenstrukturen
15
13 7 11 6 4 2 nil nil
n
A
Search(11)
Search(x)
1. for i 1 to n do
4. return nil
Datenstrukturen
16
13 7 11 6 4 2 nil nil
n
A
Search(11)
i
Search(x)
1. for i 1 to n do
4. return nil
Datenstrukturen
17
13 7 11 6 4 2 nil nil
n
A
Search(11)
i
Search(x)
1. for i 1 to n do
4. return nil
Datenstrukturen
18
13 7 11 6 4 2 nil nil
n
A
Search(11)
i
Search(x)
1. for i 1 to n do
4. return nil
Datenstrukturen
19
13 7 11 6 4 2 nil nil
n
A
Search(11)
i=3
Search(x)
1. for i 1 to n do
4. return nil
Datenstrukturen
20
Laufzeit: (n)
13 7 11 6 4 2 nil nil
n
A
Remove(i)
1. A[i] A[n]
2. A[n] nil
3. n n-1
Datenstrukturen
21
13 7 11 6 4 2 nil nil
n
A
Remove(i)
1. A[i] A[n]
2. A[n] nil
3. n n-1
Annahme:
Wir bekommen
Index i des zu
lschenden
Objekts
Datenstrukturen
22
13 7 11 6 4 2 nil nil
n
A
Remove(i)
1. A[i] A[n]
2. A[n] nil
3. n n-1
Datenstrukturen
23
13 7 11 6 4 2 nil nil
n
A
Remove(3)
Remove(i)
1. A[i] A[n]
2. A[n] nil
3. n n-1
Datenstrukturen
24
13 7 11 6 4 2 nil nil
n
A
Remove(3)
Remove(i)
1. A[i] A[n]
2. A[n] nil
3. n n-1
Datenstrukturen
25
13 7 2 6 4 2 nil nil
n
A
Remove(3)
Remove(i)
1. A[i] A[n]
2. A[n] nil
3. n n-1
Datenstrukturen
26
13 7 2 6 4 nil nil nil
n
A
Remove(3)
Remove(i)
1. A[i] A[n]
2. A[n] nil
3. n n-1
Datenstrukturen
27
n
A
Remove(3)
Remove(i)
1. A[i] A[n]
2. A[n] nil
3. n n-1
Datenstrukturen
SS 2011 28
Laufzeit:
n
A
(1)
DuA - Kapitel 10 28
Datenstruktur Feld:
Platzbedarf (max)
Laufzeit Suche: (n)
Laufzeit Einfgen/Lschen: (1)
Vorteile:
Datenstrukturen
29
Vorteile:
Schnelles Einfgen und Lschen
Nachteile:
Speicherbedarf abhngig von max (nicht vorhersagbar)
Hohe Laufzeit fr Suche
Im folgenden: w=max.
Operationen: new (fordere Speicher an) und delete (gib
Speicher frei)
Erste Idee:
Jedesmal, wenn Feld A nicht mehr ausreicht (n>w),
generiere neues Feld der Gre w+c fr ein festes c.
Dynamisches Feld
generiere neues Feld der Gre w+c fr ein festes c.
A[1] A[2] A[3] A[4] A[w] .
A[1] A[2] A[3] A[4] A[w] . A[w+1] A[w+c] .
Umkopieren in neues Feld
andere Variablen
Zeitaufwand fr Erweiterung ist (w):
A[1] A[2] A[3] A[4] A[w] .
A[1] A[2] A[3] A[4] A[w] . A[w+1] A[w+c] .
Umkopieren in neues Feld
Dynamisches Feld
Zeitaufwand fr n Insert Operationen:
Aufwand von (w) je c Operationen
Gesamtaufwand: (
i=1
n/c
ci) = (n
2
)
A[1] A[2] A[3] A[4] A[w] . A[w+1] A[w+c] .
Bessere Idee:
Jedesmal, wenn Feld A nicht mehr ausreicht
(n>w), generiere neues Feld der doppelten
Gre 2w.
A[1] A[2] A[3] A[4] A[w] .
Dynamisches Feld
Jedesmal, wenn Feld A zu gro ist (nw/4),
generiere neues Feld der halben Gre w/2.
A[1] A[2] A[3] A[4] A[w] .
A[1] A[2] A[3] A[4] A[w]+1 . A[w] A[2w] .
Seien =1/4 und =2.
Insert(e):
if n=w then
1 2 3 4 A
n=w=4:
Dynamisches Feld
if n=w then
Areallocate(A,n)
nn+1
A[n]e
1 2 3 4 A
1 2 3 e A 4
Seien =1/4 und =2.
Remove(i):
A[i]A[n]
n=5, w=16:
Dynamisches Feld
A[i]A[n]
A[n]nil
nn-1
if nw and n>0 then
Areallocate(A,n)
1 2 3 5 A
1 2 3 A 4
4
reallocate(A,w):
ww
Anew Array[1..w] of Element
for i1 to n do
Dynamisches Feld
for i1 to n do
A[i] A[i]
delete A
return A
Umkopieren
}
Lemma 10.3: Betrachte ein anfangs leeres
dynamisches Feld A. Jede Folge von n Insert
und Remove Anfragen kann auf A in Zeit O(n)
bearbeitet werden.
Dynamisches Feld
Erste Idee: Laufzeit O(n
2
)
Genauer: Im worst case nur durchschnittlich
konstante Laufzeit pro Operation
(Fachbegriff dafr: amortisiert)
Feldverdopplung:
Feldhalbierung:
1 2 3 4 A 1 2 3 4 A
Amortisierte Analyse
Von
Nchste Verdopplung: n Insert Operationen
Nchste Halbierung: n/2 Remove Ops
1 2 3 A 4
1 2 3 4 A
Von
Nchste Verdopplung: n Insert Ops
Nchste Halbierung: n/2 Remove Ops
1 2 3 4 A
Idee: verrechne reallocate-Kosten mit
Insert/Remove Kosten (ohne realloc)
Kosten fr Insert/Remove: O(1)
Kosten fr reallocate(n): O(n)
Insert/Remove Kosten
Formale Verrechnung: Zeugenzuordnung
Insert Insert Insert Insert Insert + realloc
Reallokation bei n Elementen: bezeugt durch letzte n/2 Insert Operationen
Formale Verrechnung: Zeugenzuordnung
Insert Insert Insert Insert Insert + realloc
Reallokation bei n Elementen: bezeugt durch letzte n/2 Insert Operationen
Dann jede Ins/Rem Op nur 1x Zeuge
Remove Remove Remove Remove Remove + realloc
Reallokation bei n Elementen: bezeugt durch letzte n Remove Operationen
Insert/Remove Kosten
Konkret:
Konkret:
(n) Zeugen pro reallocate(n)
verteile O(n) Aufwand gleichmig auf
Zeugen
Gesamtaufwand: O(m) bei m Operationen
Alternative zur Zeugenmethode:
Kontenmethode
Kontenmethode: Spiel mit Zeittokens
Gnstige Operationen zahlen Tokens ein
Teure Operationen entnehmen Tokens
Tokenkonto darf nie negativ werden!
Gnstige Operationen zahlen Tokens ein
pro Insert 2 Tokens
pro Remove 1 Token
Teure Operationen entnehmen Tokens
pro reallocate(n) n Tokens
Tokenkonto darf nie negativ werden!
erfllt ber Zeugenargument
Laufzeit ber Zeittoken:
Ausfhrung von Insert/Remove kostet 1 Token
Tokenkosten fr Insert: 1+2 = 3
Tokenkosten fr Remove: 1+1 = 2
Ausfhrung von reallocate(n) kostet n Tokens

Tokenkosten fr reallocate(n): n-n=0
Gesamtlaufzeit = O(Summe der Tokenlaufzeiten)
Insert Insert Insert Insert
reallocate
Wir haben schon kennengelernt:
Zeugenmethode
Kontenmethode
Im folgenden:
allgemeine Herangehensweise
Potentialmethode
S: Zustandsraum einer Datenstruktur
F: beliebige Folge von Operationen Op
1
,
Op
2
, Op
3
,,Op
n
s
0
: Anfangszustand der Datenstruktur
s
0
: Anfangszustand der Datenstruktur
Zeitaufwand T(F) =
i=1
n
T
Op
i
(s
i-1
)
s
0
Op
1 s
1
Op
2 s
2
Op
3 s
n
Op
n .
Zeitaufwand T(F) =
i=1
n
T
Op
i
(s
i-1
)
Eine Familie von Funktionen A
X
(s), eine pro
Operation X, heit Familie amortisierter
Zeitschranken falls fr jede Sequenz F von
Operationen gilt
Operationen gilt
T(F) A(F) := c +
i=1
n
A
Op
i
(s
i-1
)
fr eine Konstante c unabhngig von F
D.h. amortisierter Zeitaufwand einer Operation Op:
durchschnittlicher Aufwand von Op im worst case.
Triviale Wahl von A
X
(s):
A
X
(s) := T
X
(s)
Dynamisches Feld (Zeittoken gen. gro):
A
Insert
(s):=3, A
Remove
(s):=2, A
rellocate
(s):=0
A
Insert
(s):=3, A
Remove
(s):=2, A
rellocate
(s):=0
alternative Wahl von A
X
(s):
ber Potential :S
0
vereinfacht Beweisfhrung
1 2 3 4 A
1 2 3 4 A
1 2 3 4 A
5
5 6
1 2 3 4 A 5 6 7
(s)=0
(s)=2
(s)=4
(s)=6
reallocate
+
Insert
Beispiel: Dynamisches Feld
1 2 3 4 A 5 6 7
1 2 3 4 A 5 6 7 8
1 2 3 5 A 4 6 7 8
(s)=6
(s)=8
(s)=0
1 2 3 5 A 4 6 7 7 9
(s)=2
reallocate
+
Insert
1 2 3 4 A
(s)=0
1 2 3 A
(s)=2
1 2 A
(s)=4
Remove
+
reallocate (s)=0
1 2 A
reallocate (s)=0
Generelle Formel fr (s):
(w
s
: Feldgre von A, n
s
: Anzahl Eintrge)
(s) = 2|w
s
/2 n
s
|
Potential ist nicht gleich Konto!
1 2 3 4 A
(s)=0
1 2 3 A
(s)=2
1 2 3 4 A
(s)=0
Insert
Remove
1 2 3 4 A
(s)=0
1 2 3 4 A
Konto(s)=0
1 2 3 A
1 2 3 4 A
Insert
Remove
Konto(s)=1
Konto(s)=3
Satz 10.4: Sei S der Zustandsraum einer
Datenstruktur, sei s
0
der Anfangszustand
und sei :S
0
eine nichtnegative
Funktion. Fr eine Operation X und einen
Zustand s mit ss definiere
Zustand s mit ss definiere
A
X
(s) := T
X
(s) + ((s) - (s)).
Dann sind die Funktionen A
X
(s) eine
Familie amortisierter Zeitschranken.
Zu zeigen: T(F) c +
i=1
n
A
Op
i
(s
i-1
)
Beweis:
i=1
n
A
Op
i
(s
i-1
) =
i=1
n
[T
Op
i
(s
i-1
) + (s
i
) - (s
i-1
)]
= T(F) +
i=1
n
[(s
i
) - (s
i-1
)]
= T(F) +
i=1
[(s
i
) - (s
i-1
)]
= T(F) + (s
n
) - (s
0
)
T(F) =
i=1
n
A
Op
i
(s
i-1
) + (s
0
) - (s
n
)

i=1
n
A
Op
i
(s
i-1
) + (s
0
)
konstant
Formel fr (s):
(w
s
: Feldgre von A in Zustand s,
n
s
: Anzahl Eintrge)
(s) = 2|w
s
/2 n
s
|
Satz 3.3:
Satz 3.3:
Sei = (s)-(s) fr ss
nicht negativ, (s
0
)=1
A
Insert
(s) = + T
Insert
(s) 2+1 = 3
A
Remove
(s) = + T
Remove
(s) 2+1 = 3
A
realloc
(s) = + T
realloc
(s) (0-n
s
)+n
s
= 0
Beweis fr A
realloc
(s) 0:
Fall 1:
1 2 b 1 2 3 4 b 3 4
(s)=n
s
(s)=0
Fall 2:
(s)=n
s
(s)=0
1 2 b 1 2 b
(s)=2n
s
(s)=0
Die Potentialmethode ist universell!
Satz 10.5: Sei B
X
(s) eine beliebige Familie
amortisierter Zeitschranken. Dann gibt es eine
Potentialfunktion , so dass A
X
(s) B
X
(s) fr
X X
alle Zustnde s und alle Operationen X gilt,
wobei A
X
(s) definiert ist wie in Satz 10.4.
Problem: finde geeignetes Potential!
Wenn erstmal gefunden, dann Rest einfach.
Datenstruktur Dynamisches Feld:
Platzbedarf (n)
Laufzeit Suche: (n)
Amortisierte Laufzeit Einfgen/Lschen: (1)
Vorteile:
Datenstrukturen
Kann durch Tricks (progressives Umkopieren) in
worst case Laufzeit O(1) umgewandelt werden.
57
Vorteile:
Schnelles Einfgen und Lschen
Speicherbedarf abhngig von n
Nachteile:
worst case Laufzeit O(1) umgewandelt werden.
Warum nicht sortiertes Feld?
Mit sortiertem Feld binre Suche mglich.
Datenstrukturen
Im n-elementigen sortierten Feld wird jedes
Element in max. log n Schritten gefunden.
1 15 23 27 31 39 42 55 58 62 84 85 90 91 98
Datenstruktur Sortiertes Dynamisches Feld:
Platzbedarf (n)
Laufzeit Suche: (log n)
Laufzeit Einfgen/Lschen: (n)
Grund: Folge muss auseinander (beim Einfgen) oder
zusammen (beim Lschen) geschoben werden, was
Datenstrukturen
59
zusammen (beim Lschen) geschoben werden, was
(n) Laufzeit verursachen kann.
1 3 4 6 8 9 12
1 3 4 6 8 9 12 7
Insert(7)
Kann man Insert und Remove besser mit
einem sortierten Feld realisieren?
folge Beispiel der Bibliothek!
Sortiertes Feld
Bibliotheksprinzip: lass Lcken!
Angewandt auf sortiertes Feld:
1 3 10 14 19
Sortiertes Feld
Insert(5)
Remove(14)
1 3 5 14 19 10
1 3 5 19 10
Durch geschickte Verteilung der Lcken:
amortierte Kosten fr insert und remove (log
2
n)
Analyse allerdings komplex!
1 3 10 14 19
Sortiertes Feld
Insert(5)
Remove(14)
1 3 5 14 19 10
1 3 5 19 10
Datenstruktur Sortiertes Dynamisches Feld mit
Lcken:
Platzbedarf (n)
Laufzeit Suche: (log n)
Amortisierte Laufzeit Einfgen/Lschen: (log
2
n)
Datenstrukturen
63
Noch bessere Laufzeiten mglich mit geeigneten
Zeigerstrukturen.
Stacks (Stapel) und Queues (Schlangen)
Definition 10.5:
1. Stacks (Stapel) sind eine Datenstruktur, die die LIFO (last-in-
first-out) Regel implementiert.
Bei der LIFO Regel soll das zuletzt eingefgte Objekt entfernt
werden.
2. Queues (Schlangen) sind eine Datenstruktur, die die FIFO (first-
in-first-out) Regel implementiert.
Bei der FIFO Regel soll das am lngsten in der Menge
befindliche Objekt entfernt werden.
Stacks
Einfgen eines Objekts wird bei Stacks Push genannt.
Entfernen des zuletzt eingefgten Objekts wird Pop
genannt.
Zustzliche Hilfsoperation ist Stack-Empty, die ber-
prft, ob ein Stack leer ist.
prft, ob ein Stack leer ist.
Stack mit maximal n Objekten wird realisiert durch
ein Array S[1n] mit einer zustzlichen Variablen
top[S], die den Index des zuletzt eingefgten Objekts
speichert.
Stack - Beispiel
Objekte sind hier natrliche Zahlen.
Stack kann dann wie folgt aussehen:
15 6 2 9
[ ] 4 = S top
Stack - Operationen
( )
[ ]
FALSE 3.
TRUE 2.
0 1.
Empty - Stack
return else
return then
if = S top
S
( )
[ ] [ ]
x S, Push ( ) Pop S
( )
[ ] [ ]
[ ] [ ] x S 2.
1 1.
x S, Push
+
S top
S top S top
( )
[ ] [ ]
[ ] [ ] 1 4.
1 3.
underflow" " 2.
Empty Stack 1.
Pop
+

S top S
S top S top
S
return
else
error then
if
Satz 10.6: Mit Stacks kann die LIFO Regel in Zeit
O(1) ausgefhrt werden.
Illustration der Stackoperationen
15 6 2 9
[ ] 4 = S top
15 6 2 9 17 3
15 6 2 9 17 3
[ ] 6 = S top
Nach Push(S,17), Push(S,3):
15 6 2 9 17 3
[ ] 5 = S top
Nach Pop(S):
Queues
Einfgen eines Objekts wird Enqueue genannt.
Entfernen des am lngsten in der Queue befindlichen
Objekts wird Dequeue genannt.
Queue mit maximal n-1 Objekten wird realisiert durch ein
Feld Q[1n] mit zustzlichen Variablen head[Q], tail[Q].
head[Q]: Position des am lngsten in Queue befindlichen
Objekts
tail[Q]: erste freie Position.
Alle Indexberechnungen modulo n (+1), betrachten Array
kreisfrmig. Auf Position n folgt wieder Position 1.
Queue - Beispiele
15 6 9 8 4
[ ] 7 = Q head [ ] 12 = Q tail
15 6 9 8 4 17
[ ] 7 = Q head
5 3
[ ] 3 = Q tail
Queue - Operationen
( )
[ ] [ ]
[ ] [ ]
[ ]
[ ] [ ]

1 4.
1 3.
2.
1.
Enqueue
+
Q tail Q tail
Q tail
Q length Q tail
x Q tail Q
x , Q
else
then
if
( )
[ ] [ ]
[ ] [ ]
[ ]
[ ] [ ]

x 5.
1 4.
1 3.
2.
x 1.
Dequeue
return
else
then
if
+
Q head Q head
Q head
Q length Q head
Q head Q
Q
Illustration Enqueue
15 6 9 8 4
[ ] 7 = Q head [ ] 12 = Q tail
15 6 9 8 4 17
[ ] 7 = Q head
5 3
[ ] 3 = Q tail
Nach Enqueue(Q,17), Enqueue(Q,3), Enqueue(Q,5):
Illustration Dequeue
15 6 9 8 4 17
[ ] 7 = Q head
5 3
[ ] 3 = Q tail
15 6 9 8 4 17
[ ] 8 = Q head
5 3
[ ] 3 = Q tail
Nach Dequeue:
Laufzeit Queue-Operationen
Satz 10.7: Mit Queues kann die FIFO Regel in Zeit
O(1) ausgefhrt werden.
Problem: ein statisches Feld kann nur begrenzt viele
Elemente speichern
Lsungsmglichkeiten:
Verwende ein dynamisches Feld wie oben angegeben.
Dann sind die amortisierten Laufzeiten der Operationen
nach wie vor konstant.
Verwende Zeigerstrukturen.
Objekte, Referenzen, Zeiger
Zugriff auf Objekte erfolgt in der Regel durch
Referenzen oder Verweise auf Objekte wie in Java.
In Sprachen wie C und C++ realisiert durch Zeiger,
engl. Pointer.
Zeiger/Pointer Notation aus Introduction to Algorithms.
Verwenden Referenzen, Zeiger, Verweise synonym.
Verweise zeigen oder verweisen oder referenzieren
auf Objekte.
Doppelt verkettete Listen
Verkettete Listen bestehen aus einer Menge von
Objekten, die ber Verweise linear verkettet sind.
Objekte in doppelt verketteter Liste L besitzen
mindestens drei Felder: key, next, prev. Auerdem
sind Felder fr Satellitendaten mglich.
Zugriff auf Liste L durch Verweis/Zeiger head[L].
head[L] 9 / 16 1 / 4
key
prev next
prev=NIL
Verkettete Listen bestehen aus einer Menge von
Objekten, die ber Verweise linear verkettet sind.
Objekte in doppelt verketteter Liste L besitzen
mindestens drei Felder: key, next, prev. Auerdem
sind Felder fr Satellitendaten mglich.
Zugriff auf Liste L durch Verweis/Zeiger head[L].
Knnen alle dynamischen Mengen mit den Operationen
Insert, Remove, Search, Search-Minimum, usw unterstt-
zen. Aber Untersttzung ist nicht unbedingt effizient.
head[L] verweist auf erstes Element der Liste L.
x Objekt in Liste L: next[x] verweist auf nchstes
Element in Liste, prev[x] verweist auf voriges
Element in Liste.
prev[x]=NIL: x besitzt keinen Vorgnger. Dann ist x
prev[x]=NIL: x besitzt keinen Vorgnger. Dann ist x
erstes Element der Liste und head[L] verweist auf x.
next[x]=NIL: x besitzt keinen Nachfolger. Dann ist x
letztes Element der Liste.
head[L]=NIL: Liste L ist leer.
Interne Darstellung
head[L] 9 / 16 1 / 4
Intern: linear adressierbarer Speicher
Abstrakt: verkettete Liste
9 / 16 head[L]
Intern: linear adressierbarer Speicher
867 Adressen:
Inhalte:
1523 1280
1523 2846
NIL
1280
Interne Darstellung
head[L] 9 / 16 1 / 4
head[L] NIL: Liste noch da, aber nicht mehr ber
head[L] erreichbar.
9 / 16 head[L]
head[L] erreichbar.
867 Adressen:
Inhalte:
1523 1280
NIL
2846 1280
NIL
Interne Darstellung
head[L] 9 / 16 1 / 4
delete head[L]: Speicherplatz des Elements, auf das
head[L] zeigt, wird freigegeben.
16 head[L]
867 Adressen:
Inhalte:
1523 1280
1523
2846
NIL
1280
9 /
Interne Darstellung
head[L] 9 / 16 1 / 4
delete head[L]: Speicherplatz des Elements, auf das
16 head[L]
867 Adressen:
Inhalte:
1280
1523
2846
Interne Darstellung
head[L] 9 / 16 1 / 4
delete next[head[L]]: Speicherplatz des Elements, auf
das next[head[L]] zeigt, wird freigegeben.
head[L]
867 Adressen:
Inhalte:
1523 1280
NIL
2846
NIL
1280
9 / 16
Interne Darstellung
head[L] 9 / 16 1 / 4
delete next[head[L]]: Speicherplatz des Elements, auf
head[L]
867 Adressen:
Inhalte:
1523
NIL NIL 1280
9 /
Interne Darstellung
head[L] 9 / 16 1 / 4
new head[L]: Speicherplatz fr neues Element wird
angelegt und head[L] darauf verwiesen.
head[L]
867 Adressen:
Inhalte:
1523
1523 NIL 1280
9 /
Interne Darstellung
head[L] 9 / 16 1 / 4
new head[L]: Speicherplatz fr neues Element wird
head[L]
867 Adressen:
Inhalte:
1523 1430
1430 NIL 1280
9 /
Zeigervariablen
head[L] 9 / 16 1 / 4
Rot: Zeigervariablen
prev next
x y
Zeigervariablen sind wie Schattenvariablen, d.h. sie
stehen stellvertretend fr die Objekte, auf die sie
zeigen.
key[head[L]]: 9
next[head[L]]: y
prev[next[head[L]]]: x
Allokation und Deallokation von Speicher
new ZeigerVar:
Befehle: new ZeigerVar, delete ZeigerVar
ZeigerVar ZeigerVar
delete ZeigerVar:
ZeigerVar ZeigerVar
Vorsicht! Adresse noch in ZeigerVar, aber
Speicher fr Objekt wieder freigegeben.
Varianten verketteter Listen
Einfach verkettete Listen: Feld prev nicht vorhanden.
head[L] 9 16 1 / 4
key next
Sortierte verkettete Liste: Reihenfolge in Liste entspricht
sortierter Reihenfolge der Schlssel.
zykisch/kreisfrmig verkettete Listen: next des letzten
Objekts zeigt auf erstes Objekt. prev des ersten
Objekts zeigt auf letztes Objekt.
Doppelt verkettete Listen - Beispiel
head[L] 9 / 16 1 / 4
Schlssel
prev next
head[L] 9 16 1 4
zyklisch doppelt verkette Liste:
List-Insert(L,x)
1. next[x] head[L]
2. if head[L] nil then prev[head[L]] x
3. head[L] x
4. prev[x] nil
x: Zeigervariable, die Adresse des
einzufgenden Elements bergeben
bekommt.
91
4. prev[x] nil
nil 7 4 nil
head[L]
List-Insert(L,x)
1. next[x] head[L]
3. head[L] x
4. prev[x] nil
92
4. prev[x] nil
nil 7 4 nil
head[L]
5
x
List-Insert(L,x)
1. next[x] head[L]
3. head[L] x
4. prev[x] nil
93
4. prev[x] nil
7 4 nil
head[L]
5
x
List-Insert(L,x)
1. next[x] head[L]
3. head[L] x
4. prev[x] nil
94
4. prev[x] nil
7 4 nil
head[L]
5
x
List-Insert(L,x)
1. next[x] head[L]
3. head[L] x
4. prev[x] nil
95
4. prev[x] nil
7 4 nil
head[L]
nil 5
x
List-Remove(L,x)
1. if prev[x] nil then next[prev[x]] next[x]
2. else head[L] next[x]
3. if next[x] nil then prev[next[x]] prev[x]
96
7 4 nil
head[L]
nil 5
List-Remove(L,x)
x: zeigt auf zu lschendes Objekt
97
7 4 nil
head[L]
nil 5
x
List-Remove(L,x)
98
7
4 nil
head[L]
nil 5
x
List-Remove(L,x)
99
7
4 nil
head[L]
nil 5
x
List-Search(L,k)
1. x head[L]
2. while xnil and key[x]k do
3. x next[x]
4. return x
100
4. return x
4 nil
head[L]
nil 5
List-Search(L,k)
1. x head[L]
3. x next[x]
4. return x
101
4. return x
4 nil
head[L]
nil 5
Suche(L,4)
x
List-Search(L,k)
1. x head[L]
3. x next[x]
4. return x
102
4. return x
4 nil
head[L]
nil 5
Suche(L,4)
x
List-Search(L,k)
1. x head[L]
3. x next[x]
4. return x
103
4. return x
4 nil
head[L]
nil 5
Suche(L,4)
x
List-Search(L,k)
1. x head[L]
3. x next[x]
4. return x
104
4. return x
4 nil
head[L]
nil 5
Suche(L,4)
x
List-Search(L,k)
1. x head[L]
3. x next[x]
4. return x
105
4. return x
4 nil
head[L]
nil 5
Suche(L,4)
x
Einfgen in verkettete Liste
( )
[ ] [ ]
[ ]
[ ] [ ]
[ ]
[ ] NIL 5
4
3
NIL 2.
next 1
Insert - List
x prev .
x L head .
x L head prev .
L head
L head x .
L,x

then
if
Lemma 10.8: List-Insert erfordert Zeit (1).
Lschen aus verketteter Liste
( )
[ ]
[ ] [ ] [ ]
[ ] [ ]
[ ]
[ ] [ ] [ ] x prev x next prev
x next
x next L head
x next x prev next
x prev
L,x
5.
NIL if . 4
else . 3
. 2
NIL . 1
Remove - List
then

then
if
[ ] [ ] [ ] x prev x next prev 5. then
Lemma 10.9: List-Remove erfordert Zeit (1).
Durchsuchen einer verketteten Liste
( )
[ ]
[ ]
[ ]
x .
x next x .
k x key NIL x
L head x .
L,k
4
3
2.
1
Search - List
return
do
while

Lemma 10.10: List-Search erfordert bei einer Liste mit
n Elementen Zeit (n).
Datenstruktur Liste:
Platzbedarf (n)
Laufzeit Suche: (n)
Vorteile:
109
Vorteile:
Schnelles Einfgen/Lschen
O(n) Speicherbedarf
Nachteile:
Vereinfachung durch Sentinels (Wchter)
Vermeidung von Abfragen head[L] NIL und x NIL
durch Einfgen eines zustzlichen dummy Objekts.
dummy besitzt drei Felder key, prev, next, aber
key[dummy]= NIL.
next[dummy] verweist auf erstes (richtiges) Objekt in Liste.
prev[dummy] verweist auf letztes Objekt in Liste.
Wir ersetzen in Pseudocode NIL durch dummy.
head[L] zeigt jetzt auf dummy Objekt.
Dummy Objekt zur Vereinfachung von Randbedingungen
wird Sentinel oder Wchter genannt.
Liste ohne Sentinel
head [L] 9 / 16 1 / 4
25 / 9 16 4 1 /
Nach List-Insert(L,x), wobei key [x]=25:
head [L]
25 / 9 16 4 1 / head [L]
25 / 9 1 / 16
Nach List-Remove(L,x), wobei key [x]=4:
head [L]
Zyklisch verkette Liste mit Sentinel
head[L]
9 / 16 1 4
head[L]
dummy
25 / 9 4 16 head[L] 1
25 / 9 1 16
head[L]
Durchsuchen verketteter Liste (mit Sentinel)
( )
[ ] [ ]
[ ] [ ]
[ ]
x
x next x
k x key L head x
L head next x
L,k
. 4
. 3
2.
. 1
Search - List
return
do
while

x . 4 return
Einfgen in verkettete Liste (mit Sentinel)
( )
[ ] [ ] [ ]
[ ] [ ]
[ ] [ ]
[ ] [ ] L head x prev
x L head next
x L head next prev
L head next x next
L,x
. 4
. 3
] [ 2.
. 1
Insert - List
[ ] [ ] L head x prev . 4
Lschen aus verketteter Liste (mit Sentinel)
( )
[ ] [ ] [ ]
[ ] [ ] [ ] x prev x next prev
x next x prev next
L,x
2.
. 1
Remove - List
Platzbedarf (n)
Laufzeit Suche: (n)
Vorteile:
116
O(n) Speicherbedarf
Nachteile:
Besser: Verkettung der Elemente als Baum
Binre Bume
Neben Felder fr Schlssel und Satellitendaten
Felder p, left, right.
x Knoten: p[x] Verweis auf Elternknoten, left[x] Verweis
auf linkes Kind, right[x] Verweis auf rechtes Kind.
Falls p[x]=NIL, dann ist x Wurzel des Baums.
left[x] / right[x]=NIL: kein linkes/rechtes Kind.
Zugriff auf Baum T durch Verweis root[T] auf Wurzel-
knoten.
Binre Bume - Illustration
/
/
/
/
root[T]
/ /
/
/ /
/
/ /
/ / /
Allgemeine Bume
Darstellung fr binre Bume auch mglich fr k-nre
Bume, k fest.
Ersetze left[x]/right[x] durch child1[x],..,childk[x].
Bei Bumen mit unbeschrnktem Grad nicht mglich,
oder ineffizient, da Speicher fr viele Felder reserviert
oder ineffizient, da Speicher fr viele Felder reserviert
werden muss.
Nutzen linkes-Kind/rechtes-Geschwister- Darstellung.
Feld p fr Eltern bleibt. Dann Feld left-child fr linkes
Kind und Feld right-sibling fr rechtes Geschwister.
Allgemeine Bume - Illustration
/
/
/ /
root[T]
/
/ / /
/ / / / /
Platzbedarf (n)
Laufzeit Suche: (n)
Vorteile:
1
Vorteile:
O(n) Speicherbedarf
Nachteile:
Binre Suchbume
Verwende Binrbaum
Speichere Schlssel geordnet
Binre Suchbaumeigenschaft:
11: Binre Suchbume
2
Binre Suchbaumeigenschaft:
Sei x Knoten im binren Suchbaum
Ist y Knoten im linken Unterbaum von x, dann gilt
key[y]key[x]
Ist y Knoten im rechten Unterbaum von x, dann gilt
key[y]key[x]
Unterschiedliche Suchbume
Beispiel: Schlsselmenge 4,6,7
Binre Suchbume
6
4
7
4
6
7
Sortierte Ausgabe aller Schlssel
Gegeben binrer Suchbaum
Wie kann man alle Schlssel aufsteigend sortiert in (n)
Zeit ausgeben?
6
Binre Suchbume
4
6
4
3
7
7
9
Inorder-Tree-Walk(x)
1. if xnil then
2. Inorder-Tree-Walk(lc[x])
3. Ausgabe key[x]
4. Inorder-Tree-Walk(rc[x])
6
Binre Suchbume
5
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Aufruf ber
Inorder-Tree-Walk(root[T])
Binre Suchbume
6
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Binre Suchbume
7
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Binre Suchbume
8
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Binre Suchbume
9
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Binre Suchbume
10
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Binre Suchbume
11
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Kein linkes Kind
Binre Suchbume
12
6
4
3
7
7
9
Kein linkes Kind
vorhanden, d.h.
lc[x]=nil
x
nil
1. if xnil then
3. Ausgabe key[x]
6
Kein linkes Kind
Binre Suchbume
13
6
4
3
7
7
9
Kein linkes Kind
vorhanden, d.h.
lc[x]=nil
x
nil
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3
Binre Suchbume
14
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3
Kein rechtes Kind
Binre Suchbume
15
6
4
3
7
7
9
Kein rechtes Kind
vorhanden, d.h.
rc[x]=nil
nil
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3
Kein rechtes Kind
Binre Suchbume
16
6
4
3
7
7
9
Kein rechtes Kind
vorhanden, d.h.
rc[x]=nil
nil
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3
Binre Suchbume
17
6
4
3
7
7
9
Knoten
abgearbeitet
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4
Binre Suchbume
18
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4
Binre Suchbume
19
6
4
3
7
7
9
nil
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4
Binre Suchbume
20
6
4
3
7
7
9
nil
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4
Binre Suchbume
21
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6
Binre Suchbume
22
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6
Binre Suchbume
23
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6
Binre Suchbume
24
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6
Binre Suchbume
25
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6
Binre Suchbume
26
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6
Binre Suchbume
27
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6
Binre Suchbume
28
6
4
3
7
7
9
nil
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7
Binre Suchbume
29
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7
Binre Suchbume
30
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6
Binre Suchbume
31
6
4
3
7
7
9
nil
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7
Binre Suchbume
32
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7, 7
Binre Suchbume
33
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7, 7
Binre Suchbume
34
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7, 7
Binre Suchbume
35
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7, 7
Binre Suchbume
36
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7, 7
Binre Suchbume
37
6
4
3
7
7
9
nil
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7, 7
Binre Suchbume
38
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7, 7, 9
Binre Suchbume
39
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7, 7, 9
Binre Suchbume
40
6
4
3
7
7
9
nil
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7, 7, 9
Binre Suchbume
41
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7, 7, 9
Binre Suchbume
42
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7, 7, 9
Binre Suchbume
43
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
6
Ausgabe:
3, 4, 6, 7, 7, 9
Binre Suchbume
44
6
4
3
7
7
9
1. if xnil then
3. Ausgabe key[x]
Laufzeit (n)
Quizfrage: Warum?
Binre Suchbume
Ausgabe:
3, 4, 6, 7, 7, 9
45
Ergebnis: aufsteigend sortierte Ausgabe der Schlssel
Beweis: Suchbaumeigenschaft + vollstndige Induktion
Quizfrage: Wie erreiche ich absteigend sortierte Ausgabe?
Quizfrage: Warum?
1. if xnil then
3. Ausgabe key[x]
Binre Suchbume
Ausgabe:
3, 4, 6, 7, 7, 9
46
Ergebnis: aufsteigend sortierte Ausgabe der Schlssel
Beweis: Suchbaumeigenschaft + vollstndige Induktion
Quizfrage: Warum kann ich keinen Suchbaum in O(n)
Zeit aufbauen?
Suchen in Binrbumen
Gegeben ist Schlssel k
Gesucht ist ein Knoten mit Schlssel k
Binre Suchbume
47 SS 2011 DuA - Kapitel 11 47
Baumsuche(x,k)
1. if x=nil or k=key[x] then return x
2. if k<key[x] then return Baumsuche(lc[x],k)
3. else return Baumsuche(rc[x],k)
Binre Suchbume
48
6
4
3
7
7
9
Baumsuche(x,k)
Aufruf mit
x=root[T]
Binre Suchbume
49
6
4
3
7
7
9
Baumsuche(root[T],9)
Baumsuche(x,k)
Binre Suchbume
50
6
4
3
7
7
9
Baumsuche(x,k)
Binre Suchbume
51
6
4
3
7
7
9
Baumsuche(x,k)
Binre Suchbume
52
6
4
3
7
7
9
Baumsuche(x,k)
Binre Suchbume
53
6
4
3
7
7
9
Baumsuche(x,k)
Binre Suchbume
54
6
4
3
7
7
9
Baumsuche(x,k)
Binre Suchbume
55
6
4
3
7
7
9
Baumsuche(x,k)
Binre Suchbume
56
6
4
3
7
7
9
Baumsuche(x,k)
Binre Suchbume
57
6
4
3
7
7
9
Ausgabe: 9
Baumsuche(x,k)
Binre Suchbume
58
6
4
3
7
7
9
Hhe h
Laufzeit: O(h)
Weitere Operationen in Binrbumen
Minimum/Maximumsuche
Nachfolger/Vorgnger
Binre Suchbume
Minimum- und Maximumsuche:
Minimum- und Maximumsuche:
Suchbaumeigenschaft:
Alle Knoten im rechten Unterbaum eines Knotens x sind
grer gleich key[x]
Alle Knoten im linken Unterbaum von x sind key[x]
MinimumSuche(x)
1. while lc[x]nil do x lc[x]
2. return x
Binre Suchbume
60
6
4
3
7
7
9
MinimumSuche(x)
2. return x
Binre Suchbume
61
6
4
3
7
7
9
x
MinimumSuche(x)
2. return x
Binre Suchbume
62
6
4
3
7
7
9
x
MinimumSuche(x)
2. return x
Binre Suchbume
63
6
4
3
7
7
9
x
MinimumSuche(x)
2. return x
Laufzeit O(h)
Binre Suchbume
64
6
4
3
7
7
9
x
MaximumSuche(x)
1. while rc[x]nil do x rc[x]
2. return x
Binre Suchbume
65
6
4
3
7
7
9
x
MaximumSuche(x)
2. return x
Binre Suchbume
66
6
4
3
7
7
9
x
MaximumSuche(x)
2. return x
Binre Suchbume
67
6
4
3
7
7
9
x
MaximumSuche(x)
2. return x
Binre Suchbume
68
6
4
3
7
7
9
x
MaximumSuche(x)
2. return x
Binre Suchbume
69
6
4
3
7
7
9
x
MaximumSuche(x)
2. return x
Laufzeit O(h)
Binre Suchbume
70
6
4
3
7
7
9
x
MaximumSuche(x)
2. return x
Laufzeit O(h)
Binre Suchbume
71
6
4
3
7
7
9
x
Nachfolgersuche:
Nachfolger bzgl. Inorder-Tree-Walk
Wenn alle Schlssel unterschiedlich, dann ist das der
nchstgrere Schlssel
Binre Suchbume
72
6
4
3
7
7
9
Nachfolgersuche:
Fall 1 (rechter Unterbaum von x nicht leer):
Dann ist der linkeste Knoten im rechten Unterbaum der
Nachfolger von x
Binre Suchbume
73
6
4
3
7
7
9
Nachfolgersuche:
Nachfolger von x
Binre Suchbume
74
6
4
3
7
7
9
Nachfolgersuche:
Nachfolger von x
Binre Suchbume
75
6
4
3
7
7
9
Nachfolgersuche:
Fall 2 (rechter Unterbaum von x leer und x hat Nachfolger y):
Dann ist y der niedrigste Vorgnger von x, dessen linkes
Kind ebenfalls Vorgnger von x ist
Binre Suchbume
76
6
4
3
7
5
9
Nachfolgersuche:
Binre Suchbume
77
6
4
3
7
5
9
Nachfolgersuche:
Binre Suchbume
78
6
4
3
7
5
9
Nachfolgersuche(x)
1. if rc[x] nil then return MinimumSuche(rc[x])
2. y p[x]
3. while y nil and x=rc[y] do
4. x y
Binre Suchbume
79
4. x y
5. y p[y]
6. return y
6
4
3
7
5
9
Nachfolgersuche(x)
2. y p[x]
4. x y
Binre Suchbume
80
4. x y
5. y p[y]
6. return y
6
4
3
7
5
9
Nachfolgersuche(6)
Nachfolgersuche(x)
2. y p[x]
4. x y
Binre Suchbume
81
4. x y
5. y p[y]
6. return y
6
4
3
7
5
9
Nachfolgersuche(6)
Nachfolgersuche(x)
2. y p[x]
4. x y
Binre Suchbume
82
4. x y
5. y p[y]
6. return y
6
4
3
7
5
9
Nachfolgersuche(6)
Nachfolgersuche(x)
2. y p[x]
4. x y
Binre Suchbume
83
4. x y
5. y p[y]
6. return y
6
4
3
7
5
9
Nachfolgersuche(5)
Nachfolgersuche(x)
2. y p[x]
4. x y
Binre Suchbume
84
4. x y
5. y p[y]
6. return y
6
4
3
7
5
9
Nachfolgersuche(5)
Nachfolgersuche(x)
2. y p[x]
4. x y
Binre Suchbume
85
4. x y
5. y p[y]
6. return y
6
4
3
7
5
9
Nachfolgersuche(5)
y
Nachfolgersuche(x)
2. y p[x]
4. x y
Binre Suchbume
86
4. x y
5. y p[y]
6. return y
6
4
3
7
5
9
Nachfolgersuche(5)
y
x
Nachfolgersuche(x)
2. y p[x]
4. x y
Binre Suchbume
87
4. x y
5. y p[y]
6. return y
6
4
3
7
5
9
Nachfolgersuche(5)
y
x
Nachfolgersuche(x)
2. y p[x]
4. x y
Binre Suchbume
88
4. x y
5. y p[y]
6. return y
6
4
3
7
5
9
Nachfolgersuche(5)
y
x
Nachfolgersuche(x)
2. y p[x]
4. x y
Binre Suchbume
89
4. x y
5. y p[y]
6. return y
6
4
3
7
5
9
Nachfolgersuche(5)
y
x
Nachfolgersuche(x)
2. y p[x]
4. x y
Binre Suchbume
90
4. x y
5. y p[y]
6. return y
6
4
3
7
5
9
Nachfolgersuche(5)
y
Nachfolgersuche(x)
2. y p[x]
4. x y
Laufzeit O(h)
Binre Suchbume
91
4. x y
5. y p[y]
6. return y
6
4
3
7
5
9
Vorgngersuche:
Symmetrisch zu Nachfolgersuche
Daher ebenfalls O(h) Laufzeit
Binre Suchbume
92
6
4
3
7
5
9
Binre Suchbume:
Aufzhlen der Elemente mit Inorder-Tree-Walk in O(n) Zeit
Suche in O(h) Zeit
Minimum/Maximum in O(h) Zeit
Binre Suchbume
93
Dynamische Operationen?
Einfgen und Lschen
Mssen Suchbaumeigenschaft aufrecht erhalten
Auswirkung auf Hhe des Baums?
Einfgen:
hnlich wie Baumsuche: Finde Blatt, an das neuer Knoten
angehngt wird
Danach wird nil-Zeiger durch neues
Element ersetzt
6
Binre Suchbume
94
Element ersetzt
4
3
7
5 9
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
4. if key[z] < key[x] then x lc[x]
6
Binre Suchbume
95
5. else x rc[x]
6. p[z] y
7. if y=nil then root[T] z
8. else
9. if key[z]< key[y] then lc[y] z
10. else rc[y] z
4
3
7
5 9
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
y ist Vater des
einzufgenden
Elements
x
Binre Suchbume
96
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
x
Binre Suchbume
97
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
x y
Binre Suchbume
98
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
x y
Binre Suchbume
99
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
y
Binre Suchbume
100
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
x
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
y
Binre Suchbume
101
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
x
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
Binre Suchbume
102
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
y x
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
Binre Suchbume
103
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
y x
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
Binre Suchbume
104
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
y
x
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
Binre Suchbume
105
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
y
x
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
Binre Suchbume
106
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
y
x
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
Binre Suchbume
107
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
y
x nil
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
Binre Suchbume
108
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
y
x nil
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
Binre Suchbume
109
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
y
x nil
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
Binre Suchbume
110
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
y
x nil
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
Binre Suchbume
111
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
y
x
8
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
6
Einfgen(8)
Binre Suchbume
112
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
4
3
7
5 9
y
x
8
Einfgen(T,z)
1. ynil; x root[T]
2. while xnil do
3. y x
Einfgen(8)
Binre Suchbume
113
5. else x rc[x]
6. p[z] y
8. else
10. else rc[y] z
Laufzeit:
O(h)
Lschen:
3 unterschiedliche Flle
(a) zu lschendes Element z hat keine Kinder
(b) zu lschendes Element z hat ein Kind
Binre Suchbume
114
(c) zu lschendes Element z hat zwei Kinder
Fall (a):
zu lschendes Element z hat keine Kinder
Binre Suchbume
115
6
4
3
7
5 9
Fall (a):
zu lschendes Element z hat keine Kinder
Entferne Element
Binre Suchbume
116
6
4
3
7
5 9
6
4
3
7
9
Fall (b):
zu lschendes Element z hat ein Kind
Binre Suchbume
117
6
4
3
7
5 9
Fall (b):
zu lschendes Element z hat ein Kind
Hnge der Unterbaum von z an den Vater von z
Binre Suchbume
118
6
4
3
7
5 9
6
4
3
9
5
Fall (c):
zu lschendes Element z hat zwei Kinder
Binre Suchbume
119
6
4
3
7
5 9
Fall (c):
Schritt 1: Bestimme Nachfolger von z
Binre Suchbume
120
6
4
3
7
5 9
Fall (c):
Schritt 2: Entferne Nachfolger
Binre Suchbume
121
6
4
3
7
5 9
6
4
3
9
5
Fall (c):
Nachfolger hat nur
ein Kind!
Binre Suchbume
122
6
4
3
7
5 9
6
4
3
9
5
Fall (c):
Binre Suchbume
123
6
4
3
7
5 9
6
4
3
9
5
Fall (c):
Schritt 2: Entferne Nachfolger; ersetze durch Nachfolger
Binre Suchbume
124
6
4
3
7
5 9
7
4
3
9
5
Lschen(T,z)
1. if lc[z]=nil or rc[z]=nil then y z
2. else y NachfolgerSuche(z)
3. if lc[y] nil then x lc[y]
4. else x rc[y]
5. if x nil then p[x] p[y]
Binre Suchbume
125
6. if p[y]=nil then root[T] x
7. else if y=lc[p[y]] then lc[p[y]] x
8. else rc[p[y]] x
9. if y z then key[z] key[y]
10. return y
6
4
3
7
5 9
Lschen(T,z)
4. else x rc[y]
Lschen(6)
Binre Suchbume
126
8. else rc[p[y]] x
10. return y
6
4
3
7
5 9
Lschen(T,z)
4. else x rc[y]
Lschen(6)
Referenz auf z
wird bergeben!
Binre Suchbume
127
8. else rc[p[y]] x
10. return y
6
4
3
7
5 9
Lschen(T,z)
4. else x rc[y]
Bestimme Knoten, der
gelscht werden soll.
Der Knoten hat nur
einen Nachfolger
Lschen(6)
Binre Suchbume
128
8. else rc[p[y]] x
10. return y
6
4
3
7
5 9
z
Lschen(T,z)
4. else x rc[y]
Bestimme Knoten, der
gelscht werden soll.
Der Knoten hat nur
einen Nachfolger
Lschen(6)
Binre Suchbume
129
8. else rc[p[y]] x
10. return y
6
4
3
7
5 9
z
y
Lschen(T,z)
4. else x rc[y]
Bestimme den
Nachfolger von y
(falls dieser existiert).
Lschen(6)
Binre Suchbume
130
8. else rc[p[y]] x
10. return y
6
4
3
7
5 9
z
y
x
Lschen(6)
Lschen(T,z)
4. else x rc[y]
Aktualisiere
Vaterzeiger von
x
Binre Suchbume
131
8. else rc[p[y]] x
10. return y
6
4
3
7
5 9
z
y
x
Lschen(T,z)
4. else x rc[y]
Lschen(6)
Binre Suchbume
132
8. else rc[p[y]] x
10. return y
6
4
3
7
5 9
z
y
x
Lschen(T,z)
4. else x rc[y]
Lschen(6)
Das rechte Kind
von z wird x.
Binre Suchbume
133
8. else rc[p[y]] x
10. return y
6
4
3
7
5 9
z
y
x
Lschen(T,z)
4. else x rc[y]
Lschen(6)
Das rechte Kind
von z wird x.
Binre Suchbume
134
8. else rc[p[y]] x
10. return y
6
4
3
7
5 9
z
y
x
Lschen(T,z)
4. else x rc[y]
Lschen(6)
Binre Suchbume
135
8. else rc[p[y]] x
10. return y
7
4
3 5 9
x
Umkopieren von
y nach z.
Lschen(T,z)
4. else x rc[y]
Lschen(6)
Binre Suchbume
136
8. else rc[p[y]] x
10. return y
7
4
3 5
9
Lschen(T,z)
4. else x rc[y]
Lschen(6)
Binre Suchbume
137
8. else rc[p[y]] x
10. return y
7
4
3 5
9
Lschen(T,z)
4. else x rc[y]
Lschen(6)
Laufzeit O(h)
Binre Suchbume
138
8. else rc[p[y]] x
10. return y
7
4
3 5
9
Binre Suchbume:
Ausgabe aller Elemente in O(n)
Suche, Minimum, Maximum, Nachfolger in O(h)
Einfgen, Lschen in O(h)
Binre Suchbume
139
Frage:
Wie kann man eine kleine Hhe unter Einfgen und
Lschen garantieren?
Binre Suchbume:
Ausgabe aller Elemente in O(n)
Suche, Minimum, Maximum, Nachfolger in O(h)
Einfgen, Lschen in O(h)
12. Balancierte binre Suchbume
1
Frage:
Wie kann man eine kleine Hhe unter Einfgen und
Lschen garantieren?
SS 2010 Datenstrukturen und Algorithmen
12.Balancierte Binrbume
1
AVL-Bume
Ein Baum heit AVL-Baum, wenn fr jeden Knoten gilt:
Die Hhe seines linken und rechten Teilbaums
unterscheidet sich hchstens um 1.
Balancierte binre Suchbume
2 SS 2010 Datenstrukturen und Algorithmen
2
Satz 12.1
Fr jeden AVL-Baum der Hhe h mit n Knoten gilt:
(3/2) n 2 -1
h
h+1
3
Satz 12.1
Fr jeden AVL-Baum der Hhe h mit n Knoten gilt:
(3/2) n 2 -1
Beweis: Tafel
h
h+1
4
Beweis: Tafel
Korollar 12.2
Ein AVL-Baum mit n Knoten hat Hhe (log n).
4
Dynamische AVL-Bume
Operationen Suche, Einfgen, Lschen, Min/Max,
Vorgnger/Nachfolger, wie fr binre Suchbume
Laufzeit O(h) fr diese Operationen
Nur Einfgen/Lschen verndern Struktur des Baums
5
Problem:
Wir brauchen Prozedur, um AVL-Eigenschaft nach
Einfgen/Lschen wiederherzustellen.
5
Dynamische AVL-Bume
Operationen Suche, Einfgen, Lschen, Min/Max,
Vorgnger/Nachfolger, wie in der letzten Vorlesung
Laufzeit O(h) fr diese Operationen
Nach Korollar 12.2 gilt
h = (log n)
6
Problem:
Wir brauchen Prozedur, um AVL-Eigenschaft nach
Einfgen/Lschen wiederherzustellen.
6
Rotationen:
y
x
x
y
Rechtsrotation(T,y)
7
x
A B
C
C
A
B
y
Rechtsrotation(T,y)
Linksrotation(T,x)
7
Beispiel 1:
9
15
21
9
15
19
y
x
Rechtsrotation(T,y)
8
7
20
9
17
27
19
21
7
20
9
21
17
19
27
x
y
x
8
Beispiel 2:
9
15
21
x
y
Linksrotation(T,x)
15
21
27
x
y
9
7
20
9
17
27
19
21
9
20
15
17
7
19
27
9
Linksrotation(T,x)
1. y rc[x]
2. rc[x] lc[y]
3. if lc[y]nil then p[lc[y]] x
4. p[y] p[x]
5. if p[x]=nil then root[T] y
10
6. else if x=lc[p[x]] then lc[p[x]] y
7. else rc[p[x]] y
8. lc[y] x
9. p[x] y
10. h[x] 1+ max{h[lc[x]],h[rc[x]]}
11. h[y] 1+ max{h[lc[y]],h[rc[y]]}
10
Linksrotation(T,x)
1. y rc[x]
2. rc[x] lc[y]
4. p[y] p[x]
11
7. else rc[p[x]] y
8. lc[y] x
9. p[x] y
10. h[x] 1+ max{h[lc[x]],h[rc[x]]}
11. h[y] 1+ max{h[lc[y]],h[rc[y]]}
11
Im folgenden Beispiel werden die
Zeilen 10 und 11 nicht betrachtet
Linksrotation(T,x)
1. y rc[x]
2. rc[x] lc[y]
4. p[y] p[x]
Annahme: x hat
rechtes Kind.
12
4. p[y] p[x]
7. else rc[p[x]] y
8. lc[y] x
9. p[x] y
12
Linksrotation(T,x)
1. y rc[x]
2. rc[x] lc[y]
4. p[y] p[x]
9
15
21
x
13
4. p[y] p[x]
7. else rc[p[x]] y
8. lc[y] x
9. p[x] y
7
20
9
17
27
19
21
13
Linksrotation(T,x)
1. y rc[x]
2. rc[x] lc[y]
4. p[y] p[x]
9
15
21
x
y
14
4. p[y] p[x]
7. else rc[p[x]] y
8. lc[y] x
9. p[x] y
7
20
9
17
27
19
21
y
14
Linksrotation(T,x)
1. y rc[x]
2. rc[x] lc[y]
4. p[y] p[x]
9
15
21
x
y
15
4. p[y] p[x]
7. else rc[p[x]] y
8. lc[y] x
9. p[x] y
7
20
9
17
27
19
21
y
15
Linksrotation(T,x)
1. y rc[x]
2. rc[x] lc[y]
4. p[y] p[x]
9
15
21
x
y
16
4. p[y] p[x]
7. else rc[p[x]] y
8. lc[y] x
9. p[x] y
7
20
9
17
27
19
21
y
16
Linksrotation(T,x)
1. y rc[x]
2. rc[x] lc[y]
4. p[y] p[x]
9
15
21
x
y
nil
17
4. p[y] p[x]
7. else rc[p[x]] y
8. lc[y] x
9. p[x] y
7
20
9
17
27
19
21
y
17
Linksrotation(T,x)
1. y rc[x]
2. rc[x] lc[y]
4. p[y] p[x]
9
15
21
x
y
nil
18
4. p[y] p[x]
7. else rc[p[x]] y
8. lc[y] x
9. p[x] y
7
20
9
17
27
19
21
y
18
Linksrotation(T,x)
1. y rc[x]
2. rc[x] lc[y]
4. p[y] p[x]
9
15
21
x
y
nil
root[T]
19
4. p[y] p[x]
7. else rc[p[x]] y
8. lc[y] x
9. p[x] y
7
20
9
17
27
19
21
y
19
Linksrotation(T,x)
1. y rc[x]
2. rc[x] lc[y]
4. p[y] p[x]
9
15
21
x
y
nil
root[T]
20
4. p[y] p[x]
7. else rc[p[x]] y
8. lc[y] x
9. p[x] y
7
20
9
17
27
19
21
y
20
Linksrotation(T,x)
1. y rc[x]
2. rc[x] lc[y]
4. p[y] p[x]
15 27
21
x
y
nil
root[T]
21
4. p[y] p[x]
7. else rc[p[x]] y
8. lc[y] x
9. p[x] y
7
20
9
15
17
27
19
21
Linksrotation(T,x)
1. y rc[x]
2. rc[x] lc[y]
4. p[y] p[x]
15 27
21
x
y
nil
root[T]
22
4. p[y] p[x]
7. else rc[p[x]] y
8. lc[y] x
9. p[x] y
7
20
9
15
17
27
19
22
Linksrotation(T,x)
1. y rc[x]
2. rc[x] lc[y]
4. p[y] p[x]
15 27
21
x
y
nil
root[T]
Laufzeit: O(1)
23
4. p[y] p[x]
7. else rc[p[x]] y
8. lc[y] x
9. p[x] y
7
20
9
15
17
27
19
23
Zur Aufrechterhaltung der AVL-Baumeigenschaft
betrachten wir zunchst ein vereinfachtes
Problem.
Definition:
24
Ein Baum heit beinahe-AVL-Baum, wenn die AVL-
Eigenschaft in jedem Knoten auer der Wurzel erfllt ist
und die Hhen der Unterbume der Wurzel sich um
hchstens 2 unterscheiden.
24
Problem:
Umformen eines beinahe-AVL-Baums in einen AVL-
Baum mit Hilfe von Rotationen
O.b.d.A.: Linker Teilbaum der Wurzel hher als der
rechte
25
rechte
25
Fall 1:
y
x
26
x
A
B
C
H-1
H oder
H-1
H
26
Fall 1:
y
x
x
y
Rechtsrotation(T,y)
27
x
A
B
C
H-1
H
H oder
H-1
y
C
B
A
H oder
H-1
H-1
H
27
Fall 2:
y
x
28
x
A
B
C
H-1
H
H-1
28
Fall 2:
y
x
29
x
A
B
C
H-1
H
H-1
29
Fall 2:
y
x
30
x
A
C
H-1
H
H-1
z
B B
H-2
oder
H-1
H-2
oder
H-1
30
Fall 2:
y
x
y
z
Linksrotation(T,x)
31
x
A
C
H-1
H
H-1
z
B B
H-2
oder
H-1
H-2
oder
H-1
C
z
B
x
A
H-1
B
H-2
oder
H-1
H-1
H-2
oder
H-1
31
Fall 2:
H-1
y
z
z
y x
Rechtsrotation(T,y)
32
H-1
H-2
oder
H-1
C
B
x
A
H-1
B
H-2
oder
H-1
C
B B
A
32
Balance(T)
1. t root[T]
2. if h[lc[t]] > h[rc[t]]+1 then
3. if h[lc[lc[t]]]< h[rc[lc[t]]] then
4. Linksrotation(lc[t])
y
33
5. Rechtsrotation(t)
6. else if h[rc[t]]> h[lc[t]]+1 then
7. if h[rc[rc[t]]]< h[lc[rc[t]] then
8. Rechtsrotation(rc[t])
9. Linksrotation(t)
x
A
B
C
H-1
H oder
H-1
H
33
Balance(T)
1. t root[T]
y
34
9. Linksrotation(t)
x
A
B
C
H-1
H oder
H-1
H
34
Balance(T)
1. t root[T]
y
h gibt Hhe des Teilbaums an.
Dies mssen wir zustzlich in
unserer Datenstruktur aufrecht
erhalten.
35
9. Linksrotation(t)
x
A
B
C
H-1
H oder
H-1
H
35
Balance(T)
1. t root[T]
y
36
9. Linksrotation(t)
x
A
B
C
H-1
H oder
H-1
H
36
Balance(T)
1. t root[T]
x
37
9. Linksrotation(t)
y
A
B C
37
Balance(T)
1. t root[T]
x
Laufzeit: O(1)
38
9. Linksrotation(t)
y
A
B C
38
Kurze Zusammenfassung:
Wir knnen aus einem beinahe-AVL-Baum mit Hilfe von
maximal 2 Rotationen einen AVL-Baum machen
Dabei erhht sich die Hhe des Baums nicht
Einfgen:
39
Einfgen:
Wir fgen ein wie frher
Dann laufen wir den Pfad zur Wurzel zurck
An jedem Knoten balancieren wir, falls der Unterbaum
ein beinahe-AVL-Baum ist.
Das ergibt induktiv wieder einen korrekten AVL-Baum.
39
AVL-Einfgen(t,x)
1. if t=nil then
2. t new node(x); return
3. else if key[x]<key[t] then AVL-Einfgen(lc[t],x)
4. else if key[x]>key[t] then AVL-Einfgen(rc[t],x)
40
5. else return Schlssel schon vorhanden
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
8
5
9
6 3
Einfgen 2
40
AVL-Einfgen(t,x)
1. if t=nil then
41
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
8
5
9
6 3
Einfgen 2
41
AVL-Einfgen(t,x)
1. if t=nil then
42
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
8
5
9
6 3
Einfgen 2
42
AVL-Einfgen(t,x)
1. if t=nil then
43
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
8
5
9
6 3
Einfgen 2
43
AVL-Einfgen(t,x)
1. if t=nil then
44
3
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
8
5
9
6
Einfgen 2
44
AVL-Einfgen(t,x)
1. if t=nil then
45
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
3
8
5
9
6
Einfgen 2
45
AVL-Einfgen(t,x)
1. if t=nil then
46
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
3
8
5
9
6
Einfgen 2
46
AVL-Einfgen(t,x)
1. if t=nil then
47
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
3
8
5
9
6
Einfgen 2
nil
47
AVL-Einfgen(t,x)
1. if t=nil then
Neuen Knoten erzeugen.
48
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
3
8
5
9
6
Einfgen 2
Neuen Knoten erzeugen.
Zustzlich noch Zeiger
lc[t] und rc[t] auf nil
setzen, sowie p[t] und
den Zeiger (lc oder rc)
von p[t] (falls nil) auf t
setzen.
2
48
AVL-Einfgen(t,x)
1. if t=nil then
49
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
3
8
5
9
6
Einfgen 2
2
h[nil] definieren wir als -1.
49
AVL-Einfgen(t,x)
1. if t=nil then
50
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
3
8
5
9
6
Einfgen 2
2
50
AVL-Einfgen(t,x)
1. if t=nil then
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
51
3
8
5
9
6
Einfgen 2
2
51
AVL-Einfgen(t,x)
1. if t=nil then
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
52
3
8
5
9
6
Einfgen 2
2
52
AVL-Einfgen(t,x)
1. if t=nil then
53
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
3
8
5
9
6
Einfgen 2
2
53
AVL-Einfgen(t,x)
1. if t=nil then
54
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
3
8
5
9
6
Einfgen 2
2
54
AVL-Einfgen(t,x)
1. if t=nil then
55
6. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
7. Balance(t)
Laufzeit:
O(h) = O(log n)
3
8
5
9
6
Einfgen 2
2
55
Korrektheit(Skizze):
Induktion ber die Lnge des Suchpfads (startend vom
eingefgten Blatt):
Einfgen in einen leeren Baum funktioniert
T nicht leer, dann wird x in einen der beiden Teilbume
eingefgt
56
eingefgt
Nach Ind. Ann. sind diese Teilbume bereits AVL-
Bume und unterscheiden sich nur um maximal 2 in
ihrer Hhe
Falls die AVL-Eigenschaft nicht erhalten bleibt, dann
wird Balance ausgefhrt.
56
AVL-Lschen(t,k)
1. if k<key[t] then AVL-Lschen(lc[t],k)
2. else if k>key then AVL-Lschen(rc[t],k)
3. else if t=nil then return k nicht im Baum
4. else if lc[t]=nil then ersetze t durch rc[t]
5. else if rc[t]=nil then ersetze t durch lc[t]
57
6. else u=MaximumSuche(lc[t])
7. Kopiere Informationen von u nach t
8. AVL-Lschen(lc[t],key[u])
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
3
8
5
9
6
57
AVL-Lschen(t,k)
k bezeichnet Schlssel
des zu lschenden
Elements.
58
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
3
8
5
9
6
Lschen(3)
58
AVL-Lschen(t,k)
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
59
3
8
5
9
6
Lschen(3)
59
AVL-Lschen(t,k)
60
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
3
8
5
9
6
Lschen(3)
60
AVL-Lschen(t,k)
2. else if k>key then AVL-Lschen(rc[t],l)
Und die anderen
Zeiger aktualisieren
61
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
8
5
9
6
Lschen(3)
nil
61
AVL-Lschen(t,k)
62
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
8
5
9
6
Lschen(3)
nil
Oder h[t]=-1,
falls t=nil
62
AVL-Lschen(t,k)
63
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
8
5
9
6
Lschen(3)
nil
Nichts zu tun,
da Baum leer.
63
AVL-Lschen(t,k)
64
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
8
5
9
6
Lschen(3)
64
AVL-Lschen(t,k)
65
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
8
5 9
6
Lschen(3)
65
AVL-Lschen(t,k)
Lschen(8)
66
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
3
8
5
9
6
66
7
2
Lschen(8)
AVL-Lschen(t,k)
Lschen(8)
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
67
3
8
5
9
6
67
7
2
Lschen(8)
AVL-Lschen(t,k)
Lschen(8)
68
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
3
8
5
9
6
68
7
2
Lschen(8)
AVL-Lschen(t,k)
Lschen(8)
69
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
3
8
5
9
6
69
7
2
Lschen(8)
AVL-Lschen(t,k)
Lschen(8)
70
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
3
8
5
9
6
70
7
2
Lschen(8)
AVL-Lschen(t,k)
Lschen(8)
71
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
3
7
5
9
6
71
7
2
Lschen(8)
AVL-Lschen(t,k)
Lschen(8)
72
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
3
7
5
9
6
72
7
2
Lschen(8)
u hat kein
rechtes Kind.
AVL-Lschen(t,k)
Lschen(8)
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
73
3
7
5
9
6
73
7
2
Lschen(8)
AVL-Lschen(t,k)
Lschen(8)
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
74
3
7
5
9
6
74
2
Lschen(8)
AVL-Lschen(t,k)
Lschen(8)
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
75
3
7
5
9
6
75
2
Lschen(8)
AVL-Lschen(t,k)
Lschen(8)
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
76
3
7
5
9
6
76
2
Lschen(8)
AVL-Lschen(t,k)
Lschen(8)
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
77
3
7
5
9
6
77
2
Lschen(8)
AVL-Lschen(t,k)
Lschen(8)
9. h[t] = 1 + max{h[lc[t]], h[rc[t]]}
10.Balance(t)
78
3
7
5
9
6
78
2
Lschen(8)
Korrektheit:
hnlich wie beim Einfgen
Satz 12.3
79
Satz 12.3
Mit Hilfe von AVL-Bumen kann man Suche, Einfgen,
Lschen, Minimum und Maximum in einer Menge von n
Zahlen in (log n) Laufzeit durchfhren.
79
Zusammenfassung und Ausblick:
Effiziente Datenstruktur fr das Datenbank Problem mit
Hilfe von Suchbumen
Kann man eine bessere Datenstruktur finden?
Was muss man ggf. anders machen?
80
Was muss man ggf. anders machen?
(untere Schranke fr vergleichsbasierte Strukturen)
80
13. Hashing
AVL-Bume:
Ausgabe aller Elemente in O(n) Zeit
Suche, Minimum, Maximum, Nachfolger in O(log n) Zeit
Einfgen, Lschen in O(log n) Zeit
SS 2010 Datenstrukturen und Algorithmen -
13. Hashing
1
Frage:
Kann man Einfgen, Lschen und Suchen in O(1) Zeit?
13. Hashing
Hashing: einfache Methode, um Wrterbcher zu
implementieren, d.h. Hashing untersttzt die
Operationen Search, Insert, Remove.
Worst-case Zeit fr Search: (n).
13. Hashing
2
In der Praxis jedoch sehr gut.
Unter gewissen Annahmen, erwartete Suchzeit O(1).
Hashing: Verallgemeinerung von direkter Adressierung
durch Arrays.
Direkte Adressierung mit Arrays
Schlssel fr Objekte der dynamischen Menge aus
U:={0,,u-1}. Menge U wird Universum genannt.
Nehmen an, dass alle Objekte unterschiedliche
Schlssel haben.
13. Hashing
3
Legen Array T[0,,u-1] an. Position k in T reserviert
fr Objekt mit Schlssel k.
T[k] verweist auf Objekt mit Schlssel k. Falls kein
Objekt mit Schlssel k in Struktur, so gilt T[k]=NIL.
5
Direkte Adressierung - Illustration
Universum U
0
6
9
4
7
/
/
/
2
Schlssel
3
13. Hashing
4
8
5
Benutzte
Schlssel K 2
8
5
3
1
7
/
/
/
Satellitendaten
Operationen bei direkter Adressierung (1)
Insert(T,x):
T[key(x)] x
Remove(T,k):
13. Hashing
5
Remove(T,k):
T[k] NIL
Search(k):
return T[k]
Operationen bei direkter Adressierung (2)
Laufzeit jeweils O(1).
Direkte Adressierung nicht mglich, wenn Universum U
sehr gro ist.
Speicherineffizient ((|U|)), wenn Menge der aktuell zu
speichernden Schlssel deutlich kleiner als U ist.
13. Hashing
6
speichernden Schlssel deutlich kleiner als U ist.
Lsung: verwende Hashfunktion h:U{0,,m-1}, um
die aktuelle Schlsselmenge KU auf eine Hashtabelle
T abzubilden mit m=O(|K|).
Problem: es kann zu Kollisionen kommen!
Kollisionen sind nicht auszuschlieen
Universum U
( )
1
k h
( ) ( ) k h k h =
( )
4
k h
0
/
/
/
13. Hashing
7
Benutzte
Schlssel K
3
k
2
k
5
k
1
k
4
k
( ) ( )
5 2
k h k h =
( )
3
k h
1 m
/
/
/
Kollision
1 3 5 14 19 10
Hashfunktion h:U T
Hashing (ohne Kollisionen)
12.05.2011 Kapitel 4 8
14 5 1 3 19 10
Hashtabelle T
Insert(T,x):
T[h(key(x))] x
Remove(T,k):
if key(T[h(k)])=k then T[h(k)] NIL
Hashing (ohne Kollisionen)
12.05.2011 Kapitel 4 9
if key(T[h(k)])=k then T[h(k)] NIL
Search(T,k):
if key(T[h(k)])=k then return T[h(k)]
else return NIL
Mgliche Strategien:
Geschlossene Adressierung
Kollisionsauflsung durch Listen
Offene Adressierung
Manahmen zur Kollisionsauflsung
Offene Adressierung
Lineares/Quadratisches Hashing: es wird
nach der nchsten freien Stelle in T gesucht
Kuckuckshashing: geschickte Verwendung
von zwei Hashfunktionen
13. Hashing
10
Hashing mit Listen - Illustration
Universum U
/
/
/
1
k
4
k
k
k
Hashtabelle T
13. Hashing
11
Benutzte
Schlssel K
3
k
2
k
5
k
1
k
4
k
/
/
/
2
k
5
k
3
k
Hashing mit Listen
( )
( ) [ ]
( )
[ ] ( ) [ ]ein. Liste der Kopf am Fge . 1
Insert - Hash - Chained
. Liste in Schlssel mit Element nach Suche . 1
Search - Hash - Chained
x key h T x
T,x
k h T k
T,k
13. Hashing
12
Laufzeit fr Insert O(1).
Laufzeit fr Remove, Search proportional zur Lnge von
T[h(k)].
( )
[ ] ( ) [ ]. Liste aus Entferne . 1
Remove - Hash - Chained
x key h T x
T,x
Hashing mit Listen
m Gre der Hashtabelle T, n Anzahl der gespeicherten
Objekte. Dann heisst :=n/m der Lastfaktor von T.
ist die durchschnittliche Anzahl von Elementen in
einer verketteten Liste.
Werden alle Objekte auf denselben Wert gehasht, so
bentigt Suche bei n Elementen Zeit (n). Dasselbe
13. Hashing
13
bentigt Suche bei n Elementen Zeit (n). Dasselbe
Verhalten wie verkettete Listen.
Im Durchschnitt aber ist Suche deutlich besser, falls
eine gute Hashfunktion h benutzt wird.
Gute Hashfunktion sollte Werte wie zufllige Funktion
streuen, aber was genau heit es, gut zu sein?
Problem: Wie konstruiert man gengend
zufllige Hashfunktionen?
Definition 13.1 [universelles Hashing]:
Sei c eine positive Konstante. Eine Familie
Universelles Hashing
13. Hashing
14
Sei c eine positive Konstante. Eine Familie
H von Hashfunktionen auf {0,,m-1} heit
c-universell falls fr ein beliebiges Paar
{x,y} von Schlsseln gilt, dass
|{hH: h(x)=h(y)}| (c/m) |H|
Satz 13.2: Falls n Elemente in einer Hashtabelle T der
Gre m mittels einer zuflligen Hashfunktion h aus
einer c-universellen Familie gespeichert werden, dann ist
fr jedes T[i] die erwartete Anzahl Schlssel in T[i] in
O(cn/m).
Beweis:
13. Hashing
15
Beweis:
Betrachte festen Schlssel k
0
mit Position T[i]
Zufallsvariable X
k
{0,1} fr jeden Schlssel kK\{k
0
}
X
k
= 1 h(k)=i
X =
kk
0
X
k
: Anzahl Elemente in Position T[i] von k
0
E[X] =
kk
0
E[X
k
] =
kk
0
Pr[X
k
=1]
kk
0
(c/m)
= (n-1)c/m
H ist c-universell
Aus Satz 13.2: Tabellengre (|K|) ergibt erwartet
konstante Zeit fr Insert, Remove und Search.
Aber wie konstruieren wir eine c-universelle Hash-
funktion?
Betrachte die Familie der Hashfunktionen
13. Hashing
16
h
a
(x) = ax (mod m)
mit a,x{0,,m-1}
d
. (ax =
i
a
i
x
i
)
Satz 13.3: H={ h
a
: a{0,,m-1}
d
} ist eine 1-universelle
Familie von Hashfunktionen, falls m prim ist.
Beweis:
Betrachte zwei feste Schlssel xy mit x=(x
1
,,x
d
) und
y=(y
1
,,y
d
)
Anzahl Mglichkeiten fr a, dass h
a
(x)=h
a
(y):
h
a
(x)=h
a
(y)
i
a
i
x
i
=
i
a
i
y
i
(mod m)
a
j
(y
j
-x
j
) =
ij
a
i
(x
i
-y
i
) (mod m)
13. Hashing
17
a
j
(y
j
-x
j
) =
ij
a
i
(x
i
-y
i
) (mod m)
fr ein j mit x
j
y
j
Falls m prim, dann gibt es fr jede Wahl von a
1
,,a
j-1
,
a
j+1
,,a
d
genau ein a
j
, das diese Gleichung erfllt.
Also ist die Anzahl Mglichkeiten fr a gleich m
d-1
Daher ist Pr[h
a
(x)=h
a
(y)] = m
d-1
/m
d
= 1/m
Mgliche Strategien:
Offene Adressierung
Offene Adressierung
13. Hashing
18
Offene Adressierung (1)
Geschlossene Adressierung weist Objekt mit gege-
benem Schlssel feste Position in Hashtabelle zu.
Bei Hashing durch offene Adressierung wird Objekt mit
Schlssel keine feste Position zugewiesen.
Position abhngig vom Schlssel und bereits belegten
Positionen in Hashtabelle.
13. Hashing
19
Positionen in Hashtabelle.
Fr neues Objekt wird erste freie Position gesucht. Dazu
wird Hashtabelle nach freier Position durchsucht.
Reihenfolge der Suche hngt vom Schlssel des
einzufgenden Objekts ab.
Keine Listen zur Kollisionsvermeidung. Wenn Anzahl
eingefgter Objekte m ist, dann sind keine weiteren
Einfgungen mehr mglich.
Listen zur Kollisionsvermeidung mglich, aber Ziel von
offener Adressierung ist es, Verfolgen von Verweisen
zu vermeiden.
13. Hashing
20
Da keine Listen bentigt werden, kann die Hashtabelle
vergrert werden.
Suche von Objekten in der Regel schneller, da keine
Listen linear durchsucht werden mssen.
Laufzeit fr Einfgen nur noch im Durchschnitt (1).
Entfernen von Objekten schwierig, deshalb Anwendung
von offener Adressierung oft nur, wenn Entfernen nicht
bentigt wird.
13. Hashing
21
Hashfunktionen bei offener Adressierung
Hashfunktion legt fr jeden Schlssel fest, in welcher
Reihenfolge fr Objekte mit diesem Schlssel nach
freier Position in Hashtabelle gesucht wird.

Hashfunktion h von der Form

{ } { } 1 1 0 1 1 0 m , , , m , , , U : h K K .

m:=Gre der Hashtabelle.
13. Hashing
22
m:=Gre der Hashtabelle.

Verlangen, dass fr alle Schlssel k die Folge
( ) ( ) ( ) ( ) 1 1 0 m , k h , , , k h , , k h K eine Permutation der
Folge ( ) 1 1 0 m , , , K ist.

( ) ( ) ( ) ( ) 1 1 0 m , k h , , , k h , , k h K heisst Testfolge bei
Schlssel k.

Einfgen bei offener Adressierung
( )
( )
[ ]
[ ]
1 5
; 4
NIL 3
2
0 1
Insert - Hash
else
return then
if
repeat
i i
k j T
j T
k,i h j
i
T,k
+

13. Hashing
23
Dabei zur Vereinfachung angenommen, dass keine
Satellitendaten vorhanden, d.h., Objekt ist Schlssel.
gefllt" ig vollstnd e Hashtabell " 7
6
1 5
error
until
else
m i
i i
=
+
Suchen bei offener Adressierung
( )
( )
[ ]
[ ]
1 5
4
k 3
2
0 1
Search - Hash
else
return then
if
repeat
i i
j
j T
k,i h j
i
T,k
+
=

13. Hashing
24
[ ]
NIL 7
NIL 6
1 5
return
until
else
m i j T
i i
= =
+
Probleme bei Entfernen
Wir knnen Felder i mit gelschten Schlsseln nicht
wieder mit NIL belegen, denn dann wird Suche nach
Schlsseln, bei deren Einfgung Position i getestet
wird, fehlerhaft sein!
Mgliche Lsung ist, Felder gelschter Schlssel mit
DELETED zu markieren. Aber dann werden Laufzeiten
13. Hashing
25
DELETED zu markieren. Aber dann werden Laufzeiten
fr Hash-Insert und Hash-Delete nicht mehr nur vom
Lastfaktor =n/m abhngen.
Daher Anwendung von offener Adressierung oft nur,
wenn keine Objekte entfernt werden mssen.
Probleme bei Entfernen
Ein mglicher Trick, um Remove Operationen dennoch
zu erlauben, funktioniert wie folgt:
Markiere Felder gelschter Schlssel mit DELETED.
Ein Zhler zhlt die Anzahl gelschter Eintrge.
bersteigt die Anzahl gelschter Eintrge die Anzahl
der verbleibenden Elemente in der Hashtabelle, wird
die Hashtabelle nochmal komplett neu aufgebaut,
13. Hashing
26
die Hashtabelle nochmal komplett neu aufgebaut,
indem alle noch vorhandenen Elemente nochmal neu
in die anfangs leere Hashtabelle mittels Hash-Insert
eingefgt werden.
Potentialanalyse: Erwartete amortisierte Laufzeit von
Insert, Remove und Search konstant (fr m=(|K|) ).
Mgliche Hashfunktionen
1. { } Funktion. 1 1 0 m , , , U : ' h K
Lineares Hashen:
( ) ( ) ( ) m i k ' h i , k h mod + = .

2. { } 0. Funktion, 1 1 0
2 1
,c c m , , , U : ' h K
Quadratisches Hashen:
13. Hashing
27
Quadratisches Hashen:
( ) ( ) ( ) m i c i c k ' h i , k h mod
2
2 1
+ + = .

1 3 5 14 19 10 neu
Lineares Hashing
Speichere Element e im ersten freien
13. Hashing
28
14 5 1 3 19 10
Speichere Element e im ersten freien
Ort T[i], T[i+1], T[i+2],mit i=h(key(e))
Lauf:
14 5 1 3 19 10 12
Lauf der Lnge 5
Lineares Hashing
12.05.2011 Kapitel 4 29
Satz 13.4: Falls n Elemente in einer Hashtabelle T
der Gre m>2en mittels einer zuflligen
Hashfunktion h gespeichert werden, dann ist fr
jedes T[i] die erwartete Lnge eines Laufes in T,
der T[i] enthlt, O(1). (e: Eulersche Zahl)
Beweis:
n: Anzahl Elemente, m>2n: Gre der Tabelle
T[i]
Besetzter Lauf der Lnge k
Lineares Hashing
12.05.2011 Kapitel 4 30
Anzahl Mglichkeiten zur Wahl von k Elementen:
Wahrscheinlichkeit, dass Hashwerte in Lauf: (k/m)
k
Besetzter Lauf der Lnge k
Pr[T[i] in Lauf der Lnge k] < (en/k)
k
k(k/m)
k
< k(1/2)
k
n
k
k: #Anfnge fr Lauf
p
k
:= Pr[T[i] in Lauf der Lnge k] < k(1/2)
k
E[Lnge des Laufs ber T[i]]
=
k0
kp
k
<
k0
k
2
(1/2)
k
= O(1)
Lineares Hashing
12.05.2011 Kapitel 4 31
Also erwartet konstanter Aufwand fr
Operationen Insert, Remove und Search.
Mgliche Strategien:
Offene Adressierung
Offene Adressierung
13. Hashing
32
1 5 14
Idee: speichere Element in einer von zwei Positionen
Kuckuckshashing
13. Hashing
33
Hashtabelle T
1
5 1 14
Hashtabelle T
2
Hashfunktion h
1
Hashfunktion h
2
T
1
, T
2
: Array [0..m-1] of Element
Search(k):
if key(T
1
[h
1
(k)])=k then return T
1
[h
1
(k)]
if key(T
2
[h
2
(k)])=k then return T [h
2
(k)]
Kuckuckshashing
13. Hashing
34
if key(T
2
[h
2
2
[h
2
(k)]
return NIL
Remove(k):
if key(T
1
[h
1
(k)])=k then T
1
[h
1
(k)]NIL
if key(T
2
[h
2
(k)])=k then T
2
[h
2
(k)]NIL
Insert(e):
// key(e) schon in Hashtabelle?
if key(T
1
[h
1
(key(e))])=key(e) then
T
1
[h
1
(key(e))]e; return
if key(T
2
[h
2
(key(e))])=key(e) then
T
2
[h
2
(key(e))] e; return
// nein, dann einfgen
while true do
Kuckuckshashing
13. Hashing
35
while true do
eT
1
[h
1
(key(e))] // tausche e mit Pos. in T
1
if e=NIL then return
eT
2
[h
2
2
Oder maximal d log n oft, wobei Konstante d so gewhlt ist, dass die
Wahrscheinlichkeit eines Erfolgs unter der einer Endlosschleife liegt.
Bei Misserfolg kompletter Rehash mit neuen, zuflligen h
1
, h
2
1 5 14 10 10
Kuckuckshashing
13. Hashing
36
20 1 5 14
1 5 14 10
Kuckuckshashing
13. Hashing
37
14 5 1
Endlosschleife!
Laufzeiten:
Search, Remove: O(1) (worst case!)
Insert: O(Lnge der Umlegefolge + evtl.
Aufwand fr Rehash bei Endlosschleife)
Laufzeit der insert-Operation: 2 Flle
Kuckuckshashing
13. Hashing
38
Laufzeit der insert-Operation: 2 Flle
1. Insert luft nach t Runden in eine End-
losschleife
2. Insert terminiert nach t Runden
Im folgenden: n: #Schlssel, m: Tabellengre
Fall 1: Endlosschleife
Folgende Elementabhngigkeiten existieren in
diesem Fall ( : x verdrngt y fr HF i):
Kuckuckshashing
x y
i
13. Hashing
39
x
i+j+1
x
i+j+2
x
i+j+3
x
j
x
k
. . .
. . .
x
1
x
2
x
3
x
j
x
i
. . .
. . .
1 2 1
2
1 2 1
1 2
1
Fall 2: Terminierung nach t Runden
x
1
x
2
x
3
x
k
. . .
oder
Kuckuckshashing
1 2 1
13. Hashing
40
x
i+j+1
x
i+j+2
x
i+j+3
x
k
. . .
x
1
x
2
x
3
x
j
x
i
. . .
. . .
oder
1 2 1
2
Man kann zeigen:
Die erwartete Laufzeit von Insert ist O(1+1/)
bei Tabellengren m=O(1+)n.
Rehash bentigt O(n) erwartete Zeit, passiert
Kuckuckshashing
13. Hashing
41
Rehash bentigt O(n) erwartete Zeit, passiert
aber nur mit Wahrscheinlichkeit O(1/n).
Problem: Wahrscheinlichkeit fr Endlosschleife
noch recht hoch!
Lsung: verwende Notfallcache
T
1
, T
2
: Array [0..m-1] of Element
C: Array [0..c-1] of Element (c konstant)
Search(k):
Kuckuckshashing mit Cache
13. Hashing
42
Search(k):
if i: key(C[i])=k then return C[i]
if key(T
1
[h
1
1
[h
1
(k)]
if key(T
2
[h
2
2
[h
2
(k)]
return NIL
Remove(k):
if i: key(C[i])=k then C[i]NIL; return
if key(T
1
[h
1
(k)])=k then
// lsche k aus T
1
und ersetze es evtl. aus C
ph
1
(k); T
1
[p] NIL
13. Hashing
43
ph
1
(k); T
1
[p] NIL
if i: h
1
(key(C[i]))=p then T
1
[p]C[i]; C[i]NIL
if key(T
2
[h
2
(k)])=k then
// lsche k aus T
2
und ersetze es evtl. aus C
ph
2
(k); T
2
[p] NIL
if i: h
2
(key(C[i]))=p then T
2
[p]C[i]; C[i]NIL
Insert(e):
// key(e) schon in Hashtabelle?
if i: key(C[i])=key(e) then C[i]e; return
if key(T
1
[h
1
(key(e))])=key(e) then T
1
[h
1
(key(e))]e; return
if key(T
2
[h
2
(key(e))])=key(e) then T
2
[h
2
(key(e))]e; return
// nein, dann fge e ein
r:=1
while r<dlog n do // d: Konstante >2
13. Hashing
44
while r<dlog n do // d: Konstante >2
eT
1
[h
1
1
eT
2
[h
2
2
rr+1
If i: C[i]=NIL then C[i]e
else rehash
Man kann zeigen:
Satz 13.5: Die Wahrscheinlichkeit, dass
mehr als c Elemente zu einem Zeitpunkt in
C sind, ist O(1/n
c
).
13. Hashing
45
C sind, ist O(1/n
c
).
Beweis: aufwendig, hier nicht behandelt
Problem: Hashtabelle ist zu gro oder zu
klein (sollte nur um konstanten Faktor ab-
weichen von der Anzahl der Elemente)
Lsung: Reallokation
Dynamische Hashtabelle
13. Hashing
46
Lsung: Reallokation
Whle neue geeignete Tabellengre
Whle neue Hashfunktion
bertrage Elemente auf die neue Tabelle
Problem: Tabellengre m sollte prim sein
(fr gute Verteilung der Schlssel)
Lsung:
Fr jedes k gibt es Primzahl in [k
3
,(k+1)
3
]
13. Hashing
47
Fr jedes k gibt es Primzahl in [k
3
,(k+1)
3
]
Whle primes m, so dass m[k
3
, (k+1)
3
]
Jede nichtprime Zahl in [k
3
,(k+1)
3
] muss
Teiler < (k+1)
3
haben
erlaubt effiziente Primzahlfindung ber
Sieb des Eratosthenes
Primzahlbestimmung in {2,3,...,n}:
Sieb des Eratosthenes:
// initialisiere gestrichen-Feld
for i2 to n do
gestrichen[i]FALSE
// siebe nichtprime Zahlen aus
13. Hashing
48
// siebe nichtprime Zahlen aus
for i2 to n do
if not gestrichen[i] then
for ji to n/i do
gestrichen[ji]TRUE
// gib Primzahlen aus
for i2 to n do
if not gestrichen[i] then print i
Primzahlbestimmung in [k
3
,(k+1)
3
]:
Wende Sieb des Eratosthenes mit Werten
von 1 bis (k+1)
3
auf [k
3
,(k+1)
3
] an.
Laufzeit:
13. Hashing
49
Laufzeit:
Es gibt (k
2
) Elemente in [k
3
, (k+1)
3
]
Sieb des Eratosthenes mit Wert i auf
[k
3
,(k+1)
3
] : Laufzeit (k
2
/i).
Gesamtlaufzeit:
i
(k
2
/i) = (k
2
ln k)=o(m)
Perfektes Hashing
Soll nur Einfgen und Suchen untersttzt werden und
werden alle Objekte zu Beginn eingefgt, so kann
Hashing verbessert werden.
n Objekte werden zu Beginn in Zeit (n) eingefgt.
Jede Suche bentigt danach im worst-case Zeit (1).
13. Hashing
50
Jede Suche bentigt danach im worst-case Zeit (1).
Idee wie bei Hashing mit Kollisionsverwaltung. Allerdings
werden nicht Listen zur Kollisionsverwaltung benutzt,
sondern wieder Hashtabellen.
Verfahren wird perfektes Hashing genannt.
Exkurs in Wahrscheinlichkeitstheorie:
Zufallsvariable: X:U
Erwartungswert von X:
E[X] =
uU
Pr[u]X(u)
=
x
xPr[X=x]
Perfektes Hashing
Markov Ungleichung: Fr jede nichtnegative
Zufallsvariable X: gilt:
Pr[XkE[X]]1/k
Beweis:
E[X]
xk
xPr[X=x]
xk
kPr[X=x]=kPr[Xk]
12.05.2011 Kapitel 4 51
Ziel: perfekte Hashtabelle
1 3 5 14 19 10
Perfektes Hashing
13. Hashing
52
14 5 1 3 19 10
S: feste Menge an Elementen
H
m
: Familie c-universeller Hashfunktionen auf
{0,,m-1}
C(h) fr ein hH
m
: Anzahl Kollisionen zwischen
Elementen in S fr h, d.h.
C(h) = |{(x,y): x,yS, xy, h(x)=h(y)}|
Perfektes Hashing
13. Hashing
53
C(h) = |{(x,y): x,yS, xy, h(x)=h(y)}|
14
5
1 3
19
10
C(h) = 2+6 = 8
Lemma 13.6: E[C(h)]cn(n-1)/m, und fr
mindestens die Hlfte der hH ist
C(h)2cn(n-1)/m.
Beweis:
Zufallsvariable X {0,1} fr jedes Paar e,eS
Perfektes Hashing
13. Hashing
54
Zufallsvariable X
e,e
{0,1} fr jedes Paar e,eS
X
e,e
= 1 h(key(e))=h(key(e))
Es gilt: C(h) =
ee
X
e,e
E[C(h)] =
ee
E[X
e,e
]
ee
(c/m) = cn(n-1)/m
fr 1/2 der hH ist C(h)2cn(n-1)/m:
Nach Markov:
Pr[X kE[X]] 1/k
Also gilt
Perfektes Hashing
13. Hashing
55
Also gilt
Pr[C(h) 2cn(n-1)/m]
Da die Hashfunktion uniform zufllig
gewhlt wird, folgt Behauptung.
b
i
h
: Anzahl Elemente, fr die h(key(x))=i ist
Lemma 13.7: C(h) =
i
b
i
h
(b
i
h
-1).
Beweis:
Zufallsvariable C(h): Anzahl Kollisionen in
Perfektes Hashing
13. Hashing
56
Zufallsvariable C
i
(h): Anzahl Kollisionen in
T[i]
Es gilt: C
i
(h) = b
i
h
(b
i
h
-1).
Also ist C(h) =
i
C
i
(h) =
i
b
i
h
(b
i
h
-1).
Konstruktion der Hashtabelle:
1) Wahl einer Hashfunktion h fr S:
Whle eine Funktion hH
n
mit
C(h)2cn(n-1)/( n) = 2cn/, konstant
(Lemma 13.6: zufllige Wahl mit Wahrschein-lichkeit
1/2 erfolgreich)
Fr jede Position T[i] seien m = 2c b
h
(b
h
-1)+1 und
Perfektes Hashing
13. Hashing
57
Fr jede Position T[i] seien m
i
= 2c b
i
h
(b
i
h
-1)+1 und
S
i
= { xS | h(key(x))=i }
2) Wahl einer Hashfunktion h
i
fr jedes S
i
:
Whle eine Funktion h
i
H
m
i
mit C(h
i
)<1
(Lemma 13.6: zufllige Wahl mit Wahrschein-lichkeit
1/2 erfolgreich)
1 3 5 14 19 10
i
h
j
Gre m
Perfektes Hashing
13. Hashing
58
i
10 5 14 19 1
h
i
h
j
j
Keine Kollisionen in Subtabellen
Gre m
i
Gre m
j
1 3 5 14 19 10
s
i
,h
i
Tabellengre: m=n
s
j
,h
j
T
1
Perfektes Hashing
13. Hashing
59
s
i
,h
i
s
j
,h
j
10 5 14 19 1
.
s
i
= m
0
+m
1
++m
i-1
: Offsets fr T
2
Tabellengre:
i
m
i

i
(2cb
i
h
(b
i
h
-1)+1) 4cn/ + n
T
1
T
2
Satz 13.8: [Fredman, Komlos, Szemeredi]
Fr jede Menge von n Schlsseln gibt es
eine perfekte Hashfunktion der Gre
(n), die in erwarteter Zeit (n) konstruiert
Perfektes Hashing
13. Hashing
60
(n), die in erwarteter Zeit (n) konstruiert
werden kann.
14. Elementare Graphalgorithmen
Graphen sind eine der wichtigsten Modellierungskonzepte
der Informatik
Graphalgorithmen bilden die Grundlage vieler
Algorithmen in der Praxis
bersicht:
Zunchst eine kurze Einfhrung in Graphen.
1
Zunchst eine kurze Einfhrung in Graphen.
Dann Darstellungen von Graphen
Schlielich einfache Graphalgorithmen:
Breiten- und Tiefensuche, Zusammenhangskomponenten,
Minimalspannende Bume
Wiederholung Graphen Gerichtete Graphen
Ein gerichteter Graph G ist ein Paar (V,E), wobei V
eine endliche Menge ist und V V E .

Elemente aus V heien Knoten, Elemente aus E
heien Kanten. Entsprechend heit V Knotenmenge
und E heit Kantenmenge von G.

Kanten sind geordnete Paare von Knoten. Kanten der
Form (u,u), V u , sind zugelassen und heien
2
Form (u,u), V u , sind zugelassen und heien
Schleifen.

Ist ( ) E v , u , so sagen wir, dass die Kante von u nach
v fhrt. Sagen auch, dass u und v adjazent sind.
Mssen dann aber noch Richtung bercksichtigen.

Der Grad eines Knotens v ist die Anzahl der Kanten
(v,w) in E.
Illustration gerichteter Graph
1 2 3
{ }
( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) { } 3 , 6 , 4 , 5 , 5 , 4 , 1 , 4 , 5 , 2 , 4 , 2 , 2 , 2 , 2 , 1 E
6 , 5 , 4 , 3 , 2 , 1 V
=
=
3
5 4
6
Wiederholung Graphen Ungerichtete Graphen
Ein ungerichteter Graph G ist ein Paar (V,E), wobei V
eine endliche Menge ist und E eine Menge von
2-elementigen Teilmengen von V ist.

Elemente aus V heien Knoten, Elemente aus E
heien Kanten. Entsprechend heit V Knotenmenge
und E heit Kantenmenge von G.

4

Formal haben Kanten die Form { } V v u, mit v , u .
Schreiben aber wie bei gerichteten Graphen Kanten
als Paare (u,v), unterscheiden dabei aber nicht
zwischen (u,v) und (v,u). Kanten der Form (u,u)
sind nicht zugelassen.

Ist ( ) E v , u , so sagen wir, dass u und v adjazent sind.

Illustration ungerichteter Graph
1 2 3
{ }
( ) ( ) ( ) ( ) { } 3 , 6 , 5 , 2 , 5 , 1 , 2 , 1 E
6 , 5 , 4 , 3 , 2 , 1 V
=
=
5
5 4
6
n: Anzahl Knoten, m: Anzahl Kanten
(v,w): Distanz von w zu v in G (d.h. Anzahl Kanten
eines krzesten gerichteten Weges von v nach w)
D=max
v,w
(v,w): Durchmesser von G
Graphentheorie
6
A
D
B
C
D=4
E
G heit
(schwach) zusammenhngend: Durchmesser D
endlich, wenn alle Kanten ungerichtet
stark zusammenhngend: D endlich
Graphentheorie
7
A
D
B
C
E
Lineare Liste:
Grad 2
Graphentheorie
8
Grad 2
Hoher Durchmesser (n-1 fr n Knoten)
Vollstndiger binrer Baum:
0
Hhe h
Graphentheorie
9
n=2
h+1
-1 Knoten, Grad 3
Durchmesser ist 2h ~ 2 log
2
n
h
2-dimensionales Gitter:
1
Seitenlnge k
Graphentheorie
10
n = k
2
Knoten, maximaler Grad 4
Durchmesser ist 2(k-1) ~ 2 n
k
Hypercube:
Knoten: (x
1
,,x
d
){0,1}
d
Kanten: i: (x
1
,,x
d
)(x
1
,..,x
i-1
,1-x
i
,x
i+1
,..,x
d
)
Graphentheorie
11
d=1 d=2 d=3
Grad d, Durchmesser d
G=(V,E): Graph-Variable
Operationen:
Insert(G,e): E:=E{e}
Remove(G,i,j): E:=E\{e} fr die Kante e=(v,w) mit
key[v]=i und key[w]=j
Insert(G,v): V:=V{v}
Operationen auf Graphen
12
Insert(G,v): V:=V{v}
Remove(G,i): sei vV der Knoten mit key[v]=i.
V:=V\{v}, E:=E\{(x,y) | x=v y=v}
Search(G,i): gib Knoten v aus mit key[v]=i
Search(G,i,j): gib Kante (v,w) aus mit key[v]=i und
key[w]=j
Anzahl der Knoten oft fest. In diesem Fall:
V={1,,n} (Knoten hintereinander
nummeriert, identifiziert durch ihre Keys)
Relevante Operationen:

13
Insert(G,e): E:=E{e}
Remove(G,i,j): E:=E\{e} fr die Kante
e=(i,j)
Search(G,i,j): gib Kante e=(i,j) aus
Anzahl der Knoten variabel:
Hashing (z.B. Kuckuckshashing) kann ver-
wendet werden, um Keys von n Knoten in
Bereich {1,,O(n)} zu hashen.
14
Damit kann variabler Fall auf den Fall
einer statischen Knotenmenge reduziert
werden. (Nur O(1)-Vergrerung
gegenber statischer Datenstruktur)
Im folgenden: Konzentration auf statische
Anzahl an Knoten.
Parameter fr Laufzeitanalyse:
n: Anzahl Knoten
15
n: Anzahl Knoten
m: Anzahl Kanten
d: maximaler Knotengrad (maximale
Anzahl ausgehender Kanten von Knoten)
1. Sequenz von Kanten
2. Adjazenzfeld
3. Adjazenzliste
4. Adjazenzmatrix
Graphreprsentationen
16
4. Adjazenzmatrix
5. Adjazenzliste + Hashtabelle
6. Implizite Reprsentationen
1: Sequenz von Kanten
1 2
17
4 3
(1,2) / (4,1) (3,4) (2,3)
Dummy
(1,2) / (4,1) (3,4) (2,3)
18
Zeitaufwand:
Search(G,i,j): (m) im worst case
Insert(G,e): O(1)
Remove(G,i,j): (m) im worst case
2: Adjazenzfeld
1 2
1 3 5 6 V
1
n
offsets in Feld E
19
4 3
2 3 3 4 4 1
E
1 m
Hier: nur Zielkeys
In echter DS: E: Array [1..m] of Edge
(1,2),(1,3) (3,4)
1 2
4 3
1 3 5 6
2 3 3 4 4 1
V
E
offsets in Feld E
20
Zeitaufwand:
Search(G,i,j): Zeit O(d)
Insert(G,e): Zeit O(n+m) (worst case)
Remove(G,i,j): Zeit O(n+m) (worst case)
wegen Verschiebungen in E
3: Adjazenzliste
1 2
V
1 n
21
4 3
2
3
3
4
4 1
Hier: nur Zielkeys
In echter DS: V: Array [1..n] of List of Edge
1 2
4 3
2
3
V
3
4
4 1
22
Zeitaufwand:
Search(G,i,j): Zeit O(d)
Insert(G,e): Zeit O(1)
Remove(G,i,j): Zeit O(d)
Problem: d kann
gro sein!
4: Adjazenzmatrix
1 2
0 1 1 0
0 0 1 1
0 0 0 1
A =
23
A[i,j]{0,1} (bzw. Zeiger auf Edge)
A[i,j]=1 genau dann, wenn (i,j)E
4 3
0 0 0 1
1 0 0 0
1 2
4 3
0 1 1 0
0 0 1 1
0 0 0 1
1 0 0 0
A =
24
Zeitaufwand:
Search(G,i,j): Zeit O(1)
Insert(G,e): Zeit O(1)
Remove(G,i,j): Zeit O(1)
Aber: Speicher-
aufwand (n
2
)
5: Adjazenzliste + Hashtabelle
1 2
e
1
V
e
3
e
5
e
6
e
1
e
2
e
3
e
4
e
6
25
4 3
e
2
e
4
1,2 1,3 2,3 2,4 3,4 4,1
e
5
z.B. Kuckuckshashing
Zeitaufwand (Kuckucksh.):
Search(G,i,j):
O(1) (worst case)
Insert(G,e):
e
1
e
2
V
e
3
e
4
e
5
e
6
26
Insert(G,e):
O(1) (erwartet)
Remove(G,i,j):
O(1) (worst case)
Speicher: O(n+m)
e
2
e
4
1,2 1,3 2,3 2,4 3,4 4,1
6: Implizite Reprsentationen
(k,l)-Gitter G=(V,E):
V=[k][l] ([a]={0,,a-1} fr a)
E={((v,w),(x,y)) | (v=x |w-y|=1)
27
(w=y |v-x|=1)}
Beispiel: (5,4)-Gitter
6: Implizite Reprsentationen
(k,l)-Gitter G=(V,E):
V=[k][l] ([a]={0,,a-1} fr a)
E={((v,w),(x,y)) | (v=x |w-y|=1)
(w=y) |v-x|=1)}
28
(w=y) |v-x|=1)}
Speicheraufwand: O(log k + log l)
(speichere Kantenregel sowie k und l)
Search-Operation: O(1) Zeit (reine Rechnung)
Zentrale Frage: Wie knnen wir die Knoten
eines Graphen durchlaufen, so dass jeder
Knoten mindestens einmal besucht wird?
Graphdurchlauf
29
Zentrale Frage: Wie knnen wir die Knoten
eines Graphen durchlaufen, so dass jeder
Knoten mindestens einmal besucht wird?
Graphdurchlauf
30
Grundlegende Strategien:
Breitensuche
Tiefensuche
Starte von einem Knoten s
Exploriere Graph Distanz fr Distanz
Breitensuche
31
s
Starte von einem Knoten s
Exploriere Graph in die Tiefe
( : aktuell, : noch aktiv, : fertig)
Tiefensuche
32
s
Breitensuche berblick (1)
Die Breitensuche ist ein Algorithmus, der die
Grundlage vieler Graphenalgorithmen bildet.

Ziel der Breitensuche ist es, bei einem Graphen
G=(V,E) und einer Quelle V s alle Knoten V v
zu finden, die von s aus erreichbar sind. Dabei ist
ein Knoten v von s aus erreichbar, wenn es in G
33
ein Knoten v von s aus erreichbar, wenn es in G
einen Pfad von s nach v gibt.

Die Breitensuche berechnet auch fr alle Knoten v
den Abstand ( ) v , s von s zu v. Dabei ist der Abstand
von s zu v die minimale Anzahl von Kanten auf einem
Pfad von s nach v.

Breitensuche - berblick (2)
Wird v entdeckt, whrend [ ] u Adj nach neuen Knoten
durchsucht wird, so heisst u Vorgnger von v.
(Adj[u]: Menge der Nachbarn von u)

Knoten sind entweder wei, grau oder schwarz.

Wei sind alle noch nicht entdeckten Knoten.

34

Grau sind alle entdeckten Knoten, deren
Adjazenzliste noch nicht vollstndig nach neuen
Knoten durchsucht wurde.

Schwarz sind alle anderen Knoten, d.h., schwarze
Knoten wurden bereits entdeckt und ihre Adjazenz-
liste wurde vollstndig durchsucht.

Pseudocode fr Breitensuche
( )
{ }
[ ]
[ ]
[ ]
[ ]
[ ]
[ ]
{ }
( ) s , Q Enqueue 9
Q 8
NIL s 7
0 s d 6
GRAY s color 5
NIL u 4
u d 3
WHITE u color 2
s \ V in u Knoten jeden 1
s , G BFS

do
for
BFS benutzt Queue fr graue Knoten.

[ ] = : u color Feld fr Farbe von v. Initial
WHITE.

[ ] = : u d Feld fr bislang berechneten
Abstand zu s. Initial .

35
( )
{ }
( )
[ ]
[ ]
[ ]
[ ] [ ]
[ ]
( )
[ ] BLACK u color 18
v , Q Enqueue 17
u v 16
1 u d v d 15
GRAY v color 14
WHITE v color 13
u Adj v 12
Q Dequeue u 11
Q 10
s , Q Enqueue 9
then
if do
for
do
while

[ ] = : u Feld fr Vorgnger. Initial NIL.
( )
{ }
[ ]
[ ]
[ ]
[ ]
[ ]
[ ]
{ }
( ) s , Q Enqueue 9
Q 8
NIL s 7
0 s d 6
GRAY s color 5
NIL u 4
u d 3
WHITE u color 2
s \ V in u Knoten jeden 1
s , G BFS

do
for
Pseudocode fr Breitensuche
BFS benutzt Queue fr graue Knoten.

[ ] = : u color Feld fr Farbe von v. Initial
WHITE.

[ ] = : u d Feld fr bislang berechneten
Abstand zu s. Initial .

( )
{ }
( )
[ ]
[ ]
[ ]
[ ] [ ]
[ ]
( )
[ ] BLACK u color 18
v , Q Enqueue 17
u v 16
1 u d v d 15
GRAY v color 14
WHITE v color 13
u Adj v 12
Q Dequeue u 11
Q 10
s , Q Enqueue 9
then
if do
for
do
while
36

[ ] = : u Feld fr Vorgnger. Initial NIL.
initialisiere BFS
BFS(G,s)
1. initialisiere BFS
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
i
h
g
f
e
d
c
b
a
Breitensuche - Beispiel
37
4. for vAdj[u] do
5. if color[v]=WHITE then
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: s
37
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
i
h
g
f
e
d
c
b
a
38
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: s
38
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
u
0
i
h
g
f
e
d
c
b
a
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
39
Q:
39
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
u
0
i
h
g
f
e
d
c
b
v=a
40
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q:
40
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
u
0
i
h
g
f
e
d
c
b
v=a
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
41
Q:
41
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
u
0
i
h
g
f
e
d
c
b
v=a
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
42
Q:
42
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
u
0
1
i
h
g
f
e
d
c
b
v=a
43
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q:
43
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
u
0
1
i
h
g
f
e
c
b
v=a
44
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: a
44
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
u
0
1
i
h
g
f
e
d
c
v=b
a
45
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: a
45
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
u
0
1
i
h
g
f
e
d
c
v=b
a
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
46
Q: a
46
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
u
0
1
i
h
g
f
e
d
c
v=b
a
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
47
Q: a
47
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
u
0
1
i
h
g
f
e
d
c
v=b
a
48
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: a
1
48
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
u
0
1
i
h
g
f
e
d
c
v=b
a
49
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: a, b
1
49
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
u
0
1
i
h
g
f
e
d
c
b
a
50
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: a, b
1
50
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
u
0
1
i
h
g
f
e
d
c
b
a
51
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: a, b
1
51
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
d
c
b
u=a
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
52
Q: b
1
52
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
v=d
c
b
u=a
53
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: b
1
53
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
v=d
c
b
u=a
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
54
Q: b
1
54
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
v=d
c
b
u=a
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
55
Q: b
1
55
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
v=d
c
b
u=a
2
56
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: b
1
56
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
v=d
c
b
u=a
2
57
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: b, d
1
57
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
d
v=c
b
u=a
2
58
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: b, d
1
58
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
d
v=c
b
u=a
2
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
59
Q: b, d
1
59
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
d
v=c
b
u=a
2
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
60
Q: b, d
1
60
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
d
v=c
b
u=a
2
2
61
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: b, d
1
61
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
d
v=c
b
u=a
2
2
62
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: b, d, c
1
62
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
d
v=c
b
u=a
2
2
63
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: b, d, c
1
63
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
d
v=c
b
u=a
2
2
64
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: b, d, c
1
64
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
d
v=c
u=b
a
2
2
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
1
65
Q: d, c
65
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
d
v=c
u=b
a
2
2
66
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: d, c
1
66
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
d
v=c
u=b
a
2
2
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
67
Q: d, c
1
67
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
d
v=c
u=b
a
2
2
68
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: d, c
1
68
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
e
u=d
v=c
b
a
2
2
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
69
Q: c
1
69
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
v=e
u=d
c
b
a
2
2
70
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: c
1
70
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
f
v=e
u=d
c
b
a
2
2
3
71
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: c, e
1
71
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
v=f
e
u=d
c
b
a
2
2
3
72
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: c, e
1
72
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
s
0
1
i
h
g
v=f
e
u=d
c
b
a
2
2
3
73
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: c, e, f
1
3
73
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
g
f
e
u=d
c
b
a
2
2
3
74
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: c, e, f
1
3
74
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
g
f
e
u=d
c
b
a
2
2
3
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
75
Q: c, e, f
1
3
75
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
g
f
e
u=d
c
b
a
2
2
3
76
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: c, e, f
1
3
76
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
g
f
e
d
u=c
b
a
2
2
3
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
77
Q: e, f
1
3
77
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
g
f
e
d
u=c
b
a
2
2
3
78
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: e, f
1
3
78
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
g
f
e
d
u=c
b
a
2
2
3
79
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: e, f
1
3
79
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
g
f
u=e
d
c
b
a
2
2
3
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
80
Q: f
1
3
80
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
g
f
u=e
d
c
b
a
2
2
3
4
81
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: f, g
1
3
81
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
g
f
u=e
d
c
b
a
2
2
3
4
82
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: f, g
1
3
82
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
g
u=f
e
d
c
b
a
2
2
3
4
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
83
Q: g
1
3
83
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
g
u=f
e
d
c
b
a
2
2
3
4
84
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: g, i
1
3 4
84
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
g
u=f
e
d
c
b
a
2
2
3
4
85
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: g, i
1
3 4
85
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
u=g
f
e
d
c
b
a
2
2
3
4
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
86
Q: i
1
3 4
86
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
u=g
f
e
d
c
b
a
2
2
3
4
5
87
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: i, h
1
3 4
87
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
h
u=g
f
e
d
c
b
a
2
2
3
4
5
88
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: i, h
1
3 4
88
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
u=i
h
g
f
e
d
c
b
a
2
2
3
4
5
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
89
Q: h
1
3 4
89
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
u=i
h
g
f
e
d
c
b
a
2
2
3
4
5
90
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: h
1
3 4
90
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
u=i
h
g
f
e
d
c
b
a
2
2
3
4
5
91
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q: h
1
3 4
91
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
u=h
g
f
e
d
c
b
a
2
2
3
4
5
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
92
Q:
1
3 4
92
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
u=h
g
f
e
d
c
b
a
2
2
3
4
5
93
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q:
1
3 4
93
BFS(G,s)
2. while Q do
3. u Dequeue(Q)
4. for vAdj[u] do
v=s
0
1
i
u=h
g
f
e
d
c
b
a
2
2
3
4
5
94
4. for vAdj[u] do
6. color[v] GRAY
7. d[v] d[u]+1; [v] u
8. Enqueue(Q,v)
9. color[u] BLACK
Q:
1
3 4
94
Breitensuche Laufzeitanalyse
Zeilen 2-4 jeweils konstante Zeit. Werden 1 V mal
durchlaufen. Damit Zeit ( ) V O .

Zeilen 5-9 insgesamt konstante Zeit.

Jeder Knoten wird nur einmal in Queue eingefgt
und gelscht.
95
und gelscht.

Schleife in Zeilen 12 -17 wird fr jeden Eintrag v in
Adjazenzlisten nur einmal durchlaufen.

Zeilen 12-17 pro Durchlauf Zeit ( ) 1 O .
Breitensuche Laufzeitanalyse
Gesamtzeit fr Durchlufe der Schleife in
Zeilen 11-18 insgesamt ( ) E O . Denn Gesamtgre
aller Adjazenzlisten ( ) E .

96
Satz 14.1: Bei Eingabe von Graph G=(V,E) und
Quelle s besitzt Algorithmus BFS Laufzeit
( ) E V + O
Breitensuche Erreichbarkeit, Krzeste Pfade (1)
Lemma 14.2: Sei G= (V,E) ein gerichteter oder
ungerichteter Graph. Sei V s beliebig. Fr
jede Kante ( ) E v , u gilt

Lemma 14.3: Sei G=(V,E) ein gerichteter oder
( ) ( ) . 1 u , s v , s +
97
Lemma 14.3: Sei G=(V,E) ein gerichteter oder
ungerichteter Graph. Sei V s beliebig und s,G
Eingabe fr BFS. Nach Beendigung von BFS gilt
fr jeden Knoten V v

[ ] ( ). v , s v d
Lemma 14.4: Die Queue Q enthalte zu einem beliebigen
Zeitpunkt des Ablaufs von BFS die Knoten ( )
r 1
v , , v K ,
wobei
1
v der Kopf [ ] Q head und
r
v das Ende [ ] Q tail
sei. Dann gilt
[ ] [ ] [ ] [ ] 1. - r , 1, i , v d v d und 1 v d v d
1 i i 1 r
K = +
+
98
Korollar 14.5: Knoten
i
v werde whrend des Ablaufs
von BFS vor Knoten
j
v in die Queue Q eingefgt.
Zum Zeitpunkt, an dem
j
v in die Queue Q eingefgt
wird, gilt

[ ] [ ]. v d v d
j i

Satz 14.6: Sei G=(V,E) ein gerichteter oder
ungerichteter Graph. Sei V s beliebig und s,G
Eingabe fr BFS. Nach Beendigung von BFS gilt
fr jeden Knoten V v

Insbesondere sind die von s aus erreichbaren
Knoten v die Knoten mit [ ] < v d .
[ ] ( ). v , s v d =
99
Knoten v die Knoten mit [ ] < v d .

Weiter ist fr jeden von s aus erreichbaren Knoten
s v ein krzester Pfad von s zu v gegeben durch
einen krzesten Pfad von s zum Vorgnger [ ] v
von v erweitert um die Kante [ ] ( ) v , v .
Breitensuchbume
Betrachten nach BFS mit Eingabe G,s den Graphen
( )

= E , V G mit

und

Dann gilt
[ ] { } { }. s NIL v | V v V =
[ ] ( ) { } { }. s \ V v | v , v : E

=
100
Dann gilt

Satz 14.7: ( )

= E , V G ist ein Baum.
V enthlt genau
die von s aus erreichbaren Knoten in G. Fr jeden
Knoten
V v ist der eindeutige Pfad von s zu v in

G ein krzester Pfad von s zu v in G.

Tiefensuche
Suche zunchst tiefer im Graph
Neue Knoten werden immer vom zuletzt gefundenen
Knoten entdeckt
Sind alle adjazenten Knoten des zuletzt gefundenen
Knoten v bereits entdeckt, springe zurck zum Knoten,
101
Knoten v bereits entdeckt, springe zurck zum Knoten,
von dem aus v entdeckt wurde
Wenn irgendwelche unentdeckten Knoten brigbleiben,
starte Tiefensuche von einem dieser Knoten
Invariante Tiefensuche:
Zu Beginn: alle Knoten wei
Entdeckte Knoten werden grau
Abgearbeitete Knoten werden schwarz
Tiefensuche
102
Zwei Zeitstempel: d[v] und f[v] (liegen zwischen 1 und 2 |V|)
d[v]: v ist entdeckt
f[v]: v ist abgearbeitet
Tiefensuche
DFS(G)
1. for each vertex uV do color[u] wei ; [u] nil
2. time 0
3. for each vertex uV do
4. if color[u]=wei then DFS-Visit(u)
DFS-Visit(u)
103
DFS-Visit(u)
1. color[u] grau
2. time time +1; d[u] time
4. for each vAdj[u] do
5. if color[v] = wei then [v] u ; DFS-Visit(v)
6. color[u] schwarz
7. time time+1; f[u] time
103
DFS(G)
2. time 0
DFS-Visit(u)
Tiefensuche
104
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
104
DFS(G)
2. time 0
DFS-Visit(u)
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
105
DFS(G)
2. time 0
DFS-Visit(u)
time=0
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
106
DFS(G)
2. time 0
DFS-Visit(u)
time=0
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
107
u
107
DFS(G)
2. time 0
DFS-Visit(u)
time=0
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
108
u
108
DFS(G)
2. time 0
DFS-Visit(u)
time=0
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
109
u
109
DFS(G)
2. time 0
DFS-Visit(u)
time=1
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
110
u
1
110
DFS(G)
2. time 0
DFS-Visit(u)
time=1
v
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
111
u
1
111
DFS(G)
2. time 0
DFS-Visit(u)
time=1
v
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
112
u
1
112
DFS(G)
2. time 0
DFS-Visit(u)
time=1
u
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
113
1
113
DFS(G)
2. time 0
DFS-Visit(u)
time=2
u
2
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
114
1
2
114
DFS(G)
2. time 0
DFS-Visit(u)
time=2
u
2
v
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
115
1
2
115
DFS(G)
2. time 0
DFS-Visit(u)
time=2
u
2
v
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
116
1
2
116
DFS(G)
2. time 0
DFS-Visit(u)
time=2
2
u
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
117
1
2
117
DFS(G)
2. time 0
DFS-Visit(u)
time=3
2
u
3
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
118
1
2
118
DFS(G)
2. time 0
DFS-Visit(u)
time=3
2
u
3
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
119
1
2
119
DFS(G)
2. time 0
DFS-Visit(u)
time=3
2
u
3
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
120
1
2
120
DFS(G)
2. time 0
DFS-Visit(u)
time=4
2
3
4
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
121
1
2
121
DFS(G)
2. time 0
DFS-Visit(u)
time=4
2
3
4
u
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
122
1
2
v
122
DFS(G)
2. time 0
DFS-Visit(u)
time=4
2
3
4
u
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
123
1
2
v
123
DFS(G)
2. time 0
DFS-Visit(u)
time=4
2
3
4
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
124
1
2
u
124
DFS(G)
2. time 0
DFS-Visit(u)
time=5
2
3
4
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
125
1
2
u
5
125
DFS(G)
2. time 0
DFS-Visit(u)
time=5
2
3
4
v
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
126
1
2
u
5
v
126
DFS(G)
2. time 0
DFS-Visit(u)
time=5
2
3
4
v
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
127
1
2
u
5
v
127
DFS(G)
2. time 0
DFS-Visit(u)
time=5
2
3
4
v
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
128
1
2
u
5
v
128
DFS(G)
2. time 0
DFS-Visit(u)
time=6
2
3
4
u
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
129
1
2
5
u
6
129
DFS(G)
2. time 0
DFS-Visit(u)
time=6
2
3
4
u
v
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
130
1
2
5
u
6
130
DFS(G)
2. time 0
DFS-Visit(u)
time=6
2
3
4
u
v
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
131
1
2
5
u
6
131
DFS(G)
2. time 0
DFS-Visit(u)
time=6
2
3
4
u
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
132
1
2
5
u
6
v
132
DFS(G)
2. time 0
DFS-Visit(u)
time=6
2
3
4
u
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
133
1
2
5
u
6
v
133
DFS(G)
2. time 0
DFS-Visit(u)
time=6
2
3
4
u
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
134
1
2
5
u
6
v
134
DFS(G)
2. time 0
DFS-Visit(u)
time=7
2
3
4
7
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
135
1
2
5
7
6
v
135
DFS(G)
2. time 0
DFS-Visit(u)
time=7
2
3
4
7
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
136
1
2
5
7
6
u
136
DFS(G)
2. time 0
DFS-Visit(u)
time=8
2
3
4
7
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
137
1
2
5
7
6
8
137
DFS(G)
2. time 0
DFS-Visit(u)
time=8
2
3
4
7
u
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
138
1
2
5
7
6
8
138
DFS(G)
2. time 0
DFS-Visit(u)
time=9
2
3
4
7
9
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
139
1
2
5
7
6
8
139
DFS(G)
2. time 0
DFS-Visit(u)
time=9
2
3
4
7
9
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
140
1
2
5
7
6
8
u
v
140
DFS(G)
2. time 0
DFS-Visit(u)
time=9
2
3
4
7
9
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
141
1
2
5
7
6
8
u
v
141
DFS(G)
2. time 0
DFS-Visit(u)
time=9
2
3
4
7
9
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
142
1
2
5
7
6
8
u
142
DFS(G)
2. time 0
DFS-Visit(u)
time=10
2
3
4
7
9
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
143
1
2
5
7
6
8
u
10
143
DFS(G)
2. time 0
DFS-Visit(u)
time=10
2
3
4
7
9
v
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
144
1
2
5
7
6
8
u
10
144
DFS(G)
2. time 0
DFS-Visit(u)
time=10
2
3
4
7
9
v
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
145
1
2
5
7
6
8
u
10
145
DFS(G)
2. time 0
DFS-Visit(u)
time=10
2
3
4
7
9
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
146
1
2
5
7
6
8
u
10
v
146
DFS(G)
2. time 0
DFS-Visit(u)
time=10
2
3
4
7
9
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
147
1
2
5
7
6
8
u
10
v
147
DFS(G)
2. time 0
DFS-Visit(u)
time=10
2
3
4
7
9
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
148
1
2
5
7
6
8
u
10
v
148
DFS(G)
2. time 0
DFS-Visit(u)
time=11
2
3
4
7
9
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
149
1
2
5
7
6
8
10
v
11
149
DFS(G)
2. time 0
DFS-Visit(u)
time=11
2
3
4
7
9
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
150
1
2
5
7
6
8
10
11
150
DFS(G)
2. time 0
DFS-Visit(u)
time=12
2
3
4
7
9
Tiefensuche
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
151
1
2
5
7
6
8
10
11
12
151
time=12
2
3
4
7
9
Tiefensuche
DFS(G)
2. time 0
DFS-Visit(u)
152
1
2
5
7
6
8
10
11
12
Laufzeit:
O(|V|+|E|)
152
DFS-Visit(u)
1. color[u] grau
6. color[u] schwarz
152
Satz 14.8 (Klammersatz zur Tiefensuche):
In jeder Tiefensuche eines gerichteten oder ungerichteten
Graphen gilt fr jeden Knoten u und v genau eine der
folgenden drei Bedingungen:
Die Intervalle [d[u],f[u]] und [d[v],f[v]] sind vollstndig
Tiefensuche
153
Die Intervalle [d[u],f[u]] und [d[v],f[v]] sind vollstndig
disjunkt
Intervall [d[u],f[u]] ist vollstndig im Interval [d[v],f[v]]
enthalten und u ist Nachfolger von v im DFS-Baum
Intervall [d[v],f[v]] ist vollstndig im Interval [d[u],f[u]]
enthalten und v ist Nachfolger von u im DFS-Baum
153
Beispiel:
2
3
7
9
a
b
e
c b
4
1 12
2 9 10 11
Tiefensuche
154
1
2
5
7
6
8
10
11
12
a
c d
f
d
f
e
2 9 10 11
3 4 5 8
6 7
154
Beispiel:
2
3
7
9
a
b
e
c b
4
1 12
2 9 10 11
Tiefensuche
155
Korollar 14.9:
Knoten v ist echter Nachfolger von Knoten u im DFS-Baum
von G, gdw. d[u]<d[v]<f[v]<f[u].
1
2
5
7
6
8
10
11
12
a
c d
f
d
f
e
2 9 10 11
3 4 5 8
6 7
155
Satz 14.10 (Satz vom weien Weg)
In einem DFS-Wald eines gerichteten oder ungerichteten
Graph G ist Knoten v ein Nachfolger von Knoten u, gdw.
zum Zeitpunkt d[u] v ber einen Pfad weier Knoten
erreicht werden kann.
Tiefensuche
156
erreicht werden kann.
1
u
2
v
156
Tiefensuche - Laufzeitanalyse
Satz 14.11: Bei Eingabe von Graph G=(V,E) besitzt
Algorithmus DFS Laufzeit ( ) E V + O .

Analyse: Wie bei Breitensuche. Nutzen aus dass
Gesamtgre aller Adjazenzlisten ( ) E O

157

Klassifikation von Kanten:
Baumkanten sind Kanten des DFS-Walds G
Rckwartskanten sind Kanten (u,v), die Knoten u mit
Ahnen von u im DFS-Baum verbinden
Vorwrtskanten sind die nicht-Baum Kanten (u,v), die u
mit einem Nachfolger v in einem DFS-Baum verbinden
Rckwrtskante
Tiefensuche
Kreuzungskanten sind alle brigen Kanten
1
2
3
5
7
6
8
9
10
11
12
a
b
c d
e
4
Rckwrtskante
158
Tiefensuche
1
2
3
5
7
6
8
9
10
11
12
a
b
c d
e
4
Vorwrtskante
159
Tiefensuche
1
2
3
5
7
6
8
9
10
11
12
a
b
c d
e
4
Kreuzungskante
160
Beobachtung fr Kante (v,w):
Kantentyp d[v]< d[w] f[v]>f[w]
Baum &
Vorwrts
Ja Ja
Tiefensuche
161
Vorwrts
Ja Ja
Rckwrts Nein Nein
Kreuz Nein Ja
Anwendung:
Erkennung eines azyklischen gerichteten
Graphen (engl. DAG)
Tiefensuche
162
Merkmal: keine gerichtete Kreise
Lemma 14.12: Das Folgende ist quivalent:
1. G ist ein DAG
2. DFS enthlt keine Rckwrtskante
3. (v,w)E: f[v]>f[w]
Tiefensuche
163
3. (v,w)E: f[v]>f[w]
Beweis:
2. , 3.: folgt aus Tabelle
1. G ist ein DAG
3. (v,w)E: f[v]>f[w]
Beweis:
Tiefensuche
164
Beweis:
2 1
gerichteter Kreis
1. G ist ein DAG
3. (v,w)E: f[v]>f[w]
Beweis:
Tiefensuche
165
Beweis:
1 2
Eine davon
Rckwrtskante
1. G ist ein DAG
3. (v,w)E: f[v]>f[w]
Beweis:
Tiefensuche
166
Beweis:
1 2
Annahme: Erster
von DFS besuch-
ter Knoten im
Kreis
DFS
Rckwrtskante
Zusammenfassung
Breitensuche: Zunchst alle Nachbarn abarbeiten;
liefert krzeste Wege in (ungewichteten) Graphen.
Laufzeit O(|V|+|E|).

Tiefensuche: Zunchst in die Tiefe gehen; Durchluft
alle Knoten eines Graphen in Zeit O(|V|+|E|).

167
15. Krzeste Wege
s
t
Gewichtete Graphen
Ein gewichteter Graph G ist ein Paar (V,E) zusammen
mit einer Gewichtsfunktion w, wobei V V E und
w: E IR.

Fr eE heit w(e) das Gewicht von e. Fr einen Weg
p mit Kanten e
1
,..e
k
heit w(p)=w(e
1
)+...+w(e
k
) das
Gewicht von p.
Gewicht von p.

Ein krzester Weg von Knoten u zum Knoten v ist der
Weg mit dem kleinsten Gewicht von u nach v.

Berechnung krzester Wege
Probleme:

Krzeste Wege von einem Startknoten s
(Single Source Shortest Path)

Krzeste Wege zwischen allen Knotenpaaren
(All Pairs Shortest Path)


Single Source Shortest Path (SSSP):
o Gegeben: Gewichteter Graph G und Startknoten s
o Gesucht: Fr alle Knoten v die Distanz (s,v) sowie
ein krzester Weg.
-
+ 0
- -
-
2 -3
-1 -3 s
0
-1 -2
-2
5
2
-1
0
0
-2
42
Krzeste Wege
(s,v): Distanz zwischen s und v
(s,v) = - Weg bel. kleiner Kosten von s nach v
kein Weg von s nach v
min{ w(p) | p ist Weg von s nach v}
2 -3
-1 -3
-1 -2
-2
5
2
-
+ 0
- -
- s
0
-1
0
0
-2
42
Krzeste Wege
Wann sind die Kosten -?
Wenn es einen negativen Kreis gibt:
s
v
C
w(C)<0
Negativer Kreis hinreichend und notwendig
fr Wegekosten -.
Negativer Kreis hinreichend:
s
v
C
w(C)<0
Weg p
Weg q
Krzeste Wege
s
v
C
w(C)<0
Kosten fr i-fachen Durchlauf von C:
w(p) + iw(C) + w(q)
Fr i geht Ausdruck gegen -.
Negativer Kreis hinreichend und notwendig
fr Wegekosten -.
Negativer Kreis notwendig:
l: minimale Kosten eines einfachen Weges
von s nach v
Krzeste Wege
von s nach v
es gibt nichteinfachen Weg r von s nach v mit
Kosten w(r)<l
r nicht einfach: Zerlegung in pCq, wobei C ein
Kreis ist und pq ein einfacher Pfad
da w(r) < lw(pq) ist, gilt w(C)<0
Gerichteter azyklischer Graph (DAG): Graph
ohne gerichtete Kreise
DAG mit Kantenkosten 1: Breitensuche
2
3
Krzeste Wege in DAGs
s
1
1
2
3
2
2
3
4
4
DAG mit beliebigen positiven Kantenkosten:
Reine Breitensuche funktioniert nicht.
1
2
4
8
1
2
1
1
2
1
s
1
2
6
3
5
7
9
1
2
4
3
1
1
1
2
2
1
Korrekte Distanzen:
1
2
4
5
1
2
1
1
2
1
s
1
2
4
3
5
4
6
1
2
4
3
1
1
1
2
2
1
Strategie: nutze aus, dass Knoten in DAGs
topologisch sortiert werden knnen (alle
Kanten erfllen a<b)
1
2
2
a b
2
4 5
10
s
1
2
1
4
3
1
1
2
1
2
1
2
1
1
2
3
6
7
8
9
11
Strategie: betrachte dann Knoten in der
Reihenfolge ihrer topologischen Sortierung
und aktualisiere Distanzen zu s
2
4
1
2
2 2
4 5
10
s
1
2
6
3
5
2
4
6
5
6
1
2
1
4
3
1
1
2
1
2
1
2
1
1
2
3
6
7
8
9
11
4
4
Konkret: fr jeden besuchten Knoten u:
fr alle Kanten (u,v)E:
setze Distanz d[v] auf min{d[v],d[u]+w(u,v)}
2
4
1
2
2 2
4 5
10
s
1
2
4
3
5
2
4
4
5
6
1
2
1
4
3
1
1
2
1
2
1
2
1
1
2
3
6
7
8
9
11
Strategie:
1. Topologische Sortierung der Knoten
2. Aktualisierung der Distanzen gem der
topologischen Sortierung
Warum funktioniert das??
Betrachte krzesten Weg von s nach v.
Dieser hat topologische Sortierung (t
i
)
i
mit
t
i
<t
i+1
for alle i.
t
1
t
2
t
3
t
4
t
5
Besuch in topologischer Reihenfolge fhrt
zu richtigen Distanzen (d
i
=
ji
w
i
).
0 d
1
d
2
d
3
d
4
s v
w
1
w
2
w
3
w
4
Betrachte krzesten Weg von s nach v.
Dieser hat topologische Sortierung (t
i
)
i
mit t
i
<t
i+1
fr
alle i.
s v
t
1
t
2
t
3
t
4
t
5
Bemerkung: kein Knoten auf dem Weg zu v kann
Distanz < d
i
zu s haben, da sonst krzerer Weg
zu v mglich wre.
0 d
1
d
2
d
3
d
4
s v
w
1
w
2
w
3
w
4
Allgemeine Strategie:
Am Anfang, setze d(s):=0 und d(v):= fr alle
Knoten
besuche Knoten in einer Reihenfolge, die
sicherstellt, dass mindestens ein krzester Weg
von s zu jedem v in der Reihenfolge seiner
Krzeste Wege
von s zu jedem v in der Reihenfolge seiner
Knoten besucht wird
fr jeden besuchten Knoten u, aktualisiere die
Distanzen der Knoten v mit (u,v)E, d.h. setze
d(v) := min{d(v), d(u)+w(u,v)}
Zurck zur Strategie:
Wie fhre ich eine topologische
Sortierung durch?
Topologische Sortierung:
Verwende eine FIFO Queue Q
Anfangs enthlt Q alle Knoten, die keine
eingehende Kante haben (Quellen).
Anfangs enthlt Q alle Knoten, die keine
eingehende Kante haben (Quellen).
Solange Q nicht leer ist, entnehme v aus Q und
markiere alle (v,w)E. Falls alle Kanten nach w
markiert sind und w noch nicht in Q war, fge w
in Q ein.
Reihenfolge, in der Knoten aus Q entnommen
werden, ergibt topologische Sortierung.
Beispiel:
: Knoten momentan in Queue Q
Nummerierung nach Einfgereihenfolge
4
6
1
2
2
1
2
3
7
5
8
4
6
9
10
11
1
2
1
4
3
1
1
2
1
2
1
2
1
Korrektheit der topologischen Nummerierung:
Knoten wird erst dann nummeriert, wenn alle
Vorgnger nummeriert sind.
4
6
1
2
2
1
2
3
7
5
8
4
6
9
10
11
1
2
1
4
3
1
1
2
1
2
1
2
1
Laufzeit: Zur Bestimmung aller Knoten ohne eingehende
Kante muss Graph einmal durchlaufen werden. Danach
wird jeder Knoten und jede Kante genau einmal
betrachtet, also Zeit O(n+m).
4
6
1
2
2
1
2
3
7
5
8
4
6
9
10
11
1
2
1
4
3
1
1
2
1
2
1
2
1
Bemerkung: topologische Sortierung kann nicht
alle Knoten nummerieren genau dann, wenn
Graph gerichteten Kreis enthlt (kein DAG ist)
4
6
1
2
2
Test auf DAG-Eigenschaft
1
2
3
7
5
8
4
6
9
10
11
1
2
1
4
3
1
1
2
1
2
1
2
1
DAG-Strategie:
Laufzeit O(n+m)
Laufzeit O(n+m)
Insgesamt Laufzeit O(n+m).
Nchster Schritt: Krzeste Wege fr beliebige
Graphen mit positiven Kantengewichten.
Problem: besuche Knoten eines krzesten Weges
in richtiger Reihenfolge
Krzeste Wege
Lsung: besuche Knoten in der Reihenfolge der
Distanz zur Quelle s
0 d
1
d
2
d
3
d
4
s v
w
Algorithmus von Dijkstra:
1. Es sei S die Menge der entdeckten Knoten
2. Zu Beginn: S={s} und d[s]=0
3. while VS do
4. Whle Knoten vV \ S mit mindestens einer Kante
Krzeste Wege
Annahme: Alle Kantengewichte sind positiv
26
4. Whle Knoten vV \ S mit mindestens einer Kante
aus S und fr den d[v] := min (d[u] + w(u,v)) minimal
unter allen vV \ S ist
5. Fge v zu S hinzu
(u,v)(S,V\S)
Wie kann man Pfade berechnen?
Wie bei BFS/DFS ber Feld
Wenn (u,v) die Kante, ist fr die das Minimum in Zeile 4
erreicht wird, dann setze [v] u
Krzester s-u-Weg P(u) ist implizit gespeichert:
Krzeste Wege
27
Krzester s-u-Weg P(u) ist implizit gespeichert:
Fr u=s haben wir den leeren Weg als krzesten Weg
von s nach s
Fr u s gilt:
P(u) besteht aus Weg P((u)) gefolgt von Kante ([u],u)
Satz 15.1 (Korrektheit):
[u]: Lnge des krzesten Weges von s nach u
(S): Menge der Knoten in V\S mit Kante aus S
Invariante:
1. Fr jedes uS: d[u]=[u] und d[u]min
v(S)
[u]
2. Fr jedes v(S): d[v][v]
Krzeste Wege
28
2. Fr jedes v(S): d[v][v]
Beweisskizze:
S
Knoten v mit minimalem d[v]
Wie kann man Dijkstras Algorithmus effizient
implementieren?
Naiver Ansatz: berprfe fr jeden Knoten aus V\S alle
Kanten (Laufzeit O(|V||E|))
Krzeste Wege
29
Besser:
Halte d[v]-Werte fr alle vV\S aufrecht
Speichere alle Knoten aus V\S in Priorittenschlange ab
mit Schlssel d[v]
Problem: Was ist, wenn sich Schlssel verndern
Heaps mit Decrease-Key:
Datenstruktur Min-Heap A
Neue Funktion DecreaseKey(A, i, newkey):
Wir bekommen Index i des Elements des Heaps, dessen
Wert (Schlssel) auf den Wert newkey
newkey ist kleiner als der alte Schlssel
Krzeste Wege
Decrease-Key(A,i,newkey)
1. A[i] newkey
2. while i>1 and A[parent[i]]>A[i] do
3. A[parent[i]] A[i]
4. i parent[i]
5
11
9
12 15
30 SS 2011 DuA - Kapitel 15 30 30
Wir bekommen Index i des Elements der Heap, dessen
Krzeste Wege
1. A[i] newkey
4. i parent[i]
5
11
9
12 15
DecreaseKey(A,5,3)
31 SS 2011 DuA - Kapitel 15 31 31
Krzeste Wege
1. A[i] newkey
4. i parent[i]
5
11
9
12 3
DecreaseKey(A,5,3)
i
32 SS 2011 DuA - Kapitel 15 32 32
Krzeste Wege
1. A[i] newkey
4. i parent[i]
5
11
9
12 3
DecreaseKey(A,5,3)
i
33 SS 2011 DuA - Kapitel 15 33 33
Krzeste Wege
5
3
9
12 11
DecreaseKey(A,5,3)
i
1. A[i] newkey
4. i parent[i]
34
Krzeste Wege
1. A[i] newkey
4. i parent[i]
5
3
9
12 11
DecreaseKey(A,5,3)
i
35 SS 2011 DuA - Kapitel 15 35 35
Krzeste Wege
1. A[i] newkey
4. i parent[i]
5
3
9
12 11
DecreaseKey(A,5,3)
i
36 SS 2011 DuA - Kapitel 15 36 36
Krzeste Wege
1. A[i] newkey
4. i parent[i]
3
5
9
12 11
DecreaseKey(A,5,3)
i
37 SS 2011 DuA - Kapitel 15 37 37
Krzeste Wege
1. A[i] newkey
4. i parent[i]
3
5
9
12 11
DecreaseKey(A,5,3)
i
38 SS 2011 DuA - Kapitel 15 38 38
Krzeste Wege
1. A[i] newkey
4. i parent[i]
3
5
9
12 11
DecreaseKey(A,5,3)
i
39 SS 2011 DuA - Kapitel 15 39 39
Laufzeit: O(log n)
Krzeste Wege
1. A[i] newkey
4. i parent[i]
3
5
9
12 11
DecreaseKey(A,5,3)
i
40 SS 2011 DuA - Kapitel 15 40 40
Wie kann man Dijkstras Algorithmus effizient
implementieren?
Halte d[v] Werte fr alle vV\S aufrecht
Speichere alle Knoten aus V\S in Priorittenschlange ab
mit Schlssel d[v]
Krzeste Wege
41
mit Schlssel d[v]
Fr jeden Knoten v speichere Zeiger auf sein
Vorkommen im Heap
d[v] Werte vergrern sich nie
Benutze Decrease-Key, wenn sich Wert d[v] verringert
(im folgenden Algorithmus nicht explizit erwhnt!)
Dijkstra(G,w,s)
1. for each vertex vV do d[v]; [v]nil
2. d[s]0; S; QBuildHeap(V)
3. while Q do
4. udeleteMin(Q)
Hier mu zustzlich noch eine
Decrease-Key Operation
Krzeste Wege
42
4. udeleteMin(Q)
5. SS{u}
6. for each vertex vAdj[u] do
7. if d[v]>d[u]+w(u,v) then d[v]d[u]+w(u,v); [v]u
Decrease-Key Operation
durchgefhrt werden, da Q ein
Min-Heap mit den d-Werten der
Knoten als Schlssel ist.
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
a
b
Krzeste Wege
43
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
6
s
2
5
c
d
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2

a
b
Krzeste Wege
44
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2

c
d
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2

a
b
Krzeste Wege
45
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0

c
d
s
a
b
c d
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2

a
b
Krzeste Wege
46
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0

c
d
s
a
b
c d
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2

a
b
Krzeste Wege
47
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0

c
d
d
a
b
c
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2

a
b
Krzeste Wege
48
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0

c
d
d
a
b
c
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2

a
b
Krzeste Wege
49
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0

c
d
d
a
b
c
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
2
a
b
Krzeste Wege
50
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0

c
d
a
d
b
c
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
2
a
b
Krzeste Wege
51
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0

c
d
a
d
b
c
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
2
a
b
Krzeste Wege
52
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
7
c
d
a
c
b
d
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
2
a
b
Krzeste Wege
53
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
7
c
d
a
c
b
d
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
2
a
b
Krzeste Wege
54
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
7
c
d
c
d
b
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
2
a
b
Krzeste Wege
55
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
7
c
d
c
d
b
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
56
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
7
c
d
b
d
c
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
57
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
7
c
d
b
d
c
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
58
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4
c
d
b
d
c
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
59
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4
c
d
b
d
c
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
60
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4
c
d
c
d
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
61
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4
c
d
c
d
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
62
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4
c
d
c
d
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
63
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4
c
d
c
d
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
64
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4
c
d
d Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
65
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4
c
d
d Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
66
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4
c
d
d Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
67
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4
c
d
d Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
68
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4
c
d
d Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
69
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4
c
d
d Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
70
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4
c
d
d Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
71
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4 9
c
d
d Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
72
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4 9
c
d
d Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
73
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4 9
c
d
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
74
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4 9
c
d
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
75
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4 9
c
d
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
2
1
8
2
4
s
2
4 2
a
b
Krzeste Wege
76
4. udeleteMin(Q)
5. SS{u}
1
7
8
4
5
6
s
2
0
4 9
c
d
Q:
Dijkstra(G,w,s)
2. d[s]0; S; QV
3. while Q do
4. udeleteMin(Q)
5. SS{u}
2
1
7
8
2
4
6
s
2
0
4 2
a
b
c
d
Krzeste Wege
77
5. SS{u}
Laufzeit:
O((|V| + |E|) log |V|)
7
5
4 9
c
d
Dijkstras Algorithmus
Krzeste Wege von einem Knoten und mit positiven
Kantengewichten
Laufzeit O((|V|+|E|) log |V|)
Bessere Laufzeit von O(|V| log |V| + |E|) mglich mit
besseren Priorittenschlangen (z.B. Fibonacci Heap)
Krzeste Wege
78
besseren Priorittenschlangen (z.B. Fibonacci Heap)
Fragen:
Was passiert bei negativen Kantengewichten?
Wie kann man das krzeste Wege Problem fr alle
Paare von Knoten effizient lsen?
Beispiel fr Problem mit Dijkstra Algo:
s
-1 2
1
1
20
-1
v
Krzeste Wege
79
Knoten v hat falschen Distanzwert!
Alternative Verfahren bekannt (siehe Kapitel 17).
3
-4
1
3
-1
Das transitive Hlle Problem:
Gegeben sei ein gerichteter, ungewichteter Graph G=(V,E)
Gesucht: Die transitive Hlle G*=(V,E*) von G, wobei
E*={(u,v): es gibt Weg von u nach v in G}
G
G*
Krzeste Wege
80
G
G*
Das transitive Hlle Problem:
Gegeben sei ein gerichteter, ungewichteter Graph G=(V,E)
Gesucht: Die transitive Hlle G*=(V,E*) von G, wobei
E*={(u,v): es gibt Weg von u nach v in G}
Krzeste Wege
81
Transitive Hlle:
In O(|V|+|V| |E|) Zeit mit Breiten- oder Tiefensuche von
jedem Knoten
Geht das auch schneller?
Graphen und Matrixmultiplikation:
Sei A die nn-Adjazenzmatrix von Graph G mit
Knotenmenge {1,,n}
Was ist AA?
Krzeste Wege
82
Behauptung 15.2:
Sei Z= AA. Dann gilt z >0, g.d.w. es in G einen Pfad der
Lnge 2 von Knoten i zu Knoten j gibt.
ij
Behauptung 15.2:
Sei Z= AA + A. Dann gilt, dass z >0, g.d.w. es einen Weg
der Lnge 1 oder 2 von Knoten i zu Knoten j gibt.
Konstruiere Matrix B mit:
ij
Krzeste Wege
83
Konstruiere Matrix B mit:
b =1 z >0
Behauptung 15.3:
Matrix B hat einen Weg von Knoten i nach j, g.d.w. Matrix A
einen solchen Weg hat.
ij
ij
Behauptung 15.4:
Sei P ein Weg der Lnge k>1 in G. Dann hat P maximal
Lnge (2/3)k in dem von Matrix B beschriebenen Graph
G.
Krzeste Wege
84
Konsquenz aus Beh. 15.3 und 15.4:
Wenn wir die Berechnung von B log n mal iterieren,
haben wir die transitive Hlle berechnet
3/2
TransitiveHlle(A)
1. for i1 to log n do
2. Z A A+A
3. for i1 to n do
4. for j1 to n do
3/2
Krzeste Wege
85
4. for j1 to n do
5. if z >0 then b 1 else b 0
6. AB
7. return A
ij
ij ij
Satz 15.5:
Der Algorithmus TransitiveHlle berechnet die transitive
Hlle eines Graphen G in O(M(n) log n) Zeit, wobei M(n)
die Laufzeit zur Matrixmultiplikation bezeichnet.
Krzeste Wege
86 SS 2011 DuA - Kapitel 15
16. Minimale Spannbume
Definition 16.1:
1. Ein gewichteter ungerichteter Graph (G,w)
ist ein ungerichteter Graph G=(V,E)
zusammen mit einer Gewichtsfunktion
w:E
w:E
2. Ist H=(U,F), UV, FE, ein Teilgraph von
G, so ist das Gewicht w(H) von H definiert
als
w(H) = w(e)
eF
Minimale Spannbume

Definition 16.2:

1. Ein Teilgraph H eines ungerichteten Graphen G
heit Spannbaum von G, wenn H ein Baum auf
den Knoten von G ist.

2. Ein Spannbaum S eines gewichteten ungerichteten
2. Ein Spannbaum S eines gewichteten ungerichteten
Graphen G heit minimaler Spannbaum von G,
wenn S minimales Gewicht unter allen
Spannbumen von G besitzt.

Illustration von minimalen Spannbumen (1)
d c
b a
1
4
3
2
2
Graph G=(V,E)
d c
b a
1 3
2
Spannbaum fr G (minimal)
d c
b a
1 3 2
Spannbaum fr G
3
d c
b a
2
2
Spannbaum fr G (minimal) (nicht minimal)
4
Illustration von minimalen Spannbumen (2)
d
e
g
c
f
b
h
a i
8 7
9
10 8
4
2
7
6
14 11
g f h
2 1
Berechnung minimaler Spannbume
Ziel: Gegeben ein gewichteter ungerichteter Graph (G,w),
G=(V,E). Wir wollen effizient einen minimalen Spannbaum
von (G,w) finden.
Vorgehensweise: Erweitern sukzessive eine Kantenmenge
E A
zu einem minimalen Spannbaum
1. Zu Beginn
{ } = A
.
2. Ersetzen in jedem Schritt A durch
( ) { } v u A ,
,
2. Ersetzen in jedem Schritt A durch
( ) { } v u A ,
,
wobei
( ) v u,
eine A-sichere Kante ist.
3. Solange bis
1 = V A

Definition 16.3:
( ) v u,
heit A-sicher, wenn mit A auch
( ) { } v u A ,
zu einem minimalen Spannbaum erweitert
werden kann.

Generischer MST-Algorithmus
( )
{ }
( )
( ) { }
A 5
v u, A A 4
v u, Kante sichere - A eine Finde 3
Spannbaum keine noch ist A 2
A 1
w , G MST Generic
return
do
while


A 5 return
Schnitte in Graphen
Definition 16.4:
1. Ein Schnitt (C,V-C) in einem Graphen G=(V,E) ist
eine Partition der Knotenmenge V des Graphen.

2. Eine Kante von G kreuzt einen Schnitt (C,V-C), wenn
ein Knoten der Kante in C und der andere Knoten
in V-C liegt.


3. Ein Schnitt (C,V-C) ist mit einer Teilmenge E A
vertrglich, wenn kein Element von A den Schnitt
kreuzt.

4. Eine (C,V-C) kreuzende Kante heit leicht, wenn
sie eine Kante minimalen Gewichts unter den
(C,V-C) kreuzenden Kanten ist.

4
Schnitt in einem Graphen (1)
d
e
c b
a i
8 7
9
10 8
4
2
7
6
14 11
S
V-S
S
V-S
g f h
10
2 1
8
V-S V-S
Schnittkanten
Charakterisierung sicherer Kanten
Satz 16.5: Sei (G,w), G=(V,E) ein gewichteter ungerichteter
Graph. Die Kantenmenge E A sei in einem minimalen
Spannbaum von (G,w) enthalten. Weiter sei (C,V-C) ein
mit A vertrglicher Schnitt und ( ) v , u sei eine leichte
(C,V-C) kreuzende Kante. Dann ist ( ) v , u eine A-sichere
Kante.
Korollar 16.6: Sei (G,w), G=(V,E), ein gewichteter
ungerichteter Graph. Die Kantenmenge E A sei in
einem minimalen Spannbaum von (G,w) enthalten.
Ist ( ) v , u eine Kante minimalen Gewichts, die eine
Zusammenhangskomponente C von ( ) A , V G
A
= mit
dem Rest des Graphen
A
G verbindet, dann ist ( ) v , u
eine A-sichere Kante.
Beweis des Satzes - Illustration
Betrachte beliebigen MSB T, der A enthlt
(C,V-C): mit A vertrglicher Schnitt
e={s,t}: (C,V-C)-Kante minimaler Kosten (eA)
s t
C V-C
e
Ersetzung von e durch e fhrt zu Baum T, der e und A
enthlt und hchstens Kosten von MSB T hat, also
MSB ist
C V-C
in T
e
Algorithmus von Prim - Idee
Zu jedem Zeitpunkt des Algorithmus besteht der Graph
( ) A , V G
A
= aus einem Baum
A
T und einer Menge von
isolierten Knoten
A
I .

Eine Kante minimalen Gewichts, die einen Knoten in
A
I
mit
A
T verbindet, wird zu A hinzugefgt.


Die Knoten in
A
I sind in einem Min-Heap organisiert.
Dabei ist der Schlssel key[v] eines Knoten
A
I v
gegeben durch das minimale Gewicht einer Kante, die
v mit
A
T verbindet.
Algorithmus von Prim - Pseudocode
( )
[ ]
[ ]
[ ]
( )
{ } Q 6
V Heap - Min - Build Q 5
0 r key 4
3
v key 2
V v all 1
, , Pr
NIL v
r w G MST im
while

do
for
{ }
( )
[ ]
( ) [ ]
[ ]
[ ] ( )
[ ] ( ) v key v, Q, Key - ecrease D 12
v u, w v key 11
10
v u, w Q v 9
u Adj v all 8
Q Min - Extract u 7
Q 6
<
u v
v key
then
if do
for
do
while
Heap-Decrease-Key
Decrease-Key [ ] ( ) v key , v , H ersetzt aktuellen
Schlssel von v durch neuen Wert [ ] v key . Dabei muss
der neue Schlssel kleiner als der alte Schlssel sein.

Kann bei einem Heap mit n Elementen in Zeit ( ) ( ) n log O
ausgefhrt werden.
4
Algorithmus von Prim Illustration (1)
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
2 1
Algorithmus von Prim Laufzeit
Zeile 7 pro Durchlauf ( ) ( ) V log O , wird V -mal
durchlaufen.
Zeilen 8-12 pro Durchlauf ( ) ( ) V log O (fr
Decrease-Key).
Zeilen 9-12 E 2 -mal durchlaufen, da Gre aller
Adjazenzlisten zusammen genau E 2 .
Satz 16.7: Der Algorithmus von Prim berechnet in Zeit
( ) ( ) ( ) V log E V log V + O einen minimalen Spannbaum
eines gewichteten ungerichteten Graphen (G,w),
G=(V,E).
Mit Fibonacci-Heaps Verbesserung auf ( ) ( ) E V log V + O
mglich.
Algorithmus von Kruskal Idee (1)
Kruskals Algorithmus berechnet minimale
Spannbume, allerdings mit anderer Strategie als
Prims Algorithmus.

Kruskals Algorithmus erweitert sukzessive Kanten-
menge A zu einem Spannbaum. Zu jedem Zeit-
punkt besteht ( ) A , V G
A
= aus einer Menge von

punkt besteht ( ) A , V G
A
= aus einer Menge von
Bumen.

Eine Kante minimalen Gewichts, die in
A
G keinen
Kreis erzeugt, wird zu A in jedem Schritt hinzu
gefgt.

Algorithmus von Kruskal Idee (2)
Solch eine Kante muss zwei Bume in
A
G
verbinden.

Korrektheit folgt dann aus Satz 15.5 und
Korollar 15.6.


Zur Erinnerung
Satz 16.5: Sei (G,w), G=(V,E) ein gewichteter ungerichteter
Graph. Die Kantenmenge E A sei in einem minimalen
Spannbaum von (G,w) enthalten. Weiter sei (C,V-C) ein
mit A vertrglicher Schnitt und ( ) v , u sei eine leichte
(C,V-C) kreuzende Kante. Dann ist ( ) v , u eine A-sicher
Kante.
ungerichteter Graph. Die Kantenmenge E A sei in
einem minimalen Spannbaum von (G,w) enthalten.
Ist ( ) v , u eine Kante minimalen Gewichts, die eine
Zusammenhangskomponente C von ( ) A , V G
A
= mit
dem Rest des Graphen
A
G verbindet, dann ist ( ) v , u
eine A-sichere Kante.
Algorithmus von Kruskal Illustration
2
1
3
3
2
2
5
1
2
4
3
Algorithmus von Kruskal - Datenstruktur
Kruskals Algorithmus bentigt Datenstruktur, mit deren
Hilfe

1. fr jede Kante ( ) E v , u effizient entschieden
werden kann, ob u und v in derselben Zusam-
menhangskomponente von
A
G liegen.


2. Zusammenhangskomponenten effizient ver-
schmolzen werden knnen.

Solch eine Datenstruktur ist Union-Find-Datenstruktur
fr disjunkte dynamische Mengen.

Disjunkte dynamische Mengen (1)
Gegeben ist eine Menge U von Objekten.

Verwaltet wird immer eine Familie { }
k 2 1
S , , S , S K von
disjunkten Teilmengen von U.

Teilmengen
i
S werden identifiziert mit Hilfe eines
Elements aus S , einem so genannten
Elements aus
i
S , einem so genannten
Reprsentanten.

Disjunkte dynamische Mengen (2)
Die folgenden Operationen sollen untersttzt werden:

1. Make-Set(x). erzeugt Teilmenge { } x mit Reprsen-
tant x.

2. Union(x,y): vereinigt die beiden Teilmengen, die
x bzw, y enthalten.
x bzw, y enthalten.

3. Find-Set(x): liefert den Reprsentanten derjenigen
Menge, die x enthlt.
Union-Find mit verketteten Listen
Realisierung einer Datenstruktur fr disjunkte dynamische
Menge kann mit verketteten Listen erfolgen:

1. Fr jede Teilmenge S gibt es eine verkettete Liste
S der Objekte in S.

2. Reprsentant ist dabei das erste Objekt der Liste.


3. Zustzlich [ ] S head und [ ] S tail Verweise auf erstes
bzw. letztes Element der Liste. Feld [ ] S size
speichert Gre der Liste.

4. Fr jedes Element x der Liste Verweis [ ] x rep auf
Reprsentanten der Liste.

Union-Find mit verketteten Listen - Illustration
c h e b
/
head
tail
Operationen Make-Set und Find-Set
Make-Set: Erzeugen einer 1-elementigen Liste
mglich in Zeit ( ) 1 O .
Find-Set(x): Ausgabe des Reprsentaten [ ] x rep
mglich in Zeit ( ) 1 O

Operation Union
Union(x,y):

S
x
enthalte x und S
y
enthalte y.

1. Bestimme, welche der Listen krzer ist.
2. Hnge krzere Liste an lngere Liste.
3. Ersetze Reprsentanten fr die Elemente der
krzeren Liste.
krzeren Liste.

Lemma 16.8: Die Operation Union kann in Zeit
proportional zur Lnge der krzeren Liste durchge-
fhrt werden.

Analyse vieler Operationen
Satz 16.9: Werden verkettete Listen als Union-Find-
Datenstruktur benutzt und werden insgesamt n
Make-Set und Union Operationen und m Find-Set
Operationen ausgefhrt, so knnen alle Operationen
zusammen in Zeit ( ) ( ) n log n m+ O ausgefhrt werden.


Kruskals Algorithmus und Union-Find
Benutzen Union-Find-Datenstruktur, um Zusammen-
hangskomponenenten von ( ) A , V G
A
= zu verwalten.

Test, ob (u,v) zwei verschiedene Zusammenhangs-
komponenten verbindet durch Test, ob
Find-Set(u)=Find-Set(v).


Verschmelzen von Zusammenhangskomponenenten
durch Union.

Algorithmus von Kruskal - Pseudocode
( )
{ }
( )
Gewichts
den aufsteigen e Reihenfolg der in G von v) (u, Kante alle 5
Gewicht. dem aufsteigen nach G von Kanten die Sortiere 4
v Set - Make 3
V v alle 2
A 1
w , G MST Kruskal
for
do
for

( ) ( )
( ) { }
( )
A 9
v u, Union 8
v u, A A 7
v Set - Find u Set - Find 6
Gewichts
return
then
if do

4
Algorithmus von Kruskal Illustration (1)
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
4
d
e
g
c
f
b
h
a i
8 7
9
10
2 1
8
4
2
7
6
14 11
Laufzeitanalyse von Kruskals Algorithmus
Satz 16.10: Werden verkettete Listen als Union-Find-
Datenstruktur benutzt, so ist die Laufzeit von
Kruskals Algorithmus ( ) ( ) ( ) E log E V log V + O .

All Pairs Shortest Path (APSP):
Eingabe: Gewichteter Graph G=(V,E)
Ausgabe: Fr jedes Paar von Knoten u,vV die Distanz
von u nach v sowie einen krzesten Weg
2
4
7
a b c d e f
b
c
17. All Pairs Shortest Path (ASPS)
1
-1
5
8
-4
5
6
a
a 0 1 5 5 10 9
b 0 4 5 10 9
c -3 0 1 6 5
d -4 0 0 5 4
e 5 8 9 0 -1
f 0
f
e
d
von u nach v (und evtl. einen krzesten Weg)
2
4
7
a b c d e f
b
c
All Pairs Shortest Path
1
-1
5
8
-4
5
6
a
a 0 1 5 5 10 9
b 0 4 5 10 9
c -3 0 1 6 5
d -4 0 0 5 4
e 5 8 9 0 -1
f 0
f
e
d
Eingabe APSP:
Matrix W=(w ), die Graph reprsentiert
ij
w =
0 , wenn i=j
Gewicht der ger. Kante (i,j), wenn ij und (i,j)E
, wenn ij und (i,j)E
ij
a b c d e f
2
1
-1
5
8
4
-4
5
6
7
a
b
c
e
d
f
a b c d e f
a
0 2 5
b
0 4
c
0 1 7
d
-4 6 0 5
e
8 0 -1
f 0
Eingabe APSP:
ij
w =
0 , wenn i=j
ij
a b c d e f
2
1
-1
5
8
4
-4
5
6
7
a
b
c
e
d
f
a b c d e f
a
0 2 5
b
0 4
c
0 1 7
d
-4 6 0 5
e
8 0 -1
f 0
Eingabe APSP:
ij
w =
0 , wenn i=j
ij
a b c d e f
Annahme:
Keine negativen Zyklen!
2
1
-1
5
8
4
-4
5
6
7
a
b
c
e
d
f
a b c d e f
a
0 2 5
b
0 4
c
0 1 7
d
-4 6 0 5
e
8 0 -1
f 0
Nummeriere Knoten von 1 bis n=|V|
Betrachte krzeste i-j-Wege, die nur ber Knoten
1 bis k laufen
1 2 3 4 5 6
1
0 2 6 5 13
4 2
3
k=3
1
0 2 6 5 13
2
0 4 5 11
3
0 1 7
4
-4 0 0 5 7
5
8 14 0 -1
6 0
2
1
-1
5
8
4
-4
5
6
7
1
2
5
4
6
Nummeriere Knoten von 1 bis n=|V|
Betrachte krzeste i-j-Wege, die nur ber Knoten
1 bis k laufen
1 2 3 4 5 6
1
0 2 6 5 13
4 2
3
k=3
1
0 2 6 5 13
2
0 4 5 11
3
0 1 7
4
-4 0 0 5 7
5
8 14 0 -1
6 0
2
1
-1
5
8
4
-4
5
6
7
1
2
5
4
6
Sei G ein Graph ohne negative Zyklen und sei j von i aus
erreichbar. Dann gibt es einen krzesten i-j-Weg, der
keinen Knoten doppelt benutzt.
Wir knnen also annehmen, dass jeder Knoten in jedem
Weg maximal einmal vorkommt
Betrachte i-j-Weg, der nur ber Knoten aus {1,,k} luft:
i
j
k
i
j
k
Knoten k tritt maximal
einmal auf
i
j
k
Weg von u nach k fhrt nur
ber Knoten aus {1,,k-1}
i
j
k
Weg von k nach v fhrt nur
ber Knoten aus {1,,k-1}
Die Rekursion:
Krzester i-j-Weg ber Knoten aus {1,,k} ist
(a) krzester i-j-Weg ber Knoten aus {1,,k-1} oder
(b) krzester i-k-Weg ber Knoten aus {1,,k-1} gefolgt
von krzestem k-j-Weg ber Knoten aus {1,,k-1}
i
j
k
Fall (b):
Die Rekursion:
Sei d die Lnge eines krzesten i-j-Wegs mit ber
Knoten aus {1,,k}
w , falls k=0
ij
(k)
(k)
Matrix D =(d ) enthlt die gesuchte Lsung
d =
w , falls k=0
min ( d , d + d ), falls k1
(k)
(k-1)
(k-1) (k-1)
ij
ij
ij
ik
kj
(n)
ij
(n)
Floyd-Warshall(W,n)
1. D W
2. for k1 to n do
3. for i1 to n do
4. for j1 to n do
(0)
4. for j1 to n do
5. d min(d , d + d )
6. return D
(k)
ij
(n)
(k-1)
ij
(k-1)
ik
(k-1)
kj
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
2
3
4
5
6
1
0 2 5
2
0 4
3
0 1 7
4
-3 4 6 0 5
5
8 0 -1
6 0
D
(0)
D
(1)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 5
2
3
4
5
6
1
0 2 5
2
0 4
3
0 1 7
4
-3 4 6 0 5
5
8 0 -1
6 0
D
(0)
D
(1)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 5
2
0 4
3
4
5
6
1
0 2 5
2
0 4
3
0 1 7
4
-3 4 6 0 5
5
8 0 -1
6 0
D
(0)
D
(1)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 5
2
0 4
3
0 1 7
4
5
6
1
0 2 5
2
0 4
3
0 1 7
4
-3 4 6 0 5
5
8 0 -1
6 0
D
(0)
D
(1)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 5
2
0 4
3
0 1 7
4
-3 -1 6 0 5
5
6
1
0 2 5
2
0 4
3
0 1 7
4
-3 4 6 0 5
5
8 0 -1
6 0
D
(0)
D
(1)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 5
2
0 4
3
0 1 7
4
-3 -1 6 0 5
5
8 0 -1
6
1
0 2 5
2
0 4
3
0 1 7
4
-3 4 6 0 5
5
8 0 -1
6 0
D
(0)
D
(1)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 5
2
0 4
3
0 1 7
4
-3 -1 6 0 5
5
8 0 -1
6 0
1
0 2 5
2
0 4
3
0 1 7
4
-3 4 6 0 5
5
8 0 -1
6 0
D
(0)
D
(1)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5
2
3
4
5
6
1
0 2 5
2
0 4
3
0 1 7
4
-3 -1 6 0 5
5
8 0 -1
6 0
D
(1)
D
(2)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5
2
0 4
3
4
5
6
1
0 2 5
2
0 4
3
0 1 7
4
-3 -1 6 0 5
5
8 0 -1
6 0
D
(1)
D
(2)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5
2
0 4
3
4
5
6
1
0 2 5
2
0 4
3
0 1 7
4
-3 -1 6 0 5
5
8 0 -1
6 0
D
(1)
D
(2)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5
2
0 4
3
0 1 7
4
5
6
1
0 2 5
2
0 4
3
0 1 7
4
-3 -1 6 0 5
5
8 0 -1
6 0
D
(1)
D
(2)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5
2
0 4
3
0 1 7
4
-3 -1 3 0 5
5
6
1
0 2 5
2
0 4
3
0 1 7
4
-3 -1 6 0 5
5
8 0 -1
6 0
D
(1)
D
(2)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5
2
0 4
3
0 1 7
4
-3 -1 3 0 5
5
8 0 -1
6
1
0 2 5
2
0 4
3
0 1 7
4
-3 -1 6 0 5
5
8 0 -1
6 0
D
(1)
D
(2)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5
2
0 4
3
0 1 7
4
-3 -1 3 0 5
5
8 0 -1
6 0
1
0 2 5
2
0 4
3
0 1 7
4
-3 -1 6 0 5
5
8 0 -1
6 0
D
(1)
D
(2)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 13
2
3
4
5
6
1
0 2 6 5
2
0 4
3
0 1 7
4
-3 -1 3 0 5
5
8 0 -1
6 0
D
(2)
D
(3)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 13
2
0 4 5 11
3
4
5
6
1
0 2 6 5
2
0 4
3
0 1 7
4
-3 -1 3 0 5
5
8 0 -1
6 0
D
(2)
D
(3)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 13
2
0 4 5 11
3
0 1 7
4
5
6
1
0 2 6 5
2
0 4
3
0 1 7
4
-3 -1 3 0 5
5
8 0 -1
6 0
D
(2)
D
(3)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 13
2
0 4 5 11
3
0 1 7
4
-3 -1 3 0 5 10
5
6
1
0 2 6 5
2
0 4
3
0 1 7
4
-3 -1 3 0 5
5
8 0 -1
6 0
D
(2)
D
(3)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 13
2
0 4 5 11
3
0 1 7
4
-3 -1 3 0 5 10
5
8 9 0 -1
6
1
0 2 6 5
2
0 4
3
0 1 7
4
-3 -1 3 0 5
5
8 0 -1
6 0
D
(2)
D
(3)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 13
2
0 4 5 11
3
0 1 7
4
-3 -1 3 0 5 10
5
8 9 0 -1
6 0
1
0 2 6 5
2
0 4
3
0 1 7
4
-3 -1 3 0 5
5
8 0 -1
6 0
D
(2)
D
(3)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 10 13
2
3
4
5
6
1
0 2 6 5 13
2
0 4 5 11
3
0 1 7
4
-3 -1 3 0 5 10
5
8 9 0 -1
6 0
D
(3)
D
(4)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 10 13
2
2 0 4 5 10 11
3
4
5
6
1
0 2 6 5 13
2
0 4 5 11
3
0 1 7
4
-3 -1 3 0 5 10
5
8 9 0 -1
6 0
D
(3)
D
(4)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 10 13
2
2 0 4 5 10 11
3
-2 0 0 1 6 7
4
5
6
1
0 2 6 5 13
2
0 4 5 11
3
0 1 7
4
-3 -1 3 0 5 10
5
8 9 0 -1
6 0
D
(3)
D
(4)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 10 13
2
2 0 4 5 10 11
3
-2 0 0 1 6 7
4
-3 -1 3 0 5 10
5
6
1
0 2 6 5 13
2
0 4 5 11
3
0 1 7
4
-3 -1 3 0 5 10
5
8 9 0 -1
6 0
D
(3)
D
(4)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 10 13
2
2 0 4 5 10 11
3
-2 0 0 1 6 7
4
-3 -1 3 0 5 10
5
6 8 8 9 0 -1
6
1
0 2 6 5 13
2
0 4 5 11
3
0 1 7
4
-3 -1 3 0 5 10
5
8 9 0 -1
6 0
D
(3)
D
(4)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 10 13
2
2 0 4 5 10 11
3
-2 0 0 1 6 7
4
-3 -1 3 0 5 10
5
6 8 8 9 0 -1
6 0
1
0 2 6 5 13
2
0 4 5 11
3
0 1 7
4
-3 -1 3 0 5 10
5
8 9 0 -1
6 0
D
(3)
D
(4)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 10 9
2
3
4
5
6
1
0 2 6 5 10 13
2
2 0 4 5 10 11
3
-2 0 0 1 6 7
4
-3 -1 3 0 5 10
5
6 8 8 9 0 -1
6 0
D
(4)
D
(5)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 10 9
2
2 0 4 5 10 9
3
4
5
6
1
0 2 6 5 10 13
2
2 0 4 5 10 11
3
-2 0 0 1 6 7
4
-3 -1 3 0 5 10
5
6 8 8 9 0 -1
6 0
D
(4)
D
(5)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 10 9
2
2 0 4 5 10 9
3
-2 0 0 1 6 5
4
5
6
1
0 2 6 5 10 13
2
2 0 4 5 10 11
3
-2 0 0 1 6 7
4
-3 -1 3 0 5 10
5
6 8 8 9 0 -1
6 0
D
(4)
D
(5)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 10 9
2
2 0 4 5 10 9
3
-2 0 0 1 6 5
4
-3 -1 3 0 5 4
5
6
1
0 2 6 5 10 13
2
2 0 4 5 10 11
3
-2 0 0 1 6 7
4
-3 -1 3 0 5 10
5
6 8 8 9 0 -1
6 0
D
(4)
D
(5)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 10 9
2
2 0 4 5 10 9
3
-2 0 0 1 6 5
4
-3 -1 3 0 5 4
5
6 8 8 9 0 -1
6
1
0 2 6 5 10 13
2
2 0 4 5 10 11
3
-2 0 0 1 6 7
4
-3 -1 3 0 5 10
5
6 8 8 9 0 -1
6 0
D
(4)
D
(5)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 10 9
2
2 0 4 5 10 9
3
-2 0 0 1 6 5
4
-3 -1 3 0 5 4
5
6 8 8 9 0 -1
6 0
1
0 2 6 5 10 13
2
2 0 4 5 10 11
3
-2 0 0 1 6 7
4
-3 -1 3 0 5 10
5
6 8 8 9 0 -1
6 0
D
(4)
D
(5)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 10 9
2
2 0 4 5 10 9
3
-2 0 0 1 6 5
4
-3 -1 3 0 5 4
5
6 8 8 9 0 -1
6 0
1
0 2 6 5 10 9
2
2 0 4 5 10 9
3
-2 0 0 1 6 5
4
-3 -1 3 0 5 4
5
6 8 8 9 0 -1
6 0
D
(5)
D
(6)
1 2 3 4 5 6 1 2 3 4 5 6
2
1
-1
5
8
4
4
5
6
7
1
2
3
5
4
6
-3
1
0 2 6 5 10 9
2
2 0 4 5 10 9
3
-2 0 0 1 6 5
4
-3 -1 3 0 5 4
5
6 8 8 9 0 -1
6 0
1
0 2 6 5 10 9
2
2 0 4 5 10 9
3
-2 0 0 1 6 5
4
-3 -1 3 0 5 4
5
6 8 8 9 0 -1
6 0
D
(5)
D
(6)
Satz 17.1:
Sei G=(V,E) ein Graph mit nicht-negativen Zyklen. Dann
berechnet der Algorithmus von Floyd-Warshall die
Entfernung zwischen jedem Knotenpaar in O(|V|) Zeit.
Aufrechterhalten der krzesten Wege:
Konstruiere Vorgngermatrix
Dazu konstruiere Sequenz ,, mit =
ist Vorgngermatrix zu D
ist Vorgnger von Knoten j auf dem krzesten Weg
(n)
(1)
(n)
(k)
(k)
(k)
ij
von Knoten i ber Knoten aus {1,,k}
Die Startmatrix:
ij
=
(0)
ij
nil nil nil nil , falls i=j oder w =
i , falls ij und w <
ij
ij
Aufrechterhalten der krzesten Wege:
Konstruiere Vorgngermatrix
Dazu konstruiere Sequenz ,, mit =
ist Vorgngermatrix zu D
ist Vorgnger von Knoten j auf dem krzesten Weg
(n)
(1)
(n)
(k)
(k)
(k)
ij
Das Aktualisieren:
=
(k)
ij
, falls d d + d
, falls d > d + d
ij
ik
(k-1)
ij
(k-1)
kj
(k-1)
(k-1) (k-1)
kj
ij
(k-1)
(k-1)
ik
(k-1)
kj
Generische Optimierungsverfahren:
Systematische Suche
lass nichts aus
Divide and Conquer
lse das Ganze in Teilen
Dynamische Programmierung
18. Divide & Conquer
mache nie etwas zweimal
Greedy Verfahren
schau niemals zurck
Lokale Suche
denke global, handle lokal
Prinzip: durchsuche gesamten Lsungsraum
Auch bekannt als Brute Force
Vorteil: sehr einfach zu implementieren
Systematische Suche
Vorteil: sehr einfach zu implementieren
Nachteil: sehr zeitaufwendig und sollte
daher nur fr kleine Instanzen verwendet
werden
Beispiele:
Suche in unsortierter Liste
Suche ber Broadcasting in unstruktu-
rierten verteilten Systemen (Peer-to-Peer
Systematische Suche
rierten verteilten Systemen (Peer-to-Peer
Systeme)
Rucksackproblem (siehe nchste Folie)
Rucksackproblem:
Eingabe: n Objekte mit Gewichten
w
1
,,w
n
und Werten v
1
,,v
n
und
Rucksack mit Kapazitt W
Ausgabe: Objektmenge M maximalen
Systematische Suche
Ausgabe: Objektmenge M maximalen
Wertes, die in Rucksack passt
Lsung zum Rucksackproblem:
Probiere alle Teilmengen von Objekten
aus und merke die Menge M von Objekten
mit
iM
w
i
W, die bisher den maxima-
len Wert hatte
Systematische Suche
Aufwand: O(2
n
), da es 2
n
Mglichkeiten gibt,
Teilmengen aus einer n-elementigen
Menge zu bilden.
Divide & Conquer
Teile & Herrsche:
Problem in Teilprobleme aufteilen
Teilprobleme rekursiv lsen
Lsung aus Teillsungen zusammensetzen
Probleme:
Probleme:
Wie setzt man zusammen?
[erfordert algorithmisches Geschick und bung]
Laufzeitanalyse (Auflsen der Rekursion)
[ist normalerweise nach Standardschema; erfordert
ebenfalls bung]
Beispiele:
Mergesort
Quicksort
Binary Search
Divide & Conquer
Arithmische Operationen wie Matrixmulti-
plikation oder Multiplikation groer Zahlen
Nchstes-Paar-Problem
3 7 5 4 2 1 1 0
0 3 2 4 0 0 1 3
10 2 1 0 3 1 1 0
=
Matrix Multiplikation
8
10 2 1 0 3 1 1 0
1 0 1 0 2 3 2 2
=
3 7 5 4 2 1 1 0 29 20 23 29
0 3 2 4 0 0 1 3 14 14
10 2 1 0 3 1 1 0
=
9
10 2 1 0 3 1 1 0
1 0 1 0 2 3 2 2
=
Teile & Herrsche:
Problem: Berechne das Produkt zweier nn Matrizen
Eingabe: Matrizen X,Y
Ausgabe: Matrix Z = XY

x x x x

y y y y
10
=
4,4 4,3 4,2 4,1
3,4 3,3 3,2 3,1
2,4 2,3 2,2 2,1
1,4 1,3 1,2 1,1
x x x x
x x x x
x x x x
x x x x
X
=
4,4 4,3 4,2 4,1
3,4 3,3 3,2 3,1
2,4 2,3 2,2 2,1
1,4 1,3 1,2 1,1
y y y y
y y y y
y y y y
y y y y
Y
,
MatrixMultiplikation(Array X, Y, n)
1. new array Z[1,..,n][1,..,n]
2. for i1 to n do
3. for j 1 to n do
4. Z[i][j] 0
11
4. Z[i][j] 0
5. for k 1 to n do
6. Z[i][j] Z[i][j] + X[i][k] Y[k][j]
7. return Z
MatrixMultiplikation(Array X, Y, n) Laufzeit:
1. new array Z[1,..,n][1,..,n] (n)
2. for i1 to n do
3. for j 1 to n do
4. Z[i][j] 0
12
4. Z[i][j] 0
5. for k 1 to n do
6. Z[i][j] Z[i][j] + X[i][k] Y[k][j]
7. return Z
1. new array Z[1,..,n][1,..,n] (n)
2. for i1 to n do (n)
3. for j 1 to n do
4. Z[i][j] 0
13
4. Z[i][j] 0
5. for k 1 to n do
6. Z[i][j] Z[i][j] + X[i][k] Y[k][j]
7. return Z
1. new array Z[1,..,n][1,..,n] (n)
3. for j 1 to n do (n)
4. Z[i][j] 0
14
4. Z[i][j] 0
5. for k 1 to n do
6. Z[i][j] Z[i][j] + X[i][k] Y[k][j]
7. return Z
1. new array Z[1,..,n][1,..,n] (n)
4. Z[i][j] 0 (n)
15
4. Z[i][j] 0 (n)
5. for k 1 to n do
6. Z[i][j] Z[i][j] + X[i][k] Y[k][j]
7. return Z
1. new array Z[1,..,n][1,..,n] (n)
4. Z[i][j] 0 (n)
16
4. Z[i][j] 0 (n)
5. for k 1 to n do (n)
6. Z[i][j] Z[i][j] + X[i][k] Y[k][j]
7. return Z
1. new array Z[1,..,n][1,..,n] (n)
4. Z[i][j] 0 (n)
17
4. Z[i][j] 0 (n)
6. Z[i][j] Z[i][j] + X[i][k] Y[k][j] (n )
7. return Z
3
1. new array Z[1,..,n][1,..,n] (n)
4. Z[i][j] 0 (n)
18
4. Z[i][j] 0 (n)
6. Z[i][j] Z[i][j] + X[i][k] Y[k][j] (n )
7. return Z (1)
3
1. new array Z[1,..,n][1,..,n] (n)
4. Z[i][j] 0 (n)
19
4. Z[i][j] 0 (n)
6. Z[i][j] Z[i][j] + X[i][k] Y[k][j] (n )
7. return Z (1)
(n)
3
Teile und Herrsche:
Aufwand:
+ +
+ +
=
DH CF DG CE
BH AF BG AE
H G
F E
D C
B A
20
Aufwand:
8 Multiplikationen von n/2n/2 Matrizen
4 Additionen von n/2n/2 Matrizen
Teile und Herrsche:
Aufwand:
+ +
+ +
=
DH CF DG CE
BH AF BG AE
H G
F E
D C
B A
21
Aufwand:
8 Multiplikationen von n/2n/2 Matrizen
4 Additionen von n/2n/2 Matrizen
Laufzeit:
T(n) = 8T(n/2) + (n)
Laufzeit:
T(n) = 8 T(n/2) + kn
Master Theorem:
f(n) = k n
a
b
f(n)
f(n) = k n
22 SS 2011 DuA - Kapitel 18 22 22
Laufzeit:
T(n) = 8 T(n/2) + kn
Master Theorem:
f(n) = k n
a
b
f(n)
23
f(n) = k n
Fall 1: Laufzeit (n ) = (n)
log a
b
Laufzeit:
T(n) = 8 T(n/2) + kn
Master Theorem:
f(n) = k n
a
b
f(n)
24
f(n) = k n
Formaler Beweis durch Induktion!!
log a
b
Laufzeit:
T(n) = 8 T(n/2) + kn
Master Theorem:
f(n) = k n
a
b
f(n)
25
f(n) = k n
Formaler Beweis durch Induktion!!
Nicht besser als einfacher Algorithmus
log a
b
Teile und Herrsche (Algorithmus von Strassen):
Trick:
+ +
+ +
=
DH CF DG CE
BH AF BG AE
H G
F E
D C
B A
26
Trick:
P = A(F-H) P = (A+D)(E+H)
P = (A+B)H P = (B-D)(G+H)
P = (C+D)E P = (A-C)(E+F)
P = D(G-E)
1
2
3
4
5
6
7
Teile und Herrsche (Algorithmus von Strassen):
Trick:
+ +
+ +
=
DH CF DG CE
BH AF BG AE
H G
F E
D C
B A
27
Trick:
P = A(F-H) P = (A+D)(E+H) AE+BG = P + P - P + P
P = (A+B)H P = (B-D)(G+H) AF+BH = P + P
P = (C+D)E P = (A-C)(E+F) CE+DG = P + P
P = D(G-E) CF+DH = P + P - P - P
1
2
3
4
5
6
7
5 4 2 6
1 2
3
4
5 1 3 7
Teile und Herrsche:
Trick:
+ +
+ +
=
DH CF DG CE
BH AF BG AE
H G
F E
D C
B A
28
Trick:
P = A(F-H) P = (A+D)(E+H) AE+BG = P + P - P + P
P = (A+B)H P = (B-D)(G+H) AF+BH = P + P
P = (C+D)E P = (A-C)(E+F) CE+DG = P + P
P = D(G-E) CF+DH = P + P - P - P
1
2
3
4
5
6
7
5 4 2 6
1 2
3
4
5 1 3 7
7 Multiplikationen!!!
Laufzeit:
T(n) = 7 T(n/2) + kn
a
b
f(n)
29
Master Theorem:
f(n) = k n
Laufzeit:
T(n) = 7 T(n/2) + kn
a
b
f(n)
30
Master Theorem:
f(n) = k n
Fall 1: Laufzeit (n )
log a
b
Laufzeit:
T(n) = 7 T(n/2) + kn
a
b
f(n)
31
Master Theorem:
f(n) = k n
Fall 1: Laufzeit (n )=(n )
log a
b
log 7
2
Laufzeit:
T(n) = 7 T(n/2) + kn
Master Theorem:
a
b
f(n)
32
Master Theorem:
f(n) = k n
Fall 1: Laufzeit (n )=(n ) = (n )
Verbesserter Algorithmus!
(Erheblicher Unterschied fr groe Eingaben)
log a
b
log 7
2
2,81
Satz 18.1
Das Produkt zweier nn Matrizen kann in (n ) Laufzeit
berechnet werden.
2,81
33 33 SS 2011 DuA - Kapitel 18 33
Nchstes-Paar-Problem:
Eingabe: Menge S von n Punkten
P
1
=(x
1
,y
1
),,P
n
=(x
n
,y
n
) im 2-dimensio-
nalen Euklidischen Raum
31.05.2011 Kapitel 12 34
nalen Euklidischen Raum
Ausgabe: Punktpaar mit krzester Distanz
Annahme: n ist Zweierpotenz
Algo fr Nchstes-Paar-Problem:
Sortiere Punkte gem x-Koordinate
(z.B. Mergesort, Zeit O(n log n) )
Lse danach Nchstes-Paar-Problem
31.05.2011 Kapitel 12 35
Lse danach Nchstes-Paar-Problem
rekursiv durch Algo ClosestPair
Algo ClosestPair(S):
Eingabe: nach x-Koordinate sortierte
Punktmenge S
|S|=2: sortiere S gem y-Koordinate und gib
Distanz zwischen den Punkten in S zurck
|S|>2:
31.05.2011 Kapitel 12 36
|S|>2:
teile S in der Mitte (Position n/2) in S
1
und S
2
d
1
:=ClosestPair(S
1
); d
2
:=ClosestPair(S
2
)
d:=min{ClosestCrossPair(S
1
,S
2
,min(d
1
,d
2
)), d
1
, d
2
}
Fhre Merge(S
1
,S
2
) durch, so dass S am Ende nach
y-Koordinate sortiert ist (S
1
, S
2
bereits nach y sortiert)
gib d zurck
ClosestCrossPair(S
1
,S
2
,d):
d
2
d d
Nur Punktpaare in
Streifen interessant
d=min{d
1
,d
2
}
31.05.2011 Kapitel 12 37
S
1
S
2
d
2
d
1
Nur max. 4 Punkte
in dxd-Quadrant Punkte nach y-
Koordinate sortiert
ClosestCrossPair:
Durchlaufe die (nach der y-Koordinate
sortierten) Punkte in S
1
und S
2
von oben nach
unten (wie in Merge(S
1
,S
2
)) und merke die
Mengen M
1
und M
2
der 8 zuletzt gesehenen
Punkte in S
1
und S
2
im d-Streifen
Bei jedem neuen Knoten in M , berechne
31.05.2011 Kapitel 12 38
Bei jedem neuen Knoten in M
1
, berechne
Distanzen zu Knoten in M
2
, und bei jedem
neuen Knoten in M
2
, berechne Distanzen zu
Knoten in M
1
Gib am Ende minimal gefundene Distanz zurck
Laufzeit fr Nchstes-Paar-Algo:
Mergesort am Anfang: O(n log n)
Laufzeit T(n) von ClosestPair Algo:
T(1)=O(1), T(n)=2T(n/2)+O(n)
31.05.2011 Kapitel 12 39
T(1)=O(1), T(n)=2T(n/2)+O(n)
Gesamtlaufzeit: O(n log n)
Brute force: O(n
2
)
19. Gierige Algorithmen
Gierige Algorithmen sind eine Algorithmenmethode, um
so genannte Optimierungsprobleme zu lsen.
Bei einem Optimierungsproblem gibt es zu jeder
Probleminstanz viele mgliche oder zulssige
Lsungen. Lsungen haben Werte gegeben durch eine
Zielfunktion. Gesucht ist dann eine mglichst
Zielfunktion. Gesucht ist dann eine mglichst
gute zulssige Lsung. Also eine Lsung mit mglichst
kleinem oder mglichst groem Wert (Minimierungs-
bzw. Maximierungsproblem).
Gierige Strategie fr Optimierungsprobleme:
Aufbau einer Lsung in kleinen Schritten
In jedem dieser Schritte wird entsprechend eines definierten
Optimierungskriteriums eine irreversible Entscheidung getroffen
Frage 1:
Gierige (Greedy) Algorithmen
2
Frage 1:
Wann kann eine solche Strategie zu einer optimalen Lsung fhren?
Frage 2:
Wie beweist man, dass ein gieriger Algo. eine optimale Lsung liefert?
18.Gierige Algorithmen
2 Datenstrukturen und Algorithmen
SS 2010 2
Gierige Algorithmen Minimale Spannbume
Beispiel: Minimale Spannbume:
1. Probleminstanz gewichteter, ungerichteteter,
zusammenhngender Graph
2. Zulssige Lsungen Spannbume
2. Zulssige Lsungen Spannbume
3. Zielfunktion Gewicht eines Spannbaums
4. Gesucht Spannbaum minimalen Gewichts
Gierige Algorithmen Idee und Prim
bestimmen Lsung durch
sukzessives Er-
weitern von bereits
gefundenen Teillsungen.
2. Erweitern geschieht durch
lokal optimale Wahlen.
1. Algorithmus von Prim
bestimmt minimalen
Spannbaum durch
sukzessives Hinzufgen von
Kanten.
2. Prims Algorithmus whlt
mglichst leichte Kante, die
3. Analyse muss dann zeigen,
dass lokal optimale Wahlen
zu global optimalen
Lsungen fhrt.
isolierten Knoten mit Teilbaum
verbindet.
3. Analyse mit Hilfe von
Schnitten zeigte, dass
Teilbaum immer in einem
minimalen Spannbaum
enthalten ist.
Gierige Algorithmen Idee und Kruskal
bestimmen Lsung durch
sukzessives Er-
weitern von bereits
gefundenen Teillsungen.
2. Erweitern geschieht durch
1. Algorithmus von Kruskal
bestimmt minimalen
Spannbaum durch
sukzessives Hinzufgen von
Kanten.
2. Kruskals Algorithmus whlt
3. Analyse muss dann zeigen,
dass lokal optimale Wahlen
zu global optimalen
Lsungen fhrt.
Zusammenhangskomponen-
ten verbindet.
3. Analyse mit Hilfe von
Schnitten zeigte, dass
Teilbaum immer in einem
minimalen Spannbaum
enthalten ist.
Gieriges 1-Prozessor-Scheduling (1)
Gegeben sind n Jobs
n 1
j , , j K mit Dauer
n 1
t , , t K .

Jeder der Jobs muss auf einem einzigen Prozessor
abgearbeitet werden. Der Prozessor kann zu jedem
Zeitpunkt nur einen Job bearbeiten. Ein einmal be-
gonnener Job darf nicht abgebrochen werden.


Gesucht ist eine Reihenfolge, in der die Jobs abgear-
beitet werden, so dass die durchschnittliche Bearbei-
tungszeit der Jobs mglichst gering ist.
Bearbeitungszeit eines Jobs ist der Zeitpunkt, an dem
der Job vollstndig bearbeitet wurde.

Werden die Jobs in Reihenfolge
( ) ( ) n 1
j , , j

K ausgefhrt,
wobei eine Permutation ist, so ist die Bearbeitungs-
zeit von Job
( ) 1
j
genau
( ) 1
t
, die Bearbeitungszeit von

Job j ist t t + , usw.
Job
( ) 2
j
ist
( ) ( ) 2 1
t t

+ , usw.

Gieriges 1-Prozessor-Scheduling - Beispiel
0 15 23 26 36
Schedule Nr. 1:
Schedule Nr. 2:
Durchschnittliche Beendigung: 25
Job Laufzeit
1
j 15
2
j 8
3
j 3
j
1
j
2
j
4
j
3
j
0 3 11 21
36
Schedule Nr. 2:
Durchschnittliche Beendigung: 17,75
4
j 10

1
j
4
j
2
j
3
j
Lemma 19.1: Bei Permutation ist die durchschnittliche
Bearbeitungszeit gegeben durch

( )
( ) i
n
1 i
t 1 i n
n
1
+

Lemma 19.2: Eine Permutation fhrt genau dann zu
einer minimalen durchschnittlichen Bearbeitungszeit,
wenn die Folge
( ) ( )
( )
n 1
t , , t

K aufsteigend sortiert ist.

Gieriges Mehr-Prozessor-Scheduling
Gegeben sind n Jobs
n 1
j , , j K mit Dauer
n 1
t , , t K und m
identische Prozessoren.

Jeder der Jobs muss auf einem einzigen Prozessor
abgearbeitet werden. Jeder Prozessor kann zu jedem
Zeitpunkt nur einen Job bearbeiten. Ein einmal be-

Gesucht ist eine Aufteilung der Jobs auf die
Prozessoren und fr jeden Prozessor eine Reihenfolge
der ihm zugewiesenen Jobs, so dass durchschnittliche
Bearbeitungszeit der Jobs mglichst gering ist.

Bearbeitungszeit eines Jobs wie vorher definiert.
Gieriges Mehr-Prozessor-Scheduling (2)
Lemma 19.3: Die Permutation sei so gewhlt, dass
die Folge
( ) ( )
( )
n 1
t , , t

K aufsteigend sortiert ist. Weiter
werde dann Job
( ) i
j
auf dem Prozessor mit Nummer

m mod i ausgefhrt. Das so konstruierte Scheduling
minimiert dann die durchschnittliche Bearbeitungs-
zeit.
zeit.

Hierbei identifizieren wir 0 und m, d.h. ist i mod m =0,
so wird Job
( ) i
j
auf dem Prozesssor mit Nummer m

gestartet.

Gieriges Mehr-Prozessor-Scheduling - Beispiel
0
Schedule Nr. 1:
40
Job Laufzeit
1
j
3
2
j
5
3
j 6
4
j
10
5
j 11
j 14
1
j
4
j
7
j
2
j
5
j
8
j
9
j
6
j
3
j
0
Schedule Nr. 2:
38
6
j 14
7
j
15
8
j 18
9
j 20

1
j
5
j
9
j
2
j
4
j
7
j
8
j
6
j
3
j
Gierig ist nicht immer optimal
Optimaler Schedule:
Job Laufzeit
1
j
3
2
j
5
3
j 6
4
j
10
Betrachten dasselbe Szenario wie vorher mit
Jobs und Prozessoren.
Wollen aber jetzt den Zeitpunkt minimieren, an
dem alle Jobs beendet sind.
0 34
Greedy Scheduling (vorige Folie): 40
4
j
10
5
j 11
6
j 14
7
j
15
8
j 18
9
j 20

1
j
2
j
3
j
4
j
7
j
5
j
8
j
9
j
6
j
Geht es schlimmer? Ja!
Beispiel: m Prozessoren, m(m-1) Jobs der Lnge 1,
ein Job der Lnge m
Greedy Schedule fr m=10:
m=10
19
Greedy Schedule: 2m-1 Zeiteinheiten
Optimaler Schedule: m Zeiteinheiten
Greedy kann also Faktor 2-1/m schlechter als OPT sein.
Das ist aber fr alle Instanzen auch der worst case.
m=10
10
Greedy Schedule ber absteigend sortierte Jobzeiten:
Kann sogar nie schlechter als 4/3OPT sein.
Beweis ist sehr aufwndig.
4/3-Resultat ist bestmglich.
Beispiel: m Maschinen, n=2m+1 Jobs: jeweils 2 Jobs der
Lnge m+1,m+2,,2m und ein Job der Lnge m
Lnge m+1,m+2,,2m und ein Job der Lnge m
Vergleich zu OPT: bung.
Anwendungsbeispiel: Intervall Scheduling
17
Intervall Scheduling:
eine Ressource (Hrsaal, Parallelrechner, ...)
Menge von Anfragen der Art:
Kann ich die Ressource fr den Zeitraum [ t ,t ] nutzen?
1
2
Gierige Algorithmen Intervall Scheduling
18
Optimierungs-Ziel: Mglichst viele Anfragen erfllen
SS 2010 18
Intervall Scheduling:
eine Ressource (Hrsaal, Parallelrechner, ...)
Menge von Anfragen der Art:
Kann ich die Ressource fr den Zeitraum [ t ,t ] nutzen?
1 2
19
Optimierungs-Ziel: Mglichst viele Anfragen erfllen
SS 2010 19
Definition:
Zwei Anfragen heien kompatibel, wenn sich die
Intervalle nicht berschneiden.
20
Definition:
21
Definition:
22
Generelle berlegung:
Whle erste Anfrage i geschickt
Ist i akzeptiert, weise alle Anfragen zurck, die nicht
kompatibel sind
Whle nchste Anfrage i und weise alle Anfragen
1
1
23
zurck, die nicht mit i kompatibel sind
Mache weiter, bis keine Anfragen mehr brig sind
2
2
23
kompatibel sind
1
1
24
2
2
24
kompatibel sind
1
1
25
2
2
25
kompatibel sind
1
1
26
2
2
26
kompatibel sind
1
1
27
2
2
27
kompatibel sind
1
1
28
2
2
28
Was ist nun aber eine geschickte Auswahlstrategie ?
29
Was ist nun aber eine geschickte Auswahlstrategie ?
29
Strategie 1:
Whle immer die Anfrage, die am frhesten beginnt
30
Strategie 1:
31
Strategie 1:
32
Strategie 1:
33
Strategie 1:
34
Strategie 1:
Optimalitt ?
35
Optimalitt ?
35
Strategie 1:
Optimalitt ?
36
Optimalitt ?
36
Strategie 1:
Optimalitt ?
Nicht optimal, da eine
optimale Lsung 4
37
Optimalitt ?
optimale Lsung 4
Anfragen erfllen kann
37
Strategie 2:
Whle immer das krzeste Intervall
38
Strategie 2:
39
Strategie 2:
40
Strategie 2:
41
Strategie 2:
42
Strategie 2:
43
Strategie 2:
44
Strategie 2:
Optimalitt?
45
Optimalitt?
45
Strategie 2:
Optimalitt?
46
Optimalitt?
Ebenfalls nicht optimal, da man 2
Anfragen erfllen kann!
46
Strategie 3:
Whle immer das Intervall mit den wenigsten nicht
kompatiblen Intervallen
bei Gleichheit whle das krzeste Intervall
47
Strategie 3:
48
Strategie 3:
49
Strategie 3:
50
Strategie 3:
51
Strategie 3:
52
Strategie 3:
53
Strategie 3:
54
Strategie 3:
55
Strategie 3:
56
Strategie 3:
57
Strategie 3:
58
Optimalitt?
58
Strategie 3:
59
Optimalitt?
59
Strategie 3:
60
Optimalitt?
60
Strategie 3:
61
Optimalitt?
61
Strategie 3:
62
Optimalitt?
62
Strategie 3:
63
Optimalitt?
63
Strategie 3:
64
Optimalitt?
64
Strategie 3:
65
Optimalitt?
Wieder nicht optimal!
65
Worauf muss man achten?
Ressource muss mglichst frh wieder frei werden!
Neue Strategie:
66
Neue Strategie:
Nimm die Anfrage, die am frhesten fertig ist.
66
Neue Strategie:
67
Neue Strategie:
67
Neue Strategie:
68
Neue Strategie:
68
Neue Strategie:
69
Neue Strategie:
69
Neue Strategie:
70
Neue Strategie:
70
Neue Strategie:
71
Neue Strategie:
71
Neue Strategie:
72
Neue Strategie:
72
Neue Strategie:
73
Neue Strategie:
73
Neue Strategie:
74
Neue Strategie:
Diese Strategie ist
optimal! Aber wie
beweist man das?
74
Formale Problemformulierung:
Problem: Intervall Scheduling
Eingabe: Felder s und f, die die Intervalle [ s[i], f[i] ]
beschreiben
Ausgabe: Indizes der ausgewhlten Intervalle
75
Ausgabe: Indizes der ausgewhlten Intervalle
o.B.d.A. nehmen wir an:
Eingabe ist nach Intervallendpunkten sortiert,
d.h.: f[1] f[2] f[n]
75
IntervalScheduling(s,f)
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
76
4. for i 2 to n do
5. if s[i] f[j] then
6. A A {i}
7. j i
7. return A
1
2
3
4
5
76
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
77
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
77
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
78
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
78
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
79
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
j
79
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
80
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
j
i
80
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
81
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
j
i
f[j]
s[i]
81
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
82
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
j
i
f[j]
s[i]
82
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
83
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
j i
f[j]
83
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
84
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
j i
f[j]
s[i]
84
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
85
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
j i
f[j]
s[i]
85
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
86
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5 j
86
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
87
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5 j
i
87
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
88
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5 j
f[j]
i
s[i]
88
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
89
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5 j
f[j]
i
s[i]
89
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
90
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
j
90
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
91
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
j
91
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
92
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
j
i
92
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
93
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
j
i
f[j]
s[i]
93
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
94
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
j
i
94
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
s 1 2 4 7 5
f 3 5 6 8 9
95
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
1
2
3
4
5
j
i
95
Wie knnen wir Optimalitt zeigen?
Sei O optimale Menge von Intervallen
Knnen wir A = O zeigen ?
96
Knnen wir A = O zeigen ?
97
u. U. viele optimale Lsungen
98
99
100
101
102
=> Wir zeigen: |A| = |O|
103
Beobachtung:
A ist eine Menge von kompatiblen Anfragen,
d.h. die Menge A bildet eine zulssige resp. gltige Lsung.
104
Notation:
i , , i Intervalle von A in Ordnung des Hinzufgens
j ,, j Intervalle von O sortiert nach Endpunkt
1
1
k
m
105
i
i
i
i
j
j
j
j
1
1
2
2
3
3
4
4
105
Wir zeigen: Der gierige Algorithmus liegt vorn:
D.h. jedes Intervall in A gibt die Ressource mindestens so
frh wieder frei, wie das korrespondierende Intervall in O
Dies ist wahr fr das erste Intervallpaar: f[i ] f[j ]
Zu zeigen: Dies gilt fr alle anderen Intervallpaare !
1 1
106
Zu zeigen: Dies gilt fr alle anderen Intervallpaare !
i
i
i
i
j
j
j
j
1
1
2
2
3
3
4
4
106
Lemma 19.4:
Fr alle rk gilt f[i ] f[j ].
r
r
107
i
i
i
i
j
j
j
j
1
1
2
2
3
3
4
4
107
Lemma 19.4:
r
r
108
i
i
i
i
j
j
j
j
1
1
2
2
3
3
4
4
f[i ], f[j ]
1 1
108
Lemma 19.4:
r
r
109
i
i
i
i
j
j
j
j
1
1
2
2
3
3
4
4
f[i ]
2
2
f[j ]
109
Lemma 19.4:
r
r
110
i
i
i
i
j
j
j
j
1
1
2
2
3
3
4
4
f[i ]
3 3
f[j ]
110
Lemma 19.4:
r
r
111
i
i
i
i
j
j
j
j
1
1
2
2
3
3
4
4
f[i ]
4
4
f[j ]
111
Satz 19.5:
Die von Algorithmus IntervalScheduling berechnete Lsung
A ist optimal.
112
i
i
i
i
j
j
j
j
1
1
2
2
3
3
4
4
112
1. n length[s]
2. A {1}
3. j 1
4. for i 2 to n do
113
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
113
1. n length[s]
2. A {1} (1)
3. j 1
4. for i 2 to n do
114
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
114
1. n length[s]
2. A {1} (1)
3. j 1
4. for i 2 to n do
115
4. for i 2 to n do
6. A A {i}
7. j i
8. return A
(n)
115
1. n length[s]
2. A {1} (1)
3. j 1
4. for i 2 to n do
116
4. for i 2 to n do
6. A A {i}
7. j i
8. return A (1)
(n)
116
1. n length[s]
2. A {1} (1)
3. j 1
4. for i 2 to n do
117
4. for i 2 to n do
6. A A {i}
7. j i
8. return A (1)
(n)
(n)
117
Satz 19.6:
Algorithmus IntervalScheduling berechnet in (n) Zeit eine
optimale Lsung, wenn die Eingabe nach Endzeit der
Intervalle (rechter Endpunkt) sortiert ist. Die Sortierung
kann in (n log n) Zeit berechnet werden.
118
kann in (n log n) Zeit berechnet werden.
118
Anwendungsbeispiel: Datenkompression
119
Datenkompression
Reduziert Gren von Files
Viele Verfahren fr unterschiedliche Anwendungen:
MP3, MPEG, JPEG,
Wie funktioniert Datenkompression?
Gierige Algorithmen Datenkompression
Zwei Typen von Kompression:
Verlustbehaftete Kompression (Bilder, Musik, Filme,)
Verlustfreie Kompression (Programme, Texte, )
120 SS 2010 120 Datenstrukturen und Algorithmen
120
Datenkompression
Reduziert Gren von Files
Viele Verfahren fr unterschiedliche Anwendungen:
MP3, MPEG, JPEG,
Zwei Typen von Kompression:
Verlustbehaftete Kompression (Bilder, Musik, Filme,)
Verlustfreie Kompression (Programme, Texte, )
121
Kodierung:
Computer arbeiten auf Bits (Symbole 0 und 1), nutzen also
das Alphabet {0,1}
Menschen nutzen umfangreichere Alphabete
(z.B. Alphabete von Sprachen)
(z.B. Alphabete von Sprachen)
Darstellung auf Rechner erfordert Umwandlung in Bitfolgen
122
Beispiel:
Alphabet ={a,b,c,d,,x,y,z, ,.,:,!,?,&} (32 Zeichen)
5 Bits pro Symbol: 2 = 32 Mglichkeiten
a b z . : ! ? &
5
a b z . : ! ? &
00000 00001 11001 11010 11011 11100 11101 11110 11111
123
Beispiel:
Alphabet ={a,b,c,d,,x,y,z, ,.,:,!,?,&} (32 Zeichen)
5 Bits pro Symbol: 2 = 32 Mglichkeiten
a b z . : ! ? &
5
Fragen?
Sind 4 Bits pro Symbol nicht genug ?
Mssen wir im Durchschnitt 5 Bits fr jedes Vorkommen
eines Symbols in langen Texten verwenden?
a b z . : ! ? &
00000 00001 11001 11010 11011 11100 11101 11110 11111
124
Beobachtung:
Nicht jeder Buchstabe kommt gleich hufig vor
z.B. kommen x,y und z in der Deutschen Sprache viel
seltener vor als e, n oder r
125
Beobachtung:
z.B. kommen x,y und z in der Deutschen Sprache viel
seltener vor als e, n oder r
Idee:
Idee:
Benutze kurze Bitstrings fr Symbole die hufig vorkommen
126
Beobachtung:
Z.B. kommen x,y und z in Deutsch viel seltener vor als
e,n oder r
Idee:
Idee:
Benutze kurze Bitstrings fr Symbole die hufig vorkommen
Effekt:
Gesamtlnge der Kodierung einer Symbolfolge (eines
Textes) wird reduziert
127
Grundlegendes Problem:
Eingabe: Text ber dem Alphabet
Gesucht: Eine binre Kodierung von , so dass die Lnge
des Textes in dieser Kodierung minimiert wird
Beispiel:
Beispiel:
={0,1,2,,9}
Text = 00125590004356789 (17 Zeichen)
0 1 2 3 4 5 6 7 8 9
0000 0001 0010 0011 0100 0101 0110 0111 1000 1001
128
Beispiel:
Lnge der Kodierung:
Beispiel:
={0,1,2,,9}
Text = 00125590004356789 (17 Zeichen)
0 1 2 3 4 5 6 7 8 9
0000 0001 0010 0011 0100 0101 0110 0111 1000 1001
Lnge der Kodierung:
4 17 = 68 Bits
129
Beispiel:
Beispiel:
={0,1,2,,9}
Text = 00125590004356789 (17 Zeichen)
0 1 2 3 4 5 6 7 8 9
0 11000 11001 11010 11011 10 11100 11101 11110 11111
130
Beispiel:
Lnge der Kodierung:
5 1 + 3 2 + 9 5 = 56 Bits
Beispiel:
={0,1,2,,9}
Text = 00125590004356789 (17 Zeichen)
0 1 2 3 4 5 6 7 8 9
0 11000 11001 11010 11011 10 11100 11101 11110 11111
5 1 + 3 2 + 9 5 = 56 Bits
131
Beispiel:
Lnge der Kodierung:
5 1 + 3 2 + 9 5 = 56 Bits
Beispiel:
={0,1,2,,9}
Text = 00125590004356789 (17 Zeichen)
0 1 2 3 4 5 6 7 8 9
0 11000 11001 11010 11011 10 11100 11101 11110 11111
5 1 + 3 2 + 9 5 = 56 Bits
132
Beispiel:
Lnge der Kodierung:
5 1 + 3 2 + 9 5 = 56 Bits
Beispiel:
={0,1,2,,9}
Text = 00125590004356789 (17 Zeichen)
0 1 2 3 4 5 6 7 8 9
0 11000 11001 11010 11011 10 11100 11101 11110 11111
5 1 + 3 2 + 9 5 = 56 Bits
133
Beispiel:
Lnge der Kodierung:
5 1 + 3 2 + 9 5 = 56 Bits
Beispiel:
={0,1,2,,9}
Text = 00125590004356789 (17 Zeichen)
0 1 2 3 4 5 6 7 8 9
0 11000 11001 11010 11011 10 11100 11101 11110 11111
5 1 + 3 2 + 9 5 = 56 Bits
134
MorseCode:
Elektrische Pulse ber Kabel
Punkte (kurze Pulse)
Striche(Lange Pulse)
Beispiele aus dem MorseCode:
e ist 0 (ein einzelner Punkt)
e ist 0 (ein einzelner Punkt)
t ist 1 (ein einzelner Strich)
a ist 01 (Strich Punkt)
Problem:
Ist 0101 eta, aa, etet, oder aet ?
135 SS 2010 135 135 Datenstrukturen und Algorithmen
135
Problem Mehrdeutigkeit:
Ist die Kodierung eines Buchstabens ein Prfix der
Kodierung eines anderen Buchstabens, dann ist die
Kodierung nicht eindeutig
Beispiel:
e = 0, a = 01
0 ist Prfix von 01
SS 2010
136
Prfix-Kodierung:
Eine Prfix-Kodierung fr ein Alphabet ist eine Funktion ,
die jeden Buchstaben x auf eine endliche Sequenz von 0
und 1 abbildet, so dass fr x,y, xy, die Sequenz (x)
kein Prfix der Sequenz (y) ist.
137
Prfix-Kodierung:
Eine Prfix-Kodierung fr ein Alphabet ist eine Funktion ,
die jeden Buchstaben x auf eine endliche Sequenz von 0
und 1 abbildet, so dass fr x,y, xy, die Sequenz (x)
kein Prfix der Sequenz (y) ist.
Beispiel (Prfix-Kodierung):
x 0 1 2 3 4 5 6 7 8 9
(x)
00 0100 0110 0111 1001 1010 1011 1101 1110 1111
138
Definition (Frequenz)
Die Frequenz f[x] eines Buchstaben x bezeichnet den
Bruchteil der Buchstaben im Text, die x sind.
Beispiel:
= {0,1,2}
Text =0010022001 (10 Zeichen)
f[0] = 3/5
f[1] = 1/5
f[2] = 1/5
139
Definition (Kodierungslnge)
Die Kodierungslnge eines Textes mit n Zeichen bzgl.
einer Kodierung ist definert als
Kodierungslnge = nf[x]|(x)|
Beispiel:
= {a,b,c,d}
(a) = 0; (b) =101; (c)= 110; (d)=111
Text = aacdaabb
Kodierungslnge = 16
x
140
einer Kodierung ist definiert als
x
Anzahl der
Vorkommen von x im
Text
Beispiel:
= {a,b,c,d}
(a) = 0; (b) =101; (c)= 110; (d)=111
Text = aacdaabb
Kodierungslnge = 16
x
141
einer Kodierung ist definiert als
x
Lnge der
Codierung von
x
Beispiel:
= {a,b,c,d}
(a) = 0; (b) =101; (c)= 110; (d)=111
Text = aacdaabb
Kodierungslnge = 16
x
142
Definition (durchschn. Kodierungslnge)
Die durchschnittliche Kodierungslnge eines Buchstabens
in einem Text mit n Zeichen und bzgl. einer Kodierung ist
definiert als ABL() = f[x]|(x)|
x
Beispiel:
= {a,b,c,d}
(a) = 0; (b) =101; (c)= 110; (d)=111
Text = aacdaabb
Durchschnittliche Kodierungslnge = 16/8 = 2
143
Problem einer optimalen Prfix-Kodierung:
Eingabe:
Alphabet und fr jedes x seine Frequenz f[x]
Ausgabe:
Eine Kodierung , die ABL() minimiert
SS 2010
144
Binrbume und Prfix-Kodierungen:
b
b
a
c
d
145
b
0 1
b
a
c
d
0
0
1
1
146
b
0 1
x (x)
a 00
b
a
c
d
0
0
1
a 00
b 1
c 011
d 010
1
147
Prfix-Kodierungen und Binrbume:
x (x)
a 11
b 01
c 00
d 10
148
Prfix-Kodierungen und Binrbume:
x (x)
a 11
0
1
b 01
c 00
d 10
c b d
a
0 0 1
1
149
Definition:
Die Tiefe eines Baumknotens ist die Lnge seines Pfades
zur Wurzel.
b
0 1
b
a
c
d
0
0
1
1
Tiefe(c) = 3
150
Neue Problemformulierung:
Suche Binrbaum T, dessen Bltter die Symbole aus
sind und der
ABL(T) = f[x] Tiefe
T
(x)
minimiert.
x
minimiert.
x
SS 2010
151
Definition:
Ein Binrbaum heit voll, wenn jeder innere Knoten genau
zwei Kinder hat.
b
0 1
b
a
c
d
0
0
1
1
Ein voller Binrbaum
152
Definition:
Ein Binrbaum heit voll, wenn jeder innere Knoten genau
zwei Kinder hat.
b
0 1
b
a
d
0
0
1
Ein nicht voller Binrbaum,
da der rote innere Knoten
keine zwei Kinder hat
153
Lemma 19.7:
Der Binrbaum, der einer optimalen Prfix-Kodierung
entspricht, ist voll.
b
0 1
b
a d
0
1
1
154
Lemma 19.7:
b
u
0 1
Beweis:
Annahme: T ist optimal und
hat inneren Knoten u mit einem
Kind v
b
v
a
u
d
0
1
1
Kind v
Ersetze u durch v
Dies verkrzt die Tiefe einiger
Knoten, erhht aber keine Tiefe
Damit verbessert man die
Kodierung
155
Lemma 19.7:
b
v
0 1
Beweis:
Annahme: T ist optimal und
hat inneren Knoten u mit einem
Kind v
b
a
v
d
0
1
Kind v
Ersetze u durch v
Dies verkrzt die Tiefe einiger
Knoten, erhht aber keine Tiefe
Damit verbessert man die
Kodierung
156
Ein Gedankenexperiment:
Angenommen, jemand gibt uns den optimalen Baum T*,
aber nicht die Bezeichnung der Bltter
Wie schwierig ist es, die Bezeichnungen zu finden?
SS 2010
157
Lemma 19.8:
Seien u und v sind Bltter von T* mit Tiefe(u) <Tiefe(v).
Seien u bzw. v in einer optimalen Kodierung mit y
bzw. z bezeichnet. Dann gilt f[y]f[z].
0 1
y
z
0
0
1
1
u
v
158
Lemma 19.8:
0 1
x f[x]
a 10%
0
0
1
1
a 10%
b 12%
c 18%
d 60%
159
Lemma 19.8:
0 1
x f[x]
a 10%
d
0
0
1
1
a 10%
b 12%
c 18%
d 60%
160
Lemma 19.8:
0 1
x f[x]
a 10%
d
c
0
0
1
1
a 10%
b 12%
c 18%
d 60%
161
Lemma 19.8:
0 1
x f[x]
a 10%
d
c
b
0
0
1
1
a 10%
b 12%
c 18%
d 60%
162
Lemma 19.8:
0 1
x f[x]
a 10%
d
c
a
b
0
0
1
1
a 10%
b 12%
c 18%
d 60%
163
Lemma 19.8:
0 1
x f[x]
a 10%
d
c
b
a
0
0
1
1
a 10%
b 12%
c 18%
d 60%
Anordnung innerhalb einer
Tiefenstufe ist egal!
164
Beobachtung
Sei v der tiefste Blattknoten in T*. Dann hat v einen Bruder
und dieser ist ebenfalls ein Blattknoten.
d
0 1
1
d
c
b
a
0
0
1
1
v
w
(Bruder von v)
165
Beobachtung
Sei v der tiefste Blattknoten in T*. Dann hat v einen Bruder
und dieser ist ebenfalls ein Blattknoten.
d
0 1
1
Beweis:
Da ein optimaler Baum
voll ist, hat v einen
Bruder w
d
c
b
a
0
0
1
1
v
w
(Bruder von v)
Bruder w
Wre w kein Blatt, dann
htte ein Nachfolger von
w grere Tiefe als v
166
Zusammenfassende Behauptung
Es gibt eine optimale Prfix-Kodierung mit zugehrigem Baum T*,
so dass die beiden Blattknoten, denen die Symbole mit den
kleinsten Frequenzen zugewiesen wurden, Bruderknoten in T* sind.
kleinsten Frequenzen zugewiesen wurden, Bruderknoten in T* sind.
167
Es gibt eine optimale Prfix-Kodierung mit zugehrigem Baum T*, so
dass die beiden Blattknoten, denen die Symbole mit den kleinsten
Frequenzen zugewiesen wurden, Bruderknoten in T* sind.
0 1
x f[x]
a 10%
d
c
b
a
0
0
1
1
a 10%
b 12%
c 18%
d 60%
168
Es gibt eine optimale Prfix-Kodierung mit zugehrigem Baum T*, so
dass die beiden Blattknoten, denen die Symbole mit den kleinsten
Frequenzen zugewiesen wurden, Bruderknoten in T* sind.
0 1
x f[x]
a 10%
d
c
b
a
0
0
1
1
a 10%
b 12%
c 18%
d 60%
a und b erfllen die
Bedingungen der Behauptung!
169
Idee des Algorithmus:
Die beiden Symbole y* und z* mit den niedrigsten
Frequenzen sind Bruderknoten
Fasse y* und z* zu einem neuen Symbol zusammen
Lse das Problem fr die brigen n-1 Symbole
(z.B. rekursiv)
(z.B. rekursiv)
z*
y*
170
Idee des Algorithmus:
Die beiden Symbole y* und z* mit den niedrigsten
Frequenzen sind Bruderknoten
Fasse y* und z* zu einem neuen Symbol zusammen
Lse das Problem fr die brigen n-1 Symbole
(z.B. rekursiv)
(z.B. rekursiv)
y*z*
171
x f[x]
a 23%
b 12%
c 55%
d 10%
Huffmann()
1. n | |
2. Q /* Priority Queue bzgl. f[x] */
3. for for for for i 1 to to to to n-1 do do do do
4. x deleteMin(Q)
4. x deleteMin(Q)
5. y deleteMin(Q)
6. znew new new new BinTree(x, f[x]+f[y],y)
7. f[z]f[x] + f[y]
8. Q Q {z}
9. return return return return deleteMin(Q)
172
x f[x]
a 23%
b 12%
c 55%
d 10%
Huffmann()
1. n | |
4. x deleteMin(Q)
173 SS 2010 173
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
173
x f[x]
a 23%
b 12%
c 55%
d 10%
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
10% 12% 23% 55%
174 SS 2010 174
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
174
x f[x]
a 23%
b 12%
c 55%
d 10%
i=1
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
10% 12% 23% 55%
175 SS 2010 175
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
175
x f[x]
a 23%
b 12%
c 55%
d 10%
i=1
Huffmann()
1. n | |
4. x deleteMin(Q)
10%
x:
Q:
12% 23% 55%
176 SS 2010 176
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
176
x f[x]
a 23%
b 12%
c 55%
d 10%
i=1
Huffmann()
1. n | |
4. x deleteMin(Q)
x:
y:
Q:
23% 55%
10%
12%
177 SS 2010 177
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
177
x f[x]
a 23%
b 12%
c 55%
d 10%
i=1
Huffmann()
1. n | |
4. x deleteMin(Q)
z:
Q:
23% 55%
10% 12%
22%
178 SS 2010 178
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
178
x f[x]
a 23%
b 12%
c 55%
d 10%
i=1
Huffmann()
1. n | |
4. x deleteMin(Q)
z:
Q:
23% 55%
10% 12%
22%
179 SS 2010 179
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
179
x f[x]
a 23%
b 12%
c 55%
d 10%
i=1
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
23% 55%
10% 12%
22%
180 SS 2010 180
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
180
x f[x]
a 23%
b 12%
c 55%
d 10%
i=2
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
23% 55%
10% 12%
22%
181 SS 2010 181
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
181
x f[x]
a 23%
b 12%
c 55%
d 10%
i=2
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
23% 55%
10% 12%
22%
x:
182 SS 2010 182
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
182
x f[x]
a 23%
b 12%
c 55%
d 10%
i=2
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
23%
55%
10% 12%
22%
x:
y:
183 SS 2010 183
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
183
x f[x]
a 23%
b 12%
c 55%
d 10%
i=2
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
23%
55%
10% 12%
22%
z:
45%
184 SS 2010 184
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
184
x f[x]
a 23%
b 12%
c 55%
d 10%
i=2
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
23%
55%
10% 12%
22%
z:
45%
185 SS 2010 185
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
185
x f[x]
a 23%
b 12%
c 55%
d 10%
i=2
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
55%
23%
10% 12%
22%
45%
186 SS 2010 186
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
186
x f[x]
a 23%
b 12%
c 55%
d 10%
i=3
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
55%
23%
10% 12%
22%
45%
187 SS 2010 187
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
187
x f[x]
a 23%
b 12%
c 55%
d 10%
i=3
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
23%
10% 12%
22%
45%
55%
x:
188 SS 2010 188
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
188
x f[x]
a 23%
b 12%
c 55%
d 10%
i=3
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
23%
10% 12%
22%
45%
55% x: y:
189 SS 2010 189
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
189
x f[x]
a 23%
b 12%
c 55%
d 10%
i=3
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
23%
10% 12%
22%
45%
55% z:
100%
190 SS 2010 190
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
190
x f[x]
a 23%
b 12%
c 55%
d 10%
i=3
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
23%
10% 12%
22%
45%
55% z:
100%
191 SS 2010 191
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
191
x f[x]
a 23%
b 12%
c 55%
d 10%
i=3
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
23%
10% 12%
22%
45%
55%
100%
192 SS 2010 192
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
192
x f[x]
a 23%
b 12%
c 55%
d 10%
i=3
Huffmann()
1. n | |
4. x deleteMin(Q)
Q:
23%
10% 12%
22%
45%
55%
100%
193 SS 2010 193
4. x deleteMin(Q)
5. y deleteMin(Q)
7. f[z]f[x] + f[y]
8. Q Q {z}
193
Satz 19.9
Algorithmus Huffman() berechnet eine optimale
Prfix-Kodierung.
Beweisidee:
Lemma 19.8 gilt auch fr Teilbume, d.h. seien u und v
Knoten von T* mit Tiefe(u)<Tiefe(v). Sei f[u] die
Gesamtfrequenz der Zeichen x unter u und f[v] die
Gesamtfrequenz der Zeichen y unter v. Dann gilt
f[u]f[v].
SS 2010
194
Kann man an einem Problem erkennen,
ob ein Greedy Algorithmus eine optimale
Gierige Algorithmen Matroide
ob ein Greedy Algorithmus eine optimale
Ausgabe liefert?
195
Definition 19.10: Sei M eine endlichen Menge und T eine
nichtleere Menge von Teilmengen von M.
Das Mengensystem (M,T ) heit Teilmengensystem fr
alle A,BM gilt:
AT und BA BT
D.h. die Teilmengen in T sind bezglich abgeschlossen.
Das zu (M,T ) gehrige Optimierungsproblem besteht darin,
fr eine beliebige gegebene Gewichtsfunktion w:M eine
in T maximale Menge T zu finden, deren Gesamtgewicht
w(T):=
eT
w(e)
maximal (bzw. minimal) ist.
196
Beispiele fr ein Teilmengensystem:
T = { } { {x} | xM}
T = P(M) (P(M): Potenzmenge von M)
Kein Teilmengensystem:
Kein Teilmengensystem:
T = { {x,y} | x,yM}
Beweis: betrachte beliebige x,yM. Sei
A={x,y} und B={x}. Dann sind A,BM,
AT und BA, aber BT.
197
Gegeben sei ein Teilmengensystem (M,T )
und eine Gewichtsfunktion w:M.
Greedy-Algorithmus:
1. Sortiere die Elemente in M nach absteigen-
dem Gewicht (Maximierung). Sei
dem Gewicht (Maximierung). Sei
M={x
1
,...,x
m
} mit w(x
1
) ... w(x
m
).
2. T
3. Fr k1 bis m:
4. Falls T{x
k
}T , dann TT{x
k
}
5. Gib T aus
198
Bemerkung 19.11: Der Greedy-Algorithmus
liefert nicht immer eine Menge T mit
maximalem Gewicht.
Beispiel:
M={a,b,c}
M={a,b,c}
T={, {a}, {b}, {c}, {a,b}}
w(a)=w(b)=2, w(c)=3
Dafr berechnet der Greedy-Algorithmus
T={c} mit w(T)=3, aber die optimale Lsung
ist T={a,b} mit w(T)=4.
199
Beispiel:
Traveling Salesman Problem (TSP): Gegeben
eine Knotenmenge V mit Distanzen d:VV
+
,
finde eine Rundtour TP(VV) ber alle Knoten
mit minimaler Lnge d(T)=
eT
d(e), die jeden
Knoten genau einmal besucht.
Teilmengensystem zum TSP:
M =VV
T ={ EM | ET fr eine Rundtour T}
Das TSP ist ein NP-schweres Problem, die
Greedy-Methode kann also in der Regel keine
optimale Lsung liefern.
200
Beispiel:
Rucksack Problem: Gegeben eine Objektmenge
M mit Gewichten w:M
+
und ein Rucksack mit
maximaler Traglast W, finde eine Teilmenge T der
Objekte mit maximalem Gewicht, die in den
Rucksack passt, d.h. w(T):=
xT
w(x) W.
Teilmengensystem zum Rucksack Problem:
M wie oben definiert
T ={ TM | w(T)W }
Das Rucksackproblem ist auch ein NP-schweres
Problem, d.h. auch hier wird die Greedy-Methode
im Allgemeinen keine optimale Lsung liefern.
201
Definition 19.12: Ein Teilmengensystem (M,T ) heit
Matroid fr alle A,BT das Austauschaxiom
gilt:
|A|=|B|+1 aA\B: B{a}T
Die Mengen in T werden unabhngige Mengen
genannt. Jede maximale (d.h. nicht erweiterbare)
unabhngige Menge heit Basis.
unabhngige Menge heit Basis.
Beispiele:
Sei G=(V,E) ein Graph. Dann ist (M,T ) mit M=E
und T = { TM | (V,T) ist ein Wald} ein Matroid.
Die Teilmengensysteme zum TSP und zum
Rucksackproblem sind dagegen keine Matroide.
202
Satz 19.13: Sei (M,T ) ein Teilmengensystem. Der
Greedy-Algorithmus lst genau dann das zu
(M,T ) gehrige Optimierungsproblem (fr jede
Gewichtsfunktion w), wenn (M,T ) ein Matroid ist.
Beweis:
:
Alle maximalen Mengen von T haben wegen des
Alle maximalen Mengen von T haben wegen des
Austauschaxioms die gleiche Kardinalitt.
Sei k diese Kardinalitt und sei S={x
1
,...,x
k
} die
vom Greedy-Algorithmus berechnete Lsung. Es
gelte w(x
1
) ... w(x
k
).
Sei T={y
1
,...,y
k
} eine andere maximale Menge aus
T . Es gelte w(y
1
) ... w(y
k
).
203
Annahme: es existiert ein i mit w(y
i
)>w(x
i
).
Sei i der kleinste solche Index, also
w(y
1
)w(x
1
),...,w(y
i-1
)w(x
i-1
).
Definition 19.12 liefert mit A={y
1
,...,y
i
} und
B={x
1
,...,x
i-1
} ein y
j
A\B, so dass B{y
j
}T .
Wegen w(y)w(y)>w(x) htte der Greedy-
Wegen w(y
j
)w(y
i
)>w(x
i
) htte der Greedy-
Algorithmus vor x
i
schon y
j
genommen, wir
erhalten also einen Widerspruch zur
Annahme.
Also ist w(y
i
)w(x
i
) fr alle 1 ik und somit
w(T)w(S).
204
: Das Austauschaxiom gelte nicht.
Dann gibt es A,BT mit |A|=|B|+1, so dass
B{a}T fr alle aA\B.
Sei r=|A| und w:VV gegeben durch
r+1 falls xB
w(x):= r falls xA\B
w(x):= r falls xA\B
0 sonst
Der Greedy-Algorithmus whlt dann eine Menge T
mit TB und T(A\B)= mit Gewicht
w(T)=|B|(r+1) = r
2
-1
Whlt man stattdessen ein S mit SA, dann ergibt
sich w(S)|A|r = r
2
> w(T).
205
Gegeben sei eine Menge J={1,...,n} von Jobs.
Jeder Job habe einen Fertigstellungstermin f(i)
und eine Strafe s(i), die bei nicht rechtzeitiger
Fertigstellung gezahlt werden muss.
Pro Tag kann nur ein Job erledigt werden.
Wie muss man die Jobs einplanen, so dass die
Gesamtstrafe minimiert wird?
Wie muss man die Jobs einplanen, so dass die
Gesamtstrafe minimiert wird?
Beispiel:
206
Job 1 2 3 4 5 6
f(i) 1 1 2 3 3 6
s(i) 10 9 6 7 4 2
Modellierung als Matroid:
M = J
T = { PJ | jP: Job j ist pnktlich planbar}
Man nehme s(i) als Gewichtsfunktion und wende den
Greedy-Algorithmus an.
Terminplan:
Terminplan:
Strafe: 13
207
Job 1 2 3 4 5 6
f(i) 1 1 2 3 3 6
s(i) 10 9 6 7 4 2
Reihe 1 - 3 2 - 4
Beispiel: minimale Spannbume
Gegeben sei ein Graph G=(V,E) mit
Kantenkosten c:E. Finde einen
Spannbaum (V,T) mit TE mit mini-
malen Kosten.
malen Kosten.
M = E
T = { TE | (V,T) ist ein Wald }
Greedy-Algorithmus identisch mit Kruskal.
208
Satz 19.14: Das System (M,T ) zum
Minimalen-Spannbaum-Problem ist ein
Matroid.
Beweis:
T : klar
T : klar
AT und BA BT : klar
Wir mssen die Austauscheigenschaft
nachweisen.
209
Zu zeigen: fr alle A,BT gilt
|A|=|B|+1 aA\B: B{a}T
Betrachte zwei kreisfreie Kantenmengen A,BE.
Seien V
1
,...,V
k
die Zusammenhangskomponenten
von (V,B).
Da |B|<|A| ist, ist B kein Spannbaum, also k2.
Da A kreisfrei ist, kann A innerhalb jeder Menge V
Da A kreisfrei ist, kann A innerhalb jeder Menge V
i
hchstens |V
i
|-1 Kanten haben.
B hat in jedem V
i
genau |V
i
|-1 Kanten.
Also gibt es in A hchstens
i=1
k
(|V
i
|-1)=|B| viele
Kanten, die innerhalb eines V
i
verlaufen.
Da |A|>|B|, gibt es somit in A eine Kante e, die zwei
verschiedene V
i
verbindet. Diese kann aber in B
keinen Kreis schlieen, d.h. B{e}T.
210
Beispiel: maximales Matching
Ein Matching ist eine Kantenmenge, in der
jeder Knoten hchstens einmal vorkommt.
Gegeben sei ein bipartiter Graph G=(LR,E)
mit Knotengewichten w:L
+
. Finde ein
Matching FE mit maximalem Gewicht w(F)
Matching FE mit maximalem Gewicht w(F)
=
(u,v)F
w(u).
M=L
T = { TL | T hat ein Matching in G }
211
Satz 19.15: Das System (M,T ) zum
Maximalen-Matching-Problem ist ein
Matroid.
Beweis:
T : klar
T : klar
AT und BA BT : klar
Wir mssen die Austauscheigenschaft
nachweisen.
212
Zu zeigen: fr alle A,BT gilt
|A|=|B|+1 aA\B: B{a}T
Betrachte Knotenmengen A,BL mit |A|=|B|+1. Sei X ein
Matching zu A und Y ein Matching zu B.
Betrachte den Graphen H=(LR,XY).
Seien X die roten und Y die blauen Kanten.
H besteht aus
H besteht aus
isolierten Kanten, die rot, blau oder beides sein knnen,
und/oder
disjunkten Wegen, die aus abwechselnd roten und blauen
Kanten bestehen.
H hat mehr rote als blaue Kanten.
Also gibt es entweder eine isolierte rote Kante oder einen
Weg der Lnge >1 mit mehr roten als blauen Kanten.
213
Also: es gibt entweder eine isolierte rote Kante (mit
linkem Knoten vA\B) oder einen Weg P der Lnge
>1 mit mehr roten als blauen Kanten.
Im ersten Fall: B{v}T .
Im zweiten Fall: P hat ungerade Lnge, beginnt und
endet mit roter Kante.
B{v}T, da die roten Kanten ein Matching bilden.
214
L
R
vA\B
Fazit: Knnen wir ein Optimierungsproblem
als Matroid modellieren, wissen wir, dass
der Greedy-Algorithmus eine optimale
Lsung findet.
215
Gierige Algorithmen:
Berechne Lsung schrittweise
In jedem Schritt mache lokal optimale Wahl
Anwendbar:
20. Dynamische Programmierung
Wenn optimale Lsung eines Problems optimale Lsung
von Teilproblemen enthlt
Algorithmen:
Scheduling Probleme
Optimale Prfix-Kodierung (Huffman Codes)
SS 2011
1 DuA - Kapitel 20
Rekursiver Ansatz:
Lsen eines Problems durch Lsen mehrerer kleinerer
Teilprobleme, aus denen sich die Lsung fr das
Ausgangsproblem zusammensetzt
Phnomen:
Mehrfachberechnungen von Lsungen
Mehrfachberechnungen von Lsungen
Methode:
Lsungen zu Teilproblemen werden iterativ beginnend
mit den Lsungen der kleinsten Teilprobleme berechnet
(bottom-up).
Speichern einmal berechneter Lsungen in einer Tabelle
Typische Anwendung fr dynamisches
Programmieren: Optimierungsprobleme
Eine optimale Lsung fr das Ausgangsproblem
Eine optimale Lsung fr das Ausgangsproblem
setzt sich aus optimalen Lsungen fr kleinere
Probleme zusammen.
Mit Greedy-Algorithmen:
Algorithmenmethode, um Optimierungsprobleme zu
lsen
Mit Divide-&-Conquer:
Lsung eines Problems aus Lsungen zu Teilproblemen
Aber: Lsungen zu Teilproblemen werden nicht rekursiv
gelst.
Definition:
Seien X=(x
1
,...,x
m
) und Y=(y
1
,...,y
n
) zwei Folgen, wobei
x
i
, y
j
A fr ein endliches Alphabet A.
Dann heit Y Teilfolge von X, wenn es aufsteigend
sortierte Indizes i
1
,...,i
n
gibt mit x
i
j
= y
j
fr j = 1,...,n.
Lngste gemeinsame Teilfolge
sortierte Indizes i
1
,...,i
n
gibt mit x
i
j
= y
j
fr j = 1,...,n.
B
F
F
Y
W
Definition:
Seien X=(x
1
,...,x
m
) und Y=(y
1
,...,y
n
) zwei Teilfolgen,
wobei x
i
, y
j
sortierte Indizes i
1
,...,i
n
gibt mit x
i
j
= y
j
fr j = 1,...,n.
sortierte Indizes i
1
,...,i
n
gibt mit x
i
j
= y
j
fr j = 1,...,n.
Beispiel:
Folge Y
Folge X
Y ist Teilfolge von X
Whle (i
1
,i
2
,i
3
,i
4
) = (2,4,5,7)
B C A C
A B A C A B C
Definition:
Seien X=(x
1
,...,x
m
) und Y=(y
1
,...,y
n
) zwei Teilfolgen,
wobei x
i
, y
j
sortierte Indizes i
1
,...,i
n
gibt mit x
i
j
= y
j
fr j = 1,...,n.
sortierte Indizes i
1
,...,i
n
gibt mit x
i
j
= y
j
fr j = 1,...,n.
Beispiel:
Folge Y
Folge X
Whle (i
1
,i
2
,i
3
,i
4
) = (2,4,5,7)
B C A C
A B A C A B C
Definition:
Seien X=(x
1
,...,x
m
) und Y=(y
1
,...,y
n
) zwei Teilfolgen,
wobei x
i
, y
j
sortierte Indizes i
1
,...,i
n
gibt mit x
i
j
= y
j
fr j = 1,...,n.
sortierte Indizes i
1
,...,i
n
gibt mit x
i
j
= y
j
fr j = 1,...,n.
Beispiel:
Folge Y
Folge X
Whle (i
1
,i
2
,i
3
,i
4
) = (2,4,5,7)
B C A C
A B A C A B C
Definition:
Seien X=(x
1
,...,x
m
) und Y=(y
1
,...,y
n
) zwei Teilfolgen,
wobei x
i
, y
j
sortierte Indizes i
1
,...,i
n
gibt mit x
i
j
= y
j
fr j = 1,...,n.
sortierte Indizes i
1
,...,i
n
gibt mit x
i
j
= y
j
fr j = 1,...,n.
Beispiel:
Folge Y
Folge X
Whle (i
1
,i
2
,i
3
,i
4
) = (2,4,5,7)
B C A C
A B A C A B C
Definition:
Seien X=(x
1
,...,x
m
) und Y=(y
1
,...,y
n
) zwei Teilfolgen,
wobei x
i
, y
j
sortierte Indizes i
1
,...,i
n
gibt mit x
i
j
= y
j
fr j = 1,...,n.
sortierte Indizes i
1
,...,i
n
gibt mit x
i
j
= y
j
fr j = 1,...,n.
Beispiel:
Folge Y
Folge X
Y ist Teilfolge von X, Whle (i
1
,i
2
,i
3
,i
4
) = (2,4,5,7)
B C A C
A B A C A B C
Definition:
Seien X, Y, Z Folgen ber A.
Dann heit Z gemeinsame Teilfolge von X und Y, wenn
Z Teilfolge sowohl von X als auch von Y ist.
B
B
F
F
F
Z
Definition:
Beispiel:
Beispiel:
Folge Z
Folge X
Folge Y
Z ist gemeinsame Teilfolge von X und Y
A B A C A B C
B C A C
B A C C A B B C
Definition:
Beispiel:
Beispiel:
Folge Z
Folge X
Folge Y
A B A C A B C
B C A C
B A C C A B B C
Definition:
Beispiel:
Beispiel:
Folge Z
Folge X
Folge Y
A B A C A B C
B C A C
B A C C A B B C
Definition:
Dann heit Z lngste gemeinsame Teilfolge von X und
Y, wenn Z gemeinsame Teilfolge von X und Y ist und es
keine andere gemeinsame Teilfolge von X und Y gibt,
die grere Lnge als Z besitzt.
B
F
F
F
Definition:
Beispiel:
Folge X
Folge Y
F
A B A C A B C
B A C C A B B C
Definition:
Beispiel:
Folge X
Folge Y
Folge Z
1
A B A C A B C
B A C C A B B C
B C A C
Definition:
Beispiel:
Folge X
Folge Y
Folge Z
1
Folge Z
2
A B A C A B C
B A C C A B B C
B C A C
B A C A C
Lngste Teilfolge
hat Lnge 6
Eingabe:
Folge X=(x
1
,...,x
m
)
Folge Y=(y
1
,...,y
n
)
Ausgabe:
Ausgabe:
Lngste gemeinsame Teilfolge Z
(Longest Common Subsequenz)
B
F
F
Eingabe:
Folge X=(x
1
,...,x
m
)
Folge Y=(y
1
,...,y
n
)
Ausgabe:
Ausgabe:
Lngste gemeinsame Teilfolge Z
(Longest Common Subsequenz)
Beispiel:
Folge X
Folge Y
A B C B D A B
B D C A B A
Algorithmus:
Erzeuge alle mglichen Teilfolgen von X
Teste fr jede Teilfolge von X, ob auch Teilfolge von Y
Merke zu jedem Zeitpunkt bisher lngste gemeinsame
Teilfolge
Teilfolge
Laufzeit:
2
m
mgliche Teilfolgen
Exponentielle Laufzeit!
Satz 20.1:
Seien X=(x
1
,...,x
m
) und Y=(y
1
,...,y
n
) beliebige Folgen und
sei Z=(z
1
,...,z
k
) eine lngste gemeinsame Teilfolge von
X und Y. Dann gilt
1. Ist x
m
= y
n
, dann ist z
k
= x
m
= y
n
und (z
1
,...,z
k-1
) ist eine
lngste gemeinsame Teilfolge von (x ,...,x ) und
lngste gemeinsame Teilfolge von (x
1
,...,x
m-1
) und
(y
1
,...,y
n-1
).
Ist x
m
y
n
und z
k
x
m
, dann ist Z eine lngste gemeinsame
Teilfolge von (x
1
,...,x
m-1
) und Y.
Ist x
m
y
n
und z
k
y
n
Teilfolge von X und (y
1
,...,y
n-1
).
Satz 20.1:
Seien X=(x
1
,...,x
m
) und Y=(y
1
,...,y
n
sei Z=(z
1
,...,z
k
X und Y. Dann gilt
1. Ist x
m
= y
n
, dann ist z
k
= x
m
= y
n
und (z
1
,...,z
k-1
) ist eine
1
,...,x
m-1
) und
(y
1
,...,y
n-1
).
2. Ist x
m
y
n
und z
k
x
m
, dann ist Z eine lngste
gemeinsame Teilfolge von (x
1
,...,x
m-1
) und Y.
Ist x
m
y
n
und z
k
y
n
Teilfolge von X und (y
1
,...,y
n-1
).
Satz 20.1:
Seien X=(x
1
,...,x
m
) und Y=(y
1
,...,y
n
sei Z=(z
1
,...,z
k
X und Y. Dann gilt
1. Ist x
m
= y
n
, dann ist z
k
= x
m
= y
n
und (z
1
,...,z
k-1
) ist eine
1
,...,x
m-1
) und
(y
1
,...,y
n-1
).
2. Ist x
m
y
n
und z
k
x
m
1
,...,x
m-1
) und Y.
3. Ist x
m
y
n
und z
k
y
n
gemeinsame Teilfolge von X und (y
1
,...,y
n-1
).
Satz 20.1:
Seien X=(x
1
,...,x
m
) und Y=(y
1
,...,y
n
sei Z=(z
1
,...,z
k
X und Y. Dann gilt
1. Ist x
m
= y
n
, dann ist z
k
= x
m
= y
n
und (z
1
,...,z
k-1
) ist eine
lngste gemeinsame Teilfolge von
lngste gemeinsame Teilfolge von
(x
1
,...,x
m-1
) und (y
1
,...,y
n-1
).
2. Ist x
m
y
n
und z
k
x
m
1
,...,x
m-1
) und Y.
3. Ist x
m
y
n
und z
k
y
n
gemeinsame Teilfolge von X und (y
1
,...,y
n-1
).
Lemma 20.2:
Sei C[i][j] die Lnge einer lngsten gemeinsamen Teilfolge
von (x
1
,...,x
i
) und (y
1
,...,y
j
). Dann gilt:
= > +
= =
= y x j i j i C
j i
j i C und falls
oder falls
0 , 1 ] 1 ][ 1 [
0 0 0
] ][ [
Beobachtung:
Rekursive Berechnung der C[i][j] wrde zu Berechnung
immer wieder derselben Werte fhren. Dieses ist
ineffizient. Berechnen daher die Werte C[i][j] iterativ,
nmlich zeilenweise.
{ }
>
= > + =
j i
j i
y x j i j i C j i C
y x j i j i C j i C
und falls
und falls
0 , ] 1 ][ [ ], ][ 1 [ max
0 , 1 ] 1 ][ 1 [ ] ][ [
Lemma 20.2:
von (x
1
,...,x
i
) und (y
1
,...,y
j
). Dann gilt:
= > +
= =
= y x j i j i C
j i
j i C und falls
oder falls
0 , 1 ] 1 ][ 1 [
0 0 0
] ][ [
Beobachtung:
nmlich zeilenweise.
{ }
>
= > + =
j i
j i
y x j i j i C j i C
y x j i j i C j i C
und falls
und falls
0 , ] 1 ][ [ ], ][ 1 [ max
0 , 1 ] 1 ][ 1 [ ] ][ [
Lemma 20.2:
von (x
1
,...,x
i
) und (y
1
,...,y
j
). Dann gilt:
= > +
= =
= y x j i j i C
j i
j i C und falls
oder falls
0 , 1 ] 1 ][ 1 [
0 0 0
] ][ [
Beobachtung:
nmlich zeilenweise.
{ }
>
= > + =
j i
j i
y x j i j i C j i C
y x j i j i C j i C
und falls
und falls
0 , ] 1 ][ [ ], ][ 1 [ max
0 , 1 ] 1 ][ 1 [ ] ][ [
Lemma 20.2:
von (x
1
,...,x
i
) und (y
1
,...,y
j
). Dann gilt:
= > +
= =
= y x j i j i C
j i
j i C und falls
oder falls
0 , 1 ] 1 ][ 1 [
0 0 0
] ][ [
Beobachtung:
nmlich zeilenweise.
{ }
>
= > + =
j i
j i
y x j i j i C j i C
y x j i j i C j i C
und falls
und falls
0 , ] 1 ][ [ ], ][ 1 [ max
0 , 1 ] 1 ][ 1 [ ] ][ [
LCS-Lnge(Array X, Y)
1. m length[X]
2. n length[Y]
3. new array C[0,..,m][0,..,n]
4. for i 0 to m do C[i][0] 0
4. for i 0 to m do C[i][0] 0
5. for j 0 to n do C[0][j] 0
6. for i 1 to m do
7. for j 1 to n do
8. Lngenberechnung(X, Y, C, i, j)
9. return C
1. m length[X]
2. n length[Y]
3. new array C[0,..,m][0,..,n]
4. for i 0 to m do C[i][0] 0
4. for i 0 to m do C[i][0] 0
5. for j 0 to n do C[0][j] 0
6. for i 1 to m do
7. for j 1 to n do
9. return C
1. m length[X]
2. n length[Y]
3. new array C[0,..,m][0,..,n]
4. for i 0 to m do C[i][0] 0
Tabelle fr die
C[i][j] Werte
anlegen.
4. for i 0 to m do C[i][0] 0
5. for j 0 to n do C[0][j] 0
6. for i 1 to m do
7. for j 1 to n do
9. return C
1. m length[X]
2. n length[Y]
3. new array C[0,..,m][0,..,n]
4. for i 0 to m do C[i][0] 0
Erste Spalte
der Tabelle
4. for i 0 to m do C[i][0] 0
5. for j 0 to n do C[0][j] 0
6. for i 1 to m do
7. for j 1 to n do
9. return C
der Tabelle
auf 0 setzen.
1. m length[X]
2. n length[Y]
3. new array C[0,..,m][0,..,n]
4. for i 0 to m do C[i][0] 0
Erste Reihe
4. for i 0 to m do C[i][0] 0
5. for j 0 to n do C[0][j] 0
6. for i 1 to m do
7. for j 1 to n do
9. return C
Erste Reihe
der Tabelle
auf 0 setzen.
1. m length[X]
2. n length[Y]
3. new array C[0,..,m][0,..,n]
4. for i 0 to m do C[i][0] 0
4. for i 0 to m do C[i][0] 0
5. for j 0 to n do C[0][j] 0
6. for i 1 to m do
7. for j 1 to n do
9. return C
Lngenberechnung(Array X, Y, C, i, j)
1. if x
i
= y
j
then C[i][j] C[i-1][j-1] +1
2. else
3. if C[i-1][j] C[i][j-1] then C[i][j] C[i-1][j]
4. else C[i][j] C[i][j-1]
{ }
>
= > +
= =
=
j i
j i
y x j i j i C j i C
y x j i j i C
j i
j i C
und falls
und falls
oder falls
0 , ] 1 ][ [ ], ][ 1 [ max
0 , 1 ] 1 ][ 1 [
0 0 0
] ][ [
Lngenberechnung(Array X, Y, C, i, j)
1. if x
i
= y
j
then C[i][j] C[i-1][j-1] +1
2. else
3. if C[i-1][j] C[i][j-1] then C[i][j] C[i-1][j]
{ }
>
= > +
= =
=
j i
j i
y x j i j i C j i C
y x j i j i C
j i
j i C
und falls
und falls
oder falls
0 , ] 1 ][ [ ], ][ 1 [ max
0 , 1 ] 1 ][ 1 [
0 0 0
] ][ [
1. m length[X]
2. n length[Y]
3. new array C[0,..,m][0,..,n]
4. for i 0 to m do C[i][0] 0
4. for i 0 to m do C[i][0] 0
5. for j 0 to n do C[0][j] 0
6. for i 1 to m do
7. for j 1 to n do
9. return C
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
3 C
4 B
5 D
6 A
7 B
0
0
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0
0
0
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0 1 2 2 2 3 3
0 1 2 2 3 3 4
0 1 2 2 3 4 4
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0 1 2 2 2 3 3
0 1 2 2 3 3 4
0 1 2 2 3 4 4
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0 1 2 2 2 3 3
0 1 2 2 3 3 4
0 1 2 2 3 4 4
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0 1 2 2 2 3 3
0 1 2 2 3 3 4
0 1 2 2 3 4 4
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0 1 2 2 2 3 3
0 1 2 2 3 3 4
0 1 2 2 3 4 4
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0 1 2 2 2 3 3
0 1 2 2 3 3 4
0 1 2 2 3 4 4
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0 1 2 2 2 3 3
0 1 2 2 3 3 4
0 1 2 2 3 4 4
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0 1 2 2 2 3 3
0 1 2 2 3 3 4
0 1 2 2 3 4 4
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0 1 2 2 2 3 3
0 1 2 2 3 3 4
0 1 2 2 3 4 4
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0 1 2 2 2 3 3
0 1 2 2 3 3 4
0 1 2 2 3 4 4
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0 1 2 2 2 3 3
0 1 2 2 3 3 4
0 1 2 2 3 4 4
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0 1 2 2 2 3 3
0 1 2 2 3 3 4
0 1 2 2 3 4 4
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0 1 2 2 2 3 3
0 1 2 2 3 3 4
0 1 2 2 3 4 4
3 C
4 B
5 D
6 A
7 B
0 0 0 0 0 0 0
0 0 0 0 1 1 1
0 1 1 1 1 2 2
0 1 1 2 2 2 2
j 0 1 2 3 4 5 6
y
j
B D C A B A
i
0 x
i
1 A
2 B
3 C
0 1 1 2 2 2 2
0 1 1 2 2 3 3
0 1 2 2 2 3 3
0 1 2 2 3 3 4
0 1 2 2 3 4 4
3 C
4 B
5 D
6 A
7 B
Lemma 20.3:
Der Algorithmus LCS-Lnge hat Laufzeit O(nm), wenn die
Folgen X,Y Lnge n und m haben.
Lemma 20.4:
Die Ausgabe der lngsten gemeinsamen Teilfolge anhand
der Tabelle hat Laufzeit O(n+m), wenn die Folgen X,Y
Lnge n und m haben.
1. Bestimme rekursive Struktur einer optimalen Lsung.
2. Entwerfe rekursive Methode zur Bestimmung des
Wertes einer optimalen Lsung.
3. Transformiere rekursive Methode in eine iterative
3. Transformiere rekursive Methode in eine iterative
Methode zur Bestimmung des Wertes einer optimalen
Lsung.
4. Bestimme aus dem Wert einer optimalen Lsung und
den in 3. berechneten Zusatzinformationen eine
optimale Lsung.
Algorithmenentwurfstechnik:
Oft bei Optimierungsproblemen angewandt
Einsatz:
Bei rekursiven Problemlsungen, wenn Teillsungen mehrfach
bentigt werden
Lsungsansatz:
Tabellieren von Teilergebnissen
Vorteil:
Laufzeitverbesserungen, oft polynomiell statt exponentiell
Fraktionales Rucksack-Problem
Gegeben sind n Gegenstnde. Der i-te Gegen-
stand besitzt Wert
i
v und Gewicht g
i
. Ausserdem
ist eine Gewichtsschranke W gegeben.

Zulssige Lsungen sind Zahlen [ ] 1 , 0 a
i
mit

W. g a
n
i i


Gesucht ist eine zulssige Lsung
n 1
a , , a K mit
mglichst groem Gesamtwert

W. g a
1 i
i i

=
. v a
n
1 i
i i
=
Gierige Lsung des fraktionalen Rucksack-Problems
Algorithmus Gieriges-Einpacken:
1. Sortiere die Verhltnisse v
i
/ g
i
absteigend. Sei

fr Permutation auf (1,,n).
2. Bestimme maximales k, so dass noch gilt
( )
W g
k
1 i
i

=
.
3. Setze
( ) ( ) ( )
1
2 1
= = = =
k
a a a

L
und setze
( ) ( ) ( ) ( ) ( ) ( ) n n 2 2 1 1
g v g v g v L
3. Setze
( ) ( ) ( )
1
2 1
= = = =
k
a a a

L
und setze

Alle anderen
i
a setze auf 0.
( )
( )
( )
.
g
g W
a
1 k
k
1 i
i
1 k
+
=
+
=
Gieriges Einpacken ist optimal
Satz 20.5: Gieriges Einpacken lst das fraktionale
Rucksackproblem optimal.
Beweis: Tafel
Das Rucksackproblem:
Rucksack mit begrenzter Kapazitt
Objekte mit unterschiedlichem Wert und
unterschiedlicher Gre
Wir wollen Objekte von mglichst groem Gesamtwert
Dynamisches Programmieren Rucksack
84
Wir wollen Objekte von mglichst groem Gesamtwert
mitnehmen
Beispiel:
Rucksackgre 6
Gre 5 2 1 3 7 4
85
Wert 11 5 2 8 14 9
Beispiel:
Rucksackgre 6
Gre 5 2 1 3 7 4
86
Objekt 1 und 3 passen und haben Gesamtwert 13
Optimal?
Wert 11 5 2 8 14 9
Beispiel:
Rucksackgre 6
Gre 5 2 1 3 7 4
87
Objekt 1 und 3 passen und haben Gesamtwert 13
Optimal?
Objekt 2, 3 und 4 passen und haben Gesamtwert 15 !
Wert 11 5 2 8 14 9
Das Rucksackproblem (Optimierungsversion):
Eingabe: n Objekte {1,,n};
Objekt i hat ganzz. pos. Gre g[i] und Wert v[i];
Rucksackkapazitt W

88
Ausgabe: Menge S{1,,n} mit g[i] W und
maximalem Wert v[i]
iS
iS
Herleiten einer Rekursion:
Sei O optimale Lsung
Bezeichne Opt(i,w) den Wert einer optimalen Lsung
aus Objekten 1 bis i bei Rucksackgre w
89
Unterscheide, ob Objekt n in O ist:
Fall 1(n nicht in O):
Opt(n,W) = Opt(n-1,W)
Fall 2 (n in O):
Opt(n,W) = v[n] + Opt(n-1,W-g[n])
Rekursion:
Opt(i,0)= 0 fr 0in
Opt(0,i)= 0 fr 0iW
Wenn w<g[i] dann Opt(i,w) = Opt(i-1,w)
90
Sonst,
Opt(i,w) = max{Opt(i-1,w), v[i] + Opt(i-1,w-g[i])}
Rekursion:
Opt(i,0)= 0 fr 0in
Opt(0,i)= 0 fr 0iW
Kein Objekt
passt in den
Rucksack
91
Sonst,
Rekursion:
Opt(i,0)= 0 fr 0in
Opt(0,i)= 0 fr 0iW
Kein Objekt
steht zur
Auswahl
92
Sonst,
Rekursion:
Opt(i,0)= 0 fr 0in
Opt(0,i)= 0 fr 0iW
Passt aktuelles
Objekt in den
Rucksack?
93
Sonst,
Rekursion:
Opt(i,0)= 0 fr 0in
Opt(0,i)= 0 fr 0iW
Sonst, verwende
Rekursion
94
Sonst,
Rucksack(n,W)
1. Initialisiere Feld A[0,..,n][0,..,W] mit A[0,i] =0 fr alle
0in und A[j,0]=0 fr alle 0iW
2. for i 1 to n do
3. for j 1 to W do
95
3. for j 1 to W do
4. Berechne A[i,j] nach Rekursion
5. return A[n,W]
Beispiel:
0
0
0
0
0
g v
5 2
3 4
1 1
2 3
Gre Wert
n
1
2
96
0
0
0
0
0 0 0 0 0 0 0 0 0
2 3
1 2
7 3
4 7
3 3
0 1 W
0
1
n
Beispiel:
0
0
0
0
0
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
97
0
0
0
0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
g[1]>W:
Also Opt(i,w) = Opt(i-1,w)
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0
0
0
Gre Wert
n
Opt(i,w) = max{Opt(i-1,w),
v[i] + Opt(i-1,w-g[i])}
g v
5 2
3 4
1 1
2 3
1
2
98
0
0
0
0 0 0 0 0 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
v[i] + Opt(i-1,w-g[i])}
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0
0
0
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
99
0
0
0
0 0 0 0 0 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0
0
0
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
100
0
0
0
0 0 0 0 0 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0
0
0
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
101
0
0
0
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0
0
0
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
102
0
0
0 0 0
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0
0
0
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
103
0
0
0 0 0 4 4
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0
0
0
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
104
0
0
0 0 0 4 4 4 4 4
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0
0
0
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
105
0
0
0 0 0 4 4 4 4 4 6
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0
0
0
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
106
0
0 1 1
0 0 0 4 4 4 4 4 6
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0
0
0
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
107
0
0 1 1 4
0 0 0 4 4 4 4 4 6
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0
0
0
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
108
0
0 1 1 4 5 5 5 5
0 0 0 4 4 4 4 4 6
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0
0
0
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
109
0
0 1 1 4 5 5 5 5 6
0 0 0 4 4 4 4 4 6
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0
0
0 1 3 4 5 7 8 8 8
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
110
0 1 3 4 5 7 8 8 8
0 1 1 4 5 5 5 5 6
0 0 0 4 4 4 4 4 6
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0
0 2 3 5 6 7 9
10 10
0 1 3 4 5 7 8 8 8
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
111
0 1 3 4 5 7 8 8 8
0 1 1 4 5 5 5 5 6
0 0 0 4 4 4 4 4 6
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0
0 2 3 5 6 7 9
10 10
0 2 3 5 6 7 9
10 10
0 1 3 4 5 7 8 8 8
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
112
0 1 3 4 5 7 8 8 8
0 1 1 4 5 5 5 5 6
0 0 0 4 4 4 4 4 6
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0
0 2 3 5 7 9
10 12 13
0 2 3 5 6 7 9
10 10
0 2 3 5 6 7 9
10 10
0 1 3 4 5 7 8 8 8
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
113
0 1 3 4 5 7 8 8 8
0 1 1 4 5 5 5 5 6
0 0 0 4 4 4 4 4 6
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0 2 3 5 7 9
10 12 13
0 2 3 5 7 9
10 12 13
0 2 3 5 6 7 9
10 10
0 2 3 5 6 7 9
10 10
0 1 3 4 5 7 8 8 8
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
114
0 1 3 4 5 7 8 8 8
0 1 1 4 5 5 5 5 6
0 0 0 4 4 4 4 4 6
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0 2 3 5 7 9
10 12 13
0 2 3 5 7 9
10 12 13
0 2 3 5 6 7 9
10 10
0 2 3 5 6 7 9
10 10
0 1 3 4 5 7 8 8 8
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
Optimaler
Lsungswert fr
W=8
115
0 1 3 4 5 7 8 8 8
0 1 1 4 5 5 5 5 6
0 0 0 4 4 4 4 4 6
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Beispiel:
0 2 3 5 7 9
10 12 13
0 2 3 5 7 9
10 12 13
0 2 3 5 6 7 9
10 10
0 2 3 5 6 7 9
10 10
0 1 3 4 5 7 8 8 8
Gre Wert
n g v
5 2
3 4
1 1
2 3
1
2
Optimaler
Lsungswert fr
W=8
116
0 1 3 4 5 7 8 8 8
0 1 1 4 5 5 5 5 6
0 0 0 4 4 4 4 4 6
0 0 0 0 0 2 2 2 2
0 0 0 0 0 0 0 0 0
0 1 W
0
1
n
2 3
1 2
7 3
4 7
3 3
Satz 20.6
Algorithmus Rucksack berechnet in (nW) Zeit den Wert
einer optimalen Lsung, wobei n die Anzahl der Objekte
ist und W die Gre des Rucksacks.
117 117 SS 2011 DuA - Kapitel 20
von u nach v sowie einen krzesten Weg
2
4
7
a b c d e f
b
c
Dynamische Programmierung - APSP
2
1
-1
5
8
-4
5
6
7
a
a 0 1 5 5 10 9
b 0 4 5 10 9
c -3 0 1 6 5
d -4 0 0 5 4
e 5 8 9 0 -1
f 0
f
e
d
118
Zur Erinnerung:
i
j
k
119
Zur Erinnerung:
i
j
k
Knoten k tritt
maximal einmal auf
120
Zur Erinnerung:
Weg von u nach k
i
j
k
Weg von u nach k
fhrt nur ber Knoten
aus {1,,k-1}
121
Zur Erinnerung:
Weg von k nach v
i
j
k
Weg von k nach v
fhrt nur ber Knoten
aus {1,,k-1}
122
Krzester i-j-Weg ber Knoten aus {1,,k} ist
(a) krzester i-j-Weg ber Knoten aus {1,,k-1} oder
(b) krzester i-k-Weg ber Knoten aus {1,,k-1} gefolgt
von krzestem k-j-Weg ber Knoten aus {1,,k-1}
123
i
j
k
Fall (b):
Die Rekursion:
Sei d die Lnge eines krzesten i-j-Wegs mit Knoten
aus {1,,k}
w , falls k=0
ij
(k)
(k)
124
Matrix D =(d ) enthlt die gesuchte Lsung
d =
w , falls k=0
min ( d , d + d ), falls k1
(k)
(k-1)
(k-1) (k-1)
ij
ij
ij
ik
kj
(n)
ij
(n)
Floyd-Warshall(W,n)
1. D W
2. for k1 to n do
3. for i1 to n do
4. for j1 to n do
(0)
125
4. for j1 to n do
5. d min(d , d + d )
6. return D
(k)
ij
(n)
(k-1)
ij
(k-1)
ik
(k-1)
kj
Teile & Herrsche:
Aufteilen der Eingabe in mehrere Unterprobleme
Rekursives lsen der Unterprobleme
Zusammenfgen
Gierige Algorithmen:
Konstruiere Lsung Schritt fr Schritt
126
Konstruiere Lsung Schritt fr Schritt
In jedem Schritt optimiere einfaches, lokales Kriterium
Dynamische Programmierung:
Formuliere Problem rekursiv
Vermeide mehrfache Berechnung von Teilergebnissen
Verwende bottom-up Implementierung

DuA Alle

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

DuA Alle

Hochgeladen von

Copyright:

Verfügbare Formate

Datenstrukturen und

bersicht ber Kalkle

bersicht ber Kalkle

if A[m] = x then return m

if A[m] = x then return m

t abgeschtz aen folgenderm kann Dann werden.

min(M): gib eM mit minimalem key(e) aus

SS 2011 DuA - Kapitel 10 108

SS 2011 DuA - Kapitel 10 113

SS 2010 Datenstrukturen und Algorithmen -

SS 2010 Datenstrukturen und Algorithmen -

Operationen auf Graphen

V v ist der eindeutige Pfad von s zu v in

G ein krzester Pfad von s zu v in G.

SS 2011 DuA - Kapitel 16 6

SS 2011 DuA - Kapitel 16 33

, die Bearbeitungszeit von

auf dem Prozessor mit Nummer

auf dem Prozesssor mit Nummer m

SS 2011 DuA - Kapitel 20 81

Dynamisches Programmieren Rucksack

Das könnte Ihnen auch gefallen