Algorithmen V2.3

Algorithmen
Vorlesung im Grundstudium
Informatik
Rolf Niedermeier
Michael Kaufmann
Wilhelm-Schickard-Institut für Informatik
Universität Tübingen
Sand 13, 72076 Tübingen
{niedermr, mk}@informatik.uni-tuebingen.de
Sommersemester 2000/01
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
1
1. Suchen
Dictionaries - Mengenverwaltung
Grundsätzlich 2 Fälle:
• Zu verwaltende Datenmenge ist kleiner Teil des Universums;
• Menge praktisch das gesamte Universum.
Elemente bestehen aus Schlüssel und Information.
Auf Universum U sei lineare Ordnung (U, <) definiert. Sei
S ⊆ U die zu verwaltende Menge von Schlüsseln.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
2
1
Operationen:
Zugriff (a,S )
Einfüge (a,S )
if a ∈ S
then output (Info unter Schlüssel a )
else output ( a ∉ S )
S ← S ∪ {a}
Streiche ( a,S )
Ord (k,S )
S ← S\{a}
output ← k-t größtes Element von S
Sort ( S )
output ← S , geordnet
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
3
Beispiel für Suchen: Telefonbuch-CD
lineare Suche
U = S , S als Array
Eingabe (a ∈ U );
while not gefunden
i ← i + 1;
gefunden ← (a = S [i ])
endwhile
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
4
2
Laufzeit: T (n, best) = 2
T (n, worst) = 2 + 2n
T (n, average) = 2 + n
Gemessene Laufzeit:
Geschätzte Laufzeit:
So sucht man nicht in Telefonbüchern!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
5
1.1 Binäre Suche
Voraussetzung: S geordnet!
Laufzeit: T (n, best ) = 4

n
T (n, worst ) = 4 + T   , worst 

2
= 4 ⋅ log 2 n 
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
6
3
Eingabe ( a ∈ U )
unten ← 0, oben ← n
while unten < oben and (nicht gefunden)
  unten + oben  
do if a < S  
 
2


 unten + oben 
then if oben > 1 then oben ← 

2

else unten ← oben
fi
else
  unten + oben
if a > S  
2

 unten +
then unten ← 
2


 

oben 


+
unten
oben


else Ausgabe 
ist gesuchter Index 
2


fi
od
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
7
1.2 Interpolationssuche
Variante von binärer Suche
vorher: next ← (oben + unten )/2
jetzt:
 a − S [unten ]
(oben − unten ) + unten
next ← 
 S [oben ] − S[unten ]

Schlechtester Fall: O(n)
Im Mittel: O(log log n )
bei Annahme S zufällige
Teilmenge von [0,1]
Originalanalyse kompliziert.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
8
4
Zur Suche von a im Feld S „interpoliere“ a durch S [next ] und
bestimme Teilfeld von S der Größe n ;
im Teilfeld ggf. rekursiv nach a suchen.
Dabei zur einfacheren Analyse folgende Variante für
Wert von next benutzen:

a − S [unten − 1]
(oben − unten + 1)
next ← unten − 1 + 

 S [oben + 1] − S [unten − 1]
n ← oben − unten + 1
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
9
Interpolation von a durch S [next ]
Fall 1: „=“ fertig
lineare Suche : Vgl. a mit S [next + n ] ,
Fall 2: „>“
S [next + 2 n ] , ...
bis a < S [next + (i - 1) n ].
Bem.: a) Das kostet uns i Vergleiche
[
b) Nun gilt S next + (i − 2) n ] ≤ a < S [ next + (i − 1) n
]
Fall 3: „<“ analog
Nun rekursive Anwendung auf Teilmenge der Größe
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
n.
10
5
Sei C mittlere Anzahl der Vergleiche, um Teilproblem der
Größe n zu finden. Dabei Wahrscheinlichkeitsannahme:
x1 ,..., x n und a sind zufällige Elemente des Intervalls
( x0 , x n +1 ) gezogen gemäß Gleichverteilung; sind voneinander unabhängig.
Sei pi Wahrscheinlichkeit, dass ≥ i Vergleiche benötigt
werden.
Dann ist
C = ∑ (i − 1)( pi − pi ) = ∑ pi .
i ≥1
Vorlesung Algorithmen (RN/MK)
i ≥1
WSI für Informatik, Universität Tübingen
11
Berechnung der pi ’s : p1 = p 2 = 1 (Da stets ≥ 2 Vergleiche)
Sei nun i ≥ 3
Falls i Vergleiche nötig sind, weicht tatsächlicher Rang von a
in der Folge x1 ,..., x n (d.h. die Anzahl der x j ≤ a )
um mindestens (i − 2) n von next ab, d.h.
(
pi ≤ prob (Rang von a in x 1 ,..., x n ) − next ≥ (i − 2 ) n
)
hat die Form
(
)
prob Y - µ(Y ) ≥ (i − 2) n .
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
12
6
Y ist Zufallsvariable, die den Rang von a in x1,...,xn
angibt und (Y ) ihr Mittelwert.
Wir benutzen Tschebyscheff’sche Ungleichung
prob( Y −
> t) ≤
2
t2
Mittelwert
2
Varianz
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
13
1. Mittelwert:
Wahrscheinlichkeit, dass genau j Elemente < a sind, ist
 n j
  p (1 − p )n − j und damit
 j
n
 n
n− j
= ∑ j   p j (1 − p )
j =1  j 
n
 n − 1 j −1
 p (1 − p )n − j
= n ⋅ p ∑ 
−
i
1
j =1 

= n⋅ p
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
14
7
2. Varianz:
2
= ∑( j −
)2 
n j
n− j
 p (1 − p ) = p(1 − p ) ⋅ n
 j
Einsetzen in Tschebyscheff ergibt:
(
p i ≤ prob Rang von x - next ≥ (i − 2 ) n
≤
≤
)
2
t2
p (1 - p )n
1
≤
n 4(i − 2 )
und damit gilt
(i − 2)
2
2
C = ∑ pi ≤ 2 + ∑
i ≥1
i ≥3
1
4(i − 2 )
Vorlesung Algorithmen (RN/MK)
2
≤ 2+
2
24
≈ 2. 4
WSI für Informatik, Universität Tübingen
15
Sei nun T (n ) die mittlere Anzahl von Vergleichen, die
notwendig sind, um a mit quadratischer Binärsuche in
Menge der Größe n zu finden, dann gilt:
T (1) = 1 , T (2) ≤ 2
T (n ) ≤ C + T
( n)
n>2
und damit T (n ) ≤ 2 + C log log n
Satz: Quadratische Binärsuche braucht
im Mittel ≤ 2 + 2.4 log log n Vergleiche.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
16
8
Bemerkungen:
• Vorsicht: Annahme der Gleichverteilung ist kritisch.
• Laufzeit im schlechtesten Fall
n+
( )
n+
n + ... = O n
• exponentielle + binäre Suche erlaubt Bestimmung von i mit
O(log i) Vergleichen.
Schlechtester Fall:
log n + log
1 1 1

n + ... = log n + + + ... = log n
2 4 8

also noch besser.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
17
2. Sortieren
Beispiel für Analyse von Verfahren und gleichzeitig
„eine Art, Datenmengen zu verwalten“.
Sortieren: eine Folge so permutieren, dass sie aufsteigend
geordnet ist.
13,7,11
7,11,13
Motivation: 25% aller Rechnerzeit wird für Sortieren
verbraucht.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
18
9
2.1 Sortieren durch Auswahl:
Eingabe: 11,3,6,7,6,12
Ausgabe: 3,6,6,7,11,12
Jeweils Minimum suchen, Ausgeben, Streichen
1.) Wie repräsentieren wir Ein- und Ausgabefolgen?
2.) Was bedeutet es, eine Zahl zu streichen?
3.) Wie bestimmen wir Minimum?
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
19
Ad 1.) Benutzen z.B. Felder A und B:
i-tes Ein- und Ausgabeelement in A[i] bzw. B[i].
Ad 2.) Benutzen weiteres Feld:
Rem: array [1...n] of boolean
Rem[i] = true bedeutet, dass A[i] durchgestrichen ist.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
20
10
Ad 3.) function Posofmin: integer;
var i,pos : integer
begin i := 1;
while Rem[i] do i := i+1;
pos := i;
for i = 1 to n
do if (A[i] < A[pos]) and not Rem[i]
then pos := i;
Posofmin := pos;
end
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
21
Wenn wir nicht Zahlen sortieren, sondern beliebige
Elemente eines bestimmten Typs, so ersetzen wir
(A[i] < A[pos]) durch lessthan (A[i], A[pos]),
wobei
function lessthan (x,y : typ): boolean
geeignet definiert werden muß.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
22
11
Sortieren durch Auswahl
for i := 1 to n do Rem[i] := false;
for i := 1 to n do
begin j := posmin;
B[i] := A[j];
Rem[j] := true
end;
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
23
Elegantere und platzeffizientere Lösung
86376
3|6 8 7 6
3 6|8 7 6
3 6 6|7 8
3 6 6 7|8
36678
for i := 1 to n do
begin j := posmin (i,n);
(* posmin liefert das Minimum von A[i],...,A[n] *)
interchange (A[i], A[j]);
end;
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
24
12
2.2 Quicksort
(Sortieren durch Teilen)
Wende „Teile- und Beherrsche“-Prinzip an.
Eingabe: Feld S mit Werten x1, x2, ..., xn
Idee
1. Teile S-{x1} bzgl. x1 in 2 Mengen A,B
(Teile)
A = {xi | i ≥ 2 und xi ≤ x1 }, sei A = j
B = {xi | i ≥ 2 und xi > x1 }
Speichere A in S[1]...S[j]
x1 in S[j+1]
B in S[j+2]...S[n]
x1
A
j j+1
B
2. Wende Verfahren rekursiv auf A und B an.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
(Beherrsche)
25
Implementierung:
Füge S [0] = −∞ und S [n + 1] = +∞ zu S hinzu.
Dies erspart einige Tests.
Teil 1: Teile
i := 2 ; j := n ; k := S[1] ;
repeat while S [i ] ≤ k do i := i+1 ;
while S [ j ] > k do j := j-1 ;
if i ≤ j then vertausche (S[i], S[j])
i := i+1 ; j := j-1 ;
fi
until i > j ;
Vertausche (S[1], S[j])
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
26
13
Analyse:
Kosten = Anzahl der Vergleiche zwischen S[i]‘s.
Kosten im schlechtesten Fall:
Kosten eines Aufrufs Quicksort (l,r) sind
a) unmittelbare Kosten bei Teile-Schritt O(r-l+1) Vergleiche
b) Kosten der rekursiven Aufrufe
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
27
Sei QS(n) = max. Anzahl von Vergleichen, die Quicksort
an Feld der Länge n durchführt.
Es gilt:
QS (n ) = n + max{ QS ( j − 1) + QS (n − j )}
424
3 1424
3
1≤ j ≤ n 1
rek. Aufruf für A
QS (0 ) = QS (1) = 0.
Vorlesung Algorithmen (RN/MK)
für B
WSI für Informatik, Universität Tübingen
28
14
Behauptung:
n
QS (n ) = ∑ i ≤
i =2
( )
1
n(n + 1) = O n 2
2
Beweis: durch Induktion
Bemerkung: An Eingabe 1, 2, 3, ..., n führt Quicksort
wirklich O(n2) Vergleiche durch. Obere Schranke
ist also scharf.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
29
Kosten im Mittel:
Annahmen:
1. Elemente von S sind paarweise verschieden.
2. Jede der n! möglichen Permutationen der Eingabe ist
gleich wahrscheinlich.
Damit können wir o.B.d.A. annehmen, dass die Schlüssel
die Zahlen 1, 2, ..., n sind und dass S[1] = k ist mit
Wahrscheinlichkeit 1/n für 1 ≤ k ≤ n.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
30
15
Dann müssen rekursiv Teilprobleme der Größe k-1 und
n-k gelöst werden.
Diese Teilprobleme sind wieder zufällige Folgen,
d.h. sie erfüllen Annahmen 1.) und 2.).
(Beweis: entfällt, siehe Literatur)
Sei QS (n ) die mittlere Anzahl der Vergleiche, die
Quicksort an einem Feld der Größe n durchführt.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
QS (0 ) = QS (1) = 0
(
31
)
und QS (n ) = n + " Erwartungswert QS ( A) + QS (B ) "
= n+
(
)
1 n
∑ QS (k − 1) + QS (n − k )
n k =1
2 n −1
= n + ∑ QS (k )
n k =0
n −1
n ⋅ QS (n ) = n 2 + 2∑ QS (k )
k =0
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
32
16
und
n
(n + 1)QS (n + 1) = (n + 1)2 + 2∑ QS (k )
k =0
Dann:
(n + 1)QS (n + 1) − nQS (n ) = (n + 1)2 − n 2 + 2QS (n )
= 2n + 1 + 2QS (n )
(n + 1)QS (n + 1) = 2n + 1 + (n + 2)QS (n )
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
33
⇒
n+2
QS (n )
n +1
n+2
n +1
n
(2 + ...) 
 2 +
= 2+
2 +
n +1 
n 
n −1

QS (n + 1) ≤ 2 +
2
2
 2

= 2 + n + 2
+ +
+ K + 1
 n +1 n n −1


1
1 
 1
= 21 + n + 2
+ + K +  .
n
n
+
1
2 


Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
34
17
d.h.
n
1
 n 1 

QS (n ) ≤ 21 + (n + 1)∑  = 2 + 2(n + 1) ∑ − 1
i=2 i 

 i =1 i 
n
1
= 2 + 2(n + 1)∑ − 2(n + 1)
i =1 i
n
1
= 2(n + 1)∑ − 2n
i =1 i
≤ 2(n + 1)(1 + ln n ) − 2n
= O(n log n )
Satz: Die mittlere Laufzeit von Quicksort ist O(n log n).
Vorlesung Algorithmen (RN/MK)
2.3 Heapsort
WSI für Informatik, Universität Tübingen
35
(ein Sortieren durch Auswahl)
Heap ist Datenstruktur, die folgende Operationen
unterstützt:
• function
Emptyheap : heap;
liefert Heap mit Wert ø.
• procedure
Insert (x: item, var h: heap);
verändert „Wert“ von h durch Einfügen von x
• function
Extractmin (var h: heap): item;
verändert Wert von h durch Streichen des Minimums
und liefert gestrichenes Element.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
36
18
Heapsort:
h := Emptyheap;
for i = 1 to n
do Insert (A[i], h);
for i = 1 to n
do B[i] := Extractmin (h);
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
37
Zur Realisierung von Heaps:
Ein binärer Baum ist entweder leer oder er besteht aus einem
Knoten, der Wurzel genannt wird, und einem rechten und
linken Teilbaum.
Bsp.:
u
v
w
x
u ist die Wurzel, v die Wurzel des linken Teilbaums von u, ...
v = Kind von u, u = Elternknoten von v, x ist ein Blatt.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
38
19
Sei u ein Knoten in einem Baum T.
 0, falls u die Wurzel ist
Tiefe(u) := 
 Tiefe(Elternknoten(u)) +1, sonst
Bsp.: Tiefe(w) = 1
 0, falls u ein Blatt ist
Höhe(u) := 
 max{Höhe(v) | v ist Kind von u} +1, sonst
Bsp.: Höhe(w) = 2
Tiefe(T) := max {Tiefe(u) | u ist Knoten in T}
Höhe(T) := max {Höhe(u) | u ist Knoten in T}
= Höhe(Wurzel(T))
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
39
(Binäre) Heaps lassen sich durch Binärbäume darstellen:
Bsp.: {1, 2, 3, 4, 5} darstellbar durch
1
5
1
2
4
2
oder
3
oder ...
3
4
5
Jeder Baumknoten u ist mit einem Element S[u] beschriftet.
Zusätzlich fordern wir die „Heap-Eigenschaft“:
Ist u Elternknoten von v, so ist S [u ] ≤ S [v ]
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
40
20
Realisierung der Heap-Operationen:
• function Emptyheap:
klar!
• function Extractmin:
Minimumsbestimmung: Min. steht an der Wurzel
Minimumsentfernung: Baum muss „reorganisiert“ werden
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
41
Bsp.:
2
6
8
10
⇒
4
11
10
Reorg. I
6
15
6
8
4
11
6
15
13
13
I) Beliebiges Blatt wird entfernt und an die Wurzel gesetzt.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
42
21
II) danach wird durch sukzessives Vertauschen mit dem
kleinsten Kind die Heap-Eigenschaft wiederhergestellt:
4
Reorg. II
⇒
6
8
4
Reorg. II
⇒
10
11 6
6
8
15
6
11 10
13
13
Vorlesung Algorithmen (RN/MK)
15
WSI für Informatik, Universität Tübingen
43
procedure Insert: Einzufügendes Element an Knoten anhängen,
welcher höchstens ein Kind hat.
Danach Vertauschen mit Elternknoten, falls
dieser größer ist usw.
Bsp.: Einfügen des Elements 5:
⇒
4
6
8
6
11 10
5
⇒
4
6
15
13
Vorlesung Algorithmen (RN/MK)
8
6
11 5
10
4
6
15
13
8
11 6
5
10
WSI für Informatik, Universität Tübingen
15
13
44
22
Ausgewogene Bäume:
Es gibt k ≥ 0, sodass
1. Alle Blätter haben Tiefe k oder k+1 und
2. Blätter der Tiefe k+1 sitzen „ganz links“.
Bsp.:
1
2
4
8
3
5
6
7
Nummerierung der Knoten:
Nummeriere Knoten der Höhe
nach und innerhalb jeder Höhe
von links nach rechts.
9 10
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
45
Dann gilt:
(1) Hat ein Knoten Nummer i > 1, so hat sein Elternknoten
die Nummer i / 2 .
(2) Hat ein Knoten Nummer i, so haben seine Kinder
(falls existent) die Nummern 2i und 2i+1.
⇒
Darstellung ausgewogener binärer Baum durch Paar (A,n),
wobei n Anzahl der Knoten und A Array, sodass A[i]
Beschriftung des Knotens mit Nummer i ist für alle i = 1, ..., n.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
46
23
Beispiel:
1
16
2
14
3
4
5
8
7
8
2
4
9
1
9
10
6
3
7
10
A: 16 14 10 8 7 9 3 2 4 1
1 2 3 4 5 6 7 8 9 10
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
47
Zur Implementierung von Heapsort:
type heap = record
A: array [1...N] of item;
<*N hinreichend groß*>
n: integer;
end
function Emptyheap : heap;
var h: heap;
begin
h.n := 0; <*keine Elemente*>
Emptyheap := h
end
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
48
24
procedure Insert (x: item; var h: heap);
var i,j: integer;
finish: boolean;
begin
h.n := h.n +1; <*ein Element mehr*>
i := h.n
h.A[i] := x; <*neues, „linksbündiges“ El.*>
finish := (i = 1);
while not finish do
begin
j := i div 2 <*j Elternknoten von i*>
if h.A[i] < h.A[j]
then Interchange (h.A[i], h.A[j])
else finish := true;
i := j;
if finish = false then finish := (i=1);
end
end
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
49
Zur Laufzeit-Analyse von Heapsort:
Heapsort besteht i.w. aus je n Aufrufen von Insert und
Extractmin.
„Leicht“ sieht man:
Ausführungszeit von Insert und Extractmin ist
O(Höhe des Baumes)
Lemma:
Hat ein ausgewogener Baum die Höhe m, so enthält er
mindestens 2m und weniger als 2m+1 Knoten.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
50
25
Nun gilt:
2 m ≤ n ⇒ m − 1 ≤ log n 
Wir erhalten Laufzeit =
O(n ⋅ m ) = O(n ⋅ (log n + 1)) = O(n log n ).
Bemerkungen:
• Obwohl Heapsort im Gegensatz zu Quicksort sogar im Worst
Case Laufzeit O(n log n) hat, ist Quicksort in der Praxis
meist überlegen.
• Für „vergleichsbasierte Sortierverfahren“ läßt sich die untere
Schranke Ω(n log n ) beweisen, Heapsort ist in diesem
Sinne also asymptotisch optimal. Diese untere Schranke
gilt auch im Durchschnitt (bei Gleichverteilung).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
2.4 Mergesort
51
(Sortieren durch Mischen)
Bisher betrachtete Sortierverfahren:
Daten im Hauptspeicher.
Für externe Speichermedien, aber andere Sortierverfahren
vorteilhaft, z.B. Sortieren durch Mischen:
Füge zwei (oder mehrere) sortierte Folgen zu einer
sortierten Folge zusammen.
Z.B.
11 6
6
5
3
12 8
5
Vorlesung Algorithmen (RN/MK)
12 11 8
6
6
WSI für Informatik, Universität Tübingen
5
5
3
52
26
Mischalgorithmus:
Start mit leerer Ausgabefolge
Solange mind. eine Eingabefolge nichtleer,
- bestimme x = min A, wobei A die Menge der ersten
Elemente der nichtleeren Eingabefolgen ist,
- entferne x aus Eingabefolge, wo es vorkommt und
- füge es ans Ende der Ausgabefolge.
Korrektheit: x ist nicht nur das Minimum über A, sondern
über der Menge aller verbleibenden
Eingabeelemente ...
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
53
Zum Sortierverfahren:
Bezeichne aufsteigend sortierte Teilfolgen als „Runs“.
Grundprinzip:
Teile Eingabe in Teilfolgen der Länge 1 (das sind Runs).
Mische danach Runs zu längeren Runs.
Bsp.: Eingabe: 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5
(1) Streuphase:
3, 4, 5, 2, 5, 5
3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5
1, 1, 9, 6, 3
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
54
27
(2) Mischphase:
345255
13 59 35
11963
14 26 5
1134 355
11234569
2569
355
11233455569
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
55
Beobachtung:
Nach i-tem Durchlauf haben alle Runs
Länge ≤ 2i .
Allgemeiner: pi für p = # Eingabedateien
= # Ausgabedateien
Wenn p i ≥ n, so ist die Eingabe sortiert.
Also genau log p n  Durchläufe nötig.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
56
28
Effizienzverbesserung:
Annahme: Hauptspeicher habe Platz für m Elemente (p < m < n).
Dann können wir Durchläufe sparen, indem wir interne
Sortierverfahren dazu benutzen, anfangs Runs der Länge m
zu erstellen.
Bsp.: m = 3
134 256
3 1 4 1 5 9 2 6 5 3 5
159 35
113 459
11233455569
235 56
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
57
Analyse:
Nach i Durchläufen haben die Runs Länge m·2i (bzw. m· pi).
n

Also genügen log p  Durchläufe.
m

Bsp.: n = 107, m = 104, p = 3
⇒ 7 Durchläufe
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
58
29
2.5 Bucketsort
(Sortieren durch Fachverteilung)
Betrachte oBdA Alphabet Σ = {1, 2, ..., m}
Für die Wörter x = x1 ... xk und y = y1 ... yr ∈ Σ*
sagen wir, dass x kleiner als y (x < y) ist,
genau dann, wenn
∃i, 0 ≤ i ≤ k ∀j, 1 ≤ j ≤ i: x j = y j und
entweder i = k < r
oder i < k und i < r und xi+1 < yi+1.
Ziel: Wörter über dem Alphabet Σ bzgl. der gegebenen
Ordnung sortieren.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
59
Spezialfall 1: Alle n Wörter haben Länge 1.
Lösungsansatz: Stelle m Fächer bereit und gehe die n Zahlen
durch und wirf jede Zahl in das ihrem Wert gemäße
Fach.
Implementierung der Fächer z.B. als lineare Listen und ein
Feld der Größe m zum Speichern der Listenköpfe.
Gesamtzeitaufwand: O(n + m)
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
60
30
Spezialfall 2: Alle n Wörter haben gleiche Länge k.
Schreibweise: i-tes Wort: xi = x1i x2i ... xki
Vorteilhaft, zunächst nach dem k-ten Symbol zu sortieren,
dann nach dem (k-1)-ten, usw.
Damit k „Läufe“ über die Menge der Wörter.
Jeder Lauf gemäß Spezialfall 1
Laufzeit von O((n + m) · k)
⇒
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
61
Bsp.: 123 , 124, 223, 324, 321
m = 4, n = 5, k = 3
1. Lauf
324
124
324
124
223
123
321
2. Lauf
3. Lauf
223
123
321
124
123
Vorlesung Algorithmen (RN/MK)
223
324
321
WSI für Informatik, Universität Tübingen
62
31
Wie vermeiden wir Aufwand mit leeren Fächern?
Sei sj die Anzahl der im j-ten Lauf nichtleeren Fächer.
Ziel: Aufsammeln im j-ten Lauf in O(sj) Schritten
und damit Aufwand j-ter Lauf O(sj + n).
Erzeuge n· k Paare (j, xi), 1 ≤ i ≤ n , 1 ≤ j ≤ k
und sortiere durch Fachverteilung zunächst nach der zweiten
und dann nach der ersten Komponente.
Nach 2. Lauf liegen im j-ten Fach gerade alle Buchstaben
in sortierter Reihenfolge, die an der j-ten Stelle vorkommen.
Aufwand 1. Lauf: O(n·k + m)
Aufwand 2. Lauf: O(n·k + k)
Σ : O(n·k + m)
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
63
Allgemeiner Fall: n Wörter beliebiger Länge
n
|xi| =: li , L :=
∑r
i =1
i
, rmax := maxi {ri}
Beachte: xi nicht „zu früh“ in Fachverteilung miteinbeziehen;
erst bearbeiten, wenn nach dem ri-ten Buchstaben
sortiert wird.
(
Sortiere Wörter zunächst der Länge nach ...)
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
64
32
Algorithmus:
1 Bestimme ri ∀i und erzeuge Paare (ri, Verweis auf xi)
2 Sortiere (ri, Verweis auf xi) durch Fachverteilung nach
1. Komponente. Bezeichne Länge[k] die Liste der Elemente
der Länge k.
3 Erzeuge L Paare (j, xji), 1 ≤ i ≤ n , 1 ≤ j ≤ ri und
sortiere sie nach der 2. Und dann der 1. Komponente.
2. Fachverteilung liefert lineare Listen Nichtleer[j],
1 ≤ j ≤ rmax i. Lösche Duplikate aus Nichtleer[j].
4 Sortiere nun die Wörter xi durch Fachverteilung wie oben
beschrieben. (unter Berücksichtigung von Länge[k])
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
65
Eine einfache Analyse zeigt:
Satz:
Sortieren durch Fachverteilung sortiert n Wörter
der Gesamtlänge L über einem Alphabet der
Größe m in Zeit O(m + L).
Anwendung: Sortieren n reeller Zahlen x1, ...,xn
Vereinfachung: Betrachte reelle Zahlen aus (0,1].
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
66
33
2.6 Hybridsort
∈ R fest, k := ⋅ n
1 Schaffe k leere Körbe. Wirf xi in den Korb
k ⋅ xi  für 1 ≤ i ≤ n .
2 Wende Heapsort auf jeden Korb an und konkateniere
die Körbe, d.h. reihe sie hintereinander auf.
Mitteilung:
1. Worst Case Laufzeit von Hybridsort ist O(n log n).
2. Wenn xi unabhängig gemäß Einheitsverteilung aus (0,1]
gewählt, dann hat Hybridsort mittlere Laufzeit O(n).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
67
3.Auswählen
Gegeben: Menge S von n Schlüsseln und natürliche Zahl k
(1 ≤ k ≤ n)
Gesucht: k-t-größter Schlüssel in S
n
n
Spezialfall: k =   (bzw. k =   )
2
2
Mediansuche
Triviale Lösung in Zeit O(n log n) :
Erst sortieren, dann auswählen.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
68
34
3.1 Randomisierte Auswahl
Idee: Möglichst gleichmäßige, rekursive Partionierung der Eingabe
Algorithmus:
if n=1
r
L
R
if
then return S[1], gefunden
Zufallsinteger ∈{1,..., n}
{ x ∈ S | x ≤ S [r ]}
{ x ∈ S | x > S [r ]}
k≤L
then wähle k-t-größtes Element in L
else wähle (k − L ) − t-größtes Element in R
fi
Vorlesung Algorithmen (RN/MK)
Satz:
WSI für Informatik, Universität Tübingen
69
Der k-t-größte Schlüssel einer Schlüsselmenge mit
n Schlüsseln kann in erwarteter Zeit O(n)
bestimmt werden
Beweis: t(n) Laufzeit des obigen Algorithmus;
da rand. Algorithmus, ist t(n) Zufallsvariable.
Bestimmen E(t(n)), d.h. Erwartungswert von t(n).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
70
35
Partition von S in L und R heiße gut,
falls:
3n
3n
L≤
und R ≤
4
4
Partition ist mit Wahrscheinlichkeit 12 gut.
g(n):= # rek. Aufrufe bis gute Partition erreicht wird.
3n
Dann gilt: t (n) ≤ bn ⋅ g (n) + t  
4
insbesondere t(1)=b.
3n 

Es gilt: E (t (n)) ≤ E  bn ⋅ g (n) + t   
 4 

 3n 
= bn E ( g ( n)) + E  t   
  4 
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
71
1
1
1
E ( g (n)) = 1 ⋅ + 2 ⋅ + 3 ⋅ + ... = 2
2
4
8
Also:
3n
E (t (n)) ≤ E  t    + 2bn
  4 
log n 
3n i
⇒ E (t ( n)) ≤ 2bn ∑  
i =0  4 
⇒ E (t ( n)) = O (n)
4
Vorlesung Algorithmen (RN/MK)
3
WSI für Informatik, Universität Tübingen
72
36
3.2 Deterministische Auswahl
Idee: bestimme Median (=ˆ Pivotelement) per Sampling...
Algorithmus:
n
1. Unterteile Schlüsselmenge S in 5 Mengen mit je
(bis zu) fünf Schlüsseln
2. Finde Median jeder Fünfermenge in O(1) Zeit
n
3. Wende det. Auswahl rekursiv auf Menge der 5 vielen
Fünfer-Mediane an, um den „Median der Mediane“ x
zu finden
4. Partioniere nun S bzgl. x in L und R (analog zur
rand. Auswahl)
5. Wende det. Auswahl rekursiv auf L an, falls L ≥ k
und sonst auf R (mit neuem Par. k − L )
Vorlesung Algorithmen (RN/MK)
Satz:
WSI für Informatik, Universität Tübingen
73
Der k-t-größte Schlüssel einer Schlüsselmenge mit n
Schlüsseln kann in Worst Case Zeit O(n) bestimmt werden
Beweis:
Zentral zu bestimmen: Güte der Partionierung
Es gilt: Mind. Hälfte der in Schritt 2 gefundenen
Mediane ≥ x
⇒
1 n
⋅
−2
2  5 
Fünfermengen beinhalten mind.
3 Elemente > x
1 n
3n
⇒ 3 ⋅    − 2  ≥ − 6 Elemente > x


 2  5   10
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
74
37
Analog:
# (Elemente < x) ≥
3n
−6
10
⇒ Im schlimmsten Fall in Schritt 5 rekursiver Aufruf
mit
7n
+ 6 Schlüsseln
10
⇒ Rekursionsgleichung für worst case Laufzeit T (n) :
7n
+ 6 < n falls n > 20
Benutze hierbei
10
O(1), falls n ≤ 80

T ( n) ≤ T   n   + T   7 n + 6  + O(n) , falls n > 80
{
 5  
10
 
12
3 142
43
Schritte 2+ 4
 Schritt3
Schritt5
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
75
Lsg. mit Substitutionsmethode:
Annahme: T (n) ≤ cn für c = const einsetzen :
7n
n
T ( n) ≤ c   + c + 6  + O(n)

 5   10
cn
7cn
≤ +c+
+ 6c + O(n)
5
10
9cn
≤
+ 7c + O ( n)
10
≤ cn
n
falls c groß genug, sodass c − 7  größer als die
 10 
in O(n) „versteckte Funktion“.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
76
38
4. Balancierte Bäume
5
2
Einfügen, Streichen
Bsp.: {2, 3, 5, 7, 11, 13, 17}
7
3
13
11
17
Knoten hat Verweis auf linkes und rechtes Kind (lchild, rchild)
Oft auch Verweis auf Elternknoten.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
77
Knotenorientierte Speicherung:
1. Ein Element pro Knoten
2. Alle Elemente im linken Teilbaum von v
< Element an v
< alle Elemente im rechten Teilbaum von v, für alle v
Blattorientierte Speicherung:
1. Ein Element pro Blatt
2. Alle Elemente im linken Teilbaum von v
≤ Schlüssel an v < alle Elemente rechts
4
2
6
2
3 5
10
7
Vorlesung Algorithmen (RN/MK)
11
WSI für Informatik, Universität Tübingen
78
39
Benutzen knotenorientierte Speicherung
Suche (x):
u
Wurzel; found
false
while (u < > 0) and not found
do if info(u) = x then found
else if x < info(u) then u
else u
rchild(u)
true
lchild(u)
Einfüge (x): Zuerst Suche (x). Sei u der zuletzt besuchte
Knoten. u hat höchstens ein Kind (oder x ∈ S ).
Falls x < Info(u), erzeuge neuen Knoten mit
Beschriftung x als linkes Kind von u, andernfalls
als rechtes Kind.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
79
Streiche (x): Zuerst Suche (x). Ist x ∈ S , endet Suche in
Knoten u mit info(u) = x.
Fall 1: u ist Blatt. Streiche u
u
Fall 2: u hat nur ein Kind w. Streiche u und setze w an die
Stelle von u als Kind von u‘s Elternknoten.
v
w
u
w
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
80
40
Fall 3: u hat 2 Kinder.
Suche Knoten v mit größter Beschriftung im linken
Teilbaum von u. (Einmal nach links, dann nach rechts,
bis es nicht mehr geht). v hat höchstens Kind (evtl. lchild).
Ersetze u durch v, und streiche v an alter Stelle mit Fall 1
oder Fall 2.
u
8
7
2
9
1
2
5
10
3
7
4
6
Vorlesung Algorithmen (RN/MK)
v
9
1
5
3
10
6
4
WSI für Informatik, Universität Tübingen
81
Komplexität: O(h + 1), wobei h Höhe des Suchbaums
kann sehr schlecht sein:
Idee: 1. Hoffen, dass das selten vorkommt.
2. Baue Baum von Zeit zu Zeit neu auf (ausgewogen)
3. Balancierte Bäume!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
82
41
4.1 Balancierte Bäume: AVL-Bäume
Def.: Sei u Knoten in binärem Baum. Balance:
Bal(u) = Höhe des rechten Teilbaums von u
- Höhe des linken Teilbaums von u
-1
-1
Def.: Ein binärer Baum heißt AVL-Baum, falls
Bal(u ) ≤ 1 für alle Knoten u.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
83
Def.: Fibonacci-Bäume T0, T1, T2 sind definiert durch
T0 = leerer Baum
T1 =
Tn =
für n ≥ 2
Tn-1
Tn-2
Fibonacci-Zahlen F0, F1, ... :
F0 = 0, F1 = 1, Fn= Fn-1 + Fn-2
Behauptung: Th enthält genau Fh Blätter für h ≥ 0.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
84
42
Behauptung: AVL-Baum der Höhe h enthält ≥ Fh Blätter.
Beweis: Durch Induktion über h.
h = 0: OK
h = 1: OK
h ≥ 2 : Man erhält blattärmsten AVL-Baum der Höhe h, indem
man blattärmsten AVL-Baum der Höhe h – 1 mit dem
blattärmsten der Höhe h – 2 kombiniert.
Tn-1
Nach Induktionsannahme hat der Baum
≥ Fh −1 + Fh − 2 = Fh Blätter.
Tn-2
Behauptung: Für h ≥ 0 ist Fh =
=
1+ 5
und
2
Vorlesung Algorithmen (RN/MK)
− h
mit
5
1- 5
=
.
2
h
(Induktion)
WSI für Informatik, Universität Tübingen
85
Lemma: Ein AVL-Baum mit n Knoten hat Höhe O(log n).
Beweis: Der Baum hat ≤ n Blätter.
h
− h
≤ n.
Also Fh ≤ n oder
5
h
Da β < 1 :
⇒ n≥
⇒
h
h log (
−
5
h
≥
h
2 5
für h groß genug.
h
2 5
≤ 2 5n
) ≤ log(2
)
log (2 5 ) + log n
h≤
= O (log n )
5 + log n
log
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
86
43
Einfügen / Streichen:
Beschriften jeden Knoten v mit seiner Balance Bal(v).
Einfügen: Durch Einfügen eines Knotens w können Balancen
einiger Vorfahren von w Werte ± 2 annehmen.
Sei u der tiefste dieser Vorfahren. O.B.d.A. sei Bal(u) = 2.
w wurde also im rechten Unterbaum von u eingefügt.
Sei v rechtes Kind von w.
Beachte: Bal(v) ≠ 0, da Höhe von v verändert wurde.
Fall 1: Bal(v) = 1
u
A
v
B
Rotation
⇒
C
Vorlesung Algorithmen (RN/MK)
A
B
C
WSI für Informatik, Universität Tübingen
87
Beachte:
(1) Die Rotation bewahrt die links-nach-rechts-Ordnung.
A-u-B-v-C.
(2) u und v haben nach der Rotation die Balance 0.
Alle Knoten in A, B und C haben die gleiche (legale)
Balance wie vor der Rotation.
(3) Höhe von v nach der Rotation ist gleich der Höhe von u vor
dem Einfügen von w. Also sind nach der Rotation keine
Vorfahren von v unbalanciert.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
88
44
Fall 2: Bal(v) = –1
u
oder (B,C) vertauscht.
2
v
A
–1
z
C
D
Do
Ro ppeltati
on
B
z
u
A
Vorlesung Algorithmen (RN/MK)
0
0 / –1
B
1/0
C
D
WSI für Informatik, Universität Tübingen
89
Einfügealgorithmus:
Füge neues Blatt w ein. Dann folge dem Pfad von w zur
Wurzel, wobei alle Balancen neu berechnet werden.
Tritt eine Balance ± 2 auf, dann führe Rotation oder
Doppelrotation aus.
Beende das Einfügen.
Laufzeit: O(Höhe des Baums) = O(log n), n = # Knoten
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
90
45
Streichen:
Wie beim Einfügen können Knoten Balance ± 2 annehmen.
Sei u der tiefste solche Knoten, sei Bal(u) = 2, und sei v das
rechte Kind von u.
Fall 1: Bal(v) = 1; balanciere wie beim Einfügen.
Fall 2: Bal(v) = –1; analog.
Unterbäume B und C können jetzt beide die gleiche Tiefe
haben.
Im Fall 1 und 2 hat der betroffene Baum nach der Balancierung
kleinere Höhe als vor dem Streichen.
Balancierung muß daher höher im Baum fortgesetzt werden.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
91
Fall 3: Bal(v) = 0
Rotation
⇒
v
A
B
C
A
B
C
In diesem Fall muß die Balancierung nicht höher im
Baum fortgesetzt werden.
Satz:
Balancierte Bäume, wie AVL-Bäume, erlauben Suchen,
Einfügen und Streichen in O(log n) Zeit, wo n die
Knotenanzahl ist.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
92
46
Anwendung von balancierten Suchbäumen:
Schnitt von achsenparallelen Liniensegmenten
Gegeben: Menge von insgesamt n vertikalen und horizontalen
Liniensegmenten in der Ebene.
Gesucht: Alle Paare von sich schneidenden Elementen
Trivialer Algorithmus: O(n²)
Anwendung z.B. bei VSLI-Schaltkreisen:
VLSI-Designer will keine unerwarteten
„Drahtüberschneidungen“...
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
93
Vereinfachende Annahme nachfolgend:
Alle Anfangs- und Endpunkte horizontaler Segmente
und alle vertikale Segmente haben paarweise
verschiedene x-Koordinaten.
Idee: Vertikale „Sweepline“ geht Ebene von links nach rechts
durch; jedes aktuell von Sweepline abgedeckte vertikale
Segment kann höchstens Schnittpunkte mit gerade „aktiven“
horizontalen Segmenten haben.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
94
47
Algorithmus:
 x − Koordinaten der Anfangs- und Endpunkte 
Q←

horizontaler Segmente

∪ {x − Koordinaten von vertikalen Segmenten} ;
Sortiere Q bzgl. x-Werten;
L ← o/ ;
/ * Menge jeweils aktiver horizontaler Segmente
in aufsteigender y - Reihenfolge * /
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
95
while Q ≠ o/ do
p ← kleinstes Element in Q ;
if p linker Endpunkt eines horizontalen Segments s
then L ← L ∪ {s}
else if p rechter Endpunkt eines horizontalen Segments s
then L ← L \ {s}
else /*p ist x-Wert eines vertikalen
Segments s = ( p, yu ), ( p, yo ) * /
Bestimme alle horizontalen Segmente t ∈ L
mit yu ≤ y (t ) ≤ yo und gib (s,t) aus.
fi;
[
]
fi;
od;
Q ← Q \ {p}
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
96
48
Zur Laufzeit des Algorithmus:
Einmaliges sortieren von Q: O(n log n)
Wichtig: Wie hält man L geordnet?
Beachte: Die Information in Q ist quasi statisch,
die in L dynamisch.
Wir benötigen folgende Operationen auf L:
-Einfügen&Entfernen
-Bestimmen aller Elemente, die in geg. Bereich[ yu , yo ]
fallen: „Bereichsanfrage“, Range Query
→ Implementation von L mit balanciertem Suchbaum
mit blattorientierter Speicherung, wobei benachbarte
Blätter verkettet sind.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
97
Damit: O(log n) für Einfügen und Entfernen und O(log n + r)
für Bereichsanfrage in Bereich yu , yo ,
wobei r :=# Elemente in yu , yo .
[
[
]
]
Zusammen: Laufzeit O(n log n + k),
wobei k die Gesamtzahl sich schneidender
Segmente ist.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
98
49
4.2 B-Bäume
Für große Datenmengen, die nicht mehr in den Hauptspeicher
passen, sind AVL-Bäume ungeeignet.
Hier kommen B-Bäume zum Zug, die für Zugriff auf externe
Speicher entworfen wurden.
Definition:
Ein B-Baum der Ordnung k ≥ 2 ist ein Baum,
- dessen Blätter alle gleiche Tiefe haben,
- die Wurzel mindestens 2 Kinder und jeder andere
- innere Knoten mind. k Kinder hat und
- jeder innere Knoten höchstens 2k-1 Kinder besitzt.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
99
Lemma:
Sei T ein B-Baum der Ordnung k mit Höhe h und
h
n Blättern. Dann gilt: 2 ⋅ k h −1 ≤ n ≤ (2k − 1)
Beweis:
Minimale Anzahl von Blättern, falls jeder innere Knoten
die Minimalzahl von Kindern hat:
2 ⋅ k14
⋅ k2
⋅ ...4
⋅ k = 2 ⋅ k h−1 = nmin ≤ n
3
h −1
Analog folgt, dass die maximale Anzahl der Blätter
höchstens (2k − 1)h =: nmax ist.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
100
50
Logarithmieren ergibt:
log ( 2 k −1) n ≤ h ≤ 1 + log k
n
2
⇒ Wähle bei großen Datenmengen k so, dass auf eine Seite
ein Knoten des B - Baums passt.
Operationen: Zugriff, Einfügen, Streichen
Annahme: Wir speichern knotenorientiert;
nichts in den Blättern.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
101
Betrachte Knoten u mit l Kindern:
u
s1
s2
...
si-1
...
si ...
sl-1
Ti . . .
u hat Schlüssel s1 , s2 ,..., sl −1. (geordnet!)
Sei Ti der i-te Unterbaum von u
v gilt :
Für alle v ∈ Ti und alle Schlüssel„ s ∈„“
s ≤ si , falls i = 1
si −1 ≤ s ≤ si , falls 1 < i < l
si ≤ s, falls i = d
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
102
51
Zugriff auf (a,S):
Starte in Wurzel w und suche den kleinsten
Schlüssel si in w mit a ≤ si .
Falls si existiert:
if a = si
then gefunden
else w ← i - tes Kind von w ;
suche rekursiv weiter
fi
Falls si nicht existiert : w ← rechtestes Kind ;
suche rekursiv weiter
Laufzeit: O((log k n ) ⋅ k )
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
103
Einfügen (a,S):
(Erfolglose) Suche ende in Blatt b mit Elternknoten v,
welcher l Kinder hat.
Sei si der kleinste Schlüssel in v mit a<si (falls existent).
Füge neuen Schlüssel a in v ein und neues Blatt b′
für a, sodass
a links von si , falls i=1
a zwischen si-1 und si , falls 1<i<l
a rechts von sl-1 , falls si nicht existent
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
104
52
Also:
v
s1 s2
...
sl-1
s1 s2
14444
4244444
3
l Blätter
...
si-1 a si ... sl-1
144444
42444444
3
l + 1 Blätter
Falls l < 2k − 1 ⇒ OK.
Falls l = 2k − 1 : Spalte v in zwei Knoten v′ und v′′ mit
jeweils k Kindern
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
105
Bild:
w
v
sk
w
s1 s2
...
s2k-1
v ′ s1 . . .
sk-1
v′′ sk
. . . s2k-1
14444244443
2k Kinder
w bekommt ein Kind mehr und auch einen Schlüssel sk mehr.
Setze Aufspalten falls nötig zur Wurzel des B-Baums hin fort.
Beachte: Tiefe des Gesamtbaums bleibt erhalten, außer wenn
die Wurzel aufgespalten werden muss.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
106
53
Streichen eines Schlüssels aus einem B-Baum:
Streiche (a,S)
Annahme: a = sj kommt in Knoten u vor.
Mittels Zugriff (a,S) suche zunächst Knoten u,
in dem a als Schlüssel sj vorkommt. Wir nehmen an,
die Suche ende erfolgreich.
allg. Situation:
.......... sj-1
Tj
............. u
sj
Tj+1
Fallunterscheidung:
1.) Falls Tj ein Blatt ist, so lösche sj und Tj.
2.) Tj ist kein Blatt: Sei s der rechteste Schlüssel in Tj.
Ersetze sj durch s und lösche s samt
„rechtestem“ Blatt in Tj.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
107
Situation:
....
sj-1 sj sj+1 ....
v
s
....
sj-1 s sj+1 ....
v (ohne s)
Sei v der Knoten, in dem s (rechtsaußen) vorkomme.
Zahl der Kinder in v ist damit um 1 verringert:
Sei r die ursprüngliche Zahl der Kinder in v
mit k ≤ r ≤ 2k − 1.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
108
54
a) Falls r > k (bzw. r > 2, falls v Wurzel), so fertig, da B-BaumEigenschaft gewahrt bleibt.
b) Falls k= 2 und v Wurzel ist, so hat v nach Entfernung von s
nur noch ein Kind.
Dann „streiche“ die Wurzel.
Alle Blätter bleiben auf gleicher Tiefe, die Baumhöhe
verringert sich um 1.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
109
c) Sei r = k und v keine Wurzel. Sei w Elternknoten von v und
v´ ein „direkter“ Geschwisterknoten links von v.
Weiter sei s´ der Schlüssel in w zwischen den
Verweisen auf v und v´. Also:
.... s´´ s´ ....
s1´ .... sr´
s1 s2 .... sk-2
k ≤ r + 1 ≤ 2k − 1
Verschmelze v und v´:
.... s´´ ....
w
s1´ .... sr´ s´ s1 .... sk-2
vneu
vneu hat jetzt mind. 2k-1 und höchstens 3k-2 Kinder.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
110
55
) Falls vneu mehr als 2k-1 Kinder hat, so spalte vneu wieder
in zwei Knoten auf (wie beim Einfügen), um die
B-Baum-Eigenschaft zu erfüllen:
Jedes der Kinder hat dann mind. k und
 3k 
höchstens   - 1 Kinder.
2
) Falls vneu genau 2k-1 Kinder hat, so muss nicht gespalten
werden. Jedoch hat w nun ein Kind verloren und so
muss rekursiv mit w fortgefahren werden.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
111
Zusammenfassend ergibt sich:
Satz: Zugriff / Einfügen / Streichen kann in B-Bäumen
der Ordnung k, welche n Schlüssel verwalten,
in Zeit O(k ·logk n) durchgeführt werden.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
112
56
5.Hashing
Hash-Tafeln („Streutafeln“) dienen zur Implementierung
von „Wörterbüchern“ (Dictionaries) und sollen daher
die Operationen Zugriff, Einfügen und Streichen
unterstützen.
Ausgangslage:
Geg.: Universum U = [0 ... N-1], S ⊆ U ist die zu verwaltende
Menge.
Operationen: Zugriff(a,S), Einfügen(a,S), Streichen(a,S)
Grundprinzip ist es, die „wenigen“ Elemente von S („|S| << |U|“)
in einem kompakten Array T mit Hilfe einer Hash-Funktion
h: U
[0 ... m-1] abzuspeichern.
Ein Element x ∈ S wird dann in T[h(x)] abgespeichert.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
113
Beispiel: m = 5, S = {3, 15, 22, 24}, U = [0 ... 99]
h(x) = x mod 5
Hash-Tafel T:
0:
1:
2:
3:
4:
15
22
3
24
Offensichtlich: Problem von Kollisionen,
d.h. h(x) = h(y) für x ≠ y.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
114
57
Forderungen an Hash-Funktionen:
- Einfache Berechenbarkeit
- Minimierug der Kollisionsanzahl
Zwei Hauptmethoden zur Kollisionsbehandlung:
- Hashing mit Verkettung und
- Hashing mit offener Adressierung
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
115
5.1 Hashing mit Verkettung
Hash-Tafel als Array von linearen Listen realisiert.
Die i-te Liste ( 0 ≤ i < m ) enthält alle Elemente x ∈ S
mit h(x) = i.
Worst Case: Alle Elemente in einer Liste abgespeichert
alle Operationen erfordern lineare Laufzeit O(|S|).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
116
58
Im Durchschnitt aber viel besseres Verhalten. Um diesen
zu analysieren, machen wir folgende Annahmen:
(*) 1) h(x) in O(1) Schritten berechenbar.
2) Hash-Funktion h: U [0 ... m-1] verteilt das Universum
„gleichmäßig“ auf das Intervall [0 ... m-1], d.h.
U 
h −1 (i ) ≤  
∀i = 0, ..., m − 1
m
3) Alle Elemente von U sind mit gleicher Wahrscheinlichkeit
Argument einer Operation in einer Sequenz von Operationen,
d.h. das Argument der k-ten Operation der Sequenz ist ein
festes x ∈ U mit Wahrscheinlichkeit 1/|U|.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
117
Mit Annahmen 2) und 3) folgt:
Sei xk Argument der k-ten Operation. Dann
Prob(h(xk) = i) =
1
m
∀ k ∈ [1 ... n]
∀ i ∈ [0 ... m-1] ,
wobei n die Anzahl der Operationen sei.
Satz: Es gelten die Annahmen (*).
Nehmen wir an, dass n Operationen stattfanden.
Dann sind die erwarteten Kosten einer
n
darauffolgenden Operation O (1+ ) , wobei = .
m
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
118
59
Beweis: Schlimmstenfalls vorher n Einfügungen in die Tafel,
sodass dies die maximale Kollisionswahrscheinlichkeit ergibt.
Angenommen h(xn+1) = i.
Prob(Ln(i) = j) Wahrscheinlichkeit, dass die i-te Liste nach
der n-ten Operation Länge j hat. Dann gilt
n
EK n +1 ≤ ∑ Prob(Ln (i ) = j )(1 + j ).
j =0
Weiter gilt
 n  1   1 
Prob(Ln (i ) = j ) ≤    1 − 
 j  m   m 
j
Vorlesung Algorithmen (RN/MK)
n− j
.
WSI für Informatik, Universität Tübingen
n
 n  1 
  
EK
1
≤
+
Daraus folgt:
∑
n +1
j = 0  j  m 
j
119
n-j
 1
1-  ⋅ j
 m
n
 n − 1 1 
 
= 1 + ∑ n
j =1  j − 1 m 
j
 1
1 − 
 m
n n  n − 1 1 
 
= 1 + ∑ 
m j =1  j − 1 m 
j −1
n− j
 1
1 − 
 m
n  n −1  n − 1 1   1 
  1 − 
= 1 +  ∑ 
m  j =0  j  m   m 
j
n  1  1 
= 1 +  + 1 −  
m  m  m 
= 1+
Vorlesung Algorithmen (RN/MK)
n −1− ( j −1)
n −1− j




n −1
n
= 1+
m
WSI für Informatik, Universität Tübingen
120
60
Bei obigem Satz Annahme (*). 3) am kritischsten – eher
selten Zugriff auf Hash-Tafel gleichverteilt ...
(Bsp. Symboltabellen (Compiler)).
Aus Wissen über „Zugriffsverteilung“ läßt sich aber
ggf. eine bessere Hash-Funktion konstruieren und zuweilen
sogar bessere (erwartete) Laufzeiten erzielbar.
Weiterhin hängen erwartete Kosten von Belegungsfaktor
n
=
ab:
m
= const. ⇒ erwartete Kosten konstant.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
121
Problem: Wahl von m:
- m (zu) groß
hohe Speicherkosten und
mitunter erhöhte Laufzeit.
- m (zu) klein
erwartete Kosten (zu) hoch.
Fazit: Mit Einfügen bzw. Streichen kann
oder zu klein werden.
schnell zu groß
Lösungsansatz: „Rehashing“:
Idee: Benutze Folge T0, T1, T2, ... von Hash-Tafeln der
Größen m, 2m , 4m, ... zusammen mit jeweiligen
Hash-Funktionen h0, h1, h2, ...
Beginn mit T0.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
122
61
1) Wenn in Ti (der Größe 2i·m) nun = 1
Speichere in Ti+1 um
1
neuer Belegungsfaktor ´=
2
1
2) Wenn in Ti nun =
4
Speichere in Ti-1 um (mit Ausnahme von i = 0)
1
neuer Belegungsfaktor ´=
2
1
1
Nach Rehashing gemäß 1) mindestens ⋅ 2i +1 ⋅ m = ⋅ 2i m
4
2
Operationen bis zum nächsten Rehashing möglich.
1 i −1
⋅2 ⋅m
4
Operationen bis zum nächsten Rehashing möglich.
Nach Rehashing gemäß 2) mindestens
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
123
In beiden Fällen Rehashing-Kosten somit höchstens um
Faktor 2 größer als die danach bei „günstigem“
Belegungsfaktor mindestens ausführbaren Operationen.
D.h., dass „amortisiert“ die erwarteten Kosten pro Operation
immer konstant gehalten werden können, ohne allzu viel
Speicher zu verschwenden.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
124
62
5.2 Hashing mit offener Adressierung
Grundidee: Jedes Element x ∈ U definiert Folge h(x,i),
i = 0, 1, 2, ... von Tafelpositionen.
Diese Sequenz durchzugehen, wann immer
eine Operation mit x ausgeführt werden soll.
Oft h(x,i) als Kombination zweier Hash-Funktionen gewählt:
h(x,i) = [h1(x) + i·h2(x)] mod m
Vorteil: Kein zusätzlicher Speicherbedarf.
Nachteil: Schlechte Leistung bei Belegungsfaktor nahe 1 und
keine Unterstützung des Streichens.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
125
5.3 Perfektes Hashing
Hash-Funktion sollte injektiv sein, falls S bekannt ist.
Grundschema:
Stufe 1 arbeitet mit Hashing mit Verkettung
kreiert „kurze“ Listen
Stufe 2 benutzt für jede Liste eine eigene, injektive
Hash-Funktion
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
126
63
Zunächst zur Wahl einer injektiven Hash-Funktion:
Sei U = {0, 1, ..., N-1} und sei
[0 ... m-1] Hash-Funktion
hk : {0, ..., N-1}
für k ∈{1, ..., N-1} mit
hk (x) := ((kx) mod N) mod m.
Sei S ⊆ U mit |S| = n bekannt.
Für welches k ist hk injektiv?
Messung der „Injektivität“ vermöge:
bik := {x ∈ S : hk ( x ) = i} für 1 ≤ k ≤ N-1,
0 ≤ i ≤ m-1
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
127
Dann
bik ⋅ (bik − 1) =
{ (x,y )∈ S
2
}
x ≠ y, hk ( x ) = hk ( y ) = i
Anzahl der Paare mit Wert i, die „Injektivität“ verletzen.
m −1
Sei Bk := ∑ bik (bik − 1). Somit Zahl der Paare in S2, die
i =0
„Injektivität von hk“ verletzen:
Bk ≈ 2# Kollisionen, falls hk benutzt.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
128
64
Lemma: Voraussetzungen wie oben. Dann
1. Bk < 2 gdw. hk|S injektiv.
n
∀i ∈ {0, ..., m-1}
2. Falls bik =
m
(d.h. gleichverteilt), dann
m −1
Bk = ∑
i =0
nn 
n 
 − 1 = n − 1
mm 
m 
Beweis: 2. Offensichtlich per Def.
m −1
1. " ⇒": Bk < 2 ⇔ ∑ bik (bik − 1) ∈ {0 , 1} ⇒ ∀i:bik ∈ {0 , 1}
i =0
⇒ hk
" ⇐ ": hk
S
S
injektiv.
injektiv ⇒ ∀i bik ∈ {0 , 1} ⇒ Bk = 0
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
129
Lemma: Voraussetzungen wie oben, desweiteren sei
N Primzahl. Dann gilt
N −1 n −1
∑∑ b (b
− 1) ≤ 2 ⋅
k =1 i = 0
142
4 43
4
ik
ik
n(n − 1)
(N − 1)
m
Bk
Bemerkung:
Lemma ⇒
⇒
n(n − 1)
mittlere Anzahl der Kollisionen ≤
m
(da Bk ≈ 2⋅# Koll´en bei Benutzung von hk )
Mit m > n(n-1) ist mittlere Anzahl < 1 und
d.h., es gibt hk, das auf S injektiv ist!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
130
65
Beweis des Lemmas:
N −1 m −1
∑∑ b (b
k =1 i = 0
ik
ik
− 1)
N −1 m −1
= ∑∑
k =1 i = 0
=
{ (x,y )
∑ {k
( x,y )∈S 2
x,y ∈ S, x ≠ y, hk ( x ) = hk ( y ) = i}
hk ( x ) = hk ( y ) }
x≠ y
Seien x, y ∈ S fest. Wieviele Funktionen hk mit
hk(x) = hk(y) gibt es?
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
131
hk(x) = hk(y)
(k·x mod N) mod m = (k· y mod N) mod m
⇔
⇔
((k· x mod N) – (k·y mod N)) mod m = 0
=: g(k)
Es gilt − N + 1 ≤ g (k ) ≤ N − 1
und
g (k ) = i ⋅ m
  − N + 1   N − 1 
i ∈ 
,..., 

 m   m  
mit
Behauptung: Für jedes i gibt es höchstens ein k mit g(k) = i·m.
{k h (x ) =h ( y )} = 2 ⋅  N − 1
Falls Beh. wahr, so gilt:
k
N −1 m −1
Gesamtsumme:
∑∑ b (b
k =1 i = 0
Vorlesung Algorithmen (RN/MK)
ik
ik
k
− 1) ≤ 2 ⋅
 m 
N −1
n(n − 1)
m
WSI für Informatik, Universität Tübingen
132
66
Beweis der Behauptung:
Seien k1, k 2 ∈ [0 ... N-1] mit g(k1) = g(k2):
g(k1) = g(k2)
⇔
⇒
⇔
k1x mod N – k1y mod N = k2x mod N – k2y mod N
(k1x – k1y) – (k2x – k2y) mod N = 0
((k1 – k2)(x – y)) mod N = 0
Da Z|N Körper, folgt entweder k1 – k2 mod N = 0
oder x – y mod N = 0.
Wegen x, y, k1, k 2 ∈ [0 .. N − 1] und x ≠ y folgt k1 = k 2.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
133
Korollar 1: Voraussetzungen wie oben (Lemma).
1. ∃k ∈ [1K N-1]:Bk ≤ 2 ⋅
2. Mindestens
n(n − 1)
m
4n(n − 1)
N -1
viele hk ’s haben Bk ’s mit Bk ≤
.
2
m
n(n − 1)
ist Mittelwert, ein hk muss Bk mit
m
diesem oder kleinerem Wert haben ...
Beweis: 1.
2⋅
N −1

4n(n − 1) 
2. Sei A := k Bk >
-Annahme: A >
.
.
2
m 

N −1
N − 1 4n(n − 1)
n(n − 1)
Dann ∑ Bk ≥ ∑ Bk >
(N − 1)
⋅
=2
2
m
m
k =1
k∈ A
im Widerspruch zum Lemma!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
134
67
Korollar 2 Teil 1
n(n − 1)
1. Ein k ∈ [1K N − 1] mit Bk ≤ 2
m
in Zeit O(m + Nn) bestimmbar.
2. Sei m = n(n – 1)+1. Dann gibt es k derart, dass hk|S injektiv.
k in Zeit O(n2+Nn) zu finden.
3. Sei m = 2n (n – 1) +1. Dann mind. Hälfte der hk|S injektiv.
Bestimmungszeit O(n2) randomisiert.
Beweis: 1. Teste alle k durch. Es gibt N – 1 verschiedene k´s
und n versch. x ∈ S . „Wirf x´e in Fächer in Ges.zeit O(n·N).
Schau jeweils nach, ob Fächer zu „voll“ (Zeit O(m)).“
2. Einsetzen bei 1. liefert Bk < 2 ⇒ injektiv!
3. Einsetzen in Kor.1, Teil 2 ⇒ Mind. Hälfte der hk´s haben
Bk´s mit Bk < 2 ⇒ Mind. Hälfte der hk´s injektiv.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
135
Korollar 2 Teil 2
n(n − 1)
4. k ∈ [1K N − 1] mit Bk ≤ 4
randomisiert
m
in Zeit O(m + n) bestimmbar.
5. Sei m = n. k mit Bk ≤ 2(n − 1) in Zeit O(n·N) zu finden.
6. Sei m = n. k mit Bk ≤ 4(n − 1) randomisiert in Zeit O(n)
zu finden.

n(n − 1)   1
Beweis: 4. Prob   Bk < 4
 ≥
m   2

⇒ ... „randomisiert“ trifft man ein solches k in Zeit O(m + n).
5. Einsetzen bei 1.
6. Einsetzen bei 4.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
136
68
Zur Realisierung:
Stufe 1: Sei m = n. Gemäß Kor. 2, 1. gibt es dann Hash-Fkt. hk,
sodass Listenlängen alle O n .
( )
m −1
Denn:
∑ bik (bik − 1) = Bk ≤ 2
i =0
Def .
Kor.2,1.
( )
n(n − 1) n = m
= 2(n − 1)
m
( )
⇒ bik ∈ O n ∀i , d.h. Listenlängen O n .
Stufe 2: Auf jede dieser Teilmengen (
nochmals Hashing an.
Vorlesung Algorithmen (RN/MK)
Listen) wende
WSI für Informatik, Universität Tübingen
137
Die Einzelheiten:
Sei S ⊆ [0 .. N-1] , N Primzahl, S = n = m :
1. Wähle k mit Bk ≤ 4(n − 1) ≤ 4n.
Sei hk = ((kx) mod N) mod m.
2. Sei wi = {x ∈ S : hk ( x ) = i}, bi = wi
und mi: = 2bi (bi − 1) + 1
Wähle ki mit h k(x)
= ((kix) mod N) mod mi, sodass
i
hki injektiv für wi.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
138
69
3. Sei si := ∑ m j
j <i
Dann speichere x ∈ S in Tafelposition T [si + j ] ,
wobei
und
i = ((kx ) mod N ) mod m
j = ((ki x ) mod N ) mod mi .
Bild:
w0
0
w1
m0-1
m0 = s1
s
((kx) mod N) mod n
:
:
:
:
s2-1
:
wn-1
Vorlesung Algorithmen (RN/MK)
sn-1
mn-1+sn-1-1
WSI für Informatik, Universität Tübingen
139
Komplexitätsanalyse:
Platzbedarf:
m −1
n −1
∑ mi = ∑ [2bi (bi − 1) + 1] = n + 2Bk
i =0
i =0
≤ n + 8(n − 1) = 9n − 8 = O(n ).
Kor.2, 6
Laufzeit:
Schritt 1: O(n) randomisiert nach Korollar 2, 6.
( )
Schritt 2: O(n) randomisiert, da bi = O n
in Kor. 2, 3.
Schritt 3: O(mi + bi) für jedes ki, d.h. insges. O(n).
∑:
O(n + m) = O(n) randomisiert!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
140
70
Satz: Voraussetzungen wie oben.
Dann kann für S perfekte Hash-Tafel der Größe O(n)
und Hash-Funktion mit O(1) Zugriffszeit deterministisch
in Zeit O(n·N) und randomisiert in O(n) erwarteter Zeit
aufgebaut werden.
Bemerkung:
Randomisierte Version sehr zu bevorzugen!
Wie macht man es nun wirklich, speziell „on-line“?
Szenario: Starte mit leerer Hash-Tafel, füge x1 ein, dann x2 usw.
Beim i-ten Durchgang nur x1, ..., xi bekannt.
Grundschema: Falls auf Stufe 1 zu viele Kollisionen, oder auf
Stufe 2 nicht injektive Hash-Funktion, so verändere
Hash-Funktion bzw. -Tafel.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
141
Tafelaufbau:
Wähle k ∈ [1 .. N-1] ;
for i = 0 to n – 1 do Initialisierung
wähle ki zufällig
od;
m n; B 0;
for l = 0 to n – 1 do Insert(xl) od;
Insert(x)
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
142
71
Analyse:
Tafelaufbau und versuche_wieder können oft vorkommen.
versuche_wieder:
Test, ob gewähltes ki gut, kostet Zeit O(bi)
mi immer groß ( ≥ 2bi (bi − 1) + 1 ) gehalten, sodass ki
mit W.´keit ≥ 1 2 injektiv für wi,
d.h. im Mittel nur 2mal versuche_wieder, also O(bi)
Zeit, um injektive Hash-Funktion für wi zu finden.
Sei bif Wert von bi nach allen Einfügungen.
Dann ist Gesamtzeit für festes i
f
 bi 
f 2
≤ O ∑ j  = O bi
.
 j =1 


(( ) )
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
143
Tafelaufbau:
Passiert, wenn B > 4(n – 1).
Nach Kor. 2, 4 bzw. 6 (Beweis) gilt für zufälliges k
n −1
1
f
f
B f = ∑ bi bi − 1 ≤ 4(n − 1) mit W.´keit ≥
2
i =0
f
Da aktuelles B ≤ B , brauchen wir im Mittel
≤ 2 Versuche für k:
2
 n −1
⇒ O(n ) + O ∑ bi f  = O(n ) + O B f = O(n )
 i =0

Tafelaufbauzeitkomplexität insgesamt
(
)
( )
Vorlesung Algorithmen (RN/MK)
( )
WSI für Informatik, Universität Tübingen
144
72
Platzbedarf:
mi wächst während des Einfügens.
Seien mi,1, mi,2, ... die versch. Werte für mi und
mif der letzte Wert.
Es gilt: mi,p +1 ≥ 2mi,p + 1
f
⇒
mi
f
≤ 2mi
∑p mi,p ≤ ∑
p
p ≥0 2
⇒ Gesamtplatzbedarf :
n-1
n −1
( (
) )
≤ ∑ 2 ⋅ mi ≤ ∑ 8bi bi − 1 + 2
f
i =0
i =0
f
f
≤ 8 ⋅ 4(n-1) + 2n ≤ 34n
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
145
Satz:
Sei N Primzahl und S Teilmenge von U
mit |S| = n. Dann kann perfekte Hash-Tafel
der Größe O(n) on-line in O(n) erwarteter
Zeit berechnet werden.
Zugriffszeit ist O(1).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
146
73
6. Graphenalgorithmen
Grundlagen:
1. Paar (V, E) heißt gerichteter Graph G, wobei
V endl. Menge von Knoten und
endl. Menge von Kanten ist.
2
Element e = (v,w) ∈ E
1
3
heißt Kante von v nach w
(„ v
w “)
v ist Startknoten von e
5
w ist Zielknoten von e
w ist Nachbarknoten von v (w ist adjazent zu v)
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
4
147
2. Pfad in G ist Folge (v0, ..., vk) von Knoten mit k ≥ 0
und (vi, vi+1) ∈ E für 0 ≤ i ≤ k − 1.
Länge des Pfades ist k.
Falls v0 = vk und k ≥ 1, so heißt der Pfad Kreis bzw. Zykel.
Falls vi ≠ v j für alle i ≠ j , so heißt der Pfad einfach.
Falls es Pfad von v nach w in G gibt, so schreibt man
*
v
→
w.
G
Gerichteter Graph heißt zyklisch, falls er Kreis enthält;
sonst azyklisch.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
148
74
6.1 Darstellung von Graphen
Annahme: V = {1, 2, ..., n}, G = (V, E), n = |V|.
Zwei Darstellungsarten sind üblich:
1. Darstellung: Adjazenzmatrix A = (aij ) , 1 ≤ i,j ≤ n
falls (i,j ) ∈ E
sonst.
1 ,
aij := 
0 ,
1 2 3 4 5
Bsp.:
1
1
2
3
4
5
4
2
3
5
Vorlesung Algorithmen (RN/MK)
0
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
1
1
0
0
0
WSI für Informatik, Universität Tübingen
149
Bei ungerichteten Graphen ist die Adjazenzmatrix
symmetrisch:
1
4
2
5
falls {i,j}∈ E
sonst.
1 ,
hier: aij := 
0 ,
3
1 2 3 4 5
1
2
3
4
5
Vorlesung Algorithmen (RN/MK)
0
1
0
0
1
1
0
0
0
1
0
0
0
0
1
0
0
0
0
0
1
1
1
0
0
WSI für Informatik, Universität Tübingen
150
75
Platzbedarf: O(n2)
ist günstig, falls m := E ≈ n 2 .
Aber: Oft sind Graphen dünn, d.h. m ≈ O (n ) .
Bsp.:
Zahl der Kanten in Bäumen mit n Knoten ist n – 1.
Planare Graphen: Graph heißt planar, falls er in Ebene
gezeichnet werden kann, ohne dass sich Kanten
überkreuzen.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
151
Zwei nicht-planare, ungerichtete Graphen:
K5
K3,3
(„vollständiger“ bipartiter
Graph mit 3 und 3 Knoten)
Mitteilung: Ein planarer Graph mit n Knoten enthält
maximal 3n – 6 Kanten.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
152
76
2. Darstellung: Adjanzenzlisten
Speichere für jeden Knoten v seine „Nachbarn“:
G = (V, E) gerichtet:
InAdj(v ) = { w ∈ V
(w, v ) ∈ E}
OutAdj(v ) = { w ∈ V (v, w) ∈ E}
G ungerichtet:
Adj(v ) = { w ∈ V
Vorlesung Algorithmen (RN/MK)
{v,w}∈ E}
WSI für Informatik, Universität Tübingen
153
Im vorigen Beispiel (gerichtet):
InAdj: 1
2
3
4
5
2
OutAdj:
5
1
2
1
2
3
4
5
5
1
5
3
Platzbedarf: O(n + m)
Nachteil: Zugriffszeit auf Kante abhängig von Listenlänge,
d.h. Knotengrad:
Eingangsgrad indeg(v) eines Knoten v = { (w, v ) (w, v ) ∈ E } ,
Ausgangsgrad outdeg(v) eines Knoten v = { (v, w) (v, w) ∈ E} ,
analog für ungerichtete Graphen.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
154
77
Graph G = (V, E) heißt Baum, falls
a) V enthält genau einen Knoten v0 mit indeg(v0) = 0.
b) ∀ v ∈ V \ {v0 }: indeg(v ) = 1
c) G ist azyklisch.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
155
6.2 Topologisches Sortieren
Sei G = (V, E) gerichteter Graph.
Abbildung num: V
{1, ..., n} mit n = |V| heißt
topologische Sortierung von G, falls num(v) < num(w)
für alle (v, w) ∈ E .
Bsp.:
1
4
2
5
2
1
5
3
4
3
1
2
Vorlesung Algorithmen (RN/MK)
3 es gibt keine
topologische
Sortierung!
WSI für Informatik, Universität Tübingen
156
78
Lemma:
Gerichteter Graph G = (V, E) besitzt genau dann
eine topologische Sortierung, wenn G azyklisch ist.
Beweis:
"⇒" :
Sei G zyklisch. Dann ist etwa (v0, ..., vk), k ≥ 1,
ein Kreis. Für eine topologische Sortierung muß
aber gelten:
num(v0) < num(v1) < ... < num(vk) = num(v0).
Widerspruch!!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
157
"⇐" :
Sei G azyklisch.
Beh.: G enthält Knoten v mit indeg(v) = 0.
Wir finden solchen Knoten v wie folgt.
Starte mit bel. Knoten w und gehe entlang eingehender
Kanten „rückwärts“. Da Graph azyklisch und endlich,
wird kein Knoten auf diesem „Rückweg“ zweimal besucht
und daher terminiert dieser Prozess mit einem Knoten v
mit indeg(v) = 0.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
158
79
Jetzt zur topologischen Sortierung:
Beweis per Induktion über Knotenzahl:
|V| = 1: trivial.
|V| > 1: Wähle (gemäß Beh.) v mit indeg(v) = 0.
Entferne v und sortiere den Restgraph G´ topologisch
induktiv, d.h.:
Sei num´ : V´
{1, ..., |V´|} top. Sortierung für G´.
Dann ergibt sich für die top. Sort. num vermöge
num´(w ) + 1,
num(w) = 
1,

Vorlesung Algorithmen (RN/MK)
falls w ≠ v
falls w = v.
WSI für Informatik, Universität Tübingen
159
Grundalgorithmus für topologisches Sortieren:
count
0;
while ∃ v ∈ V mit indeg(v) = 0 do
count ++;
num(v)
count;
streiche v und alle von v ausgehenden Kanten aus G;
od
if count < |V|
then ausgabe(G zyklisch!)
fi
Komplexitätsanalyse:
Problem: Test auf Existenz eines Knotens v mit indeg(v) = 0.
Lösung: Merke alle Knoten mit indeg = 0 in Menge ZERO.
Führe für jeden Knoten Buch über Anzahl jeweils
einmündender Kanten.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
160
80
Algorithmus TOPSORT:
(1) ZERO
Ø;
(2) for all v ∈ V do INDEG[v]
0 od;
(3) for all e ∈ E do INDEG[target(e)] ++ od;
(4) for all v ∈ V do
(5)
if INDEG[v] = 0 then ZERO
ZERO ∪ {v} fi
(6) od
(7) count
0;
Fortsetzung
nächste Folie
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
161
(8) while ZERO ≠ Ø do
(9)
wähle und streiche v ∈ ZERO ;
(10)
count ++;
(11)
num[v]
(12)
count;
for all (v, w ) ∈ E do
(13)
INDEG[w] – – ;
(14)
if INDEG[w] = 0 then ZERO
(15)
ZERO ∪ {v} fi
od
(16) od;
(17) if count < |V| then ausgabe(G zyklisch!) fi
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
162
81
Satz:
Topologische Sortierung eines gerichteten
Graphen G = (V, E) kann in Zeit O(n + m)
(Linearzeit!) berechnet werden.
Hierbei: n = |V|, m = |E|.
Beweis: Die Korrektheit folgt unmittelbar mit dem Lemma.
Zur Komplexität: Übungsaufgabe!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
163
6.3 Billigste Wege
Sei G = (V, E) gerichteter Graph mit Kostenfunktion
c: E
R, ein sogenanntes Netzwerk.
Sei p = (v0, ..., vk) Pfad von v0 = v nach vk = w.
Dann heißt k −1
c( p ) := ∑ c(vi , vi +1 )
i =0
Kosten des Pfades von v nach w.
dist(v, w) = inf {c(p) | p ist Pfad von v nach w}
heißt Entfernung.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
164
82
Beispiel:
2
–1
4
1
2
3
3
4
dist(1,2) = – 1
dist(3,1) = ∞
dist(3,4) = – ∞ , da
Pfad (3,4,(5,6,4)i) Kosten 3 – i
hat für alle i ≥ 0.
negativer Zyklus
2
6
–6
5
3
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
165
3 grundsätzliche Problemstellungen:
1 single pair shortest paths
(kürzeste Wege zwischen einem Knotenpaar)
2 single source shortest paths
(kürzeste Wege von einem Knoten aus)
3 all pairs shortest paths
(kürzeste Wege zwischen allen Knotenpaaren)
Bemerkung:
Unbekannt, ob 1 leichter/effizienter lösbar als 2 .
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
166
83
Single Source Shortest Paths
Sei s der „Quellknoten“. G = (V, E).
Gesucht für alle u ∈ V
∞, falls kein Pfad von s nach u in G,
(u ) := 
dist (s, u ), sonst.
Lemma:
Sei u ∈ V . Dann gilt:
i)
(u ) = −∞
gdw. u ist erreichbar aus negativem
Zyklus, der von s aus erreichbar ist.
ii) (u ) ∈ R ⇒ ∃ billigster einfacher Pfad von
s nach u mit Kosten δ (u ) .
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
167
Beweis:
i) "⇐" : klar!
"⇒" : Sei c := ∑ c(e ) und sei p ein kürzester Weg von
e∈E
s nach u mit c(p) < – c.
Dann muss p Zyklus q enthalten, d.h. p ist nicht
einfach. Wäre nun c(q ) ≥ 0, so könnten wir
q aus p entfernen und so p verkürzen.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
168
84
(u )∈ R, so gibt es Pfad von s nach u.
Wir zeigen: (u ) = min{ c( p ) p ist Pfad von s nach u
und p ist einfach }.
ii) Falls
Sei p* billigster einfacher Weg von s nach u.
Ist Behauptung falsch, dann gibt es einen nichteinfachen
Weg q von s nach u mit c(q) < c(p*).
Durch Entfernen des Zyklus aus q entsteht kürzerer
Weg q´ und da Zyklus (gemäß i) ) nicht negativ ist, folgt
c(q´) < c(q) < c(p*), ein Widerspruch.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
169
1. Situation: Der geg. Graph G = (V, E) ist azyklisch.
Bsp.:
2
2
3
5
2
5
s
–1
3
2
6
4
1
(s ) = 0,
(2) = 2,
(3) = −1,
(4) = inf {7,1} = 1,
(5) = 2 + 3 = 5,
(6 ) = inf {5 + 2, 7 + 1, 1 + 1} = 2
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
170
85
Nachfolgender Algorithmus setzt voraus, dass Graph
topologisch sortiert ist, „also“ V = {1, 2, ... , n}.
Algorithmus:
d(s)
0;
Pfad(s) s;
(* Pfad als Liste repräsentiert *)
for all v ∈ V \ {s} do d(v)
∞ od;
for v = s + 1 to n do
d(v) min {d(u) + c(u,v) | (u,v) ∈ E}
(* u* sei hierbei ein optimaler u-Wert *)
Pfad(v) Pfad(u*) ° v
od
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
171
Satz:
Nach Ausführung von obigem Algorithmus gilt
∀v ∈ V
1) d (v ) = (v )
2) d (v ) < ∞ ⇒ Pfad(v) ist billigster Weg
von s nach v.
3) Algorithmus hat Laufzeit O( n + m), wobei
n = |V| und m = |E|.
Beweis:
Korrektheit ( 1) + 2) ): Induktion über v
v < s:
v = s:
(v ) = ∞, da v von s aus nicht erreichbar.
d (v ) = ∞, da nach Init. nicht mehr verändert
(v ) = d (v ) = 0. Pfad(s) = s ist einziger Weg.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
172
86
v > s: Sei In (v ) := { u ∈ V (u , v ) ∈ E }.
Nach Ind´vor. gilt für u ∈ In(v ) schon
d (u ) = (u ) und Pfad(u) ist berechnet.
Ist In (v ) = Ø, dann d (v ) =
(v ) = ∞.
Ist In (v ) ≠ Ø, so wähle u* mit
d (u *) + c(u*, v ) minimal.
Falls d(u*) = ∞ , so auch d (v ) = (v ) = ∞.
Sonst ergibt sich billigster Weg nach v
durch Konkatenation und
(v ) = (u *) + c(u*, v ) = (v ).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
173
Laufzeit:
Topologisches Sortieren kostet Zeit O( n + m ).
Initialisierung: O(n)
„Hauptteil“: Komplexität wird i.w. bestimmt durch
∑ In(v )
= m,
v∈V
also O( n + m ).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
174
87
2.Situation: Alle Kantenkosten nichtnegativ (d.h. ∀e ∈ E , c(e) ≥ 0 ),
Zykel erlaubt
Dijkstras Algorithmus:
Nachfolgend nur Kosten kürzester Pfad berechnet;
eigentliche Pfadberechnung analog vorher.
Idee:
Für Menge S von Knoten mit bereits bestimmtem kürzesten
Pfad muss es Knoten x ∈ V \ S geben, sodass kürzester Weg
von s nach x über die Knoten in S geht und dann noch eine
Kante aus S nach x.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
175
Genauer: x ist Knoten, der, für alle u ∈ S , den Ausdruck
(u ) + c(u, x ) minimiert.
Nachfolgend:
S := Menge der Knoten u mit bekanntem (u ).
S ′ := Menge der Knoten aus V \ S , die Nachbarn in S haben
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
176
88
Algorithmus:
S ← {s}; d (s ) ← 0;
S ′ ← OutAdj(s );
for all u ∈ S ′ do;
d ′(u ) ← c(s, u );
for all u ∈ V − (S ∪ S ′) do
d ′(u ) ← ∞;
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
177
while S ′ ≠ o/ do
x ← derjenige Knoten aus S ′ mit minimalem d ′ - Wert;
d ( x ) ← d ′( x );
S ← S ∪ {x};
S ′ ← S ′ \ {x};
for all u ∈ OutAdj( x ) do
if u ∉ S
then S ′ ← S ′ ∪ {u};
d ′(u ) ← min{d ′(u ), d ( x ) + c( x, u )}
fi
od
od
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
178
89
Beispiel (Ungerichteter Graph):
3
1
1
2
2
0
Vorlesung Algorithmen (RN/MK)
4
3
3
1
5
1
2
5
WSI für Informatik, Universität Tübingen
179
Lemma:
Sei x ∈ S ′ so gewählt, dass d ′( x ) minimal ist.
Dann gilt d ′( x ) = ( x ).
Beweis:
Sei p ein billigster Weg von s nach x derart, dass alle
Knoten (bis auf x) in S liegen.
Angenommen, es gäbe einen billigeren Weg q von s nach x.
q muss einen ersten Knoten v in V \ S haben und nach Wahl
von x ist d ′(v ) ≥ d ′( x ).
Da alle Kanten nichtnegativ sind, gilt aber
c(q ) ≥ d ′(v ) ≥ d ′( x ) = d ( x ) = c( p ),
ein Widerspruch.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
180
90
Zur Laufzeit:
Implementiere S und S ′ als Bitvektoren
und d und d ′ als Arrays.
•Aufwand für „ for all u ∈ OutAdj( x ) “:
∑ OutAdj( x ) = O(m + n ).
x∈V
•n-maliges Minimieren über S ′ : O(n² ).
Insgesamt ergibt sich Laufzeit O(n²+m),
für dichte Graphen (m ≈ n ² ) ausreichend.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
181
Alternativ:
Speichere S ′ in Heap (balancierter Baum), gemäß d ′-Werten
geordnet.
Damit Laufzeit O((m+n)log n),
da nun Einfügen und Löschen in S ′ je O(log n ) Zeit kostet.
Für dünne Graphen ist dies eine Verbesserung.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
182
91
Satz:
Mit Hilfe des Algorithmus von Dijkstra läßt sich das
Single Source Shortest Path Problem in Laufzeiten
O(n ² ) bzw. O((m + n ) log n ) lösen.
Mitteilung:
Mit Hilfe sogenannter Fibonacci-Heaps läßt sich die
Laufzeit des Algorithmus von Dijkstra asymptotisch
zu O(n log n + m) verbessern.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
183
3.Situation: Negative Kantenkosten erlaubt, aber keine
negativen Zykel.
Bellman-Ford-Algorithmus
Das „Entspannen einer Kante (v,w)“ bezeichnen wir mit
Relax ((v,w)):
d (w) ← min{d (w), d (v ) + c(v, w)}
Offensichtlich: Entspannen einer Kante erhöht keinen d-Wert
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
184
92
Lemma:
Falls für alle u ∈ V vor dem Entspannen einer beliebigen
Kante (v,w) gilt, dass d (u ) ≥ (u ), dann gilt dies auch
hinterher.
Beweis:
Jeder Weg von s nach v zusammen mit Kante (v,w)
ergibt Weg von s nach w.
Deshalb (v ) + c(v, w) ≥
(w).
Weiterhin : (v ) + c(v,w) ≤ d (v ) + c(v,w)
⇒ (w) ≤ d (v ) + c(v, w)
⇒ (w) ≤ d (w) falls (v,w) „echt“ relaxiert.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
185
Algorithmus:
d (s ) ← 0;
for all v ≠ s do
d (v ) ← ∞
while „möglich“ do
Entspanne Kanten
od
Beobachtung: d(u) wird immer kleiner, unterschreitet aber nie
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
(u ) .
186
93
Offen bleibt noch die Frage nach der „Entspannungs-Reihenfolge“,
sodass d schnell gegen konvergiert.
Lemma:
Sei w ∈ V und sei (w) < ∞ und sei (v, w) die letzte Kante auf
billigstem Weg von s nach w.
Dann gilt:
Falls (v,w) entspannt wird, nachdem d (v ) =
worden ist, so ist danach d (w) = (w).
(v ) ge-
Beweis: Übung!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
187
Algorithmus:
d (s ) ← 0;
for all v ≠ s do
d (v ) ← ∞;
for i ← 1 to n − 1 do
for all (v, w) ∈ E do
Relax ((v, w));
Lemma:
Für i=0,...,n-1 gilt:
Nach dem i-ten Durchlauf der for-Schleife ist d (w) = (w)
für alle w ∈V , für die es einen billigsten Pfad der Länge i
von s nach w gibt.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
188
94
Beweis:
Induktion über i:
i = 0 : d (s ) =
(s ), da es keine negativen Zykel gibt.
i → i +1:
Sei w der Knoten mit billigstem Weg von s nach w der
Länge i+1 und sei (v,w) die letzte Kante auf diesem Weg.
Also gibt es billigsten Weg von s nach v der Länge i und
nach Induktionsannahme ist nach dem i-ten Durchlauf
der for-Schleife d (v ) = (v ) . Im (i+1)-ten Durchlauf wird
insbesondere (v,w) entspannt:
⇒ d (w) = d (v ) + c((v, w))
= (v ) + c((v, w))
= (w)
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
189
Korollar:
Nach dem (n-1)-ten Schleifendurchlauf gilt für alle v aus V,
dass d (v ) = (v ).
Beweis:
Nach obigem Lemma und der Annahme der Nichtexistenz
negativer Zykel folgt, dass alle billigsten Wege Länge
höchstens n-1 haben.
Insgesamt:
Satz:
In Laufzeit O(n ⋅ m ) läßt sich das Single Source Shortest Path
Problem lösen, falls der Graph keine negativen Zykel enthält.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
190
95
4.Situation: Auch negative Zykel erlaubt.
Algorithmus:
1 Führe zuerst die n-1 for-Schleifendurchläufe des Algorithmus von Bellman-Ford aus und merke in d1 die so
erzielten d-Werte.
2 Führe n weitere for-Schleifendurchläufe aus und speichere
das Ergebnis in d2.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
191
Lemma:
Für w ∈ V gilt :
i) d 2 (w) = d1 (w) ⇒
(w ) = d1 (w)
ii) d 2 (w) < d1 (w) ⇒ (w ) = −∞
Beweis: Übung!
Bemerkung:
Wenn sich nach nur einem weiteren Durchlauf der
for-Schleife nach Abschluss von 1 noch etwas ändert, so
gibt es einen negativen Zykel, sonst aber nicht.
Um aber alle Zykel entdecken zu können, benötigt man
in 2 insgesamt n Durchläufe.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
192
96
All Pairs Shortest Paths
Annahme: Keine negativen Zykel.
V = {1,2,..., n}
Für i, j ∈ V und 0 ≤ k ≤ n definiere
k
(i, j ) := Kosten des billigsten Weges von i nach j,
dessen innere Knoten ≤ k sind.
Beispiel:
(1,4 ) = ∞
1 (1,4 ) = ∞
2 (1,4 ) = 6
3 (1, 4 ) = 1
4 (1,4 ) = 1
2
2
1
-3
Vorlesung Algorithmen (RN/MK)
4
5
3
WSI für Informatik, Universität Tübingen
193
c(i, j ), falls (i, j ) ∈ E.

, falls i = j.
0 (i, j ) =  0
 ∞ , sonst.

Also:
n
2
4
0
(i, j ) = (i, j ) = Kosten des billigsten Weges von i nach j.
Frage: Wie berechnet sich
k
aus
2 Möglichkeiten:
k-1
Also gilt:
k
(i, j )
(i, k )
(i, j ) = min{
Vorlesung Algorithmen (RN/MK)
?
Entweder k Teil eines billigeren
Weges oder nicht:
k-1
i
k-1
k −1
j
(k , j )
k
k-1
(i, j ),
k −1
(i, k ) +
k −1
(k , j )}
WSI für Informatik, Universität Tübingen
194
97
Algorithmus:
for all i, j ∈ V do
0
c(i, j ), falls (i, j ) ∈ E
(i, j ) ←  0 , falls i = j
 ∞ , sonst
;

for k = 1 to n do
for all i = 1 to n do
for all j = 1 to n do
(i, j ) ← min{
k
k −1
(i, j ), (i, k ) +
k −1
k −1
(k , j )}
od
od
od
Laufzeit: O(n³)
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
195
Alternativer Algorithmus:
Benutze Algorithmus von Dijkstra bzw. Bellman-Ford
Idee:
Führe n-mal für alle möglichen Startknoten Bellman-FordAlgorithmus aus.
Laufzeit : O(n ⋅ nm )
Beobachtung:
Es reicht sogar, einmal Bellman-Ford und (n-1)-mal
Dijkstra auszuführen.
Laufzeit : O(n ⋅ (n + m ) log n )
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
196
98
6.4 Depth First Search (Tiefensuche)
Durchmusterung von Graphen.
Wichtige Eigenschaften:
Mit DFS Graph systematisch von einem Knoten s aus zu
durchmustern, dabei immer zuerst „in die Tiefe“.
Beispiel:
s
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
197
Rekursion:
procedure DFS (s)
besucht [s]
true;
drucke (s);
for all (s, v ) ∈ E do
if not besucht [v]
then DFS(v)
fi;
od
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
198
99
DFS teilt die Kanten des Graphen in vier Klassen ein, je nach
Art des Besuchs:
Wir betrachten gerade die gerichtete Kante (v,w):
1. (v,w) gehört zu Baumkanten T, falls w noch nicht besucht.
2. (v,w) gehört zu Vorwärtskanten F, falls w schon besucht
*T w “, d.h. ∃ Pfad von v nach w bestehend aus
und „v 
→
lauter Baumkanten.
3. (v,w) gehört zu Rückwärtskanten B, falls w schon besucht
*T v.
→
und w 
4. (v,w) gehört zu Querkanten C, falls w schon besucht, aber
*T v.
*T w noch w 
→
weder v 
→
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
199
Erweiterung um dfsnum(v) und compnum(v):
• dfsnum(v): Reihenfolge der rekursiven DFS-Aufrufe.
• compnum(v): Abschlussreihenfolge der DFS-Aufrufe.
Hauptprogramm:
false od;
for all v ∈ V do besucht[v]
z1
z2
0;
(* T ← B ← F ← C ← o/ ;*)
for all v ∈ V do
if not besucht[v] then DFS(v) fi
od
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
200
10
0
Für die Implementierung brauchen wir 2 Zähler z1, z2:
(1) procedure DFS(v)
(2)
besucht [v]
true; z1
z1+1
(3)
dfsnum [v]
z1;
(4)
for all (v, w) ∈ E do
(5)
if not besucht [w] then DFS(w) (* T ← T ∪ {(v, w)}*)
(6)
(*
*T w then F ← F ∪ {(v, w)}
(7)
else if v 
→
*T v then B ← B ∪ {(v, w)}
→
(8)
else if w 
(9)
else C ← C ∪ {(v, w)}
(10)
fi
(11)
fi
(12)
*)fi
(13) od
(14) z 2 ← z 2 + 1;
(15) compnum[v]
z2
Vorlesung Algorithmen (RN/MK)
Beispiel:
WSI für Informatik, Universität Tübingen
i 9
201
d 4
b 2
f 6
s
a 1
c 3
e 5
g 7
h 8
Laufzeit:
da
O(n+m)
a) Einzellaufzeit eines Aufrufs (ohne Rekursion)
ist O(1+outdeg(v))
b) für jeden Knoten einmal DFS-Aufruf
⇒ O ∑ (1 + out deg(v ))  = O(n + m ).
 v∈V

Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
202
10
1
Lemma (Eigenschaften, Teil 1):
a) Kantenklassen T,B,F,C bilden Partition der Kantenmenge E
b) T entspricht dem Wald der rekursiven Aufrufe
*T w gdw. dfsnum[v ] ≤ dfsnum[w] und
c) v 
→
compnum[w] ≤ compnum[v ].
* z) ,
*T w, (w, z ) ∈ E und ¬ (v 
d) Seien v, w, z ∈ V mit v 
→
→
T
dann
i) dfsnum[z ] < dfsnum[v]
ii) (w, z ) ∈ B ∪ C
iii) compnum[z ] > compnum[v ] gdw. (w, z ) ∈ B.
iv) compnum[z ] < compnum[v ] gdw. (w,z ) ∈ C.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
203
Beweis: a), b) klar: direkt aus Algorithmus.
*T w ⇔ Aufruf DFS(w) geschachtelt in DFS(v)
→
c) v 
⇔ dfsnum[v] ≤ dfsnum[w] und
compnum[v ] ≥ compnum[w].
d)
*T w ⇒ dfsnum[v ] ≤ dfsnum[w]
v
→
(w, z ) ∈ E ⇒ DFS( z ) wird aufgerufen, bevor DFS(w)
endet, und auch bevor DFS(v) endet.
*T z ) ⇔ DFS( z ) nicht in DFS(v) geschachtelt
¬(v 
→
⇒ DFS( z ) startet vor Aufruf DFS(v ).
⇒ dfsnum[z ] < dfsnum[v]
(i)
e) ( Teil 2 )
→ (w, z ) ∈ B ∪ C
(ii)
*T w nach Definition von B
(w, z ) ∈ B ⇔ z →
* v da v 
*T w und ¬(v 
*T z )
→
→
⇔z
→
T
⇔ compnum[z ] > compnum[v ]
(iii)
(ii), (iii)
(iv)
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
204
10
2
Lemma (Eigenschaften, Teil 2):
Sei (v, w) ∈ E :
e) (v, w) ∈ T ∪ F ⇔ dfsnum[v ] ≤ dfsnum[w].
f) (v, w) ∈ B ⇔ dfsnum[w] < dfsnum[v ] und
compnum[w] > compnum[v ].
g) (v, w) ∈ C ⇔ dfsnum[w] < dfsnum[v ] und
compnum[w] < compnum[v ].
Vorlesung Algorithmen (RN/MK)
Beweis:
e)
WSI für Informatik, Universität Tübingen
205
*T w ⇒ dfsnum[v ] ≤ dfsnum[w]
(v, w) ∈ T ∪ F ⇒ v →
Sei dfsnum[v ] ≤ dfsnum[w].
Da (v, w) ∈ E , muss DFS(w) vor Abschluss von
DFS(v ) aufgerufen werden.
⇒ echte* Schachtelung
v
→
w
T
⇒
⇒ (v, w) ∈ T ∪ F
f), g) folgen aus d) und e) ...
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
206
10
3
Bemerkungen:
•T, B, F, C werden im wesentlichen durch dfsnum, compnum
festgelegt (vgl. Lemma!)
•In azyklischen Graphen gibt es keine Rückwärtskanten, d.h.
∀(v, w) ∈ E : compnum[v ] > compnum[w]
⇒ Nummerierung num(v ) := n + 1 − compnum[v]
ergibt topologische Sortierung.
Mitteilung:
Zusammenhangskomponenten in ungerichteten Graphen
können mit Hilfe von DFS in Zeit O(n+m) berechnet werden.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
207
Starke Zusammenhangskomponenten
Ein gerichteter Graph G=(V,E) heißt stark zusammen* w.
→
hängend gdw. ∀v, w ∈ V : v 
E
Die maximalen (bzgl. Mengeninklusion) stark zusammenhängenden Teilgraphen von G heißen starke Zusammenhangskomponenten (SZK‘s).
Beispiel:
a
c
b
K3
d
K1
h K4
e
K2
Vorlesung Algorithmen (RN/MK)
f
g
WSI für Informatik, Universität Tübingen
208
10
4
Idee für Algorithmus:
Erweitere DFS:
Sei G′ = (V ′, E ′) bisher erforschter Teilgraph von G.
Verwalte die SZK’s von G :
Starte mit V ′ = {a}, E ′ = o/ , SZK = {{a}}.
Sei (v,w) die nächste Kante in DFS. Dann ist v ∈ V ′.
Ist w ∉ V ′, d.h. (v, w) ∈ T , dann erweitere SZK um {w}.
Ist w ∈ V ′, dann füge mehrere SZK' s zu einer zusammen
(falls (v, w) ∈ B ∪ C )
Aber wie zusammenfügen?
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
209
Bezeichnungen:
•SZK K heißt abgeschlossen, wenn alle DFS-Aufrufe für Knoten
in K abgeschlossen sind.
•Wurzel von K ist der Knoten mit kleinster dfsnum in K.
•Folge von Knoten heißt unfertig, falls ihre DFS aufgerufen sind,
aber ihre SZK noch nicht abgeschlossen ist. (Sortiert nach dfsnum!)
•wurzeln ist Folge der Wurzeln von noch nicht abgeschlossenen
SZK´s. (Sortiert nach dfsnum!)
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
210
10
5
Beispiel:
a
c
b
d
h
e
f
unfertig:
wurzeln:
a
a
bc
b
e
e
g
f
f
g
g
Beobachtung:
*E g
→
1. ∀v ∈ unfertig : v 
2. ∃/(v, w) ∈ E : v in abgeschlossener und
w in nichtabgeschlossener Komponente.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
211
Von g ausgehende Kanten:
( g , d ) ∈ C : tut nichts, d liegt in abgeschlossener SZK.
( g , b ) ∈ B : vereinigt vier Komponenten {b, c}, {e}, { f }, {g}.
unfertig:
wurzeln:
a
a
bcefg
b
( g , h ) ∈ T : erzeuge neue Komponente {h}
Beim Abschluss von DFS(v) teste, ob v Wurzel.
Wenn ja, so gib Komponente mit v als Wurzel aus und streiche
sie aus unfertig und v aus wurzeln.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
212
10
6
Operationen auf unfertig und wurzeln erlauben Implementierung
als Keller (Stack):
z.B. Vereinigen von Komponenten:
K1
unfertig
K2
w
K3
K4
v
wurzeln
K2, K3 und K4 werden vereinigt durch pop(wurzeln)
bis top(wurzeln) = Wurzel der SZK von w.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
213
Korrektheit:
Invarianten:
I1:
∃/(v, w) ∈ E mit v in abgeschlossener und w in nichtabgeschlossener SZK.
I2:
Nichtabgeschlossene SZK´s liegen auf einem Pfad,
insbesondere ihre Wurzeln liegen auf einem
Baumpfad
I3:
Knoten jeder nichtabgeschlossenen Komponente Ki
bilden Intervall in „unfertig“, erstes Element des
Intervalls ist die Wurzel von Ki.
Zu zeigen:
Invarianten bleiben beim Einfügen neuer
Kanten (v, w) ∈ E erfüllt.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
214
10
7
1.Fall: (v, w) ∈ T :
push (w, unfertig); push (w, wurzeln)
I1:
Es wird keine SZK abgeschlossen.
I2:
Sei r Wurzel der Komponente von v.
*T v und (v, w) ∈ T
Dann r 
→
*T w
⇒ r
→
I3:
Trivial!
Vorlesung Algorithmen (RN/MK)
2.Fall: (v, w) ∈/ T :
a)
b)
WSI für Informatik, Universität Tübingen
215
w in abgeschlossener SZK: Tue nichts.
w in nichtabgeschlossener SZK: Vereinige
oberste SZK´s bis zu der, in der w liegt.
In a) passiert nichts. Nur b) zu betrachten:
I1:
Es wird keine SZK abgeschlossen...
I2:
Pfad wird verkürzt.
I3:
Löschen der obersten Wurzel vereinigt Intervalle zu
einem neuen. Da vorher I2 galt, bildet dieses eine
Intervall eine einzige Komponente.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
216
10
8
Vermöge nachfolgendem Algorithmus (Programm) erhalten wir:
Satz:
Starke Zusammenhangskomponenten eines gerichteten
Graphen können in Zeit O(n+m) berechnet werden.
Das Hauptprogramm wird erweitert um:
unfertig
wurzeln
leerer Keller
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
217
(1) procedure DFS(v)
(2) besucht[v]
true; z1
z1+1; dfsnum[v]
z1;
(3) push(v, unfertig); push(v, wurzeln);
(4) for all (v, w ) ∈ E do
(5)
if not besucht[w] then DFS(w)
(6)
else if w ∈ unfertig
(7)
then while dfsnum[top(wurzeln )] > dfsnum[w] do
(8)
pop(wurzeln) od ;
(9)
fi
(10)
fi
(11) od
(12) z2
z2+1; compnum[v]
z2
(13) if v = top(wurzeln)
(14)
then repeat w
pop(unfertig)
(15)
print(w)
(16)
until v = w ;
(17)
pop(wurzeln) ;
(18) fi
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
218
10
9
Zeilen (13)-(16) : Ausgabe der SZK mit Wurzel v.
Bemerkungen:
•
Test „w ∈ unfertig“ wird mit zusätzlichem boole‘schem Feld
in_unfertig unterstützt.
•
Jeder Knoten wird höchstens einmal nach unfertig bzw.
wurzeln aufgenommen.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
219
6.5 Minimal aufspannende Bäume (MST)
Sei G(V,E) ein zusammenhängender, ungerichteter Graph.
Sei c:E → R+ eine Kostenfunktion.
Ziel: Berechne ET ⊆ E, sodass G(V,ET) zusammenhängend ist
und c( ET ) := ∑ c(e ) kleinstmöglich ist.
e∈ET
Beispiel:
10
3
1
4
2
3
2
6
2
8
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
220
11
0
Anwendungsbeispiele:
• Computer-Netzwerke...
• Elektronische Schaltkreise...
• Netz von Telefonanschlüssen...
uvm.
Lemma:
G(V,ET) ist azyklisch.
Beweis:
Würde G(V,ET) einen Kreis enthalten, so könnte man
eine Kante entfernen, der Graph wäre weiterhin zusammenhängend und die Gesamtkosten geringer.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
221
Wir suchen also einen „aufspannenden Baum“ mit minimalen
Kosten (MST, Minimum Spanning Tree).
Kruskals Greedy-Algorithmus für MST
Sortiere Kanten e1, e2, ... , em so, dass
c(e1 ) ≤ c(e2 ) ≤ ... ≤ c(em );
ET ← o/ ;
for i ← 1 to m do
if (V , ET ∪ {ei }) azyklisch
then ET ← ET ∪ {ei }
fi
od
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
222
11
1
Satz:
Der Greedy-Algorithmus von Kruskal ist korrekt, d.h.
er findet immer einen MST.
Beweis:
Eine Kantenmenge E ′ ⊆ E heiße „gut“, falls sie zu
einem MST erweiterbar ist.
Behauptung:
Sei E ′ ⊆ E gut und sei e ∈ E \ E ′ eine billigste Kante,
sodass der Graph (V , E ′ ∪ {e}) azyklisch ist.
Dann ist auch E ′ ∪ {e} gut.
Beweis der Behauptung per Induktion:
Sei T1 = (V , E1 ) ein MST mit E ′ ⊆ E1
(T1 existiert, da E ′ gut ).
Ist e ∈ E1 , so fertig.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
223
Ist e ∉ E1, so betrachte Graph H = (V , E1 ∪ {e}).
H enthält einen Kreis, auf dem e liegt. Da (V , E ′ ∪ {e}) azyklisch
ist, enthält dieser Kreis auch eine Kante aus E1 \ ( E ′ ∪ {e}).
Sei eine solche Kante e1.
Betrachte T2 = (V , ( E1 \ {e1}) ∪ {e}).
T2 ist aufspannend und c(T2 ) = c(T1 ) + c(e ) − c(e1 ).
Da e eine billigste Kante war, gilt c(e ) ≤ c(e1 ).
Also c(T2 ) ≤ c(T1 ).
Da nach Voraussetzung T1 ein MST ist, gilt c(T2 ) = c(T1 ).
D.h. T2 auch ein MST, also E ′ ∪ {e} gut.
Mit der Behauptung folgt die Korrektheit von Kruskals
Algorithmus unmittelbar.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
224
11
2
Beispielbild:
T1 : E1
e1
e
T2 : ( E1 \ {e1}) ∪ {e}
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
225
Zur Implementierung:
Wir halten uns eine Partition V1 ∪ V2 ∪ ... ∪ Vk = V
von V : ∀i ≠ j : Vi ∩ V j = o/ und ∀i : Vi ≠ o/ .
Operationen:
Starten mit Partition {{1}, {2}, ... , {n}}.
Benötigen:
•Find(x):
•Union(a,b):
Vorlesung Algorithmen (RN/MK)
Gibt Namen der Menge zurück,
die x enthält.
Vereinigt die Mengen a und b.
WSI für Informatik, Universität Tübingen
226
11
3
Damit wir d die for-Schleife in Kruskals Algorithmus zu:
for i ← 1 to m do
sei ei = {u , v};
a ← Find (u );
b ← Find(v );
if a ≠ b
then ET ← ET ∪ {ei };
Union(a,b)
fi
od
Bemerkung:
Auf diese Weise lassen sich i.w. auch die Zusammenhangskomponenten eines Graphen berechnen.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
227
Zur Realisierung der Union-Find-Datenstruktur:
Erste naheliegende Idee:
Realisierung als Feld R[1 .. n], wobei R[x] Name der
Menge sein soll, die x enthält.
Damit:
Find(x):
return R[x]
Union(a,b): for i ← 1 to n do
if R[i ] = a then R[i ] ← b fi
od
Laufzeit:
Find(x):
Union(a,b):
O(1)
O(n)
Algorithmus von Kruskal:
2m Find-Operationen und n-1 Union-Operationen.
Laufzeit Kruskal: O(m+n²+m log m)
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
228
11
4
Heuristische Ideen zur Verbesserung:
•Union sollte nicht alle Elemente anschauen...
Verwalte Elemente jeder Menge separat...
•Behalte bei Union immer die Namen der größeren
Mengen.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
229
Also zusätzlich Verwaltung der Mengen als Listen
(samt Größenangabe):
Bild:
Size Elem.
1
2 2
3 5
4 1
R:
Vorlesung Algorithmen (RN/MK)
wie vorher
WSI für Informatik, Universität Tübingen
230
11
5
Damit folgende Implementierung:
Initialisierung:
Find(x):
Union(a,b):
for x ← 1 to n do
R[x] ← x;
Elem[x ] ← {x};
size[x ] ← 1;
od
return R[x]
if size[a] < size[b] then „vertausche“ a und b fi;
for all x ∈ Elem[b] do
R[ x ] ← a ;
insert(x, Elem[a])
od;
size[a ] ← size[a ] + size[b]
Beachte: Im Worst Case kann ein Union aber dennoch
Zeit O(n) benötigen.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
231
Satz:
Mit obiger Implementierung lassen sich die Initialisierungen
sowie n-1 Union-Operationen und m Find-Operationen in
Laufzeit O(n ⋅ log n + m ) realisieren.
Beweis:
Initialisierungen:
O(n), klar!
m Find-Operationen: O(m), klar!
n Union-Operationen kosten Zeit O(n log n):
Union(a,b): Vereinige zwei Mengen mit na bzw. nb Elementen;
o.E. sei nb ≤ na ⇒ Laufzeit O(1 + nb ).
Sei ni für i-tes Union die Größe der kleineren Menge. Damit
n −1
Zeit für alle Union-Operationen:  n −1
O ∑ (ni + 1) = O n + ∑ ni .
 i =1



i =1
Immer wenn
ein
Element
die
Menge
wechselt,
trägt
es
n −1
genau 1 zu ∑ ni bei.
i =1
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
232
11
6
n −1
n
i =1
j =1
Also ∑ ni = ∑ r j , wobei r j angibt, wie oft Element j die
Menge wechselt.
Behauptung: rj ≤ log 2 n für alle j = 1, 2, ... , n.
Beweis der Behauptung:
Wenn j die Menge wechselt und vorher in einer Menge
mit l Elementen war, so ist j nachher in einer Menge mit
mindestens 2l Elementen.
D.h. nach dem k-ten Wechsel ist j in einer Menge
mit ≥ 2 k Elementen.
Da es nur n Elemente gibt, folgt k ≤ log 2 n.
Mit Hilfe der Behauptung folgt somit, dass n Union-Operationen
Zeit O(n log n) kosten.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
233
Korollar:
Der Algorithmus von Kruskal hat Laufzeit O(m ⋅ log m ) .
Bemerkung:
Obiges ist ein Beispiel für amortisierte Analyse:
Wir betrachten statt Einzeloperationen, welche verschieden
teuer sind, eine Folge von Operationen und stellen fest,
wieviel diese zusammen kosten.
Anderes Beispiel für amortisierte Analyse:
Binärzähler:
Vorlesung Algorithmen (RN/MK)
Nicht trivial n log n, sondern
2n amortisiert...
WSI für Informatik, Universität Tübingen
234
11
7
Alternative zur vorigen Implementierung:
Idee: Repräsentiere jede Menge durch einen Baum
(i.a. nicht binär):
Jeder Knoten (außer Wurzel) zeigt auf Elternknoten,
Wurzel enthält Namen der Menge.
R[x]
x
Damit:
Union(a,b): „Zusammenhängen“ von Bäumen.
a
b
Zeit: O(1)
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
235
Find(x):
Folge dem Pfad von x zur Wurzel.
Zeit: O(1+Tiefe(x)).
Ideal wäre also Baumtiefe 1...
Im Worst Case können n Union-Operationen aber zu Tiefe
n-1 führen.
Deshalb: „Gewichtete Vereinigungsregel“:
Hänge immer den kleineren an den größeren Baum
(Baumgröße = Anzahl der Knoten).
Weitere Idee: Pfadkomprimierung
Wenn bei Find der Pfad zur Wurzel zurückverfolgt wird,
so hänge alle Zeiger des Pfades zur Wurzel hin um:
Bild:
x
Vorlesung Algorithmen (RN/MK)
x
WSI für Informatik, Universität Tübingen
236
11
8
Mitteilung:
Mit gewichteter Verzweigungsregel und Pfadkomprimierung
lassen sich die Initialisierungen sowie n-1 Union-Operationen
und m Find-Operationen in Laufzeit O(n + m ⋅ (m + n,n ))
realisieren, wobei die Inverse der Ackermannfunktion ist.
wächst extrem langsam und ist für alle realistischen
Werte ≤ 5.
Der Beweis obiger Mitteilung ist ziemlich kompliziert.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
237
7. Mustersuche in Zeichenketten
Zeichenkette (String) T ist endliche Folge von Symbolen
aus endlichem Alphabet Σ .
Besteht T aus n Symbolen, so werden diese in
T[1], T[2], ..., T[n] gespeichert.
T[i..j], 1 ≤ i ≤ j ≤ n ist das an der Position i beginnende
und an der Position j endende Teilwort von T.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
238
11
9
Grundlegendes Problem:
Gegeben: Zwei Zeichenketten P[1..m] und T[1..n] mit m ≤ n.
Frage: Kommt P als Teilwort in T vor?
Naiver Algorithmus:
for i = 1 to n – m + 1 do
überprüfe, ob P = T[i..i+m–1]
od
Laufzeit im Worst Case O(m·n).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
239
7.1 Der Algorithmus von Knuth-Morris-Pratt
Naiver Algorithmus verschwendet gewissermaßen Information:
Merkt sich nicht, welche Zeichen in T bereits mit Anfangsstück
von P übereingestimmt haben, bis „Mismatch“ auftrat:
Vergleichszeiger
Situation: (naiverAlg.)
T
···
P
a
b
a
a
b
a
a
b
a
b
a
a
a ···
Mismatch
Nächster Schleifendurchlauf: Verschiebung des
Vergleichsfensters um eins nach rechts:
T
P
···
a
b
a
a
b
a
a
a
b
a
b
a
a
Vorlesung Algorithmen (RN/MK)
wurde
zurückgesetzt
b ···
WSI für Informatik, Universität Tübingen
240
12
0
Im Gegensatz dazu speichert der Alg. von KMP besagte
Information – einerseits, um Verschiebung der Muster nach
rechts zu vergrößern und andererseits, um Vergleichszeiger
nicht „zurückzusetzen“.
Die Präfixfunktion eines Musters
Zentral für den KMP-Algorithmus:
Angenommen, P[1..q] = T[s+1..s+q], q < m.
Was ist das kleinste s´ > s, sodass
P[1..k] = T[s´+1..s´+k], wobei s´+k = s+q ?
Für solches s´ stimmen die ersten k Zeichen von P mit den
entsprechenden Zeichen in T überein.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
241
Beispiel:
T
b
a
c
b
s=4
a
b
a
b
a
a
b
a
b
a
b
a
c
a
a
b
a
Mismatch
q=5
Hier: s´ = 6
c
b
a
b
a
c
a
(s´= 5 (= s+1) führt notwendig sofort zu Mismatch!)
Zur Beantwortung obiger Frage notwendige Information
kann vorausberechnet werden, indem Muster P
„mit sich selbst verglichen“ wird!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
242
12
1
Def.:
Gegeben sei Muster P[1..m]. Dann
Präfixfunktion π : {1, ... , m}
{0, ... , m – 1}
für P definiert vermöge
(q ): = max
{k
0≤ k < q
P[1..k ] ist Suffix von P[1..q ] }
d.h. ∃ P´∈ Σ q −k : P[1..q ] = P´o P[1..k ]
Beispiel: P = a
i= 1
π(i) = 0
b
2
0
a
3
1
b
4
2
z.B. Berechnung von P[4]:
P[1..q] = a b a b
Test k = 3: P[1..3] = a b a
Test k = 2: P[1..2] = a b
Vorlesung Algorithmen (RN/MK)
a
5
3
b
6
4
a
7
5
b
8
6
c
9
0
a
10
1
kein Suffix!
Suffix!
WSI für Informatik, Universität Tübingen
243
KMP-Matcher(T, P)
(1) n
Länge von T; m Länge von P;
(2) π
Berechne_Präfixfunktion(P);
(3) q
0;
(4) for i 1 to n do
(5)
while q > 0 and P[q+1] ≠ T[i] do
(6)
q
π[q]
(7)
od;
(8)
if P[q+1] = T[i]
(9)
then q
q + 1;
(10)
fi
(11)
if q = m
(12)
then Ausgabe „Muster kommt ab Stelle i–m+1 vor“
(13)
q
π[q]
(14)
fi
(15) od
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
244
12
2
Berechne_Präfixfunktion(P)
(1) m Länge von P;
(2) π[1] 0;
(3) k 0;
2 to m do
(4) for q
(5)
while k > 0 and P[k+1] ≠ P[q]
(6)
do k π[k]
(7)
od;
(8)
if P[k+1] = P[q]
(9)
then k k+1
(10)
fi;
(11)
π[q] k
(12) od
(13) return π
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
245
Zeitkomplexität:
Laufzeit von Berechne_Präfixfunktion(P):
Betrachte k. while-Schleife (5) - (7) nur ausgeführt, falls k > 0.
Beginnen mit k = 0 (3) und in jedem Durchlauf der
for-Schleife wird k um maximal 1 erhöht.
Andererseits in jedem Durchlauf der while-Schleife k um
mindestens 1 erniedrigt, denn π[k] < k ∀ k!
D.h., „amortisiert“ betrachtet Kosten pro einem
for-Schleifendurchlauf O(1).
Damit Laufzeit von Berechne_Präfixfunktion(P) O(m).
Gesamtlaufzeit von KMP-Matcher: O(m+n)
O(m) für Berechne_Präfixfunktion(P)
und
O(n) für Rest: Analyse analog zu
Berechne_Präfixfunktion(P) mit q anstelle von k ...
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
246
12
3
Korrektheit von Berechne_Präfixfunktion(P):
Lemma 1:
Sei π*(q) := {q, π(q), π(π(q)), ... }.
Dann gilt für q = 1, 2, ..., m , dass
π*(q) = { k | P[1..k] ist Suffix von P[1..q] }.
Beweis:
" ⊆" : i ∈ * (q )
⇒ i = j (q ) für ein j.
Beweis per Induktion über j:
Ind´anfang: j = 0 ⇒ i = q und Beh. folgt, da P[1..q] Suffix
von sich selbst ist.
Ind´beh. folgt aus der Tatsache, dass P[1.. π(i)] Suffix
von P[1..i] und der Transitivität der Suffixrelation.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
247
"⊇" : Widerspruchsbeweis:
Ann.: ∃ j ∈ { k P[1..k ] ist Suffix von P[1..q ] } \ * (q ) .
OE sei j maximal. Es muss j < q gelten, da q in beiden
Mengen ist.
Sei j´ kleinste Zahl in π*(q), die größer als j ist.
P[1..j] ist Suffix von P[1..q]
P[1..j´] ist Suffix von P[1..q]
1444442444443
⇒ P[1..j] ist Suffix von P[1..j´] und j ist maximal unter
Zahlen mit dieser Eigenschaft.
⇒ π(j´) = j und damit j ∈ π * (q )
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
248
12
4
Klar: Berechne_Präfixfunktion(P) korrekt für π(1) = 0
(siehe Zeile (2) ).
Lemma 2:
∀ q = 1, 2 , ..., m:
(q ) > 0 ⇒ (q ) − 1∈ * (q − 1) .
Beweis:
Falls k = π(q) > 0, so ist P[1..k] Suffix von P[1..q].
D.h. auch, dass P[1..k–1] Suffix von P[1..q–1] ist.
Mit Lemma 1 folgt k − 1 ∈ * (q − 1) .
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
249
Definiere für q = 2, ... , m
Eq −1 := { k k ∈ * (q − 1) und P[k + 1] = P[q ] }
Lemma 3:
∀ q = 2 , ..., m:
0 ,
(q ) = 
1 + max
Vorlesung Algorithmen (RN/MK)
falls Eq-1 = o/
{k ∈ E },
q −1
sonst .
WSI für Informatik, Universität Tübingen
250
12
5
Beweis:
(q > 0 ) :
(q ), d.h. P[1..r ] ist Suffix von P[1..q ]
und mit r ≥ 1 folgt P[r ] = P[q ].
Sei r =
Lemma 2
⇒ r = 1 + max{k ∈ * (q - 1) P[k + 1] = P[q ]}
1444442444443
=E
q −1
Falls r = 0, so ex. kein k ∈ (q − 1) für welches P[1..k ]
auf P[1..k + 1] ausgeweitet werden kann, sodass ein Suffix
von P[1..q ] entsteht (sonst wäre (q) > 0).
Also Eq −1 = o/ .
*
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
251
Korrektheit von Berechne-Präfixfunktion (P) nun wie folgt:
Zu Beginn der for-Schleife in Zeilen (4)-(12)
gilt immer k = [q − 1] :
Betreten der Schleife: Zeilen (2) und (3)
Weitere Durchläufe: Zeile (11)
Zeilen (5)-(10) passen k so an, dass es der korrekte Wert
von [q ] wird:
while-Schleife in Zeilen (5)-(7) sucht durch alle Werte mit
k ∈ * [q − 1] bis einer gefunden wird mit P[k + 1] = P[q ] ;
dann ist k maximaler Wert in Menge Eq −1 und dank Lemma 3
können wir [q ] den Wert k + 1 zuweisen.
Falls kein solches k gefunden; sprich k=0,
so wird [q ] auf 0 gesetzt.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
252
12
6
Mitteilung:
Mit wenig Mehraufwand und i.w. analog zur Korrektheit
von Berechne_Präfixfunktion(P) folgt schließlich die
Korrektheit von KMP Matcher(T,P).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
253
7.2 Der Algorithmus von Boyer-Moore
Für Anwendungen in der Praxis ist meist der Algorithmus
von Boyer-Moore (bzw. Variationen davon) erste Wahl.
Er ist besonders vorteilhaft bei großen Alphabeten
und relativ langen Mustern.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
254
12
7
Naiver Matcher (T , P, ∑ )
(1) n ← Länge von T ; m ← Länge von P;
(2)
(3)
(4) s ← 0
(5) while s ≤ n − m do
j ← m;
(6)
(7)
while j > 0 and P[ j ] = T [s + j ] do
(8)
j ← j −1
(9)
od
(10)
if j = 0
(11)
then Ausgabe „Muster kommt ab Stelle s+1 vor“;
(12)
s ← s +1
(13)
else s ← s + 1
(14)
fi
(15) od
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
255
Boyer-Moore-Matcher (T , P, ∑ )
(1) n ← Länge von T ; m ← Länge von P;
(2) ← Berechne_Letztes _Vorkommen ( P, m, ∑ );
(3) ← Berechne_Gutes_Suffix ( P, m );
(4) s ← 0
(5) while s ≤ n − m do
j ← m;
(6)
(7)
while j > 0 and P[ j ] = T [s + j ] do
(8)
j ← j −1
(9)
od
(10)
if j = 0
(11)
then Ausgabe „Muster kommt ab Stelle s+1 vor“;
(12)
s ← s + 1 s ← s + [0]
(13)
else s ← s + 1 s ← s + max( [ j ], j − [T [s + j ]])
(14)
fi
(15) od
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
256
12
8
Die wesentlichen Eigenschaften des Algorithmus von
Boyer-Moore sind
der Vergleich des Musters selbst gegen ein Textstück
von rechts nach links
und die Benutzung zweier, unabhängig voneinander
arbeitender Heuristiken „schlechter Buchstabe“ und
„gutes Suffix“.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
257
Die Heuristik „schlechter Buchstabe“
Angenommen, es kommt beim zeichenweisen Vergleich
zum Mismatch P[ j ] ≠ T [s + j ] für ein j , 1 ≤ j ≤ m.
Definiere
max {i T [s + j ] = P[i ]}, falls T [s + j ] in P vorkommt.
k :=  1≤i≤ m
0
, sonst.
Lemma: s kann gemäß der Heuristik „schlechter Buchstabe“
um j-k erhöht werden.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
258
12
9
Beweis:
Fall 1: k=0:
D.h., T [s + j ] kommt nicht in P vor und so kann P
gegenüber T oE um j nach rechts verschoben werden.
Bild/Beispiel:
T:
1
2
3
4
5
6
7
8
9
10
11
a
b
r
d
l
a
d
a
b
r
a
a
b
j=2
a
d
a
b
a
d
s=3
P:
Verschiebung um j=2:
Extremfall: T = b n , P = a m
⇒ k = 0 und j = m in allen Fällen, also maximale
Verschiebung möglich!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
259
Fall 2: k < j :
D.h., T [s + j ] kommt in P links von der Stelle j vor und j − k > 0.
Ohne Verlust kann um j − k verschoben werden.
Bild/Beispiel:
T:
P:
1
2
3
4
5
6
7
8
9
10
11
a
b
r
d
l
a
d
a
b
r
a
a
d
k=2
s=1 a l a d
j=4 (=m)
j-k=2
a
l
Verschiebung um j-k = 4-2 = 2
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
260
13
0
Fall 3: k >j:
D.h. T[s+j] kommt in P rechts von der Stelle j vor
und j-k < 0.
Heuristik schlägt Verschiebung des Vergleichsfensters
nach links vor, d.h. Verkleinerung von s.
Boyer-Moore-Algorithmus umgeht diese Problematik
dadurch, dass zweite Heuristik „gutes Suffix“ immer
Verschiebung nach rechts vorschlägt und der
BM-Algorithmus immer die maximale Verschiebung
nach rechts wählt (vgl. auch Zeile (13) im Algorithmus).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
261
Bild/Beispiel:
T:
P:
a
b
r
a l l
k=4 (=m)
s=2
a
l a
j=3
d
a
b
r
a
l
Negative Verschiebung um j-k = -1:
a
l
a
l
Sei [a ] die am weitesten rechte Position in P, an der a ∈ Σ
in P vorkommt (also insbesondere a = P[ [a ]] ).
Falls a nicht in P vorkommt, so setze [a ] := 0.
heißt „Letztes_Vorkommen_Funktion“ und wird durch folgenden
Algorithmus bestimmt:
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
262
13
1
Berechne_letztes_Vorkommen ( P, m, Σ ) :
for „alle a ∈ Σ “ do
[a ] ← 0;
od;
for j ← 1 to m do
[P[ j ]] ← j;
od;
return
Laufzeit: O( Σ + m )
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
263
Die Heuristik „gutes Suffix“:
T:
a
b
P:
r
a
l
a
d
a
d
b
a
d
a
b
r
a
d
a
„gutes Suffix“
Verschiebung, bis ad
wieder auftritt:
3
a
d
b
Seien Q und R Zeichenketten: Q heißt ähnlich zu R
(in Zeichen Q ~ R), falls Q Suffix von R oder R Suffix von Q ist.
Heuristik „gutes Suffix“ besagt, dass wir, falls P[ j ] ≠ T [s + j ]
(j < m), oE das Vergleichsfenster um
[ j ] := m − 0max
{k P[ j + 1..m] ~ P[1..k ]}
≤k <m
nach rechts schieben können
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
264
13
2
ist die Gutes_Suffix_Funktion
Zur Berechnung von :
Beobachtung 1:
[ j ] ≤ m − [m]
Damit Umschreiben der Definition von
[ j] = m −
Vorlesung Algorithmen (RN/MK)
[ j]:
max {k P[ j + 1..m] ~ P[1..k ]}
( m )≤ k < m
WSI für Informatik, Universität Tübingen
265
Beobachtung 2: Falls P[1..k ] Suffix von P[ j + 1..m] ist,
dann ist es auch Suffix von P[1..m ] und deshalb
k ≤ [m] gemäß Definition von .
Damit weiteres Umschreiben der Definition von
[ j] = m −
max
( m )≤ k < m
[ j] :
({ [m]} ∪ {k P[ j + 1..m] ist Suffix von P[1..k ]})
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
266
13
3
Zur weiteren Vereinfachung von :
s
Sei P′ := P ( P revertiert), und ′ die Präfixfunktion von P′.
Sei weiter k maximal unter allen Worten mit der Eigenschaft, dass P[ j + 1..m] Suffix von P[1..k ] ist.
Lemma:
π′[l ] = m − j , wobei l = (m − k ) + (m − j ).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
267
Beweis:
P′[1..m − j ] ist Suffix von P′[1..l ] , also π′[l ] ≥ m − j.
Widerspruchsannahme: π′[l ] > m − j
Def . π′
⇒ P′[1..π′[l ]] ist Suffix von P′[1..l ],
d.h. P′[1..π′[l ]] = P′[l − π′[l ] + 1..l ],
d.h. P[m − π′[l ] + 1..m] = P[m − l + 1..m − l + π′[l ]].
Einsetzen von l = 2m − k − j ergibt :
P[m − π′[l ] + 1..m] = P[k − m + j + 1..k − m + j + π′[l ]]
⇒ P[m − π′[l ] + 1..m] ist Suffix von P[1..k − m + j + π′[l ]].
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
268
13
4
Nun gilt:
m − π′[l ] + 1 < m − (m − j ) + 1 = j + 1
und damit ist P[ j + 1..m] Suffix von P[1..k − m + j + π′[l ]]
=: k ′
Schließlich gilt wegen π′[l ] > m − j auch k ′ > k , wobei
k ′ := k − m + j + π′[l ].
zur Maximalität von k
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
269
Mit Hilfe des Lemmas und der Tatsache, dass
aus π′[l ] = m − j folgt,
dass j = m − π ′[l ] und k = m − l + π ′[l ],
können wir die Definition von ein letztes Mal umschreiben:
[ j ] = m − max
({ [m]} ∪ {m − l + π′[l ]
1≤ l ≤ m
j = m − π′[l ]})
= min ({m − π[m]} ∪ {l − π′[l ] j = m − π′[l ]})
1≤ l ≤ m
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
270
13
5
Damit:
Berechne_Gutes_Suffix (P,m):
π ← Berechne_Präfixfunktion( P);
P′ ← Revertiere ( P);
π′ ← Berechne_Präfixfunktion ( P′);
for j ← 0 to m do
γ[ j ] ← m − π[m]
od;
for l ← 1 to m do
j ← m − π′[l ] ;
if γ[ j ] > l − π′[l ]
then γ[ j ] ← l − π′[l ]
fi
od;
return
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
Laufzeit Berechne_Gutes_Suffix:
271
O(m)
Gesamte Laufzeit Boyer-Moore:
(Worst Case)
Vorlesung Algorithmen (RN/MK)
O((n − m )m + Σ )
WSI für Informatik, Universität Tübingen
272
13
6
7.3 Der Algorithmus von Karp-Rabin
Vereinfachende Annahme: Σ = {0,1,...,9}
Verallgemeinerung auf beliebige Alphabete leicht zu tun.
Definiere folgende „Fingerabdrucksfunktion“ für eine Primzahl:
Fp : Z → Z +p , Fp ( x ) = x (mod p ).
Zur Vereinfachung sucht folgender Algorithmus nur nach dem
ersten Auftreten von P in T.
Er interpretiert Zeichenketten als natürliche Zahlen.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
273
Der Algorithmus von Karp-Rabin:
Karp_Rabin_Matcher (T,P)
p
zufällige Primzahl zwischen 1 und mn 2 log (mn 2 ) ;
match false;
s
0;
while match=false and s ≤ n − m do
if Fp (T [s + 1 .. s + m]) = Fp ( P )
then match
true
else Berechne Fp (T [s + 2 .. s + m + 1])
aus Fp (T [s + 1 .. s + m]) ;
s
s+1
fi;
od;
return match
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
274
13
7
Entscheidend für die Effizienz des Algorithmus:
Fp (T [s + 2 .. s + m + 1]) läßt sich einfach und schnell aus
Fp (T [s + 1 .. s + m]) berechnen :
Fp (T [s + 2 .. s + m + 1]) =
(10 ⋅ (F (T [s + 1 .. s + m]) − 10
m −1
p
T [s + 1]) + T [s + m + 1])(mod p )
Fp (T [s + 2 .. s + m + 1]) kann also mit konstant vielen arithmetischen
Operationen modulo p aus Fp (T [s + 1 .. s + m]) berechnet werden,
falls 10 m−1 (mod p ) schon einmalig vorausberechnet wurde.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
275
Beispiel:
T=
0
2
3
1
4
P=
3
1
4
1
5
1
5
2
6
7
3
9
9
2
Primzahl p = 13
⇒ F13 ( P ) = 7
F13 (T [1 .. 5]) = F13 (0 2 3 1 4 ) = 0
F13 (T [2 .. 6]) = F13 (2 3 1 4 1) = 1
F13 (T [3 .. 7 ]) = F13 (3 1 4 1 5) = 7
Match!
F13 (T [9 .. 13]) = F13 (6 7 3 9 9 ) = 7
Mismatch!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
276
13
8
Mitteilung:
Der Karp-Rabin-Algorithmus benötigt O(n+m) Schritte
1
und hat Fehlerwahrscheinlichkeit O .
n
Im Gegensatz zu anderen Algorithmen läßt sich der Karp-RabinAlgorithmus leicht auf zweidimensionale Mustersuche
verallgemeinern und ist auch für „Online-(Realzeit)-Eingabe“
geeignet.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
277
7.4 Suffixbäume:
Definition:
Ein Suffixbaum T für eine Zeichenkette S mit S = n ist ein
Baum mit Wurzel mit n Blättern, nummeriert von 1 bis n:
•
•
•
Jeder interne, von der Wurzel verschiedene Knoten hat
mindestens zwei Kinder und jede Kante in T ist mit einem
nichtleeren Teilwort von S beschriftet.
Keine zwei Kanten, die einen Knoten verlassen, können Beschriftungen haben, die mit demselben Buchstaben
beginnen.
Für jedes Blatt i (1 ≤ i ≤ n ) gilt, dass die Konkatenation
der Kantenbeschriftungen auf dem Pfad der Wurzel zu i
genau das Suffix S [i .. n] von S ergibt.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
278
13
9
Um zu gewährleisten, dass Suffixbaum für eine Zeichenkette S
immer existiert, nehmen wir an, dass S [n] = $, wobei $ ein
Sonderzeichen, das nirgends sonst in S vorkommt.
Beispiel:
S=aabbabb$
$
a
bb
abbabb$
1
b
abb$
2
Vorlesung Algorithmen (RN/MK)
8
abb$
$
5
$
b
4 abb$
$
7
3
WSI für Informatik, Universität Tübingen
279
Eine erste Anwendung:
Lösung des grundlegenden Problems „Mustersuche in
Zeichenketten“ mittels Suffixbäumen:
Gegeben Suffixbaum T für Text S und ein Muster P. Gehe in T entlang des durch P eindeutig bestimmten Pfades, bis P entweder
„erschöpft“ ist oder bis keine Übereinstimmung mehr möglich ist.
Im ersten Fall repräsentiert jedes Blatt im zugehörigen Unterbaum
die Anfangsposition eines Vorkommens von P in S.
Im zweiten Fall kommt P nicht in S vor.
Beispiel (Fortsetzung):
P = ab , S = aabbabb$
P kommt in S ab den Positionen 2 und 5 vor.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
280
14
0
Es gilt:
Kommt P k-mal in S vor, so ist die Zeit zur Bestimmung
aller Vorkommen von P in S (bei gegebenem
Suffixbaum) O(m+k).
Denn:
Mache Tiefensuche auf betreffendem Unterbaum und
notiere die vorkommenden Blattnummern.
Da jeder innere Knoten mindestens zwei Kinder hat, ist die
Zahl der vorkommenden Blätter proportional zur Zahl der
traversierten Kanten und somit ist die Laufzeit der
Tiefensuche O(k).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
281
Ein naiver Algorithmus zum Aufbau von Suffixbäumen:
Idee:
Beginne mit einzelner Kante für das Suffix S [1 .. n].
Mit i=2 beginnend, füge sukkzessiv Suffixe S [i .. n ] hinzu.
Genauer:
Sei Ni der Baum, der nach eintragen von Suffix
S [i .. n ] entstand.
Konstruktion von Ni+1 aus Ni:
Starte an der Wurzel von Ni und finde den eindeutig bestimmten längsten Pfad, der mit einem Präfix von S [i + 1 .. n ]
übereinstimmt.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
282
14
1
Zwei Fälle:
•Der Pfad endet inmitten einer Kante (u,v) in T:
Dann zerteile (u,v) in zwei Kanten durch Einfügen eines
neuen Knoten w an der Stelle, wo die letzte Buchstabenübereinstimmung war.
Beschrifte Kanten (u,w) und (w,v) durch entsprechende
Aufteilung der Kantenbeschriftung für (u,v).
(*)
Füge neue Kante (w,i+1) hinzu und beschrifte sie mit dem
Suffix von S [i + 1 .. n] , das noch nicht beim Finden des beschriebenen längsten Pfades verbraucht wurde.
•Der Pfad endet an einem Knoten w in T :
Vorlesung Algorithmen (RN/MK)
(*).
WSI für Informatik, Universität Tübingen
283
Bei Annahme eines Alphabets konstanter Größe hat obiger Algorithmus Laufzeit O(n²).
Mitteilung:
Mit Hilfe der Algorithmen von McCreight, Weiner oder
Ukkonen lassen sich Suffixbäume in Zeit O(n) aufbauen.
Anwendungen von Suffixbäumen:
Natürlich sind Suffixbäume den Algorithmen von KMP
oder BM weit überlegen, falls für eine gegebene, feste (!)
Zeichenkette mehrmals häufig nach verschiedenen
Mustern gesucht werden muss.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
284
14
2
Verallgemeinerte Suffixbäume:
Darstellung einer Menge von Zeichenketten{S1 , S 2 , ... , S r }
anstelle nur einer.
Eine Konstruktionsmöglichkeit:
Nimm an, alle r Zeichenketten enden in verschiedenen Endsymbolen $1 ,$ 2 , ... ,$ r.
Konkateniere S1 , S 2 , ..., S r und bilde Suffixbaum für konkatenierte Zeichenkette in Zeit O( S1 + ... + S r ) .
Die entstehenden Blattnummern lassen sich leicht in zwei
Blattnummern umwandeln, wobei eine die zugehörige Zeichenkette und die andere die Position in der jeweiligen Zeichenkette
bezeichnet...
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
285
Problem: „Künstliche Suffixe“, die sich über mehr als eine
Zeichenkette erstrecken.
Da aber $i ≠ $ j für i ≠ j , muss jeder Pfad von der Wurzel zu einem
inneren Knoten mit einer Teilzeichenkette nur einer der Zeichenketten S1 , S 2 , ... , S r beschriftet sein.
Daher können nur Kanten zu Blättern mit Teilwörtern aus
verschiedenen Zeichenketten beschriftet sein;
Weglassen des entsprechenden zweiten Beschriftungsteils löst
das Problem.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
286
14
3
Beispiel: S1 = ab$1 , S 2 = aa$ 2 ,
S 3 = S1 o S 2 = ab$1 aa$ 2
$2
a
$1 aa$ 2
b$1 aa$2
b$1 aa$2
$2
a$ 2
1
6
3
5
2
4
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
287
Anwendung: Längste gemeinsame Teilzeichenkette zweier
Zeichenketten
Beispiel:
S1 = superiorcalifornialives
S2= sealiver
Lösung: alive
Satz:
Das Problem des Findens der längsten gemeinsamen
Zeichenkette zweier Zeichenketten S1 und S2 kann in
Zeit O( S1 + S 2 ) gelöst werden.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
288
14
4
Allgemeine Lösungsmethode:
•Bilde verallgemeinerten Suffixbaum für S1 und S2.
Jedes Blatt repräsentiert entweder ein Suffix von S1 oder
ein Suffix von S2.
•Markiere jeden inneren Knoten v mit 1 bzw. 2 je nachdem,
ob es ein Blatt in seinem Unterbaum gibt, das ein Suffix von
S1 oder S2 ist.
•Die Pfadbeschriftungen zu einem mit sowohl 1 als auch 2
markierten inneren Knoten bilden eine gemeinsame
Teilzeichenkette von S1 und S2.
Suche also denjenigen Pfad dieser Art, der die längste Teilzeichenkette ergibt. Dies geht z.B. mit Tiefensuche in Linearzeit.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
289
Anwendung: Datenkompression:
Definition: Gegeben: Eine Zeichenkette S der Länge n und
sei 1 ≤ i ≤ n
1. Die Teilzeichenkette Priori ist das längste Präfix von
S[i .. n], welches zugleich als Teilzeichenkette in S[1.. i-1]
vorkommt.
2. li := Priori und für li > 0 sei si die Anfangsposition des am
weitesten linken Vorkommen von Priori in S[1.. i-1].
Beispiel:
S=
1
2
3
4
5
6
7
8
9
10
11
12
a
b
a
x
c
a
b
a
x
a
b
z
Prior7 =
b
a
x
l7 = 3, s7 = 2.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
290
14
5
Wir betrachten Variante der Ziv-Lempel-Kompressionsmethode
Idee:
Falls S[1.. i-1] schon repräsentiert (komprimiert?!) ist und
falls li > 0,
so müssen die nächsten li Buchstaben von S (d.h. Priori)
nicht explizit angegeben werden,
sondern können durch das Paar (si,li) beschrieben werden.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
291
Kompressionsalgorithmus:
i
1;
repeat do
berechne li und si ;
if li > 0
then output (si, li);
i
i+ li
else output S[ i ];
i
i+ 1
fi;
until i > n
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
292
14
6
Beispiel:
1. S =
a
b
a
c
a
b
a
x
a
b
z
ab (1,1) c (1,3) x (1,2 ) z
2. S = (ab )16
ab (1,2 )(1,4 )(1,8)(1,16 )
Implementierung des Kompressionsalgorithmus mit Hilfe von
Suffixbäumen:
Zentral: Berechnung von li und si.
Beobachtung: Komprimierte Teilwörter überlappen nicht
miteinander.
Falls jedes gewünschte Paar (si,li) in Zeit O(li)
gefunden werden kann, so ist die Gesamtlaufzeit des Algorithmus O(n).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
293
Realisierung:
Zunächst konstruiere Suffixbaum T zu S in Linearzeit.
Nummeriere jeden Knoten v mit:
cv := kleinste Blattnummerierung im Unterbaum von v
D.h., cv gibt die am weitesten linke Anfangsposition in S für alle
Vorkommen derjenigen Teilzeichenkette in S, die den Pfad von
der Wurzel von T bis v beschriftet.
Mit Standardbaumtraversierungen (z.B. Tiefensuche) können
die cv -Werte in O(n) Zeit für alle Baumknoten bestimmt werden.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
294
14
7
Nun Anwendung der cv -Werte:
Zur Berechnung von (si,li) folgt der Algorithmus dem eindeutig
bestimmten Pfad in T, der durch ein Präfix von S[i .. n] bestimmt
ist.
Der Pfad endet an einem Punkt p (nicht notwendig einem Knoten)
und sei v der erste Knoten nach p (p = v möglich).
Dabei ergibt sich p entweder dadurch, dass ein Mismatch auftritt
oder dass auf dem Pfad zu p bereits i- cv Symbole „verbraucht“
wurden.
si := cv
li := Zahl der auf dem Pfad zu p verbrauchten Symbole
Bei konstanter Alphabetgröße findet sich somit (si,li) in Zeit O(li),
w.z.z.w.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
295
< Ende Vorlesung Algorithmen >
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
296
14
8