Algorithmen 1. Suchen

Operationen:
Algorithmen
Zugriff (a,S )
Vorlesung im Grundstudium
Informatik
Rolf Niedermeier
Michael Kaufmann
Einfüge (a,S )
Wilhelm-Schickard-Institut für Informatik
Universität Tübingen
Sand 13, 72076 Tübingen
{niedermr, mk}@informatik.uni-tuebingen.de
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
Sommersemester 2000/01
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
1
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
3
Beispiel für Suchen: Telefonbuch-CD
1. Suchen
lineare Suche
Dictionaries - Mengenverwaltung
U = S , S als Array
Eingabe (a ∈ U );
while not gefunden
i ← i + 1;
gefunden ← (a = S [i ])
endwhile
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
Vorlesung Algorithmen (RN/MK)
1
WSI für Informatik, Universität Tübingen
4
2
Eingabe ( a ∈ U )
unten ← 0, oben ← n
while unten < oben and (nicht gefunden)
Laufzeit: T (n, best) = 2
  unten + oben  
do if a < S  
 
2


T (n, worst) = 2 + 2n
T (n, average) = 2 + n
 unten + oben 
then if oben > 1 then oben ← 

2

else unten ← oben
fi
else
Gemessene Laufzeit:
Geschätzte Laufzeit:
  unten + oben  
if a > S  
 
2


 unten + oben
then unten ← 
2

 unten + oben
else Ausgabe 
2

fi
So sucht man nicht in Telefonbüchern!




ist gesuchter Index 

od
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
5
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
1.1 Binäre Suche
Voraussetzung: S geordnet!
jetzt:
Laufzeit: T (n, best ) = 4

n
T (n, worst ) = 4 + T   , worst 
2

 
= 4 ⋅ log 2 n 
 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
6
Vorlesung Algorithmen (RN/MK)
3
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.
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
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
C = ∑ (i − 1)( pi − pi ) = ∑ pi .
i ≥1
9
Vorlesung Algorithmen (RN/MK)
Interpolation von a durch S [next ]
bis a < S [next + (i - 1) n ].
(
pi ≤ prob (Rang von a in x 1 ,..., x n ) − next ≥ (i − 2 ) n
Bem.: a) Das kostet uns i Vergleiche
[
b) Nun gilt S next + (i − 2) n ] ≤ a < S [ next + (i − 1) n
]
)
hat die Form
(
)
prob Y - µ(Y ) ≥ (i − 2) n .
Fall 3: „<“ analog
WSI für Informatik, Universität Tübingen
11
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.
S [next + 2 n ] , ...
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
Berechnung der pi ’s : p1 = p 2 = 1 (Da stets ≥ 2 Vergleiche)
Fall 1: „=“ fertig
lineare Suche : Vgl. a mit S [next + n ] ,
Fall 2: „>“
Nun rekursive Anwendung auf Teilmenge der Größe
i ≥1
n.
10
Vorlesung Algorithmen (RN/MK)
5
WSI für Informatik, Universität Tübingen
12
6
2. Varianz:
Y ist Zufallsvariable, die den Rang von a in x1,...,xn
angibt und (Y ) ihr Mittelwert.
2
Wir benutzen Tschebyscheff’sche Ungleichung
prob( Y −
> t) ≤
(
p i ≤ prob Rang von x - next ≥ (i − 2 ) n
2
≤
Mittelwert
2
n j
n− j
 p (1 − p ) = p(1 − p ) ⋅ n
 j
)2 
Einsetzen in Tschebyscheff ergibt:
2
t
= ∑( j −
≤
Varianz
)
2
t2
p (1 - p )n
(i − 2)2 n
≤
1
4(i − 2 )
2
und damit gilt
C = ∑ pi ≤ 2 + ∑
i ≥1
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
13
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:
 n j
  p (1 − p )n − j und damit
 j
T (1) = 1 , T (2) ≤ 2
 n
n− j
= ∑ j   p j (1 − p )
j =1  j 
n
 n − 1 j −1
 p (1 − p )n − j
= n ⋅ p ∑ 
j =1  i − 1 
= n⋅ p
T (n ) ≤ C + T
n
WSI für Informatik, Universität Tübingen
4(i − 2 )
Vorlesung Algorithmen (RN/MK)
1. Mittelwert:
Wahrscheinlichkeit, dass genau j Elemente < a sind, ist
Vorlesung Algorithmen (RN/MK)
i ≥3
1
( 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.
14
Vorlesung Algorithmen (RN/MK)
7
WSI für Informatik, Universität Tübingen
16
8
2.1 Sortieren durch Auswahl:
Bemerkungen:
• Vorsicht: Annahme der Gleichverteilung ist kritisch.
• Laufzeit im schlechtesten Fall
n+
Eingabe: 11,3,6,7,6,12
Ausgabe: 3,6,6,7,11,12
Jeweils Minimum suchen, Ausgeben, Streichen
( )
n+
n + ... = O n
• exponentielle + binäre Suche erlaubt Bestimmung von i mit
O(log i) Vergleichen.
1.) Wie repräsentieren wir Ein- und Ausgabefolgen?
2.) Was bedeutet es, eine Zahl zu streichen?
3.) Wie bestimmen wir Minimum?
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
Vorlesung Algorithmen (RN/MK)
2. Sortieren
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.
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
Vorlesung Algorithmen (RN/MK)
9
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
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;
21
Vorlesung Algorithmen (RN/MK)
Wenn wir nicht Zahlen sortieren, sondern beliebige
Elemente eines bestimmten Typs, so ersetzen wir
86376
3|6 8 7 6
3 6|8 7 6
3 6 6|7 8
3 6 6 7|8
36678
wobei
function lessthan (x,y : typ): boolean
geeignet definiert werden muß.
WSI für Informatik, Universität Tübingen
23
Elegantere und platzeffizientere Lösung
(A[i] < A[pos]) durch lessthan (A[i], A[pos]),
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
22
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)
11
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
B = {xi | i ≥ 2
und xi
und xi
≤ x1 },
> 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
Kosten im schlechtesten Fall:
sei A = j
Kosten eines Aufrufs Quicksort (l,r) sind
a) unmittelbare Kosten bei Teile-Schritt O(r-l+1) Vergleiche
b) Kosten der rekursiven Aufrufe
B
2. Wende Verfahren rekursiv auf A und B an.
Vorlesung Algorithmen (RN/MK)
Analyse:
Kosten = Anzahl der Vergleiche zwischen S[i]‘s.
WSI für Informatik, Universität Tübingen
(Beherrsche)
25
Vorlesung Algorithmen (RN/MK)
Implementierung:
Füge S [0] = −∞ und S [n + 1] = +∞ zu S hinzu.
Dies erspart einige Tests.
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.
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
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.
26
Vorlesung Algorithmen (RN/MK)
13
für B
WSI für Informatik, Universität Tübingen
28
14
Behauptung:
n
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)
( )
1
QS (n ) = ∑ i ≤ n(n + 1) = O n 2
2
i =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
Sei QS (n ) die mittlere Anzahl der Vergleiche, die
Quicksort an einem Feld der Größe n durchführt.
29
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
31
Kosten im Mittel:
QS (0 ) = QS (1) = 0
Annahmen:
1. Elemente von S sind paarweise verschieden.
2. Jede der n! möglichen Permutationen der Eingabe ist
gleich wahrscheinlich.
(
)
und QS (n ) = n + " Erwartungswert QS ( A) + QS (B ) "
= n+
(
)
1
∑ QS (k − 1) + QS (n − k )
n k =1
= n+
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.
n
2 n −1
∑ 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
30
Vorlesung Algorithmen (RN/MK)
15
WSI für Informatik, Universität Tübingen
32
16
d.h.
und
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
(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
= 2(n + 1)∑ − 2n
i =1 i
≤ 2(n + 1)(1 + ln n ) − 2n
= O(n log n )
(n + 1)QS (n + 1) = 2n + 1 + (n + 2)QS (n )
Satz: Die mittlere Laufzeit von Quicksort ist O(n log n).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
33
Vorlesung Algorithmen (RN/MK)
⇒
2.3 Heapsort
n+2
QS (n )
QS (n + 1) ≤ 2 +
n +1
n+2
n +1
n
(2 + ...) 
2 +
= 2+
2 +
n + 1 
n 
n −1

• function
(ein Sortieren durch Auswahl)
Emptyheap : heap;
liefert Heap mit Wert ø.
• procedure
Insert (x: item, var h: heap);
verändert „Wert“ von h durch Einfügen von x

1
1 
 1
= 21 + n + 2
+ + K +  .
n
n
1
2 
+


WSI für Informatik, Universität Tübingen
35
Heap ist Datenstruktur, die folgende Operationen
unterstützt:
2
2
 2

= 2 + n + 2
+ +
+ K + 1
 n +1 n n −1

Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
• function
34
Extractmin (var h: heap): item;
verändert Wert von h durch Streichen des Minimums
und liefert gestrichenes Element.
Vorlesung Algorithmen (RN/MK)
17
WSI für Informatik, Universität Tübingen
36
18
Sei u ein Knoten in einem Baum T.
Heapsort:
 0, falls u die Wurzel ist
Tiefe(u) := 
h := Emptyheap;
for i = 1 to n
do Insert (A[i], h);
for i = 1 to n
do B[i] := Extractmin (h);
 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
37
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
Zur Realisierung von Heaps:
(Binäre) Heaps lassen sich durch Binärbäume darstellen:
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
Bsp.: {1, 2, 3, 4, 5} darstellbar durch
v
1
5
w
39
1
2
4
2
oder
3
oder ...
3
4
5
x
Jeder Baumknoten u ist mit einem Element S[u] beschriftet.
Zusätzlich fordern wir die „Heap-Eigenschaft“:
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
Ist u Elternknoten von v, so ist S [u ] ≤ S [v ]
38
Vorlesung Algorithmen (RN/MK)
19
WSI für Informatik, Universität Tübingen
40
20
Realisierung der Heap-Operationen:
• function Emptyheap:
II) danach wird durch sukzessives Vertauschen mit dem
kleinsten Kind die Heap-Eigenschaft wiederhergestellt:
klar!
4
Reorg. II
⇒
• function Extractmin:
Minimumsbestimmung: Min. steht an der Wurzel
Minimumsentfernung: Baum muss „reorganisiert“ werden
6
8
4
Reorg. II
⇒
10
11 6
15
6
8
6
11 10
13
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
41
Vorlesung Algorithmen (RN/MK)
6
8
⇒
4
11 6
10
10
Reorg. I
15
6
8
4
11
6
⇒
4
8
I) Beliebiges Blatt wird entfernt und an die Wurzel gesetzt.
42
13
Vorlesung Algorithmen (RN/MK)
21
⇒
4
6
6
11 10 15
5
WSI für Informatik, Universität Tübingen
43
Bsp.: Einfügen des Elements 5:
6
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
15
13
13
13
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.:
2
15
8
11 5
10
4
6
6
15
13
8
5
11 6
10
WSI für Informatik, Universität Tübingen
15
13
44
22
Ausgewogene Bäume:
Beispiel:
1
16
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“.
2
14
4
Bsp.:
1
2
4
8
3
10
3
5
6
7
5
8
Nummerierung der Knoten:
Nummeriere Knoten der Höhe
nach und innerhalb jeder Höhe
von links nach rechts.
7
8
2
4
9
1
9
6
3
7
10
9 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
45
Vorlesung Algorithmen (RN/MK)
47
Zur Implementierung von Heapsort:
Dann gilt:
type heap = record
(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.
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
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
WSI für Informatik, Universität Tübingen
46
Vorlesung Algorithmen (RN/MK)
23
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
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).
49
Vorlesung Algorithmen (RN/MK)
Zur Laufzeit-Analyse von Heapsort:
WSI für Informatik, Universität Tübingen
2.4 Mergesort
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)
(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.
Lemma:
Hat ein ausgewogener Baum die Höhe m, so enthält er
mindestens 2m und weniger als 2m+1 Knoten.
Z.B.
11 6 6 5 3
12 8 5
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
51
50
Vorlesung Algorithmen (RN/MK)
25
12 11 8
6 6
WSI für Informatik, Universität Tübingen
5
5 3
52
26
(2) Mischphase:
Mischalgorithmus:
345255
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.
11963
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
13 59 35
14 26 5
1134 355
11234569
2569
355
11233455569
53
Vorlesung Algorithmen (RN/MK)
Zum Sortierverfahren:
Bezeichne aufsteigend sortierte Teilfolgen als „Runs“.
WSI für Informatik, Universität Tübingen
Grundprinzip:
Teile Eingabe in Teilfolgen der Länge 1 (das sind Runs).
Mische danach Runs zu längeren Runs.
Beobachtung:
Nach i-tem Durchlauf haben alle Runs
Länge ≤ 2i .
Allgemeiner: pi für p = # Eingabedateien
= # Ausgabedateien
Bsp.: Eingabe: 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5
(1) Streuphase:
Wenn p i ≥ n, so ist die Eingabe sortiert.
Also genau log p n  Durchläufe nötig.
55
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
Vorlesung Algorithmen (RN/MK)
27
WSI für Informatik, Universität Tübingen
56
28
Effizienzverbesserung:
2.5 Bucketsort
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.
(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.
Bsp.: m = 3
134 256
3 1 4 1 5 9 2 6 5 3 5
159 35
Ziel: Wörter über dem Alphabet Σ bzgl. der gegebenen
Ordnung sortieren.
113 459
11233455569
235 56
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
57
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
59
Analyse:
Spezialfall 1: Alle n Wörter haben Länge 1.
Nach i Durchläufen haben die Runs Länge m· 2i (bzw. m· pi).
Lösungsansatz: Stelle m Fächer bereit und gehe die n Zahlen
durch und wirf jede Zahl in das ihrem Wert gemäße
Fach.
n

Also genügen log p  Durchläufe.
m

Implementierung der Fächer z.B. als lineare Listen und ein
Feld der Größe m zum Speichern der Listenköpfe.
Bsp.: n = 107, m = 104, p = 3
⇒ 7 Durchläufe
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
Gesamtzeitaufwand: O(n + m)
58
Vorlesung Algorithmen (RN/MK)
29
WSI für Informatik, Universität Tübingen
60
30
Spezialfall 2: Alle n Wörter haben gleiche Länge k.
Wie vermeiden wir Aufwand mit leeren Fächern?
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)
⇒
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
61
Vorlesung Algorithmen (RN/MK)
324
124
124
123
Vorlesung Algorithmen (RN/MK)
223
∑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 ...)
324
124
223
123
321
2. Lauf
3. Lauf
n
|xi| =: li , L :=
223
123
321
63
Allgemeiner Fall: n Wörter beliebiger Länge
Bsp.: 123 , 124, 223, 324, 321
m = 4, n = 5, k = 3
1. Lauf
WSI für Informatik, Universität Tübingen
324
321
WSI für Informatik, Universität Tübingen
62
Vorlesung Algorithmen (RN/MK)
31
WSI für Informatik, Universität Tübingen
64
32
Algorithmus:
2.6 Hybridsort
1 Bestimme ri ∀i und erzeuge Paare (ri, Verweis auf xi)
∈ R fest, k := ⋅ n
2 Sortiere (ri, Verweis auf xi) durch Fachverteilung nach
1. Komponente. Bezeichne Länge[k] die Liste der Elemente
der Länge k.
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.
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].
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).
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
Vorlesung Algorithmen (RN/MK)
Eine einfache Analyse zeigt:
Satz:
WSI für Informatik, Universität Tübingen
67
3.Auswählen
Sortieren durch Fachverteilung sortiert n Wörter
der Gesamtlänge L über einem Alphabet der
Größe m in Zeit O(m + L).
Gegeben: Menge S von n Schlüsseln und natürliche Zahl k
(1 ≤ k ≤ n)
Gesucht: k-t-größter Schlüssel in S
Anwendung: Sortieren n reeller Zahlen x1, ...,xn
Vereinfachung: Betrachte reelle Zahlen aus (0,1].
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
66
Vorlesung Algorithmen (RN/MK)
33
WSI für Informatik, Universität Tübingen
68
34
Partition von S in L und R heiße gut,
falls:
3n
3n
L≤
und R ≤
4
4
Partition ist mit Wahrscheinlichkeit 12 gut.
3.1 Randomisierte Auswahl
Idee: Möglichst gleichmäßige, rekursive Partionierung der Eingabe
Algorithmus:
if n=1
r
L
R
if
g(n):= # rek. Aufrufe bis gute Partition erreicht wird.
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
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 
fi
Vorlesung Algorithmen (RN/MK)
Satz:
WSI für Informatik, Universität Tübingen
69
Vorlesung Algorithmen (RN/MK)
Also:
Beweis: t(n) Laufzeit des obigen Algorithmus;
da rand. Algorithmus, ist t(n) Zufallsvariable.
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
Bestimmen E(t(n)), d.h. Erwartungswert von t(n).
WSI für Informatik, Universität Tübingen
71
1
1
1
E ( g (n)) = 1 ⋅ + 2 ⋅ + 3 ⋅ + ... = 2
2
4
8
Der k-t-größte Schlüssel einer Schlüsselmenge mit
n Schlüsseln kann in erwarteter Zeit O(n)
bestimmt werden
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
70
Vorlesung Algorithmen (RN/MK)
35
3
WSI für Informatik, Universität Tübingen
72
36
Analog:
3n
−6
10
3.2 Deterministische Auswahl
# (Elemente < x) ≥
Idee: bestimme Median (=ˆ Pivotelement) per Sampling...
⇒ Im schlimmsten Fall in Schritt 5 rekursiver Aufruf
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
mit
⇒ 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
{
 
 53
  142
10 43
12
Schritte 2+ 4
 Schritt3
Schritt5
73
Vorlesung Algorithmen (RN/MK)
Fünfermengen beinhalten mind.
3 Elemente > x
n
falls c groß genug, sodass c − 7  größer als die
 10 
in O(n) „versteckte Funktion“.
1 n
3n
⇒ 3 ⋅    − 2  ≥ − 6 Elemente > x
 2  5   10
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
75
n
7n
T ( n) ≤ c   + c + 6  + O(n)
 5   10

7cn
cn
≤ +c+
+ 6c + O(n)
5
10
9cn
≤
+ 7c + O ( n)
10
≤ cn
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 
WSI für Informatik, Universität Tübingen
Lsg. mit Substitutionsmethode:
Annahme: T (n) ≤ cn für c = const einsetzen :
Der k-t-größte Schlüssel einer Schlüsselmenge mit n
Schlüsseln kann in Worst Case Zeit O(n) bestimmt werden
⇒
7n
+ 6 Schlüsseln
10
74
Vorlesung Algorithmen (RN/MK)
37
WSI für Informatik, Universität Tübingen
76
38
Benutzen knotenorientierte Speicherung
4. Balancierte Bäume
5
2
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
rchild(u)
else u
Einfügen, Streichen
Bsp.: {2, 3, 5, 7, 11, 13, 17}
7
3
13
11
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.
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
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.
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
Fall 1: u ist Blatt. Streiche u
u
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
10
5
11
7
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
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
78
Vorlesung Algorithmen (RN/MK)
39
WSI für Informatik, Universität Tübingen
80
40
4.1 Balancierte Bäume: AVL-Bäume
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
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
2
9
1
2
5
10
3
7
4
6
Vorlesung Algorithmen (RN/MK)
v
9
1
5
3
Def.: Ein binärer Baum heißt AVL-Baum, falls
Bal(u ) ≤ 1 für alle Knoten u.
10
6
4
WSI für Informatik, Universität Tübingen
81
Vorlesung Algorithmen (RN/MK)
Komplexität: O(h + 1), wobei h Höhe des Suchbaums
kann sehr schlecht sein:
Tn-2
Fibonacci-Zahlen F0, F1, ... :
F0 = 0, F1 = 1, Fn= Fn-1 + Fn-2
Idee: 1. Hoffen, dass das selten vorkommt.
2. Baue Baum von Zeit zu Zeit neu auf (ausgewogen)
3. Balancierte Bäume!
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
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
Behauptung: Th enthält genau Fh Blätter für h ≥ 0.
82
Vorlesung Algorithmen (RN/MK)
41
WSI für Informatik, Universität Tübingen
84
42
Behauptung: AVL-Baum der Höhe h enthält ≥ Fh Blätter.
Einfügen / Streichen:
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
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.
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
Fall 1: Bal(v) = 1
u
A
(Induktion)
WSI für Informatik, Universität Tübingen
85
v
B
Rotation
⇒
C
Vorlesung Algorithmen (RN/MK)
A
B
C
WSI für Informatik, Universität Tübingen
Lemma: Ein AVL-Baum mit n Knoten hat Höhe O(log n).
Beachte:
Beweis: Der Baum hat ≤ n Blätter.
h
− h
≤ n.
Also Fh ≤ n oder
5
(1) Die Rotation bewahrt die links-nach-rechts-Ordnung.
A-u-B-v-C.
h
Da β < 1 :
⇒ n≥
⇒
h
h log (
−
5
h
≥
(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.
h
2 5
87
für h groß genug.
h
(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.
2 5
≤ 2 5n
) ≤ log(2
)
log (2 5 ) + log n
= O (log n )
h≤
5 + log n
log
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
86
Vorlesung Algorithmen (RN/MK)
43
WSI für Informatik, Universität Tübingen
88
44
Streichen:
Fall 2: Bal(v) = –1
u
v –1
A
z
C
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.
oder (B,C) vertauscht.
2
D
Do
Ro ppeltati
on
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.
B
z
u
A
Vorlesung Algorithmen (RN/MK)
0
0 / –1
B
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.
1/0
C
D
WSI für Informatik, Universität Tübingen
89
Vorlesung Algorithmen (RN/MK)
Einfügealgorithmus:
WSI für Informatik, Universität Tübingen
Fall 3: Bal(v) = 0
Füge neues Blatt w ein. Dann folge dem Pfad von w zur
Wurzel, wobei alle Balancen neu berechnet werden.
Rotation
⇒
v
A
B
Tritt eine Balance ± 2 auf, dann führe Rotation oder
Doppelrotation aus.
C
A
B
Beende das Einfügen.
In diesem Fall muß die Balancierung nicht höher im
Baum fortgesetzt werden.
Laufzeit: O(Höhe des Baums) = O(log n), n = # Knoten
Satz:
Vorlesung Algorithmen (RN/MK)
91
WSI für Informatik, Universität Tübingen
90
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)
45
C
WSI für Informatik, Universität Tübingen
92
46
Anwendung von balancierten Suchbäumen:
Algorithmus:
Schnitt von achsenparallelen Liniensegmenten
Gegeben: Menge von insgesamt n vertikalen und horizontalen
Liniensegmenten in der Ebene.
Gesucht: Alle Paare von sich schneidenden Elementen
 x − Koordinaten der Anfangs- und Endpunkte 
Q←

horizontaler Segmente

∪ {x − Koordinaten von vertikalen Segmenten} ;
Trivialer Algorithmus: O(n²)
Sortiere Q bzgl. x-Werten;
L ← o/ ;
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
/ * Menge jeweils aktiver horizontaler Segmente
in aufsteigender y - Reihenfolge * /
93
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;
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.
]
fi;
od;
Q ← Q \ {p}
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
94
Vorlesung Algorithmen (RN/MK)
47
WSI für Informatik, Universität Tübingen
96
48
4.2 B-Bäume
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
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.
→ 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
Vorlesung Algorithmen (RN/MK)
[
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)
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 .
[
]
WSI für Informatik, Universität Tübingen
]
Beweis:
Minimale Anzahl von Blättern, falls jeder innere Knoten
die Minimalzahl von Kindern hat:
Zusammen: Laufzeit O(n log n + k),
wobei k die Gesamtzahl sich schneidender
Segmente ist.
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
98
Vorlesung Algorithmen (RN/MK)
49
WSI für Informatik, Universität Tübingen
100
50
Logarithmieren ergibt:
Zugriff auf (a,S):
Starte in Wurzel w und suche den kleinsten
Schlüssel si in w mit a ≤ si .
n
log ( 2 k −1) n ≤ h ≤ 1 + log k
2
⇒ Wähle bei großen Datenmengen k so, dass auf eine Seite
Falls si existiert:
ein Knoten des B - Baums passt.
Operationen: Zugriff, Einfügen, Streichen
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
Annahme: Wir speichern knotenorientiert;
nichts in den Blättern.
Laufzeit: O((log k n ) ⋅ k )
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
101
Vorlesung Algorithmen (RN/MK)
s1
s2
...
si-1
...
si ...
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).
Betrachte Knoten u mit l Kindern:
u
WSI für Informatik, Universität Tübingen
sl-1
Füge neuen Schlüssel a in v ein und neues Blatt b′
für a, sodass
Ti . . .
u hat Schlüssel s1 , s2 ,..., sl −1. (geordnet!)
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
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
Vorlesung Algorithmen (RN/MK)
51
WSI für Informatik, Universität Tübingen
104
52
Streichen eines Schlüssels aus einem B-Baum:
Also:
v
s1 s2
...
sl-1
s1 s2
14444
4244444
3
l Blätter
Streiche (a,S)
Annahme: a = sj kommt in Knoten u vor.
... si-1 a si ... sl-1
Mittels Zugriff (a,S) suche zunächst Knoten u,
in dem a als Schlüssel sj vorkommt. Wir nehmen an,
die Suche ende erfolgreich.
144444
42444444
3
l + 1 Blätter
Falls l < 2k − 1 ⇒ OK.
allg. Situation:
Falls l = 2k − 1 : Spalte v in zwei Knoten v′ und v′′ mit
WSI für Informatik, Universität Tübingen
105
Vorlesung Algorithmen (RN/MK)
Bild:
.... sj-1 sj sj+1 ....
sk
w
v
s1 s2
WSI für Informatik, Universität Tübingen
107
Situation:
w
v
............. u
sj
Tj
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.
jeweils k Kindern
Vorlesung Algorithmen (RN/MK)
.......... sj-1
...
s2k-1
v ′ s1 . . .
sk-1
v′′ sk
. . . s2k-1
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:
14444244443
2k Kinder
Sei r die ursprüngliche Zahl der Kinder in v
mit k ≤ r ≤ 2k − 1.
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
Vorlesung Algorithmen (RN/MK)
53
WSI für Informatik, Universität Tübingen
108
54
) 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:
a) Falls r > k (bzw. r > 2, falls v Wurzel), so fertig, da B-BaumEigenschaft gewahrt bleibt.
Jedes der Kinder hat dann mind. k und
 3k 
höchstens   - 1 Kinder.
2
b) Falls k= 2 und v Wurzel ist, so hat v nach Entfernung von s
nur noch ein Kind.
) 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.
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
Vorlesung Algorithmen (RN/MK)
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:
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.
.... s´´ s´ ....
s1´ .... sr´
WSI für Informatik, Universität Tübingen
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
Vorlesung Algorithmen (RN/MK)
55
WSI für Informatik, Universität Tübingen
112
56
5.Hashing
Forderungen an Hash-Funktionen:
Hash-Tafeln („Streutafeln“) dienen zur Implementierung
von „Wörterbüchern“ (Dictionaries) und sollen daher
die Operationen Zugriff, Einfügen und Streichen
unterstützen.
- Einfache Berechenbarkeit
- Minimierug der Kollisionsanzahl
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)
- Hashing mit Verkettung und
- Hashing mit offener Adressierung
Zwei Hauptmethoden zur Kollisionsbehandlung:
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
Vorlesung Algorithmen (RN/MK)
0:
1:
2:
3:
4:
115
5.1 Hashing mit Verkettung
Beispiel: m = 5, S = {3, 15, 22, 24}, U = [0 ... 99]
h(x) = x mod 5
Hash-Tafel T:
WSI für Informatik, Universität Tübingen
15
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.
22
3
24
Worst Case: Alle Elemente in einer Liste abgespeichert
alle Operationen erfordern lineare Laufzeit O(|S|).
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
Vorlesung Algorithmen (RN/MK)
57
WSI für Informatik, Universität Tübingen
116
58
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
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 
∀i = 0, ..., m − 1
h −1 (i ) ≤  
m
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
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
Vorlesung Algorithmen (RN/MK)
1
m
119
n-j
n
 n − 1 1   1 
  1 − 
= 1 + ∑ n
m
j =1  j − 1 m  
∀ k ∈ [1 ... n]
j
∀ i ∈ [0 ... m-1] ,
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
WSI für Informatik, Universität Tübingen
WSI für Informatik, Universität Tübingen
j
wobei n die Anzahl der Operationen sei.
Vorlesung Algorithmen (RN/MK)
.
n
 n  1   1 
Daraus folgt: EK n+1 ≤ 1 + ∑    1-  ⋅ j
m
j = 0  j  m  
Mit Annahmen 2) und 3) folgt:
Sei xk Argument der k-ten Operation. Dann
Prob(h(xk) = i) =
n− j
j −1
= 1+
n n  n − 1 1 
∑   
m j =1  j − 1 m 
= 1+
n  n −1  n − 1 1   1 
∑    1 − 
m  j =0  j  m   m 
= 1+
n  1  1 
 + 1 −  
m  m  m  
= 1+
n
= 1+
m
 1
1 − 
 m
j
118
Vorlesung Algorithmen (RN/MK)
59
n− j
n −1− ( j −1)
n −1− j




n −1
WSI für Informatik, Universität Tübingen
120
60
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.
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
1 i −1
⋅2 ⋅m
4
Operationen bis zum nächsten Rehashing möglich.
Nach Rehashing gemäß 2) mindestens
121
Vorlesung Algorithmen (RN/MK)
Problem: Wahl von m:
- m (zu) groß
hohe Speicherkosten und
mitunter erhöhte Laufzeit.
- m (zu) klein
erwartete Kosten (zu) hoch.
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
Fazit: Mit Einfügen bzw. Streichen kann
oder zu klein werden.
schnell zu groß
immer konstant gehalten werden können, ohne allzu viel
Speicher zu verschwenden.
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
Vorlesung Algorithmen (RN/MK)
61
WSI für Informatik, Universität Tübingen
124
62
5.2 Hashing mit offener Adressierung
Zunächst zur Wahl einer injektiven Hash-Funktion:
Grundidee: Jedes Element x ∈ U definiert Folge h(x,i),
i = 0, 1, 2, ... von Tafelpositionen.
Sei U = {0, 1, ..., N-1} und sei
hk : {0, ..., N-1}
[0 ... m-1] Hash-Funktion
für k ∈{1, ..., N-1} mit
hk (x) := ((kx) mod N) mod m.
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
Sei S ⊆ U mit |S| = n bekannt.
Für welches k ist hk injektiv?
Messung der „Injektivität“ vermöge:
Vorteil: Kein zusätzlicher Speicherbedarf.
bik := {x ∈ S : hk ( x ) = i} für 1 ≤ k ≤ N-1,
0 ≤ i ≤ m-1
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
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
127
Dann
5.3 Perfektes Hashing
bik ⋅ (bik − 1) =
Hash-Funktion sollte injektiv sein, falls S bekannt ist.
{ (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
Grundschema:
i =0
Stufe 1 arbeitet mit Hashing mit Verkettung
kreiert „kurze“ Listen
„Injektivität von hk“ verletzen:
Bk ≈ 2# Kollisionen, falls hk benutzt.
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
Vorlesung Algorithmen (RN/MK)
63
WSI für Informatik, Universität Tübingen
128
64
Beweis des Lemmas:
Lemma: Voraussetzungen wie oben. Dann
N −1 m −1
∑∑ b (b
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
k =1 i = 0
ik
ik
− 1)
N −1 m −1
= ∑∑
k =1 i = 0
nn 
n 
 − 1 = n − 1
mm 
m 
=
{ (x,y )
∑ {k
( x,y )∈S 2
x,y ∈ S, x ≠ y, hk (x ) = hk ( y ) = i}
hk ( x ) = hk ( y ) }
x≠ y
Beweis: 2. Offensichtlich per Def.
Seien x, y ∈ S fest. Wieviele Funktionen hk mit
hk(x) = hk(y) gibt es?
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
Vorlesung Algorithmen (RN/MK)
N −1 n −1
− 1) ≤ 2 ⋅
142
4 43
4
k =1 i = 0
ik
ik
n(n − 1)
(N − 1)
m
=: g(k)
Es gilt − N + 1 ≤ g (k ) ≤ N − 1
Bk
Bemerkung:
Lemma ⇒
⇒
n(n − 1)
mittlere Anzahl der Kollisionen ≤
m
(da Bk ≈ 2⋅# Koll´en bei Benutzung von hk )
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.
Mit m > n(n-1) ist mittlere Anzahl < 1 und
d.h., es gibt hk, das auf S injektiv ist!
{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)
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
Lemma: Voraussetzungen wie oben, desweiteren sei
N Primzahl. Dann gilt
∑∑ b (b
WSI für Informatik, Universität Tübingen
WSI für Informatik, Universität Tübingen
130
Vorlesung Algorithmen (RN/MK)
65
ik
ik
k
− 1) ≤ 2 ⋅
 m 
N −1
n(n − 1)
m
WSI für Informatik, Universität Tübingen
132
66
Korollar 2 Teil 1
n(n − 1)
1. Ein k ∈ [1K N − 1] mit Bk ≤ 2
m
in Zeit O(m + Nn) bestimmbar.
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
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.
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
Vorlesung Algorithmen (RN/MK)
Korollar 1: Voraussetzungen wie oben (Lemma).
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. ∃k ∈ [1K N-1]:Bk ≤ 2 ⋅
m
4n(n − 1)
N -1
viele hk ’s haben Bk ’s mit Bk ≤
.
2. Mindestens
m
2
n(n − 1)
ist Mittelwert, ein hk muss Bk mit
m
diesem oder kleinerem Wert haben ...
Beweis: 1.
WSI für Informatik, Universität Tübingen
2⋅

n(n − 1)   1
Beweis: 4. Prob   Bk < 4
 ≥
m   2

⇒ ... „randomisiert“ trifft man ein solches k in Zeit O(m + n).
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∈ A
k =1
5. Einsetzen bei 1.
6. Einsetzen bei 4.
im Widerspruch zum Lemma!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
134
Vorlesung Algorithmen (RN/MK)
67
WSI für Informatik, Universität Tübingen
136
68
3. Sei si := ∑ m j
Zur Realisierung:
j <i
Dann speichere x ∈ S in Tafelposition T [si + j ] ,
Stufe 1: Sei m = n. Gemäß Kor. 2, 1. gibt es dann Hash-Fkt. hk,
sodass Listenlängen alle O n .
( )
m −1
Denn:
∑ b (b
i =0
ik
ik
− 1) = Bk
Def .
( )
( )
⇒ bik ∈ O n ∀i , d.h. Listenlängen O n .
Stufe 2: Auf jede dieser Teilmengen (
nochmals Hashing an.
i = ((kx ) mod N ) mod m
j = ((ki x ) mod N ) mod mi .
wobei
und
n(n − 1) n = m
≤ 2
= 2(n − 1)
m
Kor.2,1.
Bild:
Listen) wende
w0
0
w1
m0-1
m0 = s1
s
((kx) mod N) mod n
:
:
s2-1
:
:
:
sn-1
wn-1
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
137
Vorlesung Algorithmen (RN/MK)
mn-1+sn-1-1
WSI für Informatik, Universität Tübingen
139
Komplexitätsanalyse:
Die Einzelheiten:
Sei S ⊆ [0 .. N-1] , N Primzahl, S = n = m :
Platzbedarf:
m −1
1. Wähle k mit Bk ≤ 4(n − 1) ≤ 4n.
Sei hk = ((kx) mod N) mod m.
n −1
∑ m = ∑ [2b (b − 1) + 1] = n + 2B
i =0
i
i =0
i
i
k
≤ n + 8(n − 1) = 9n − 8 = O(n ).
Kor.2, 6
2. Sei wi = {x ∈ S : hk ( x ) = i}, bi = wi
und mi: = 2bi (bi − 1) + 1
Laufzeit:
Schritt 1: O(n) randomisiert nach Korollar 2, 6.
Wähle ki mit h k(x)
= ((kix) mod N) mod mi, sodass
i
hki injektiv für wi.
( )
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).
∑:
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
138
O(n + m) = O(n) randomisiert!
Vorlesung Algorithmen (RN/MK)
69
WSI für Informatik, Universität Tübingen
140
70
Analyse:
Tafelaufbau und versuche_wieder können oft vorkommen.
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.
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,
Bemerkung:
Randomisierte Version sehr zu bevorzugen!
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 


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
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
143
Tafelaufbau:
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;
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
Da aktuelles B ≤ Bf, 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
(
)
( )
( )
Insert(x)
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
142
Vorlesung Algorithmen (RN/MK)
71
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
⇒
∑m
i,p
p
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
f
mi
f
≤ 2mi
p
p ≥0 2
≤∑
⇒ Gesamtplatzbedarf :
n-1
n −1
( (
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)
) )
≤ ∑ 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
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.
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).
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
146
Vorlesung Algorithmen (RN/MK)
73
WSI für Informatik, Universität Tübingen
148
74
Platzbedarf: O(n2)
ist günstig, falls m := E ≈ n 2 .
6.1 Darstellung von Graphen
Annahme: V = {1, 2, ..., n}, G = (V, E), n = |V|.
Aber: Oft sind Graphen dünn, d.h. m ≈ O (n ) .
Zwei Darstellungsarten sind üblich:
1. Darstellung: Adjazenzmatrix A = (aij ) , 1 ≤ i,j ≤ n
Bsp.:
Zahl der Kanten in Bäumen mit n Knoten ist n – 1.
falls (i,j ) ∈ E
sonst.
1 ,
aij := 
0 ,
Planare Graphen: Graph heißt planar, falls er in Ebene
gezeichnet werden kann, ohne dass sich Kanten
überkreuzen.
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
Vorlesung Algorithmen (RN/MK)
Bei ungerichteten Graphen ist die Adjazenzmatrix
symmetrisch:
1
4
2
5
151
Zwei nicht-planare, ungerichtete Graphen:
falls {i,j}∈ E
1 ,
hier: aij := 
0 ,
WSI für Informatik, Universität Tübingen
K3,3
K5
sonst.
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
(„vollständiger“ bipartiter
Graph mit 3 und 3 Knoten)
1
1
1
0
0
WSI für Informatik, Universität Tübingen
Mitteilung: Ein planarer Graph mit n Knoten enthält
maximal 3n – 6 Kanten.
150
Vorlesung Algorithmen (RN/MK)
75
WSI für Informatik, Universität Tübingen
152
76
2. Darstellung: Adjanzenzlisten
Graph G = (V, E) heißt Baum, falls
Speichere für jeden Knoten v seine „Nachbarn“:
a) V enthält genau einen Knoten v0 mit indeg(v0) = 0.
G = (V, E) gerichtet:
b) ∀ v ∈ V \ {v0 }: indeg(v ) = 1
InAdj(v ) = { w ∈ V
(w, v ) ∈ E}
OutAdj(v ) = { w ∈ V (v, w) ∈ E}
c) G ist azyklisch.
G ungerichtet:
Adj(v ) = { w ∈ V
Vorlesung Algorithmen (RN/MK)
{v,w}∈ E}
WSI für Informatik, Universität Tübingen
153
Vorlesung Algorithmen (RN/MK)
Im vorigen Beispiel (gerichtet):
InAdj: 1
2
3
4
5
2
OutAdj:
5
1
2
155
6.2 Topologisches Sortieren
1
2
3
4
5
5
1
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 .
5
3
Bsp.:
1
Platzbedarf: O(n + m)
4
2
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} ,
5
WSI für Informatik, Universität Tübingen
2
1
1
2
154
Vorlesung Algorithmen (RN/MK)
77
5
3
4
3
analog für ungerichtete Graphen.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
3 es gibt keine
topologische
Sortierung!
WSI für Informatik, Universität Tübingen
156
78
Jetzt zur topologischen Sortierung:
Beweis per Induktion über Knotenzahl:
|V| = 1: trivial.
Lemma:
Gerichteter Graph G = (V, E) besitzt genau dann
eine topologische Sortierung, wenn G azyklisch ist.
|V| > 1: Wähle (gemäß Beh.) v mit indeg(v) = 0.
Entferne v und sortiere den Restgraph G´ topologisch
induktiv, d.h.:
Beweis:
"⇒" :
Sei G zyklisch. Dann ist etwa (v0, ..., vk), k ≥ 1,
ein Kreis. Für eine topologische Sortierung muß
aber gelten:
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,

num(v0) < num(v1) < ... < num(vk) = num(v0).
falls w ≠ v
falls w = v.
Widerspruch!!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
157
Vorlesung Algorithmen (RN/MK)
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
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
WSI für Informatik, Universität Tübingen
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.
158
Vorlesung Algorithmen (RN/MK)
79
WSI für Informatik, Universität Tübingen
160
80
Algorithmus TOPSORT:
(1) ZERO
Satz:
Topologische Sortierung eines gerichteten
Graphen G = (V, E) kann in Zeit O(n + m)
(Linearzeit!) berechnet werden.
Hierbei: n = |V|, m = |E|.
Ø;
(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
Beweis: Die Korrektheit folgt unmittelbar mit dem Lemma.
Zur Komplexität: Übungsaufgabe!
(6) od
(7) count
0;
Fortsetzung
nächste Folie
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
161
Vorlesung Algorithmen (RN/MK)
(8) while ZERO ≠ Ø do
(9)
wähle und streiche v ∈ ZERO ;
(10)
count ++;
(11)
num[v]
(12)
(13)
INDEG[w] – – ;
if INDEG[w] = 0 then ZERO
(15)
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 )
ZERO ∪ {v} fi
i =0
Kosten des Pfades von v nach w.
od
(16) od;
dist(v, w) = inf {c(p) | p ist Pfad von v nach w}
heißt Entfernung.
(17) if count < |V| then ausgabe(G zyklisch!) fi
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
163
6.3 Billigste Wege
count;
for all (v, w ) ∈ E do
(14)
WSI für Informatik, Universität Tübingen
162
Vorlesung Algorithmen (RN/MK)
81
WSI für Informatik, Universität Tübingen
164
82
Beispiel:
Single Source Shortest Paths
2
–1
4
1
2
3
3
4
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:
negativer Zyklus
2
(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 ) .
6
–6
5
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.
i)
3
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
165
Vorlesung Algorithmen (RN/MK)
3 grundsätzliche Problemstellungen:
WSI für Informatik, Universität Tübingen
167
Beweis:
i) "⇐" : klar!
1 single pair shortest paths
(kürzeste Wege zwischen einem Knotenpaar)
"⇒" : Sei c := ∑ c(e ) und sei p ein kürzester Weg von
e∈E
s nach u mit c(p) < – c.
2 single source shortest paths
(kürzeste Wege von einem Knoten aus)
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.
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
Vorlesung Algorithmen (RN/MK)
83
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
Nachfolgender Algorithmus setzt voraus, dass Graph
topologisch sortiert ist, „also“ V = {1, 2, ... , n}.
Algorithmus:
p*
Sei 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*).
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
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
Vorlesung Algorithmen (RN/MK)
2
2
3
5
2
5
s
–1
3
2
6
4
1
Beweis:
Korrektheit ( 1) + 2) ): Induktion über v
(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
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|.
1. Situation: Der geg. Graph G = (V, E) ist azyklisch.
Bsp.:
WSI für Informatik, Universität Tübingen
v < s:
v = s:
170
(v ) = ∞, da v von s aus nicht erreichbar.
d (v ) = ∞, da nach Init. nicht mehr verändert
(v ) = d (v ) = 0.
Vorlesung Algorithmen (RN/MK)
85
Pfad(s) = s ist einziger Weg.
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 ) =
2.Situation: Alle Kantenkosten nichtnegativ (d.h. ∀e ∈ E , c(e) ≥ 0 ),
Zykel erlaubt
Dijkstras Algorithmus:
(v ) = ∞.
Nachfolgend nur Kosten kürzester Pfad berechnet;
eigentliche Pfadberechnung analog vorher.
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
Idee:
173
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)
Laufzeit:
Topologisches Sortieren kostet Zeit O( n + m ).
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.
Initialisierung: O(n)
„Hauptteil“: Komplexität wird i.w. bestimmt durch
∑ In(v )
= m,
v∈V
also O( n + m ).
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
174
Vorlesung Algorithmen (RN/MK)
87
WSI für Informatik, Universität Tübingen
176
88
Algorithmus:
Beispiel (Ungerichteter Graph):
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 ) ← ∞;
3
1
2
2
0
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
177
Vorlesung Algorithmen (RN/MK)
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 )}
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 ).
fi
Da alle Kanten nichtnegativ sind, gilt aber
c(q ) ≥ d ′(v ) ≥ d ′( x ) = d ( x ) = c( p ),
ein Widerspruch.
od
od
Vorlesung Algorithmen (RN/MK)
1
WSI für Informatik, Universität Tübingen
178
Vorlesung Algorithmen (RN/MK)
89
WSI für Informatik, Universität Tübingen
180
90
Zur Laufzeit:
Implementiere S und S ′ als Bitvektoren
und d und d ′ als Arrays.
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.
•Aufwand für „ for all u ∈ OutAdj( x ) “:
∑ OutAdj( x ) = O(m + n ).
x∈V
•n-maliges Minimieren über S ′ : O(n² ).
Mitteilung:
Mit Hilfe sogenannter Fibonacci-Heaps läßt sich die
Laufzeit des Algorithmus von Dijkstra asymptotisch
zu O(n log n + m) verbessern.
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
Vorlesung Algorithmen (RN/MK)
Alternativ:
Speichere S ′ in Heap (balancierter Baum), gemäß d ′-Werten
geordnet.
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)):
Damit Laufzeit O((m+n)log n),
da nun Einfügen und Löschen in S ′ je O(log n ) Zeit kostet.
d (w) ← min{d (w), d (v ) + c(v, w)}
Für dünne Graphen ist dies eine Verbesserung.
Offensichtlich: Entspannen einer Kante erhöht keinen d-Wert
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
182
Vorlesung Algorithmen (RN/MK)
91
WSI für Informatik, Universität Tübingen
184
92
Offen bleibt noch die Frage nach der „Entspannungs-Reihenfolge“,
sodass d schnell gegen konvergiert.
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.
Lemma:
Sei w ∈ V und sei (w) < ∞ und sei (v, w) die letzte Kante auf
billigstem Weg von s nach w.
Beweis:
Jeder Weg von s nach v zusammen mit Kante (v,w)
ergibt Weg von s nach w.
Deshalb (v ) + c(v, w) ≥
Dann gilt:
Falls (v,w) entspannt wird, nachdem d (v ) =
worden ist, so ist danach d (w) = (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
Beweis: Übung!
185
Vorlesung Algorithmen (RN/MK)
Algorithmus:
d (s ) ← 0;
for all v ≠ s do
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));
d (v ) ← ∞
while „möglich“ do
Entspanne Kanten
od
Beobachtung: d(u) wird immer kleiner, unterschreitet aber nie
Vorlesung Algorithmen (RN/MK)
(v ) ge-
WSI für Informatik, Universität Tübingen
(u ) .
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.
186
Vorlesung Algorithmen (RN/MK)
93
WSI für Informatik, Universität Tübingen
188
94
Beweis:
Induktion über i:
i = 0 : d (s ) =
4.Situation: Auch negative Zykel erlaubt.
(s ), da es keine negativen Zykel gibt.
Algorithmus:
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.
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.
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:
2 Führe n weitere for-Schleifendurchläufe aus und speichere
das Ergebnis in d2.
⇒ d (w) = d (v ) + c((v, w))
= (v ) + c((v, w))
=
Vorlesung Algorithmen (RN/MK)
(w)
WSI für Informatik, Universität Tübingen
189
Vorlesung Algorithmen (RN/MK)
Korollar:
Nach dem (n-1)-ten Schleifendurchlauf gilt für alle v aus V,
dass d (v ) = (v ).
i) d 2 (w) = d1 (w) ⇒
ii) d 2 (w) < d1 (w) ⇒
(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.
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.
WSI für Informatik, Universität Tübingen
191
Lemma:
Für w ∈ V gilt :
Beweis:
Nach obigem Lemma und der Annahme der Nichtexistenz
negativer Zykel folgt, dass alle billigsten Wege Länge
höchstens n-1 haben.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
Um aber alle Zykel entdecken zu können, benötigt man
in 2 insgesamt n Durchläufe.
190
Vorlesung Algorithmen (RN/MK)
95
WSI für Informatik, Universität Tübingen
192
96
All Pairs Shortest Paths
Annahme: Keine negativen Zykel.
V = {1,2,..., n}
Algorithmus:
for all i, j ∈ V do
Für i, j ∈ V und 0 ≤ k ≤ n definiere
0
k
(i, j ) := Kosten des billigsten Weges von i nach j,
dessen innere Knoten ≤ k sind.
(1,4 ) = ∞
(
1 1,4 ) = ∞
2 (1,4 ) = 6
3 (1, 4 ) = 1
4 (1,4 ) = 1
-3
k
WSI für Informatik, Universität Tübingen
193
Vorlesung Algorithmen (RN/MK)
k −1
k −1
(k , j )}
k
aus
2 Möglichkeiten:
Idee:
(i, j )
k-1 (i , k )
(i, j ) = min{
Vorlesung Algorithmen (RN/MK)
?
k −1
Beobachtung:
Es reicht sogar, einmal Bellman-Ford und (n-1)-mal
Dijkstra auszuführen.
Laufzeit : O(n ⋅ (n + m ) log n )
j
(k , j )
k
k-1
(i, j ),
k −1
(i, k ) +
k −1
Führe n-mal für alle möglichen Startknoten Bellman-FordAlgorithmus aus.
Laufzeit : O(n ⋅ nm )
Entweder k Teil eines billigeren
Weges oder nicht:
k-1
i
k-1
195
Benutze Algorithmus von Dijkstra bzw. Bellman-Ford
, sonst.
Frage: Wie berechnet sich
WSI für Informatik, Universität Tübingen
Alternativer Algorithmus:
(i, j ) = (i, j ) = Kosten des billigsten Weges von i nach j.
k
(i, j ), (i, k ) +
od
Laufzeit: O(n³)
∞

Also gilt:
k −1
od
5
c(i, j ), falls (i, j ) ∈ E.

(
,
)
=
, falls i = j.
i
j
0
0
Also:
;
od
4
3
, sonst
for all j = 1 to n do
(i, j ) ← min{
2
2
1
Vorlesung Algorithmen (RN/MK)
n
2
4
∞

for k = 1 to n do
for all i = 1 to n do
Beispiel:
0
c(i, j ), falls (i, j ) ∈ E
(i, j ) ←  0 , falls i = j
(k , j )}
WSI für Informatik, Universität Tübingen
194
Vorlesung Algorithmen (RN/MK)
97
WSI für Informatik, Universität Tübingen
196
98
DFS teilt die Kanten des Graphen in vier Klassen ein, je nach
Art des Besuchs:
Wir betrachten gerade die gerichtete Kante (v,w):
6.4 Depth First Search (Tiefensuche)
Durchmusterung von Graphen.
Wichtige Eigenschaften:
1. (v,w) gehört zu Baumkanten T, falls w noch nicht besucht.
Mit DFS Graph systematisch von einem Knoten s aus zu
durchmustern, dabei immer zuerst „in die Tiefe“.
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.
Beispiel:
3. (v,w) gehört zu Rückwärtskanten B, falls w schon besucht
*T v.
→
und w 
s
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
197
Vorlesung Algorithmen (RN/MK)
Rekursion:
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.
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
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
198
Vorlesung Algorithmen (RN/MK)
99
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
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.
201
Vorlesung Algorithmen (RN/MK)
f 6
Laufzeit:
da
a 1
c 3
e 5
d)
g 7
⇒ O ∑ (1 + out deg(v ))  = O(n + m ).
 v∈V

WSI für Informatik, Universität Tübingen
*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)
h 8
O(n+m)
a) Einzellaufzeit eines Aufrufs (ohne Rekursion)
ist O(1+outdeg(v))
b) für jeden Knoten einmal DFS-Aufruf
Vorlesung Algorithmen (RN/MK)
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 4
b 2
s
WSI für Informatik, Universität Tübingen
202
Vorlesung Algorithmen (RN/MK)
101
WSI für Informatik, Universität Tübingen
204
10
2
Bemerkungen:
•T, B, F, C werden im wesentlichen durch dfsnum, compnum
festgelegt (vgl. Lemma!)
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 ].
•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)
Beweis:
e)
WSI für Informatik, Universität Tübingen
205
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
Starke Zusammenhangskomponenten
*T w ⇒ dfsnum[v ] ≤ dfsnum[w]
(v, w) ∈ T ∪ F ⇒ v →
Ein gerichteter Graph G=(V,E) heißt stark zusammen* w.
→
hängend gdw. ∀v, w ∈ V : v 
E
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
Die maximalen (bzgl. Mengeninklusion) stark zusammenhängenden Teilgraphen von G heißen starke Zusammenhangskomponenten (SZK‘s).
Beispiel:
a
f), g) folgen aus d) und e) ...
c
b
K3
d
K1
h K4
e
K2
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
207
206
Vorlesung Algorithmen (RN/MK)
103
f
g
WSI für Informatik, Universität Tübingen
208
10
4
Idee für Algorithmus:
Erweitere DFS:
Beispiel:
Sei G′ = (V ′, E ′) bisher erforschter Teilgraph von G.
Verwalte die SZK’s von G :
a
c
b
Starte mit V ′ = {a}, E ′ = o/ , SZK = {{a}}.
Sei (v,w) die nächste Kante in DFS. Dann ist v ∈ V ′.
d
h
e
f
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 )
unfertig:
wurzeln:
a
a
bc
b
e
e
g
f
f
g
g
Beobachtung:
* g
→
1. ∀v ∈ unfertig : v 
E
Aber wie zusammenfügen?
2. ∃/(v, w) ∈ E : v in abgeschlossener und
w in nichtabgeschlossener Komponente.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
209
Vorlesung Algorithmen (RN/MK)
Bezeichnungen:
( g , b ) ∈ B : vereinigt vier Komponenten {b, c}, {e}, { f }, {g}.
unfertig:
wurzeln:
•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!)
a
a
bcefg
b
( g , h ) ∈ T : erzeuge neue Komponente {h}
•wurzeln ist Folge der Wurzeln von noch nicht abgeschlossenen
SZK´s. (Sortiert nach dfsnum!)
WSI für Informatik, Universität Tübingen
211
Von g ausgehende Kanten:
( g , d ) ∈ C : tut nichts, d liegt in abgeschlossener SZK.
•SZK K heißt abgeschlossen, wenn alle DFS-Aufrufe für Knoten
in K abgeschlossen sind.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
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.
210
Vorlesung Algorithmen (RN/MK)
105
WSI für Informatik, Universität Tübingen
212
10
6
1.Fall: (v, w) ∈ T :
push (w, unfertig); push (w, wurzeln)
Operationen auf unfertig und wurzeln erlauben Implementierung
als Keller (Stack):
z.B. Vereinigen von Komponenten:
K1
unfertig
K2
w
K3
K4
v
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!
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
Vorlesung Algorithmen (RN/MK)
2.Fall: (v, w) ∈/ T :
a)
b)
Korrektheit:
Invarianten:
I1:
∃/(v, w) ∈ E mit v in abgeschlossener und w in nichtabgeschlossener SZK.
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:
I2:
I3:
Zu zeigen:
Nichtabgeschlossene SZK´s liegen auf einem Pfad,
insbesondere ihre Wurzeln liegen auf einem
Baumpfad
Knoten jeder nichtabgeschlossenen Komponente Ki
bilden Intervall in „unfertig“, erstes Element des
Intervalls ist die Wurzel von Ki.
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.
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
Vorlesung Algorithmen (RN/MK)
107
WSI für Informatik, Universität Tübingen
216
10
8
Vermöge nachfolgendem Algorithmus (Programm) erhalten wir:
Zeilen (13)-(16) : Ausgabe der SZK mit Wurzel v.
Bemerkungen:
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
•
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)
(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
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
218
Vorlesung Algorithmen (RN/MK)
109
WSI für Informatik, Universität Tübingen
220
11
0
Anwendungsbeispiele:
• Computer-Netzwerke...
• Elektronische Schaltkreise...
• Netz von Telefonanschlüssen...
uvm.
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.
Lemma:
G(V,ET) ist azyklisch.
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:
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
Beweis der Behauptung per Induktion:
Sei T1 = (V , E1 ) ein MST mit E ′ ⊆ E1
(T1 existiert, da E ′ gut ).
Ist e ∈ E1 , so fertig.
221
Vorlesung Algorithmen (RN/MK)
Kruskals Greedy-Algorithmus für MST
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 ).
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
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.
Wir suchen also einen „aufspannenden Baum“ mit minimalen
Kosten (MST, Minimum Spanning Tree).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
Da nach Voraussetzung T1ein 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.
222
Vorlesung Algorithmen (RN/MK)
111
WSI für Informatik, Universität Tübingen
224
11
2
Damit wir d die for-Schleife in Kruskals Algorithmus zu:
Beispielbild:
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
T1 : E1
e1
e
T2 : ( E1 \ {e1}) ∪ {e}
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
225
Vorlesung Algorithmen (RN/MK)
Zur Implementierung:
Wir halten uns eine Partition V1 ∪ V2 ∪ ... ∪ Vk = V
von V : ∀i ≠ j : Vi ∩ V j = o/ und ∀i : Vi ≠ o/ .
•Union(a,b):
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
Operationen:
Starten mit Partition {{1}, {2}, ... , {n}}.
Benötigen:
•Find(x):
WSI für Informatik, Universität Tübingen
Gibt Namen der Menge zurück,
die x enthält.
Vereinigt die Mengen a und b.
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
226
Vorlesung Algorithmen (RN/MK)
113
WSI für Informatik, Universität Tübingen
228
11
4
Damit folgende Implementierung:
Heuristische Ideen zur Verbesserung:
Initialisierung:
•Union sollte nicht alle Elemente anschauen...
Verwalte Elemente jeder Menge separat...
•Behalte bei Union immer die Namen der größeren
Mengen.
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
229
Vorlesung Algorithmen (RN/MK)
Also zusätzlich Verwaltung der Mengen als Listen
(samt Größenangabe):
Size Elem.
1
2 2
3 5
4 1
Vorlesung Algorithmen (RN/MK)
wie vorher
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.
Bild:
R:
WSI für Informatik, Universität Tübingen
i =1
Vorlesung Algorithmen (RN/MK)
230
115
WSI für Informatik, Universität Tübingen
232
11
6
n −1
n
i =1
j =1
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]
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.
x
Damit:
Union(a,b): „Zusammenhängen“ von Bäumen.
a
b
Zeit: O(1)
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
Vorlesung Algorithmen (RN/MK)
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).
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.
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:
Anderes Beispiel für amortisierte Analyse:
Nicht trivial n log n, sondern
2n amortisiert...
x
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
235
Find(x):
Korollar:
Der Algorithmus von Kruskal hat Laufzeit O(m ⋅ log m ) .
Binärzähler:
WSI für Informatik, Universität Tübingen
234
Vorlesung Algorithmen (RN/MK)
117
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.
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:
wächst extrem langsam und ist für alle realistischen
Werte ≤ 5.
for i = 1 to n – m + 1 do
überprüfe, ob P = T[i..i+m–1]
od
Der Beweis obiger Mitteilung ist ziemlich kompliziert.
Laufzeit im Worst Case O(m· n).
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
237
Vorlesung Algorithmen (RN/MK)
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.)
Zeichenkette (String) T ist endliche Folge von Symbolen
aus endlichem Alphabet Σ .
T
Besteht T aus n Symbolen, so werden diese in
T[1], T[2], ..., T[n] gespeichert.
···
P
T[i..j], 1 ≤ i ≤ j ≤ n ist das an der Position i beginnende
und an der Position j endende Teilwort von T.
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
WSI für Informatik, Universität Tübingen
239
7.1 Der Algorithmus von Knuth-Morris-Pratt
7. Mustersuche in Zeichenketten
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
238
···
a
b
a
a
b
a
a
a
b
a
b
a
a
Vorlesung Algorithmen (RN/MK)
119
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“.
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
Die Präfixfunktion eines Musters
Zentral für den KMP-Algorithmus:
d.h. ∃ P´∈ Σ q −k : P[1..q ] = P´o P[1..k ]
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 ?
Beispiel: P = a
i= 1
π(i) = 0
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
b
a
c
b
s=4
a
b
a
b
a
a
b
241
a
b
a
b
a
c
a
Vorlesung Algorithmen (RN/MK)
a
b
b
a
b
a
c
a
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
a
3
1
b
4
2
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
Mismatch
q=5
Hier: s´ = 6
c
b
2
0
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
Beispiel:
T
P[1..k ] ist Suffix von P[1..q ] }
242
Vorlesung Algorithmen (RN/MK)
121
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;
(4) for q 2 to m do
(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
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.
245
Vorlesung Algorithmen (RN/MK)
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.
P[1..j] ist Suffix von P[1..q]
P[1..j´] ist Suffix von P[1..q]
1444442444443
D.h., „amortisiert“ betrachtet Kosten pro einem
for-Schleifendurchlauf O(1).
Damit Laufzeit von Berechne_Präfixfunktion(P) O(m).
⇒ P[1..j] ist Suffix von P[1..j´] und j ist maximal unter
Zahlen mit dieser Eigenschaft.
⇒ π(j´) = j und damit j ∈ π * (q )
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 ...
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.
Andererseits in jedem Durchlauf der while-Schleife k um
mindestens 1 erniedrigt, denn π[k] < k ∀ k!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
246
Vorlesung Algorithmen (RN/MK)
123
WSI für Informatik, Universität Tübingen
248
12
4
Klar: Berechne_Präfixfunktion(P) korrekt für π(1) = 0
(siehe Zeile (2) ).
Beweis:
(q > 0 ) :
Sei r =
Lemma 2:
∀ q = 1, 2 , ..., m:
(q ) > 0 ⇒ (q ) − 1∈ * (q − 1) .
Lemma 2
⇒ r = 1 + max{k ∈ * (q - 1) P[k + 1] = P[q ]}
1444442444443
=E
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
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/ .
249
Vorlesung Algorithmen (RN/MK)
Eq −1 := { k k ∈ * (q − 1) und P[k + 1] = P[q ] }
Lemma 3:
∀ q = 2 , ..., m:
0 ,
(q ) = 
1 + max
q −1
sonst .
WSI für Informatik, Universität Tübingen
251
Zeilen (5)-(10) passen k so an, dass es der korrekte Wert
von [q ] wird:
falls Eq-1 = o/
{k ∈ E },
WSI für Informatik, Universität Tübingen
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)
Definiere für q = 2, ... , m
Vorlesung Algorithmen (RN/MK)
(q ), d.h. P[1..r ] ist Suffix von P[1..q ]
und mit r ≥ 1 folgt P[r ] = P[q ].
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.
250
Vorlesung Algorithmen (RN/MK)
125
WSI für Informatik, Universität Tübingen
252
12
6
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
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
Vorlesung Algorithmen (RN/MK)
(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“;
s ← s + 1 s ← s + [0]
(12)
(13)
else s ← s + 1 s ← s + max( [ j ], j − [T [s + j ]])
(14)
fi
(15) od
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.
WSI für Informatik, Universität Tübingen
255
Boyer-Moore-Matcher (T , P, ∑ )
7.2 Der Algorithmus von Boyer-Moore
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
254
Vorlesung Algorithmen (RN/MK)
127
WSI für Informatik, Universität Tübingen
256
12
8
Beweis:
Fall 1: k=0:
D.h., T [s + j ] kommt nicht in P vor und so kann P
Die wesentlichen Eigenschaften des Algorithmus von
Boyer-Moore sind
der Vergleich des Musters selbst gegen ein Textstück
von rechts nach links
gegenüber T oE um j nach rechts verschoben werden.
Bild/Beispiel:
und die Benutzung zweier, unabhängig voneinander
arbeitender Heuristiken „schlechter Buchstabe“ und
„gutes Suffix“.
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 , P = a
⇒ k = 0 und j = m in allen Fällen, also maximale
n
m
Verschiebung möglich!
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
257
Vorlesung Algorithmen (RN/MK)
259
Fall 2: k < j :
D.h., T [s + j ] kommt in P links von der Stelle j vor und j − k > 0.
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
WSI für Informatik, Universität Tübingen
Ohne Verlust kann um j − k verschoben werden.
Bild/Beispiel:
max {i T [s + j ] = P[i ]}, falls T [s + j ] in P vorkommt.
k :=  1≤i≤ m
0
, sonst.
T:
P:
Lemma: s kann gemäß der Heuristik „schlechter Buchstabe“
um j-k erhöht werden.
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
258
Vorlesung Algorithmen (RN/MK)
129
WSI für Informatik, Universität Tübingen
260
13
0
Berechne_letztes_Vorkommen ( P, m, Σ ) :
Fall 3: k >j:
D.h. T[s+j] kommt in P rechts von der Stelle j vor
und j-k < 0.
for „alle a ∈ Σ “ do
[a ] ← 0;
od;
for j ← 1 to m do
[P[ j ]] ← j;
od;
return
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
Laufzeit: O( Σ + m )
261
Vorlesung Algorithmen (RN/MK)
P:
a
b
r
a l l
k=4 (=m)
s=2
a
l a
j=3
d
a
b
r
T:
a
l
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:
l
a
d
b
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
heißt „Letztes_Vorkommen_Funktion“ und wird durch folgenden
Algorithmus bestimmt:
WSI für Informatik, Universität Tübingen
3
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.
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.
Vorlesung Algorithmen (RN/MK)
a
l
Negative Verschiebung um j-k = -1:
a
263
Die Heuristik „gutes Suffix“:
Bild/Beispiel:
T:
WSI für Informatik, Universität Tübingen
nach rechts schieben können
262
Vorlesung Algorithmen (RN/MK)
131
WSI für Informatik, Universität Tübingen
264
13
2
ist die Gutes_Suffix_Funktion
Zur weiteren Vereinfachung von :
s
Sei P′ := P ( P revertiert), und ′ die Präfixfunktion von P′.
Zur Berechnung von :
Beobachtung 1:
[ j ] ≤ m − [m]
Damit Umschreiben der Definition von
[ j] = m −
Vorlesung Algorithmen (RN/MK)
Sei weiter k maximal unter allen Worten mit der Eigenschaft, dass P[ j + 1..m] Suffix von P[1..k ] ist.
[ j]:
max {k P[ j + 1..m] ~ P[1..k ]}
Lemma:
π′[l ] = m − j , wobei l = (m − k ) + (m − j ).
( m )≤ k < m
WSI für Informatik, Universität Tübingen
265
Vorlesung Algorithmen (RN/MK)
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 −
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
[ 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 ]].
max ({ [m]} ∪ {k P[ j + 1..m] ist Suffix von P[1..k ]})
( m )≤ k < m
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
266
Vorlesung Algorithmen (RN/MK)
133
WSI für Informatik, Universität Tübingen
268
13
4
Damit:
Nun gilt:
Berechne_Gutes_Suffix (P,m):
π ← Berechne_Präfixfunktion( P);
P′ ← Revertiere ( P);
m − π′[l ] + 1 < m − (m − j ) + 1 = j + 1
und damit ist P[ j + 1..m] Suffix von P[1..k − m + j + π′[l ]]
π′ ← 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
=: 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
Vorlesung Algorithmen (RN/MK)
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
WSI für Informatik, Universität Tübingen
Laufzeit Berechne_Gutes_Suffix:
271
O(m)
Gesamte Laufzeit Boyer-Moore:
(Worst Case)
j = m − π′[l ]})
O((n − m )m + Σ )
= min ({m − π[m]} ∪ {l − π′[l ] j = m − π′[l ]})
1≤ l ≤ m
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
270
Vorlesung Algorithmen (RN/MK)
135
WSI für Informatik, Universität Tübingen
272
13
6
7.3 Der Algorithmus von Karp-Rabin
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 :
Vereinfachende Annahme: Σ = {0,1,...,9}
Verallgemeinerung auf beliebige Alphabete leicht zu tun.
Fp (T [s + 2 .. s + m + 1]) =
(10 ⋅ (F (T [s + 1 .. s + m]) − 10
Definiere folgende „Fingerabdrucksfunktion“ für eine Primzahl:
Fp : Z → Z , Fp ( x ) = x (mod p ).
WSI für Informatik, Universität Tübingen
273
Vorlesung Algorithmen (RN/MK)
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
WSI für Informatik, Universität Tübingen
WSI für Informatik, Universität Tübingen
275
Beispiel:
Der Algorithmus von Karp-Rabin:
Vorlesung Algorithmen (RN/MK)
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,
m −1
falls 10 (mod p ) schon einmalig vorausberechnet wurde.
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)
m −1
p
+
p
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
274
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)
137
WSI für Informatik, Universität Tübingen
276
13
8
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.
Mitteilung:
Der Karp-Rabin-Algorithmus benötigt O(n+m) Schritte
1
und hat Fehlerwahrscheinlichkeit O .
n
Beispiel:
S=aabbabb$
1
WSI für Informatik, Universität Tübingen
277
abb$
Vorlesung Algorithmen (RN/MK)
•
•
WSI für Informatik, Universität Tübingen
$
5
$
b
4 abb$
$
7
3
WSI für Informatik, Universität Tübingen
279
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.
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)
8
abb$
Eine erste Anwendung:
Lösung des grundlegenden Problems „Mustersuche in
Zeichenketten“ mittels Suffixbäumen:
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:
•
b
bb
abbabb$
2
Vorlesung Algorithmen (RN/MK)
$
a
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.
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.
278
Vorlesung Algorithmen (RN/MK)
139
WSI für Informatik, Universität Tübingen
280
14
0
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).
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
•Der Pfad endet an einem Knoten w in T :
281
Vorlesung Algorithmen (RN/MK)
Beginne mit einzelner Kante für das Suffix S [1 .. n].
Mit i=2 beginnend, füge sukkzessiv Suffixe S [i .. n ] hinzu.
Genauer:
(*).
WSI für Informatik, Universität Tübingen
283
Bei Annahme eines Alphabets konstanter Größe hat obiger Algorithmus Laufzeit O(n²).
Ein naiver Algorithmus zum Aufbau von Suffixbäumen:
Idee:
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.
Mitteilung:
Mit Hilfe der Algorithmen von McCreight, Weiner oder
Ukkonen lassen sich Suffixbäume in Zeit O(n) aufbauen.
Sei Ni der Baum, der nach eintragen von Suffix
S [i .. n ] entstand.
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.
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
Vorlesung Algorithmen (RN/MK)
141
WSI für Informatik, Universität Tübingen
284
14
2
Beispiel: S1 = ab$1 , S 2 = aa$ 2 ,
Verallgemeinerte Suffixbäume:
Darstellung einer Menge von Zeichenketten{S1 , S 2 , ... , S r }
anstelle nur einer.
S 3 = S1 o S 2 = ab$1 aa$ 2
Eine Konstruktionsmöglichkeit:
Nimm an, alle r Zeichenketten enden in verschiedenen Endsymbolen $1 ,$ 2 , ... ,$ r.
$2
a$ 2
1
6
3
5
2
4
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...
WSI für Informatik, Universität Tübingen
b$1 aa$2
b$1 aa$2
Konkateniere S1 , S 2 , ..., S r und bilde Suffixbaum für konkatenierte Zeichenkette in Zeit O( S1 + ... + S r ) .
Vorlesung Algorithmen (RN/MK)
$2
$1 aa$ 2
a
285
Vorlesung Algorithmen (RN/MK)
Problem: „Künstliche Suffixe“, die sich über mehr als eine
Zeichenkette erstrecken.
WSI für Informatik, Universität Tübingen
287
Anwendung: Längste gemeinsame Teilzeichenkette zweier
Zeichenketten
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.
Beispiel:
S1 = superiorcalifornialives
S2= sealiver
Lösung: alive
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
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.
286
Vorlesung Algorithmen (RN/MK)
143
WSI für Informatik, Universität Tübingen
288
14
4
Allgemeine Lösungsmethode:
Wir betrachten Variante der Ziv-Lempel-Kompressionsmethode
•Bilde verallgemeinerten Suffixbaum für S1 und S2.
Jedes Blatt repräsentiert entweder ein Suffix von S1 oder
ein Suffix von S2.
Idee:
•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.
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.
•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
Vorlesung Algorithmen (RN/MK)
Anwendung: Datenkompression:
291
Kompressionsalgorithmus:
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=
WSI für Informatik, Universität Tübingen
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
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
l7 = 3, s7 = 2.
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
290
Vorlesung Algorithmen (RN/MK)
145
WSI für Informatik, Universität Tübingen
292
14
6
Beispiel:
1. S =
a
b
a
c
a
b
a
x
a
b
Nun Anwendung der cv -Werte:
z
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.
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
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.
293
Vorlesung Algorithmen (RN/MK)
WSI für Informatik, Universität Tübingen
295
Realisierung:
Zunächst konstruiere Suffixbaum T zu S in Linearzeit.
Nummeriere jeden Knoten v mit:
cv := kleinste Blattnummerierung im Unterbaum von v
< Ende Vorlesung Algorithmen >
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
Vorlesung Algorithmen (RN/MK)
147
WSI für Informatik, Universität Tübingen
296
14
8