Algorithmen und Datenstrukturen (ALP 3)im WS 08/09

geschrieben von Simon Putzke

gehalten von Prof. Dr. Christian Knauer

1

.

"THE BEER-WARE LICENSE" (Revision 42):Simon Putzke wrote this file. As long as you retain this notice

you can do whatever you want with this stu!.If we meet some day, and you thinkthis stu! is worth it,

you can buy me a beer in return<sputzke@inf.fu-berlin.de>

2

Inhaltsverzeichnis

1 Analyse von Algorithmen 6

1.1 E"zienz (insbesondere Laufzeit) von Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . 6

1.1.1 Experimentelle Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.1.2 Theoretische Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.1.3 Pseudo- Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.1.4 Registermaschine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.1.5 Laufzeit von Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.1.6 Asymptotisches Laufzeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

1.1.7 Rekursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1.1.8 Rekursion auf der RAM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

1.2 Datenstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

1.2.1 Beispiel Stapel (Stack) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

1.2.2 “Indirekte” Anwendung von Stapeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

1.3 Dynamisierung Array- basierter Datenstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . 21

2 Datenabstraktion 24

2.1 Geheimnisprinzip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.2 Abstrakte Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

2.2.1 Explizite Schnittstellenbeschreibung in Java . . . . . . . . . . . . . . . . . . . . . . . . 25

3 ADT- Anwendungen, Implementierungen 27

3.1 Der ADT - Prioritätswarteschlange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

3.1.1 Implementierung des ADT PWS (für U = N) . . . . . . . . . . . . . . . . . . . . . . . 28

3.2 Implementieruung des Heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.3 Erweiterung des ADT PWS : VPWS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

3.4 neue Implementierung als Binomialheaps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3.5 Lokalisierung von Einträgen in Datenstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . 38

3.6 Bäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

3.6.1 Schnittstelle zum ADT Baum (Auswahl) . . . . . . . . . . . . . . . . . . . . . . . . . 39

3.6.1.1 Darstellung als Ausdrucksbaums . . . . . . . . . . . . . . . . . . . . . . . . 42

3.6.1.2 Umgekehrte Polnische Notation (UP- Notation): . . . . . . . . . . . . . . . . 42

3.6.2 weitere Anwendungen: Spielbäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

3.6.3 Breitensuche in Bäumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

3.6.4 Tiefensuche in Bäumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

3.7 ADT Wörterbuch (Dictionary) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

3

3.7.1 Implementierung des ADT Wörterbuch . . . . . . . . . . . . . . . . . . . . . . . . . . 443.7.2 Implementierung durch Hashing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453.7.3 Hashcodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

3.7.3.1 Analyse der mittleren Laufzeit von Hashing mit Verkettung . . . . . . . . . . 473.7.4 Zufallsexperiment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493.7.5 Universelle Hashfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

3.8 ADT Geordnetes Wörterbuch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533.8.1 Implementierung ADT Geordnetes Wörterbuch . . . . . . . . . . . . . . . . . . . . . 533.8.2 Skip Liste: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

3.8.2.1 Suche in einer Skip- Liste(find, succ, pred) . . . . . . . . . . . . . . . . . . . 543.8.2.2 Bestimmung der Si (mod r)

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543.8.2.3 Löschen von z ! S . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543.8.2.4 Einfügen von z ! S . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

3.8.3 Balancierte Mehrweg- Bäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563.9 (2,4)- Bäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

3.9.1 (a,b)- Bäume (a, b ! N, b + 1 " 2a) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613.9.2 Amortisierte Rebalancierungskosten in (2,5)- Bäumen . . . . . . . . . . . . . . . . . . 61

3.10 Implementierung von geordneten Wörterbüchern für Zeichenketten . . . . . . . . . . . . . . . 623.11 Wörterbücher für Strings- Trie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

3.11.1 Su"xbaum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653.12 Su"x- Bäume TRIE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663.13 Sequence- Alignment Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

3.13.1 Kosten eines Alignments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 673.13.2 Alignment von Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

3.13.2.1 Berechnung von OPT(m,n) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

4 Algorithmen auf Graphen 724.1 Grundbegri!e aus der Graphentheorie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724.2 Repräsentation von Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 734.3 Der ADT Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 754.4 Graphenalgorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

4.4.1 Kürzeste Wege in Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 764.4.1.1 Eigenschaften kürzester Wege . . . . . . . . . . . . . . . . . . . . . . . . . . . 764.4.1.2 Das Single-Source-Shortest Path Problem . . . . . . . . . . . . . . . . . . . 804.4.1.3 All-pairs Shortest Path Problem . . . . . . . . . . . . . . . . . . . . . . . . . 814.4.1.4 Kürzeste Wege von einem ausgezeichneten Startknoten . . . . . . . . . . . . 834.4.1.5 Relaxation einer Kante (u, v) ! E . . . . . . . . . . . . . . . . . . . . . . . . 834.4.1.6 Algorithmus von Bellman- Ford . . . . . . . . . . . . . . . . . . . . . . . . . 854.4.1.7 Der Algorithmus von Dijkstra . . . . . . . . . . . . . . . . . . . . . . . . . . 89

4

5 Minimal aufspannenden Bäumen (MST) 92

5.1 Berechnung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

5.2 Generischer MST- Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

5.3 Begri!e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

5

16. Oktober 2008

1 Analyse von Algorithmen

“Def.”: Ein Algorithmus ist eine Schritt-für-Schritt Anleitung zur Lösung eines Problems

• Speicherverbrauch kann durch geeigneten Algorithmus gering gehalten werden

• Zeitbedarf kann durch geeigneten Algorithmus gering gehalten werden

Frage nach

1. der E"zienz von Algorithmen

2. der Korrektheit von Algorithmen

1.1 E!zienz (insbesondere Laufzeit) von Algorithmen

• Algorithmus transformiert Eingabe in Ausgabe

• Die Laufzeit eines Algorithmus hängt von der Größe der Eingabe ab

(Funktion die einer Eingabe die Laufzeit des Algorithmus darauf zuordnet)

1.1.1 Experimentelle Analyse

oft gar nicht möglich, bzw. sinnvoll

• Implementierung

• Messung der Laufzeit auf vielen, “typischen” Eingaben

Problematisch!

1.1.2 Theoretische Analyse

• abstrakte Beschreibung des Algorithmus (Pseudocode)

• Charakterisierung der Laufzeit (als Funktion der Größe der Eingabe)

• dabei betrachten wir den schlechtesten Fall für alle Eingaben fester Länge (“worst case”- Analyse)

6

1.1.3 Pseudo- Code

• abstrakte Beschreibung eines Algorithmus “Programm”

• “strukturierter” (& detaillierter) als prosaische Beschreibung

• weniger detailliert als Java- Programm

Bsp.

ArrayMax (A, n)

Input: Feld A [1, ..., n] von n ganzen Zahlen

Output: max1! i!n A [i]

currentMax # A [1]

for i = 2 to n

if current Max < A [i] then currentMax = A [i]

return currentMax

Im Detail:

• Kontrollflussanweisungen (for, while, repeat, if then ... else, goto)

• Deklariationen

• Methodenaufrufe

• Wertrückgabe

• Ausdrücke (Zuweisungen, Tests, ...)

“Verboten”:

ArrayMax+ (A, n)

return max1! i!n A [i]

• nicht verboten bei Test auf Korrektheit, aber bei Analyse

1.1.4 Registermaschine

7

• Rechenkern = arithm. Operationen (+, -, ·, /)

• Kontrollflussoperationen (JMP, bedingte Sprünge)

• all diese Operatoren können in einem Takt bearbeitet werden

– linear organisierter Speicher mit whalfreiem Zugri!! jede Zelle kann eine ganze Zahl speichern! auf jede Zelle kann in einem Takt (durch Angabe der Adresse) zugegri!en werden! der Speicher ist unbegrenzt

Pseudo Code ist O.K. falls jede primtive Operation durch $ 10 RAM- Anweisungen ausgeführt werden kann.

1.1.5 Laufzeit von Algorithmen

Def:

A Algorithmus (RAM- Programm)

I Eingabe für A

TA(I) = Anzahl der RAM Operationen die A auf Eingabe I macht “Rechenzeit von A uf I”

TA(n) = max maxI,Groesse von I=n TA(I) “worst- case Rechenzeit von A”

Laufzeit von A (Funktion N % N)

Beispiel (I) mit Addition:

Algorithm double ( x )

Input x ! NOutput 2xy <& xy <& y + xreturn y

(Pseudocode)

LOAD 0 (CPU <& x )STORE 1 (CPU <& y )LOAD 1 (CPU <& y )ADD 0 (CPU <&CPU + x)STORE 1 (CPU <& y )LOAD 1 (CPU <& y )RETURN RAM

8

Beispiel (II) ohne Addition:

Algorithm double ( x )

Input x ! N

Output 2xz <& xy <& xf o r i=1 to z doy <& y + 1return y

(Pseudocode)

TA(x)& ”3 + 2x

Typischerweise analyisieren wir Algorithmen im Pseudocode (Laufzeit 'Anzahl der Pseudocodezeilen)

Das ist zulässig, solange der verwendete Pseudo- Code die Eigenschaft hat, dass jede Code- Zeile durchkonstant viele RAM- Operationen realisiert wrrden können.

1.1.6 Asymptotisches Laufzeit

• “moderate” Änderungen des Maschinenmodells ändern die Laufzeit nur um einen konstanten Faktor.

• die asymptotische Laufzeit ignoriert konstante Faktoren und Terme niederer Ordnung.

Bsp.:

TA(n) = 1, 75n3 + (0, 4 log2n) = !(n3)

Erinnerung (O- Notation):DEF.:

f, g ! NN

f = O(g) ( )c > 0 )n0 ! N *n " n0 : f(n) $ c · g(n)

manchmal schreibt man auch für f = O(g) auch

1. f(n) = O(g(n))

2. f ! O(g)

BSP :

1. 12n& 4 $ 12n d.h. 12n& 4 = O(n)

2. n2 = O(n) gilt nicht!!

9

O-Notation HOWTO1.)

f(n) =!d

i=0 aini mit ai " 0

f(n) = O(nd)

2.)Wir sagen ”2n = O(n)” statt ”2n = O(n2)”

3.)Wir sagen ”2n = O(n)” statt ”2n = O(3n& 6)”

4.)Die Analogie O=̂ $, "=̂ ", !=̂ =

klappt oft (aber Vorsicht: nicht immer)5.)n! = O(n") *" $ #

6.)(log n)! = O(n") *", # > 0

Beispiel:Algorithm PrefixAverage (X, n)

Input X[0], . . . , X[n& 1], n

Output A[0], . . . , A[n& 1] mit A[i] = 1i+1

!j!i A[j]

A<&l e e r e s Feld mit n Elementen //1&mal durch lau fenf o r i = 0 to n&1 do //n&mal durch lau fensum <& 0 //n&mal durch lau fenf o r j = 0 to i do //( i+1 mal durch lau fen )sum <& sum + X[ j ] //im i&ten Durchlauf der äußeren S c h l e i f eA[ i ] <& (sum)/( i +1) //n&mal durch lau fenreturn A //1&mal durch lau fen

Gesamtkosten:

O(1)"#$%1&7

+O(n)" #$ %2&6,3

+ O(n"1&

i=0

(i + 1))

" #$ %4&5

= O(1) + O(n) + O(n2) = O(n2)

Algorithmus PrefixAverage2 (A,n)

In : s . o .Out : s . o .A <& l e e r e s Feld //1&malsum <& 0 //1&malf o r i = 0 to n&1 do //n&malsum <& sum + X[ i ] //n&malA[ i ]<& (sum)/( i +1) //n&malreturn A //1&mal

Laufzeit O(n)

10

1.1.7 Rekursion

Beispiel:

Potenzieren x, n ! Np(x, n) := xn = x · . . . · x" #$ %

n"mal

Lösung 1 : Iterartiv O(n)

Lösung 2: p(x, n) =

'x · p(x, n& 1)

1n > 0n = 0

Algorithm Pow (x,n)

Input x, n ! NOutput xn

i f n = 0 then return 1return x ! Pow (x , n&1)

Laufzeit:

T (n) =

'O(1)

T (n& 1) + O(1)n = 0n > 0

Lösung (n > 0) mit C > 0

T (n) $ T (n& 1) + C $ T (n& 2) + 2 · C $ T (n& 3) + 3 · Cper Induktion: T(n) $ T(n& k) + k · C*k $ 1 für k = n: T (n) $ T (0) + n · CBeweis:

x · Pow(x, n& 1)

x!Pow(x , n&1)=x!x!Pow(x , n&2)=x!x!x!Pow(x , n&3)=x!(n&mal )!x!Pow(x , 0 ) //Pow(x ,0)=1

Damit T (n) = O(n)

Lösung 3:

p(x, n) =

()*

)+

1,p

,x, n

2

--2

,p

,x, n"1

2

--2 · x

n = 0n = 2k

n = 2k & 1

Algorithm PowFast(x,n)

i f n=0 return 1i f n=2k thenz <& PowFast (x , 1/2 ) // n i cht so ! Syntakt i s ch aber kor rektre turn z!zi f n=2k+1 thenz <& PowFast (x , ( n&1)/2)re turn z!z!x

11

Laufzeitanalyse

Beschränken auf n = 2r für r " 0

T (n) =

'O(1)

T,

n2

-+ O(1)

n = 1n > 1

S(r) := T(2r)

S(r) =

'O(1)

S(r & 1) + O(1)r = 1r > 0

wie in (2:)

S(r) = O(r) = T (2r)

also

T (n) = O(log n)

12

28.Oktober 2008

1.1.7.1 Rekursionsbäume

Bsp.: PowFast

Fibonacci Zahlen

Bsp: Fibonacci- Zahlen

F(0)=F(1)=1

F(n)=F(n-1)+F(n-2), n " 2

Definition:

Rekursionbaum einer Prozedur A ist ein Baum TA, wobei

• jeder Aufruf der Prozedur entspricht einem Knoten

13

• Kinder von Knoten v sind die (rek.) Aufrufe von A die v tätigt (mit den jeweiligen Argumenten)

Die Rechenzeit von A auf x lässt sich bestimmen, indem man die in den Knoten des Berechnugsbam von Aauf x anfallende Arbeit aufsummiert.

Bsp: Mergesort

zum Sortieren von A[0], A[n + 1](n = 2kmit k " 0)

Anm. d. A.:

Mergesort funktioniert wie Quicksort nach dem Teile- und- Herrsche- Prinzip.

Es zerlegt die Liste in immer kleinere Listen, bis die Liste nur noch aus einem Element besteht und dieseTeillisten werden dann sortiert Schritt für Schritt wieder zusammengeführt.

Analyse

(a) T (n) = 2 · T (n2 ) + O(n)

per Induktion: T (n) = O(n · log n)

(b) Rekursionsaufruf für M.S. auf A[0], ..., A[n]

14

Gesamtkosten:

c · n"#$%Wurzel

+ c(n

2) + c(

n

2)

" #$ %Kinder d. Wurzel

+ c(n

4) + c(

n

4) + c(

n

4) + c(

n

4)

" #$ %Enkel der Wurzel

+ . . .

= c · (n + n2 ) + n

2 ) + (n4 + n

4 + n4 + n

4 ) + . . .)

= c(n + n + n + n + . . .)

= c · n (1 + 1 + 1 + . . . + 1)" #$ %#Rekursionsstufen

= c · n· Höhe des Baumes = c · n · log n

zu BSP (Fibonacci- Rekursion)

Laufzeit der direkten Rekursion

T (n) =

'!(1)

T (n& 1) + T (n& 2) + !(1)n $ 1n > 1

also

T (n) "'

1T (n& 1) + T (n& 2)

n $ 1n > 1

damit T (n) " F (n) (per Induktion)

F(0)=F(1)=1

F(n)=F(n-1)+F(n-2), n > 1 (s.o.)

= F (n& 2) + F (n& 3) + F (n& 2)

" 2F (n& 2)

" 2(2F (n& 4))

15

" 2(2(2 · F (n& 6)))

" 2i · F (n& 2i) (per Induktion)Damit (i = u

2 )

F (n) = 2n2 = (

+2)n

Alternativen

• tabellieren der bereits berechneten F(1) für 0 $ i < n (dynamisches Programmieren)Laufzeit O(n), Platzbedarf "(n)

• iterative LösungLaufzeit O(n), Platzbedarf "(1)

•.

F (n)F (n& 1)

/=

.F (n& 1) + F (n& 2)

F (n& 1)

/=

.1 11 0

/ .F (n& 1)F (n& 2)

/

mit $fn :=.

F (n)F (n& 1)

/

$fn =.

1 11 0

/

" #$ %M

·$fn"1

$f1 =.

11

/

Iteration:$fn = M · $fn"1 = M · M · $fn"2 = M · M · M · $fn"3

Ind.= M · . . . · M · $fn"i" #$ %i"mal

(i " 1)

= M i · $fn"i

i=n"1= Mn"1 · $f1

Kann in O(log n) Zeit durch schnelle (Matrix-) Exponentiation berechnet werden.

1.1.8 Rekursion auf der RAM

Algorithm min ( )x <& 5subrout ine1 (x )

Algorithm subrout ine1 ( i )k <& i+1subrout ine2 (k )

Algorithm subrout ine (k )y <& 6

• merken, welche Unterroutine gerade ausgeführt wird

• es gibt für jede Unterroutine eine Struktur in der ihr idealer Kontext (Variablenwerte, Rücksprung-adresse) gespeichert wird

(vgl. Rekursionsaufruf in z.B. MMIX)

16

30. Oktober 2008

1.2 Datenstrukturen

Schema zur Organisation von Daten, so dass gewisse Operationen auf / Manipulationen von Daten e!ektivdurchführbar sind.

1.2.1 Beispiel Stapel (Stack)

Manipulation von von Objekten erfolgt nach dem LIFO (last in- first out) Prinzip (hier: “Objekte”=int)

d.h. wir benötigen die Operationen

• einfügen eines neuen Elements (push)

• entfernen des zuletzt eingefügten Elements (pop)

• lesen des zuletzt eingefügten Elements (ohne es zu entfernen) (top)

• Test, ob der Stapel leer ist

(x#, S#) = pop(push(x, S)) , x# = x und S# = S

wobei :pop : Stape l ( i n t ) &> in t x Stape l ( i n t )push : i n t x Stape l ( i n t ) &> Stape l ( i n t )

Implementierung:

• int-Array F mit M Einträgen

• Zeiger top auf oberstes Element (int top=-1)

Melde Fehler , f a l l s Array F v o l l ( top = M&1)

& push (x ) top <& top + 1F [ top ] <& x

& pop ( ) re turn F [ top&&]Feh ler s i g n a l i s i e r e n , f a l l s Stack l e e r i s t ( top = &1)

17

Java- Implementierung:

c l a s s i n t ArrayStack {i n t F [ ] ;i n t top ;i n t M;i n t ArrayStack ( i n t m) {

M = m;top = &1;F = new in t M[ ] ;

}

i n t pop ( ) throws EmptyIntArrayStackEception {i f ( top == &1) throw . . .e l s e re turn F [ top&&];

}

Analyse von Datenstrukturen

• Wie e"zient sind die Operatoren auf der D.S.?(in Abhängigkeit von der Anzahl der in der Struktur gespeicherten Objekte)

• Wie viel Speicherplatz benötigt die Struktur?

hier:

• Platzbedarf !(M)

• !(1) Zeit für push & pop

Probleme:

• maximale Größe fest

• Implementierungsspezifische Ausnahmebehandlung

Implemetierung mittels verketteten Listen

• einfach verkettete Liste

18

• Einfügen und Löschen am Anfang der einfach verketteten Liste ist einfach (!(1) Zeit )

1.2.2 “Indirekte” Anwendung von Stapeln

• als Hilfsstruktur für andere D.S.

• beim Entwurf von Algorithmen

Beispiel: Gegeben

x2 wird von x3 verdeckt, x4 wird von x5 verdeckt. Wäre ein x6 größer als x5 und kleiner als x3, wäre auchx5 verdeckt.

Span berechnen:

Feld X[0],...,X[1] von n Zahlen

Berechne für alle 0 $ i $ n& 1

S[i] = max. Anzahl von aufeinanderfolgenden Elementen unmittelbar vor X[i] die kleiner als X[i] sind.

Algorithm Span (X, n)S <& Neues Feld mit n Einträgen

| f o r i = 0 to n&1 do| S [ i ] <& 0| | f o r j = 0 to i do| | i f X[ i&j ] " k l e i n e r g l e i c h " X[ i ] do| | S [ i ]++| | e l s e break ;

i

!(n"1&

i=0

&

j=0

1) = !(n2)

19

04. November 2008

Besser mittels Hilfsfunktion

• arbeiten X von links nach rechts

• von rechts “sichtbare” Elemente im Stapel (von rechts nach links)

• am Index ientferne alle Elemente von der Spitze des Stapels die $ X[i] sind und zähle span(X[i]) je um eins hochlege X[i] auf Stapel

Algorithm span (X, n)S <& neues Feld von n ZahlenA <& neuer l e e r e r Stape l

f o r i=0 to n&1 dowhi l e ( ! isEmpty (A)&&((X[ top (A)])<= X[ i ] ) ) do // en t f e rn e a l l e Elementepop (A) // aus A d i e k l e i n e r a l s X[ i ] s ind

i f isEmpty (A) S [ i ] <& i+1e l s e S [ i ] <& i & top (A)push ( i ,A)

$ i wird gelöscht und i wird hinzugefügt.

Analyse:

n push&Operationen$ n pop&Operationen$ 2n isEmpty &Operationen

Stack mit einfach verketteten Listen , !(n) Gesamtlaufzeit.

20

1.3 Dynamisierung Array- basierter Datenstrukturen

Konkretes Beispiel : Stapel

Ziel:

• Implemetierung von Stacks durch Arrays

• keine feste Größe

Idee: (nur push-Ops)

• Wir haben zu jedem Zeitpunkt ein Array in dem alle Elemente des Stapels abgespeichert sind.

• Wenn Platz in diesem Array nicht mehr ausreicht, legen wir ein neues Array doppelter Größer an undkopieren das alte Feld in den Anfang des neuen Feldes.

!(1) Zeit für push-Op (solange noch Platz!)

!(M) Zeit für push-Op die Umkopieren erfordert.

(typisch ist M’=2M, hier im Bild jedoch nicht.)

Probleme dabei:

Es gibt push- Operationen die "(#Elemente im Stapel) Zeit benötigen.

ABER:

Jede Folge von n push/pop- Operationen benötigt O(n) Zeit.

alternatives Argument via Bankiermethode.

21

Begründung:

1. Eine pop- Op benötigt nur !(1) Zeit. D.h. alle pop- Op’s in einer Folge von n push/pop- Op’s benötigtO(n) Zeit.

2. Betrachte Folge von n push- Op’s.

Die k-te push- Operation benötigt Zeit Tk =

'O(k)O(1)

k = 2i

sonst

Gesamtzeit für n push- Operationen

n&

k=0

Tk = O(n) +$log2 n%&

i=0

T2i

= O(n) +$log2 n%&

i=0

O(2i)

= O(n) + O(n)n&

k=0

Tk = O(n)

amortisierte Kosten von “O(1)”

Idee: (Wiederholung von oben)

• Jede elementare Operation verursacht gewisse Kosten

(z.B.: Kosten von pop: O(1) : 1$ ;Kosten von von push (kein Umkopieren): O(1) : 1$ , (mit Umkopieren) O(Größe des Arrays : #Elemente imStack $))

Definition (amortisiert):

Gegeben sie eine Datenstruktur, für die eine Folge von n Operationen insgesamt T(n) Zeit benötigt.

Dann nennen wir T (n)n die amortisierten Kosten pro Operation.

22

06. November 2008

• Eine Folge F von Operationen verursacht damit Gesamtkosten cF

(Ziel: zeige, dass cF = O(n) falls |F | = n)

• Wir werden zeigen: Falls wir jeder Operation 2$ “mitgeben”, können wir am Schluss die Kosten cF

begleichen.

Buchhaltervorschrift

• pop- Operation (bringt 2$ mit) :bezahle die Kosten (1$) und lege 1$ auf Sparbuch (der DS)

• push- Operation (bringt 2$ mit) :

– kein Kopieren : bezahle Kosten (1$) und lege 1$ auf das DS Sparbuch– mit Kopieren: bezahle Kosten (# Elemente im Stack) von meinen 2$ auf Sparbuch

Wir werden zeigen: das Sparbuch ist nie im Minus

1. die Kosten cF können bezahlt werden

2. es gilt cF = 2$ · |F |

• eine push- Op veranlasst, das im Fall mit M Einträgen verdoppelt wird, hat zur Folge, dass danachmind. M Operationen ausgeführt werden können, die nur 1$ kosten.

• der nächste au!allende Verdopplung kostet 2M $.

Problem: Der Platzbedarf der DS hängt nicht von der Anzahl der Elemente (tatsächlich von der maximalenStackgröße) ab, die in der DS gespeichert worden, sondern von der Anzahl der durchgeführten Operationen.

Lösung: Modifiziere pop

(falls Array nur noch zu 14 belegt ist, halbiere & kopiere um)

Implementierung (in Java)

23

2 Datenabstraktion

2.1 Geheimnisprinzip

Kenntnis der Spezifikationen eines Moduls, Datentyp, Systems ist notwendige und hinreichende Voraussetzungfür deren konkrete Benutzung.

Bsp.: Prozentuale Abstraktion

Datenabstraktion ist die Anwendung des Geheimnisprinzips auf die Darstellung komplexer Datenstrukturen:

• nicht direkt manipulierbar

• nur über (prozedurale) Schnittstelle manipulierbar (die geeignete Operationen zur Verfügung stellt)

Einschränkung der Sichtbarkeit bei der klassenbasierten Datenabstraktion:

• Das Klassenkonzept untersützt die Zusammenfassung von Daten und dem sie manipulierenden Opera-tionen (in einer syntaktischen Form).

• In Java kann das Verberigen der internen Repräsentation durch Sichtbarkeitsmodifikatoren erreichtwerden.

– public : überall– protected : innerhalb des eigenen Pakets und in den Unterklassen– private : nur innerhalb der umschließenden Klasse– default : innerhalb des Pakets

• Diese steuern die Sichtbarkeit von Attributen und Methoden

Bsp.: Stacks (als Arrays)

class Stack {int max = 100 ;Object [ ] S = new Object [max ] ;int t = 0 ;

void push ( Object o ) throws Exception {i f ( t == max) throw new Exeption ( ) ;s [ t++] = o ; // e r s t s [ t ] o zuweisen und dann t inkrement ieren

}

Object pop ( ) . . .}

Problem: direkte Manipulation der Daten möglich.

Stack s = new Stack ( ) ;s t = 124 ;s . push ( 3 ) ;

24

11. November 2008

2.2 Abstrakte Datentypen

Definition ADT :

Ein ADT ist eine Menge von Objekten mit einer Menge von Operationen auf diesen Objekten.

alternativ:

Ein Typ, dessen Objekte nur über die Operationen seiner Schnittstelle manipuliert werden können.

Beispiel: Stack

Operationen :push : ( x , S ) &> Spop : ( S) &> S

Objekte

Folgen (von Elementen)

- nach dem LIFO- Prinzip

Vorteile der Datenabstraktion

• Implementierung unabhängig vom Modell

• Sicherheit : Objekte können nicht in ungültige Zustände versetzt werden

• Flexibilität : Code kann unabhängig vom benutzten Code entwickelt werden

• Komfort : Benutzer abstrahiert von der Repräsentation

Reale Welt“reelle” Objekte mit “rellen” Operatoren

. Modellierung

Modell abstrakte Objekte , Operationen

. Implementierung

Datenstruktur, Methoden

2.2.1 Explizite Schnittstellenbeschreibung in Java

“Probleme”

• Operationen müssen aus dem Quelltext der Klasse herausgesucht werden

• die Implemetierung der Methoden wird nicht vom Benutzer verborgen

25

9, 1, 2, 5, 7, 5,

push_left push_rightpop_left pop_right

Deklaration eines Schnittstellentyps

interface S ta ck In t e r f a c e {void push ( Object o ) ;Object pop ( ) ;

}

• Methoden haben leeren Rumpf

• keine (non-const) Attribute

• Standardsichtbarkeit public

Im Programm:

(1 ) Fest legung auf e in e konkrete Implementierung

Stack s = new Stack ( ) ;

(2 ) e v t l . andere

S t a ck In t e r f a c e s = new Stack ( ) ;

(3 ) geht n i cht !

S t a ck In t e r f a c e s = new S ta ck In t e r f a c e ( ) ;

Implementierung einer Schnittstelle

Pflichten:

1. alle Schnittstellenmethoden müssen implementiert werden

2. alle Schnittstellenmethoden müssen public sein

Rechte:

1. Parameter von Schnittstellenmethoden dürfen umbenannt werden

2. beliebige weitere Attribute/Methoden

3. Schnittstelle kann als Typ verwendet werden (aber keine Instanzen möglich)

Bemerkung:

• Eine Klasse kann mehrere Schnittstellen implementieren

• guter Stil als Typbezeichner möglichst Schnittstellentypen verwenden, Klassentypen nur bei Instanzie-rung

26

13. November 2008

3 ADT- Anwendungen, Implementierungen

3.1 Der ADT - Prioritätswarteschlange

Motivation:

1. Scheduling von Prozessen im Betriebssystem (benötigt Operationen)

• finde Prozess mit höchster Priorität• erzeuge neuen Prozess (mit vorgegebener Priorität)• verringere Priorität eines Prozesses

2. Sortieren durch wiederholes Betimmen des kleinsten Elements: benötigt Operationen

• finde Element das am kleinsten ist• entferne dieses Element

ADT PWS (priority queue)

U: Universum, total geordnet via $ (Relation)

Objekte des ADT: endl. Teilmengen S / U

Operationen & ! &: findmin : S % U liefert min {x ! S}

deletemin S 0% S# mit S# = S \ min S

insert : (x, S) 0% S# mit S# = S 1 {x} x ! U

Damit:

Algorithm PQSort (A)

Input : Array A [ 1 ] , . . . ,A[ n ] von Elementen aus UOutput : Sor t i e rung von A ( bzg l . der Ordnung auf U)

PQ H;f o r i = 1 to n do

H. i n s e r t (A[ i ] ) ;

f o r i = 1 to n dopr in t H. f indmin ( ) ;H. de letemin ( ) ;

Laufzeit von PQSort:

TX Laufzeit von X ! {findmin, deletemin, insert}

Gesamtlaufzeit: O(n · Tinsert + n · Tfindmin + n · Tdeletemin + n)

Damit: Gesamtlaufzeit O,n2

-

27

3.1.1 Implementierung des ADT PWS (für U = N)

(a)

Implementierung der PWS als einfach verkettete Liste

Tfindmin = O(|S|), Tinsert = O(1), Tdeletemin = O(|S|)

(b)

Als Folge l unsortierter Listen mit

'l & 1 haben m Elemente

1 hat $ m Elementebei denen die Minima in einer Liste

(unsortiert) verkettet sind.

l · n = m

Tfindmin = O(l)

Tinsert = O(l)

Tdeletemin = O(l + m)

Damit:

Gesamtlaufzeit : (Optimal für l = m =+

n)

O(n · l + n · m + n) = O(n ·+

n)

(c) Heaps

Ein heapgeordneter Baum für eine Menge S / U ist ein Baum auf den Elementen von S, wobei gilt:

u Kind von v , u " v

28

Bsp.:

29

insbesondere:

Eigenschaften heapgeordneter Bäume:

• Minimum ist in der Wurzel

• Jeder Teilbaum ist Heap-g.

interface Pr ior i tä t sWarteSch lange {void i n s e r t ( Object o ) ;Object f indmin ( ) ;void de letemin ( ) ;

}

30

18. November 2008

3.2 Implementieruung des Heap

heapgeordneter Bäume (s.o.) | Wälder

Implementierung des PWS - Op auf Heap- geordneten Bäumen

* findmin trivial

* deletemin setzt die Wurzel auf ”2” und lässt sie “absinken” bis zu einem Blatt und entfernt dieses

* insert ausgehend von einer “freien Position” (abhängig von Details der Baumstruktur)füge neues Objekt ein und lass es “aufsteigen”

Konkreter binärer Heap

wir betrachten:

• binär

• heap- geordnete Bäume, wo die Tiefe von Blättern sich max im 1 unterscheidet

• alle bis auf einen inneren Knoten genau zwei Kinder haben

Fakt:

Diemaximale Tiefe eines binären Heaos mit n Elementen ist O(log n)

• deletemin auf bin. Heaps:Schreibe rechtetes Blatt in die Wurzel & lass es absinken (entferne das Blatt, mache es zum ersten Blattund aktualisiere das rechteste Blatt)

• insert auf bin. Heaps:Schreibe das neue Element in das nächste freie Blatt & lass es aufsteigen, mache es zum rechtestenBlatt und bestimme das neue rechte nächste freie Blatt

31

• wir stellen binäre Heaps so dar, dass die letzte Ebene des Baumes von links nach rechts aufgefüllt ist

• wir “merken” uns das “rechteste” Blatt der letzten Ebene & das erste freie Blatt

Mögliche Implementierungen von binären Heaps

1. verzeigerte Struktur (später)

2. flach in einem Array

• Speichere bin. Heap mit n Elementen in Feld der Länge n

• Knoten mit Index i hat linke (rechte) Kind bei Index Index 2i (2i+1)

• “letztes” Element ist bei Index n gespeichert, die erste freie Position bei Index n+1

• Dynamisierung durch iteriertes Verdoppeln/Halbieren (amortisiert O(1) pro Operation)

32

Laufzeit:

deletemin & isert O(log n)findmin O(1)

Damit Laufzeit von PWSSort (Heapsort):

O(n · log n)

Ziel:

(E"ziente) Implementierung der Operation (P,Q, PWS)

33

20. November 2008

3.3 Erweiterung des ADT PWS : VPWS

triviale Implementierung

interface VPWS {void i n s e r t ( Object o ) ;void de letemin ( ) ;Object f indmin ( ) ;void meld (VPWS P) ;

}

interface PWS {void i n s e r t ( Object o ) ;void de letemin ( ) ;Object f indmin ( ) ;

class NameVPWS implements VPWS {private BinaererHeap P;// irgendwo i s t " c l a s s BinaererHeap implements PWS{ . . . } "

void de letemin ( ) {P. de letemin ( ) ;

}

void meld (NameVPWS Q) {so lange Q nicht l e e r :

P . i n s e r t (Q. f indmin ( ) ) ;Q. de letemin ( ) ;

}}

34

Vererbung (Einschluss- Polymorphie) in Java

(Polymorphie = Vielgestaltigkeit)

Klasse (bzw. Schnittstelle) Y wird als Erweiterung der Klasse X vereinbart und erbt damit die Eigenschaftenvon X.

Syntax:

class X { Text von X }

class Y extends X {Text von Y}&&&&&en t sp r i c h t f a s tclass Y {

Text von XText von Y

}

Umgesetzt:

interface VPWS extends PWS {void meld ( . . . ) ;

}

bzw.

class VBinaerHeap extends BinaerHeap implements VWPS {void meld . . .

}

35

3.4 neue Implementierung als Binomialheaps

Binomialbäume:

Bi bezeichnet einen Binomialbaum vom Grad i.

induktiv definiert:

Bsp:

Es gilt:

1. Bi hat 2i Knoten (Induktion)

2. Die Wurzel von Bi hat i Knoten

3. Die Tiefe von Bi ist i

Ein Binomialheap mit n Elementen S ist ein Wald von Binomialbäumen in denen die Elemente von S heap-geordnet gespeichert sind. Jeder Bi kommt dabei höchstens 1x vor. Das gilt immer !

Bsp:

S = {7, 5, 1, 4, 13, 6} n = 6 = 22 + 21 , B1 und B2

Es gilt: wir benötigen !(log n)

Binomialbäume in einem Binomialheap für n Elemente

(hint: Binärdarstellung)

36

Die (Wurzeln) der Binomilabäume sind in einer Liste verkettet, sortiert nach ihrem Grad.

Bsp.: S = {7, 5, 1, 4, 13, 6, 15, 9, 3, 8, 27, 21, 34, 99} n = 14 = 23 + 22 + 21

Implementierung der VPWS- Operationen

(a) meld

• durchlaufe Wurzellisten P und Q (angefangen beim kleinsten Grad)

• zu jedem Zeitpunkt stellen wir sicher, dass es im Resultat nur einen Baum pro Grad gibt

• es gibt jeweils maximal einen Baum C der aus dem vorherigen Schritt als Übertrag kommt

• sei A der aktuelle Binomialbaum von Psei B der aktuelle Binomialbaum von Q

– Fall 1: es gibt kein C

! deg A < deg B : schreibe A in die Wurzelliste von P 1Q , ersetze A durch seinen Nachfolger! deg A > deg B : umgekehrt! deg A = deg B

· min B < min A : mache A zu Kind der Wurzel B und setze das Ergebnis als Übertrag CErsetze A (und B) durch ihre Nachfolge

· min A < min B : umgekehrt

– Fall 2: es gibt ein C (=, Übungsaufgabe)

37

25. November 2008

verschmelzen

n = 4

8 + 4 + 2 = 23 + 22 + 21

Implemetierung der restlichen Heap- Operationen

• findmin(P)

– Durchlaufen der WurzellisteO(log |P |) Zeit

• insert(P,x)

– durch meld (P,{x})O(log |P |) Zeit

• deletemin(P)

– Finde Bi in der Wurzelliste der Minimum speichert (in seiner Wurzel), entferne Bi aus der Wurzel-liste, entferne Wurzel von Bi (resultiert in {B0, . . . , Bi"1}) und erzeugen damit neuen Binärheap.Verschmelzen den neuen & den alten Heap.O(log |P |) Zeit

3.5 Lokalisierung von Einträgen in Datenstrukturen

Typischerweise “wissen” Einträge in einer DS wo sie in der Struktur gepeichert sind.

Sonst ist das manipulieren von Einträgen in der DS “schwierig” (d.h. unmöglich/ine"zient).

Bsp.:

• Löschen von Einträgen aus einer PWS

• Ändern der Priorität von Einträgen einer PWS

38

mögliche Lösung

Schnittstellenmethoden zum Einfügen von Objekten liefern einen “Zeiger” auf den Eintrag der Objekte in derDS.

z.B.:

class PWSEintrag {int Pr i o r i t a e t ;Object Eintrag ;int Pos i t i on ;

}

3.6 Bäume

mathematischer Kontext Informatik KontextKreisfreier zusammenhängender Graph gerichteter Graph T = (V,E)typischerweise gibt es eine (totale Ordnung) Wurzel w ! Vauf den Kindern eines Knotens. (u, v) ! E

v heißt Kind (Nachfolger) von uu heißt Erziehungsberechtigter (Vorgänger) von v

Bäume als ADT

ADT Knoten

• speichert Objekte

• Manipulation/Zugri!void setInfo (Object o);Object getInfo();

3.6.1 Schnittstelle zum ADT Baum (Auswahl)

Knoten getRoot ( ) ;Knoten getParent (Knoten k ) ;boolean aLeaf (Knoten k ) ;Knoten getChi ld (Knoten k , int i ) ;int getDegree (Knoten k ) ;

39

27. November 2008

Implementierung von Bäumen

1. Verkettete Struktur auf den KnotenPlatzbedarf für Baum mit n Knoten : O(n)

Spezialfall: k- näre Bäume (k > 2)

• jeder Knoten hat $ k Kinder

• falls jeder inäre Knoten genau k- Kinder hat, heißt der Baum wohl

• bei geordneten Binärbäumen heißt das

– 1. Kind auch linkes Kind– 2. Kind: auch rechtes Kind

Bsp. k=3

Höhe des Baumes ist h.

h = 0 30 = 1

h = 1 30 + 3 · 30 = n0 + 3n0 = 4

h = 2 4 + 3 · 3 = 13

h = 3 13 + 9 · 3 = 40

h&

i=0

qi =qn+1 & 1

q & 1

2. Arraydarstellung k- närer Bäumek- närer Baum der Höhe h wird im Array mit kh+1"1

k"1 Elementen abgespeichert.Das i-te Kind (1 $ i $ k) eines Knotens der beim j-ten Eintrag gespeichert ist, wird im (k · j + i)Eintrag abgelegt.

Zugri! auf Elternknoten durch gannzahlige Division.

(evtl. Problem)

Das Array kann exponentiell groß (im Vergleich zum Baum) sein.

40

Algorithmen auf Bäumen

• Traversierung von Bäumen

inorder: besuche erst den linken Teilbaum unter der Wurzel, dann die Wurzel, dann ihren rechtenTeilbaum

preorder: besuche zuerst die Wurzel, dann dann links, dann rechts

postorder: besuche erst links, dann rechts, dann Wurzel

(1) Anwendung von inorder- Traversierung

T = (V,E)

in : V % N inorder Traversierung

h : V % N Höhenfunktion

% =

'V % R2

1 % (in(u), h(u))

ist eine kreuzungsfreie Zeichnung von T in der Ebene.

(2) Arithmetische Ausdrücke (auf ganzen Zahlen)

(über {+,&})

rekursiv definiert:

(i) x ! Z ist ein arithm. Ausdruck

(ii) e, f arithmetische Ausdrücke, (e + f) sind arithm. Ausdrücke(e& f)

z.B. 12345+3456.

41

3.6.1.1 Darstellung als Ausdrucksbaums z.B.: ((2 + 5)& (7 + 12))

Auswertung durch postorder- Traversierung.

3.6.1.2 Umgekehrte Polnische Notation (UP- Notation): 2, 5,+, 7, 12,+,&

42

02. Dezember 2008

3.6.2 weitere Anwendungen: Spielbäume

TicTacToe

Beginnt der Kreis- Spieler in der Mitte, hat der Kreuz- Spieler acht verschiedene Möglichkeiten sein Kreuzzu setzen.

Dann hat der Kreis- Spieler sieben Möglichkeiten. ...

Nehme als Root das leere Spielfeld. Der erste Nachfolger sind neun Knoten, alle Möglichkeiten für die ersteBelegung. Die Nachfolger dieser Knoten sind jeweils die acht Möglichkeiten, ein Kreuz zu setzen. usw.

Es gibt besondere Knoten, bei denen das Spiel zu Ende ist. Dieser Knoten ist ein Blatt. Entweder, das Spielwird gewonnen oder es gibt ein Remis.

Zunächst werden alle Nachfolger der Wurzel erzeugt, erfüllen sie die Anforderung? Nun werden die Kindererzeugt, usw.

, Breitensuche

3.6.3 Breitensuche in Bäumen

Traversiere den Baum in der folgenden Reihenfolge.

(Hier ein Baum mit immer drei Nachfolgern)

1. Wurzel (r)

2. Kinder der Wurzel (seien diese w1, w2, w3)

3. Kinder der Knoten aus 2. ; erst die Kinder von w1 , dann die Kinder von w2 , dann die Kinder von w3

4. Deren Kinder. Nach Methodik von 3.

Diese Knoten werden in einer Liste verwaltet:

r, w1, w2, w3, w11, w12, w13, w21, w22, w23, w31, w32, w33

Dies ist eine Warteschlange (Queue).

3.6.4 Tiefensuche in Bäumen

Traversierung mittels Stack

Erst ganz links bis nach unten, dann von “ganz unten” zum ersten Vater, dessen nächstes Kind, dann einshoch, nächstes Kind,...

43

3.7 ADT Wörterbuch (Dictionary)

Verwalten einer endlichen Teilmenge S / U eines Universums U

Operationen :

find(k,S) bestimme, ob k ! S

insert(k,S) füge k zu S hinzu

delete(k,S) lösche k aus S

Bemerkung:

• Gegebenenfalls Fehlerbehandlung (z.B. bei delete)

• im Allgemeinen is S eine Multimenge

Vielfache Anwendungen!

3.7.1 Implementierung des ADT Wörterbuch

1. Verkettete ListePlatzbedarf !(|S|)Laufzeit:insert !(1) ggf. !(|S|)find !(|S|)delete !(1) falls falls Zeiger in die Liste zeigtsonst !(|S|)

2. Hashing (Streuspeicherung)

1.Idee Finde “gute” Abbildung h1 : U % N

2.Idee Finde “gute” Abbildung h2 : N % [1, . . . N ]

Speichere S in ein Array T [1, . . . , N ]

und zwar speichern x ! U in T [h2(h1(x))]

44

04. Dezember 2008

3.7.2 Implementierung durch Hashing

U Universum

S / U

h1 : U % N

h2 : N % [1, . . . N ]

h2(n) = 1 + (n mod 4)

3.7.3 Hashcodes

1. Zeichenketten s = s1 . . . sk !!&

(a) Länge

(b) h!(s) =!0h1(si)|

!|

!{&0, . . . ,&l}

wobei 0h1 =

'!% N

&i 0% i

z.B.: ASCIIs = AFFE|!

| = 256, h1(A) = 65 , h2(F ) = 70 , h3(E) = 69 , h1(s) = (((65 · 256 + 70) · 256) + 70) · 256 + 69

2. Floatingpoint- Zahlen

(a) h1(x) = 3x4(b) h1(x) = Mantisse von x als Integer

Kompressionsverfahren

Idee: h2 soll S “möglichst geleichmäßig” auf [1, . . . N ] aufteilen. Typischerweise ist N eine Primzahl

Bsp.:

1. h2(x) = 1 + (x modN)

2. h2(x) = 1 + (ax + b modN)a'=0(mod N), a,b(N

Hashing mit Verkettung

U Universum

|U | = u

S / U, |S| = n

45

Hashfunktion in Tabelle T der Größe N. (Hashfunktion ist fest)

Hashtabelle mit N Einträgen

h : U % [0, . . . , N & 1]

n- elementige Teilmengen von U sollen verwaltet werden.

Idee: Speichere x ! S an Position h(x) in T

x1, x2 ! S kollidieren (bzgl. h), falls h(x1) = h(x2)

Behandlung von Kollisionen durch Verkettung

T [i] zeigt af eine verkettete Liste in der alle x ! S mit h(x) = i gespeichert sind.

Bsp.:

• Einfügen/Löschen/Suchen eines Eintrags e mit Schlüssel k

• berechne i = h(k)

• Einfügen / L / S von e in Liste T [i] wie oben

Analyse:

Platzbedarf : O(N)" #$ %Array T

+ O(n)" #$ %Knoten der Liste

= O(n + N)

Laufzeit (für Eintrag mit Schlüssel k)

hängt ab von

1. der Zeit, die zur Berechnung von h() benötigt wird.

2. der Länge der Liste die den Eintrag speichert.

Cs(k) = {y ! S|h(y) = h(k)}

Falls h in O(n) Zeit ausgewertet werden kann, benötigen alle Operationen !(1 + |Cs(k)|) Zeit.

46

3.7.3.1 Analyse der mittleren Laufzeit von Hashing mit Verkettung

U sei fest. (U sei endlich, |U | = u)

n sei fest.

h sei fest.

S / U wird zufällig (gleichverteilt) gewählt.

U hat.

un

/= |W | viele n- elementigen Teilmengen

Für V / U mit |V | = n fest, gilt:

Pr(S = V ) = pv =1.un

/ =1

|W |

W = {S / U | |S| = n}

Für k ! U fest betrachten wir Cs(k) Zufallsvariable und interessieren uns für

E [CS(K)] =

&

v(W

pv |Cv(k)| =1

|W |

!v(W [CS(K)]

Beweis:

[CS(K)] =&

y(S, h(k)=h(y)

1 =&

y(U, h(k)=h(y)

iS(y) mit iS(y) =

'1 y ! S

0 sonst

Damit

E [CS(K)] =1

|W | ·&

V (W

[CV (K)]

=1

|W | ·&

V (W

·&

y(U, h(k)=h(y)

v(y)

=&

V (W

·&

y(U, h(k)=h(y)

pv$%"#1

|W | v(y)

=&

V (W

·

E[iS(y)] für y fest$ %" #&

y(U, h(k)=h(y)

p(v) · iv(y)

=&

y(U, h(k)=h(y)

n

u

47

E[iS(y)] = 1 · Pr(iS(y) = 1) + 0 · Pr(is(y) = 0) = Pr(y ! S) =

,u"1n"1

-,n

u

- =n

u

(*)

48

09. Dezember 2008

3.7.4 Zufallsexperiment

S !,U

n

-wird zufällig (unter Gleichverteilung gewählt)

Analyse Zufallsvariable (für x ! U)

|CS(x)| = |{y ! S|h(x) = h(y)}| (s.o.)

Fortsetzung von (*)

=, E [CS(x)] =&

y(U, h(k)=h(y)

n

u

=n

u·

&

y(U, h(k)=h(y)

1

=n

u· |CS(x)| = |{y ! S|h(x) = h(y)}|

Def.:

Eine Hashfunktion h : U % [1, . . . , N & 1] heißt fair, falls

|{y ! U |h(y) = i}| $1 u

N

2*0 $ i $ N

Falls h fair:

E [CS(x)] $ n

u·1 u

N

2'

Belegungsfaktor der Hashtabelle$%"#n

N

Zusammengefasst:

Die erwartete Zugri!szeit für Hashing mit Verkettung (bei Verwendung einer fairen Hashfunktion) bei derVerwaltung von n- elementigen Teilmengen von U in einer Tabelle mit N Einträgen ist

O31 +

n

N

4

Bsp:

h(x) =

'[0, . . . , u& 1] % [0, . . . , N & 1]x 0% x mod N

ist fair.

Beweis:

(a) mit N = !(n) erhalten wir !(1) (erwartete) Zugri!szeit und !(n) Speicher.(unter den bekannten Annahmen)

(b) Falls n nicht bekannt ist, kann durch Verdoppeln, bzw. Halbieren der Tabellengröße (inkl. Umko-pieren) !(1) amortisierte erwartete Laufzeit bei !(n) Platz erreicht werden.

49

Alternative: Universelles Hashing

Idee: Wählen h beim Aufbau der Struktur (unter Gleichverteilung) aus einer Menge von “guten” Hashfunk-tionen H.

Analyse:

Sei S / U mit |S| = n und x ! U fest.

Für h ! H sei

Cx(h) = {y ! S|h(x) = h(y)}=

&

y(S

'xy(h)

mit 'xy(h) =

'1 h(x) = h(y)0 sonst

E [|Cx(h)|] = E

5

6&

y(S

'xy(h)

7

8

=&

y(S

['xy(h)]

=&

y(S

(Pr (h(x) = h(y)))

mit

!"

#$Pr(h(x) = h(y)) =

|{h ! H|h(x) = h(y)}||H| =

1N

E [|Cx(h)|] $&

y(S

1N

=n

N

Def.:

Eine Menge H / {0, . . . , N & 1}U von Hashfunktionen heißt universell, falls *x, y ! U mit x 5= y

|{h ! H|h(x) = h(y)}| $ |H|N

Damit:

Die erwartete Zugri!szeit für Hashing mit Verkettung bei zufälliger Wahl von h aus einer universellen Familievon H- Funktionen bei der Verkettung einer (jeder!) (festen) n- elementigen Teilmenge S / U in einer Tabellemit N Einträgen ist !

31

n

N

4bei !(n + N + |h|"#$%

Platzbedarf, um h zu codieren

) Speicher.

50

3.7.5 Universelle Hashfunktionen

1. {0, . . . , N & 1}{0,...,u"1} ist universell, aber nicht platsparend repräsentierbar bzw. e"zient auswertbar.

2. Angenommen, x ! U kann in eindeutiger Weise als (r + 1)- Tupel x = (x1, . . . , xr) mit 0 $ xi < t *iund eine Primzahl t. (z.B. t=257 und x wird byteweise gelesen).

Für

a$ %" #(a0, . . . , ar) ! {0, . . . t& 1}r+1 definieren wir die Hashfunktion

ha(x) = h(a0,...,ar)(x0, . . . , xr)

=&

0!i!r

aixi mod N

Dann ist H =9

ha|a ! {0, . . . , N & 1}r+1:

universell.

Bemerkung:

(a) Zum Abspeichern von h(a0,...,ar) wird !(r) Platz benötigt.

(b) Zum Berechnen von h(a0,...,ar)(x0, . . . xr) wird !(r) Zeit benötigt.

51

11. Dezember 2008

Fortsetzung “Universelle Hashfunktion”:

U = {0, . . . , u& 1} u = Nr+1

N Primzahl (Größe der Hashtabelle)

x ! U ( (x0, . . . , xr) mit 0 $ xi $ N

Zu (a0, . . . , ar+1) ! {0. . . . , N & 1}r+1 definieren wir

h2 =

'U % {0. . . . , N & 1}x = (x0, . . . , xr) 0%

!ri=0 aixi mod N

Dann ist H =9

h0|a ! {a0, . . . N & 1}r+1:

universell.

Bemerkung:

1. Um h ! R zufällig zu wählen müssen r + 1 Zufallszahlen im Intervall [0, N & 1] erzeugt werden.

2. Um (bei festen h ! R) zu x = (x0, . . . , xi) h(x) auszuwerten, werden r + 1 Multiplikationen (undAddition) mittels N benötigt.

Angenommen x, y ! U mit x 5= y und ha(x) = ha(y) (*)

Da x 5= y muss (x0, . . . , xr) + (y0, . . . , yr)

Wir nehmen oBdA an, dass x0 5= y0 .

(*)

r&

i=0

aixi =r&

i=0

aiyi (mod N)

a0(x0 & y0) = a0x0 & a0y0

=r&

i=0

ai(yi & xi) (mod N)

Bei gegebenen x und y gibt jede Wahl von a1, . . . ar auf der rechten Seite eine feste Zahl C. Da N prim istund x0 5= y0 gibt es genau eine Möglichkeit, a0 zu wählen, um die Gleichnug zu erfüllen.

a0 = C · (x0 & y0)"1 (mod N)

Es gibt genau Nr Möglichkeiten a1, . . . ar zu wählen.

Damit

%&

'(|{ha|ha(x) = h(y)}| = Nr =

|H|N

52

3.8 ADT Geordnetes Wörterbuch

Ziel: Verwaltung einer Teilmenge S von Elementen aus einem total geordneten Universum U ( wir werdendie Ordnung mit $ bezeichnen) unter dem Operation

find(x) bestimme, ob x ! S

insert(x) setze S # S 1 {x}

delete(x) setze S # S\{x}

min bestimme min S

max bestimme max S

succ(x) bestimme das kleinste Element S, mit der Eigenschaft: min {y ! S|y " x}

pred(x) bestimme das größte Element S, mit der Eigenschaft: max {y ! S|y $ x}

Bemerkung:

Wir nehmen an, dass die Ordunungsrelation in O(1) Zeit entschieden werden kann.

3.8.1 Implementierung ADT Geordnetes Wörterbuch

1. Suchbäume (später)

2. Geordnete nach $ verkettete Liste

3. Skip- Listen

• Hierarchische DS mit r Stufen L1, . . . , Lr

• In Stufe Li ist die Menge Si / S in einer Liste gespeichert, wobeiS = S1 " S2 " S3 " . . . " Sr = "

• Für z ! Si+1 6 Si gibt es einen Zeigervon Eintrag für z in Li

3.8.2 Skip Liste:

Ist ähnlich zu verketten Listen. Die Daten werden in Containern abgelegt. Jeder Container enthält einenSchlüssel und einen Zeiger auf den nächsten Container. Es können jedoch auch Zeiger auf andere Containerenthalten sein, welche nicht direkt nachfolgen. Demnach können auch Schlüssel übersprungen werden. DieZeiger werden von 0 bis h durchnummeriert, wobei h die Höhe ist; h ist um 1 kleiner als die Anzahl derZeiger, die ein Container enthält.

53

3.8.2.1 Suche in einer Skip- Liste (find, succ, pred) Suche nach q ! U

• bestimme in Li das Intervall #i , welches q enthält, durch lineare Suche

• die lineare Suche in Li beginnt beim Anfangspunkt des Intervalls #i+1

3.8.2.2 Bestimmung der Si (mod r)S1 = Si = 1while S1 5= "

Si+1 = {z ! Si|Münzwurf für z zeigt Kopf}i = i + 1

r = 1

3.8.2.3 Löschen von z ! S Lösche z aus allen Li mit z ! Si (inklusive der vertikalen Zeiger)

3.8.2.4 Einfügen von z ! S

• wirf eine Münze bis zum ersten Mal Zahl auftaucht

– j = #Münzwürfe -1

• füge z in die Liste L1, . . . , Lj+1 ein.

– unterteile #i bei z– verkette die Vorkommen von z in aufeinanderfolgenden Stufen vertikal

• falls j + 1 > r erzeuge

– j + 1& r neue Stufen die nur z enthalten

54

16. Dezember 2008

Die Größe der DS ( sowie die Zugri!szeiten) hängen von den zufälligen Entscheidungen ab, die der Algorith-mus tri!t.

Wie lange dauert es, nach einem Element zu suchen? Da gibt es mehrere Größen.

“vertikale” Höhe, i.e. r, die Anzahl der Stufen

Für c > 2 ist Pr(r > c · log2 n) $ 1nc"1

Sei x ! S und k ! N

Pr(x ist in mehr als k Stufen) =12k

Pr(es gibt mehr k Stufen) = Pr(;

x(S

x ist in mehr als k Stufen)

$&

x(S

Pr(x ist in mehr als k Stufen)

=|S|2k

=n

2k

mit k = c · log2 n

$ n

2c·log2 n

=n

nc

=1

nc"1

!

E[Größe der DS] = !(n)

Zu x ! S betrachten wir die Zufallsvariable hx = #Stufen die x enthalten

pi = Pr(hx = i)

i 1 2 3

pi12

12

· 12

=14

123

=18

E[hx] =&

i)1

i · Pr(hx = 1)

=&

i)1

i · 12i

= 2

Die erwartete Zeit zum Löschen eines, über einem Zeiger definierten Elements, ist !(1) (falls alle Listendoppelt verkettet sind).

Man kann zeigen, dass die erwartete Suchzeit !(logn) ist.

55

3.8.3 Balancierte Mehrweg- Bäume

In einem Mehrweg Suchbaum, der eine Menge S über einem Universum U (mit totaler Ordnung $ ) speichert,ist jeder innere Knoten v mit d " 2 Kindern mit d& 1 Schlüsseln.

k1(v) < . . . < kd"1(v) aus U markiert. Das i-te Kind speichert nur Elemente, die

• > ki"1(v)

• $ ki(v)

sind.Die Elemente aus S werden in den Blättern gespeichert.

56

18. Dezember 2008

Geordnete Wörterbücher - Balancierte Mehrweg Suchbäume

Ein Mehrwegsuchbaum heißt ein (2,4)- Baum, falls

1. jeder innere Knoten (außer root) " 2 und $ 4 Kinder hat.

2. alle Blätter die gleiche Tiefe haben.

Für die Höhe h eines (2,4)- Baumes mit n Blättern gilt:

.12

log2n = log4n

/$ h $ log2n

Beispiel 2- Baum:

h = 3 8 + 4 + 2 + 1 = 15 , 2h+1 & 1 Knoten

Mit anderen Worten: (2,4)- Bäume sind balanciert.

Pseudocode:

57

Access (x,T)Input: x ! U , Suchbaum T für S / UOutput: Blatt y ! S mit y = min {z ! S| z " x}

beginv # Wurzel von Twhile v ist kein Blattdo

Bestimme 1 $ i $ deg(v) mit Ki"1(v) < x $ Ki(v)

Die Prozedur Access terminiert in einem (2,4)- Baum der Höhe h in O(h) Schritten.

Bemerkung:

In einem Mehrwegsuchbaum T der Höhe h terminineiert die Prozedur in O(h · maxv(T

· deg v) Schritten.

Mittels Access kann in einem (2,4)- Baum, der n Elemente speichert, find/succ in O(logn) realisiert werden.

58

Einfügen:

Die 11 wird eingefügt, nun ist der Baum jedoch nicht mehr balanciert und erfüllt das Kriterium nicht mehr:

Passe den Key oben an. 11 nach oben, es ist größer als alles aus dem linken Teilbaum. Somit ist der Baumwieder balanciert.

Nun wird ein Knoten, bzw. ein Blatt entfernt. Doch was nun? Zwei Kinder sind Pflicht!

59

Einfügen in (2,4)- Baum

1. Einfügen in Knoten vom Grad < 4 ist einfach.

2. Einfügen in Knoten v mit 4 Kindern (wie bei 1 – generiert Knoten) mit 5 Knoten.Zerteile diesen in v1, v2 mit 2 Knoten (bzw. 3) . Setze das Einfügen (jetzt von v2 ) bis zur Wurzel fort.

Mit dieser Prozedur kann in einem (2,4)- Baum mit n Elementen in O(log n) Zeit ein neues Element eingefügtwerden.

Löschen eines Knotens v aus (2,4)- Baum

Sei p Mutterknoten von v

1. deg(p) " 3 , Löschen einfach

2. deg(p) = 2

(a) Falls ein Nachbarknoten von p mindestens drei Kinder hat, stehle ein Kind.(b) Falls alle Nachbarn von p genau zwei Kinder haben, verschmelzen wir p mit einem dieser Nachbarn

q zu einem Knoten mit drei Kindern und setzen das Löschen rekursiv bis zur Wurzel fort.

An der Wurzel einfach: Entferne alte Wurzel und mache ihr einziges Kind zur neuen Wurzel.

60

06. Januar 2008

3.9 (2,4)- Bäume

• Mehrweg- Suchbäume

• alle Blätter haben die gleiche Tiefe

• der Grad jedes inneren Knotens ist " 2 und $ 4

3.9.1 (a,b)- Bäume (a, b ! N, b + 1 " 2a)

• Mehreg- Suchbäume

• alle Blätter haben die gleiche Tiefe

• der Grad jedes inneren Knotens ist " a und $ b

Es gilt: logbn $ Tiefe eines (a,b)- Baumes $ 1 + logan

2

Anwendungen:

• Datenstruktur im Externspeicher(1972, Bayer & McGreight, B- Bäume, b=2a-1 )b ' Blockgröße des Externspeichers

• “klassisch”: (2,3)- Bäume, aber bei (2,4)- Bäumen sind die amortisierten Kosten für das Löschen einesBlattes O(1)(tatsächlich: amortisierte Rebalancierungskosten sind O(1))

• (2,4)- Bäume “=” Rot- Schwarz- Bäume

3.9.2 Amortisierte Rebalancierungskosten in (2,5)- Bäumen

Rebalancierungskosten:

Löschen: Anzahl der Knotenverschmelzungen

Einfügen: Anzahl der Knotenspaltungen

Es gilt, wenn wir in einem Anfangs leeren (2,5)- Baum eine Folge von n Einfügungen/Löschoperationendurchführen, dann sind die gesamten Rebalancierungskosten $ 2n

(d.h. die amortisierten R.- Kosten sind $ 2)

Wir zeigen das mittels der Buchhaltermethode:

• Wir halten folgende Invariante aufrecht:

Knoten vom Grad 1 2 3 4 5 6speichern " 3" 1" 0" 0" 1" 3"

• Jede Operation bringt 2" mit

61

Einfügen:

1. falls keine Rebalancierung, speichere (ggf.) 1" bei dem betro!enen Knoten. Fertig.

3.10 Implementierung von geordneten Wörterbüchern für Zeichenketten

Trie (retrieval)

Bsp.: S = {bear, bell, bid, buy, sell, stock}

62

08. Januar 2009

3.11 Wörterbücher für Strings- Trie

Ein (Standard-) Trie ür eine Menge S von Zeichenketten über einem Alphabet $ ist ein gewurzelter, geordneterBaum, bei dem

• jede Kante mit einem Symbol ! $ beschriftet ist.

• die Kinder eines Knotens (entsprechend der Kantenbeschriftung) geordnet sind.

• die Kantenbeschriftung von der Wurzel bis zu den Blättern die Wörter aus S ergeben.

• S präfixfrei ist.

Ein Trie benötigt O(Gesamtlänge der Wörter aus S) Platz.

Suchen, Löschen und Einfügen von x benötigt O(|$| · |x|) bzw, O(log |$| · |x|) Zeit.

Ein komprimierter Trie entsteht durch Kompression von Ketten von Knoten mit Grad 1 zu einer Kante.

Kompakte Darstellung:

Kantenbeschriftung ist nicht explizit, sondern nur als Zeiger in die entsprechenden Strings von S.

Anwendung: String Patternmatching

Gegeben:

T = T [1 . . . n] ! $&

M = M [1 . . . m] ! $&

Finde:

alle Positionen 1 $ i $ n in denen M in T vorkommt, d.h.

M [1] = T [i]M [2] = T [i + 1]

......

...M [m] = T [i + m& 1]

<)))=

)))>(7)

Sei T = mississippi und M = is

M kommt in T an Position 2&5 vor.

Naiv:

Teste, ob die Eigenschaft (7) für i = 1, 2, . . . , n&m + 1 gilt.

Laufzeit: m!(m · (n&m))

Beobachtung:

M kommt an Position i in T vor, genau dann, wenn M Präfix von T [i, . . . , n]" #$ %i-te Su"x von T

ist.

Mit anderen Worten: Um alle Vorkommen von M in T zu bestimmen, müssen alle Su"xe von T gefundenwerden, die mit M anfangen.Speichere alle Su"xe von T in einen komprimierten Trie: O(n) Platzbedarf.

63

Bsp.:T = mississippi$

S(T ) = {mississippi$, ississippi$, ssissippi$, . . . , ppi$, pi$, i$, $}

|S(T )| = 12&

#(S(T )

|(| = 78

im Allgemeinen gilt:n · (n + 1)

2= !

,n2

-

Unkomprimierter Trie:

Komprimierter Trie:

64

Dies ist ein Baum mit n Blättern, alle inneren Knoten haben einen Grad > 1. D.h. es gibt insgesamt !(n)Knoten/Kanten.

Ein Komprimierter Trie kann in O(n) Zeit aufgebaut werden.

3.11.1 Su!xbaum

Suche nach M in T=̂ Suche nach den Einträgen im Su"xbaum, die M als Präfix haben.

Die Laufzeit ist O(m + # Positionen, an denen M in T auftaucht) .

65

13. Januar 2009

3.12 Su!x- Bäume TRIE

T = ississippi$

T0 = ississippi$

T1 = ssissippi$

T2 = sissippi$

...

alternative: Su!xarray

Ordnung: $ < a < b < c

T = abcab$ = T1

bcab$ = T2

cab$ = T3

ab$ = T4

b$ = T5

$ < ab$ < abcab$ < b$ < bcab$ < cab$

T6 < T4 < tT1" #$ %M ist kleiner

< T5"#$%M ist kleiner (suche nur links davon)" #$ %

lexikographische Ordnung auf {$,a,b,c}&

< T2 < T3

M = ab in das obige einnotieren,

$ <

M$%"#ab < ab$ < . . . c . . .

Das Su"xarray von T lautet:

6 4 1 5 2 3 == Länge des Wortes

66

3.13 Sequence- Alignment Problem

o c u r a n c e...

...o c c u r a n c e

o c _ u r a n c e...

......

......

......

......

o c c u r a n c e

Gegeben seiein zwei Strings:

X = x1 . . . xm

und Y = y1 . . . yn

Eine Folge M von Paaren von Indizes aus {1, . . . ,m}8 {1 . . . n} bei der kein Index zweimal vorkommt heißtein Matching.

Bsp.:

x1 x2 x3 . . . xm

. . . . . ....

y1 y2 y3 . . . yn

3.13.1 Kosten eines Alignments

Parameter

1. ' > 0 (Lückenkosten)Für jede Position von X oder Y die nicht zugeordnet ist, zahlen wir '

2. für p, q !!!

gibt es Fehlerkosten "p,q > 0Falls (i, j) ! M zahlen wir "xi,yj

M = {(i1, j1), . . . , (ik, jk)} Alignment von

X = x1, . . . , xm und Y = y1, . . . , yn

cost(M) =

?k&

l=1

"xil,yjl

@

" #$ %Fehlerkosten

+ (m + n& 2k) · '

!" #$Die Fehlerwerte werden durch die Anwendung vorgegeben (z.B. ' = 1)

Alignment Problem

Gegeben X, Y. Berechne M mit minimalen Kosten

1. x1 x2 . . . xm"1 xm

y1 y2 . . . yn"1 yn

2. In einem Aligment M von X und Y mit (m, n) /! M ist entweder die letzte Position von X oder von Ynicht zugeordnet.

67

OPT(i,j): Kosten des besten Alignments von Xi = x1 . . . xiund Yj = y1 . . . yj

(Wir wollen OPT(m,n))

mit (1)&(2): OPT(i, j) =

()*

)+

"xi.yj + OPT(i& 1, j & 1)' + OPT(i& 1, j)' + OPT(i, j & 1)

68

15. Januar 2009

3.13.2 Alignment von Zeichenketten

&7 9

X = x1 . . . . . . xm

:... + "xmyn

Y = y1*y2 . . . yn

OPT(i, j)" #$ %Kosten des besten (billigsten) Alignments von x1...xi und y1...yi

=

()*

)+

"xi.yj + OPT(i& 1, j & 1)' + OPT(i& 1, j)' + OPT(i, j & 1)

<)=

)>i, j " 1

(7)

OPT(0, j) = j · ' (1 $ j $ n)

OPT(i, 0) = i · ' (1 $ i $ m)

wir suchen: OPT(m, n)

3.13.2.1 Berechnung von OPT(m,n)

1. rekursiv gemaß (*) :schlechte Idee, exponentiell in (max(m,n) ) großen Rekursionsbaum; viele Teilprobleme tauchen darinmehrfach auf.

2. Zwischenspeichern (“Caching”) von Teilergebnissen in einer Tabelle mit m · n Einträgen

3.

X

Y0 1

n2a

3m

4e

0 0 2 4 6 81 n 2 0 22 a 43 e 64 m 8

" :

()))*

)))+

Vokal - Vokal = 1Konsonant - Konsonant = 1Vokal - Konsonant = 3x-x = 0

$=2

OPT(1, 1) = min

'0 +

0$%"#"n,n, 2 + 2

A= 0

OPT(2, 1) = min

(*

+2 + "n,n"#$%3

, 0 + 2, 4 + 2

<=

> = 2

Xi

Yj0 1 . . . i-1 i . . . m-1 m

0

j-1 x xj x #;-

n

69

Zeilenweises Ausfüllen der Tabelle

Algorithmus Align (X,Y)

Eingabe X = x1 . . . xm, Y = y1 . . . ynAusgabe Kosten des güns t i g s t en Alignment von X und Y

f o r i = 0 to m do OPT( i , 0 ) = i ! de l t af o r j = 0 to n do OPT(0 , j ) = i ! de l t af o r j = 1 to n dof o r i = 1 to m doOPT( i , j ) = min {OPT( i &1, j&1)+alpha_{ x i y j } , OPT( i &1, j )+de l ta , OPT( i , j&1)+de l t a }return OPT(m, n)

Analyse: Laufzeit !(m, n)Speicherbedarf !(m, n)

Bemerkung: Platzbedarf kann auf !(min(m, n)) verbessert werden:Ausfüllen der j-ten Zeile benötigt aus OPT nur den Inhalt der (j-1)-ten Zeile

Definiere gerichteten, gewichteten Graphen GXY auf Knotenmenge, Kanten vertikal, horizontal: ', diagonal:"xi,yj bei manchen zum Verdeutlichen, einen Weg verdeutlichen

70

——-

GXY = {(i, j) |0 $ i $ m, 0 $ j $ n}

mit Kanten

(i, j) $% (i, j + 1) * 0 $ i $ m, 0 $ j $ n

(i, j) $% (i + 1, j) * 0 $ i $ m, 0 $ j $ n

(i, j)!xi,yj% (i, j) * 1 $ i $ m, 1 $ j $ n

f(i, j) seien die Kosten eines kürzesten Weges in GXY von (0,0) nach (i,j).

Dann gilt für alle i,j (i, j) = OPT(i, j)

71

20. Januar 2009

4 Algorithmen auf Graphen

4.1 Grundbegri"e aus der Graphentheorie

Ein gerichteter Graph G = (V,E) besteht aus einer Menge V von Knoten und einer Menge E / V 8 V vonKanten zwischen den Knoten.

Bemerkung: E entspricht einer 2-stelligen Relation auf V.z.B. G = (V,E)V = N(x, y) ! E ( x|y

Illustration von gerichteten Graphen

u ! V v ! V

u,v heissen die Endpunkte einer Kante e = (u, v).

G heißt ungerichtet, falls *x, y ! V : (x, y) ! E , (y, x) ! E

Üblicherweise fassen wir bei ungerichteten Graphen die Knotenmenge als Teilmenge von,V

2

-auf.

,V2

-= {(x, y) |x, y ! V }

Bei gerichteten Graphen gibt es eine Funktion ( : E % R (Gewichtfunktion).

Für e ! E heißt ((e) das Gewicht (manchmal Länge) oder Kosten.

Eine Folge ) = (v1, . . . , vm) von Knoten aus V mit (vi, vi+1) heißt Weg von v1 nach vm

72

Die Kosten ) sind:

(()) =m"1&

i=1

((vi, vi+1)

) heißt einfach, falls v1 5= vj * i 5= j mit (i, j) 5= (1.m)

Falls v1 = vm , heißt ) Kreis.

Falls es zu allen u, v ! V einen Weg von u nach v gibt, so heißt G stark zusammenhängend (bzw. zusammen-hängend, falls G ungerichtet ist)

Beobachtung: G = (V,E) zusammenhängend , |E| "| V |& 1

4.2 Repräsentation von Graphen

1. AdjazenzlisteG = (V,E) mit E / V 8 V wird repräsentiert durch Listen {LU |v ! V }LU = {v ! V |(u, v) ! E}

LU = {v1, v2, v3}

LW = {U, U #}Platzbedarf: O(|E| + |V |)

2. Adjazenzmatrixdarstellung|V |8| V | -Matrix A = (aij)1!i,j!n

V = {1, . . . , n} n = |V |

aij =

'1 (i, j) ! E

0 (i, j) /! E

73

Dieser Graph wird durch die folgendeTabelle beschrieben:

1 2 3 41 0 1 1 02 0 0 1 03 0 0 0 14 0 0 0 0

Platzbedarf: O(|V |2).

74

4.3 Der ADT Graph

benötigte Operationen:

(E für Edges, V für Vertices)

(1) Knoten(): liefert Liste der Knoten des Graphen(2) Kanten(): liefert Liste der Kanten des Graphen(3) adjazenzListe(u): liefert die Liste aller zu u adjazenten Knoten(4) loescheKante(u,v): entferne die Kante (u,v) aus E(5) erzeugeKante(u,v): füge die Kante (u,v) zu E hinzu(6) loescheKnoten(u): entferne den Knoten u aus V(7) erzeugeKnoten(u): füge den Knoten u zu V hinzu(8) gewicht(u,v): liefere ((u,v)(9) setzeGewicht(u,v,(#) setze ((u, v) := (#

(10) istKante(u,v): liefere 1, falls (u, v) ! E , 0 sonst(11) knotenInfo(u): liefere die zu u assoziierte Information (als Object)(12) kantenInfo(u,v): liefere die zu (u,v) assoziierte Information (als Object)(13) setzeKnotenInfo(u,o): setze die zu u assoziierte Information zu o(14) setzeKantenInfo(u,v,o): setze die zu (u,v) assoziierte Information zu o

Laufzeiten:Operation A-Liste A-Matrix

(1) O(|V |) O(|V |)(2) O(|E|) O(|V |2)(3) O(1)(4)(5)(6)(7)(8)(9)(10)(11)(12)(13)(14)

75

22. Januar 2009

4.4 Graphenalgorithmen

4.4.1 Kürzeste Wege in Graphen

Gegeben:

G = (V,E) gerichteter Graph mit V = {1, . . . , n}

Gewichtsfunktion ( : E % R+

Gesucht:

Abstandsfunktion ' : V 8 V % R+ mit '(i, j) = Länge des kürzesten Weges von i nach j

Weg von 1 (über 3 und 2) zum Knoten 5Länge = 1, 24 + 0, 8 + 127, 3 = 129, 8

Bemerkung:

Falls es keinen Weg von i nach j in G gibt, so ist '(i, j) = 2

4.4.1.1 Eigenschaften kürzester Wege

1. Da es keine negativen Kreise in G gibt, ist jeder kürzeste Weg einfach.

2. Teilwege von kürzesten Wegen

sind ebenfalls kürzeste Wege.

3. Wenn k der größte (numerisch) Knoten auf dem kürzesten Weg von i nach j ist, dann zerfällt dieser inzwei Teilwege (selbst wieder kürzeste Wege) auf denen k nicht vorkommt.

76

Für i, j, k ! {1, . . . , n} sei

di,j = Länge des kürzesten Weges von i nach j, deren Zwischenknoten alle aus der Menge {1, . . . , k}sind.

Für k = 0: d(0)ij = ((i, j)

Für k > 0:

Sei ein Weg von i nach j, $ k, der Weg sei ) .

Nun gibt es zwei Möglichkeiten:

1. k liegt auf ) :Es gibt zwei Teilwege: Der Weg von i nach k, für diesen gilt: $ k & 1 , von k nach j gilt : $ k & 1Länge = d(k"1)

ik + d(k"1)kj

2. k liegt nicht auf ) :Es gibt keinen Teilweg, bzw. der einzige “Teilweg” ist weiterhin der Weg von i nach j, für diesen gilt:$ k & 1Länge von ) = d(k"1)

ij

also:

d(k)ij = min

3d(k"1)

ik + d(k"1)kj , d(k"1)

ij

4

77

kleiner Einschub vom Autor:Graph:

k: Matrixdi,j : Eintrag der Matrix

Sei D(0):

i \ j 1 2 3 41 0 1 4 22 1 0 1 43 4 1 0 14 2 4 1 0

d(1)ij = min

3d(0)

ij , d(0)ik + d(0)

kj

4

D(1)ij ist dann:

i \ j 1 2 3 41 0 1 4 22 1 0 1 43 4 1 0 14 2 4 1 0

d(2)ij = min

3d(1)

ij , d(1)ik + d(1)

kj

4

D(2) ist nun:

i \ j 1 2 3 41 0 1 2 52 1 0 1 43 2 1 0 14 5 4 1 0

Mache weiter bis D(4)

78

Für k < 0 :

Bottom - Up : Berechnung der d(k)ij

for i = 1 to nfor j=1 to nd(0)

ij # ((i, j)for k=1 to n

for i=1 to nfor j=1 to nd(k)

ij = min3d(k"1)

ik + d(k"1)kj , d(k"1)

ij

4

return d(n)

79

Analyse: Laufzeit

Da der Algorithmus drei ineinander verschachtelte for-Schleifen beinhaltet, ist die Laufzeit O(n3).

Der Platzbedarf ist ebenfalls O(n3), da ein 3-dimensionales Array verwendet wird, welches alle möglichenWerte speichert.,O

,n2

-als Platzbedarf ist möglich

-

Floyd- Warshall- Algorithmus

All-pairs-shortest-path problem

Bemerkung: Kürzeste Wege können ebenfalls berechnet werden.

4.4.1.2 Das Single-Source-Shortest Path Problem .

Gegeben: Gewichteter, gerichteter Graph G = (V,E), (Gewichtsfunktion (), Startknoten s ! V

Gesucht: '(i) = Länge des kürzesten Weges von s nach i * i ! V

80

27. Januar 2009

4.4.1.3 All-pairs Shortest Path Problem .

Diesmal:

d(m)ij = Länge des kürzesten Weges von i nach j der höchstens m Kanten enthält.

V = {1, . . . , n} ((i, j) " 0

d(k)ij = min

3d(k"1)

ij , d(k"1)ik + d(k"1)

kj

4

Floyd- Warshall- Algorithmus

All-pairs-shortest-path problem

dij =

'+2 i 5= j

0 i = j

für

m > 0 : d(m)ij = min

.min

1!k!n

3d(m"1)

ik + ((k, j)4

, d(m"1)ij

/= min

1!k!n

3d(m"1)

ik + ((k, j)4

Es gilt: '(i.j) = d(n"1)ij

insbesondere d(n)ij = d(n+1)

ij = d(n+2)ij = d(n+r)

ij = d(n"1)ij * r " 0

D(m) =3d(m)

ij

4

1!i,j!nn8 n- Matrix für m = 0, 1, 2, . . .

W = (( (i, j))1!i,j!n n8 n- Matrix, wobei wir annehmen, dass ((i, j) = 2 falls (i, j) /! E

D(0) =3d(0)

ij

4

i,jwie oben.

Algorithmus um D(n) aus D("1) zu berechnen.

Algorithmus Nächster (D(n"1), W )

for i = 1 to nfor j=1 to nd(m)

ij = 2for k=1 to n do

d(m)ij = min

3d(m)

ij , d(m"1)ik + ((k, j)

4

return D(m)

Laufzeit von Nächster O(n3)

81

Berechnung von ' mittels Nächster:

Initialisere D(0)

for n=1 to n-1D(m) = Nächster

,D(m"1), (

-

return D(n"1)

Laufzeit: O(n4)

Zusammenhang mit Matrixmultiplikation

A = (aij) , B = (bij) , C = (cij)

n8 n Matrizen mit

C = A · B d.h.

cij =n&

k=1

aik · bkj

mit

· %<+ % min

cij % d(n)ij

aik % d(n"1)ik

bkj % ((k, j)cij = min

1!k!n(aik + bkj) (7)

d(n)ij = min

1!k!n

3d(n"1)

ik , ((k, j)4

Wenn = die Matrix”multplikation” gemäß der Vorschrift (7) berechnet, so gilt

D(n) = D(n"1) =W

Der obige Algorithmus bezeichnet D(0), D(1) = D(0)=W, D(2) = D(0)=W=W D(1) = W D(3) = W=W=W

Die Matrixmultiplikation ist assoziativ , W 3 . . .

D(n"1) = W (n"1)

Statt iterativ, können wir D(n"1) aus W auch durch schnelle Exponentiation berechnen:

Bsp.:

W 8 =,W 4

-2

=3,

W 2-2

42

82

D(2) = W 2 = Nächster (W, W )

D(4) = W 4 = Nächster3D(2), D(2)

4

D(8) = W 8 = Nächster3D(8), D(8)

4

Fazit:

log n + 1 Aufrufe der Prozedur Nächster. Gesamtlaufzeit : O,n3 · log n

-

4.4.1.4 Kürzeste Wege von einem ausgezeichneten Startknoten .

Gegeben: G = (V,E) gerichteter Graph, Startknoten s ! VKantenlängen ( : E % R>0

Gesucht: ' =

'V % R>0

i 0% Länge eines kürzesten Weges von s nach i

Die folgenden Algorithmen speichern für jeden Knoten i ! V einen Wert di , der als Abschätzung für '(i)dient. Dabei ist stets di = '(i) und es gibt in G stets einen Weg von s nach i der Länge di . Am Ende wirddi = '(i) für alle i ! V sein (das ist natürlich zu zeigen).

4.4.1.5 Relaxation einer Kante (u, v) ! E .

dv = min (dv, dn + ((u, v))

Eigenschaften der Relaxation

angenommen wir starten mit d3 = 0, di = +2 für i 5= s

(0) Die dv’s werden nie größer (unter Relaxierung)

(1) Unmittelbar nach der Relaxation ( nach RELAX(u,v) ) von (u, v) ist dv $ dv + (u, v)

(2) für jede Folge von Relaxierungen (RELAX- Operationen) ist '(v) $ dv für alle v ! V (7)

(3) Gilt zu einem Zeitpunkt '(v) = dv , bleibt diese Eigenschaft bei (weiteren) Relaxierungen erhalten.

83

29. Januar 2009

Beweis zu (2):

1. (7) gilt am Anfang der Folge

2. Angenommen, die Aussage ist nicht wahr.

Sei v der erste Knoten, bei dem der Aufruf RELAX(u,v) dazu führt, dass dv < '(v) gilt.

Idee (was gezeigt werden soll):Wenn die Annahme gilt, dann es muss es vorher bereits einen Knoten gegeben haben, für den die Aussagenicht gegolten hat und genau dies ist ein Widerspruch zur Annahme.

Unmittelbar nach dem Aufruf von RELAX(u,v) gilt:

dv"#$%!$(v)

= du + ((u, v)

'(v) $ '(u) + ((u, v)also du + ((u, v) < '(u) + ((u, v)

( du < '(u)

Also muss auch du < '(u) vor RELAX(u,v) gelten. Dies ist ein Widerspruch zur Annahme, dass v der ersteKnoten ist, bei dem (7) passiert.

!

Weitere Eigenschaften der Relaxation

(4) Für einen kürzesten Weg (mit u, v ! V, (uv) ! E) , der die Kante (u, v) enthält, gilt:

Wenn du = '(u) , dann gilt nach RELAX(u,v) auch dv = '(v)

1. RELAX(s, 1) % d1 = '(1)

2. RELAX(3, 7)

3. RELAX(2, 4)

4. RELAX(1, 2) % d2 = '(2)

5. RELAX(2, 3) % d3 = '(3)

6. RELAX(3, 4) % d4 = '(4)

84

1. 4. 5. 6.s % 1 1 % 2 2 % 3 3 % 4

R(5, 7)R(1, 2)R(0, 4)R(2, 3)R(3, 4)R(7, 2)R(s, 5)R(s, 1)

<))))))))))=

))))))))))>

|E| Relaxierungen(|V |& 1) -mal

(5)

Für einen kürzesten Weg s % v1 % v2 % . . . % vk gilt:

Jede Folge von Relaxierungen, die die Teilfogen (RELAX (s, v1) ,RELAX (v1, v2) , . . . ,RELAX (vk"1, vk)) ent-hält, führt dazu, dass dvi = '(vi) für 1 $ i $ k . (Folgt aus (4) mit Induktion)

4.4.1.6 Algorithmus von Bellman- Ford .

Input: G = ({1, . . . , n} , E) , w, s

Output: Array d mit d [i] = '(i)

for i = 1 to nd[i] = +2

d [s] = 0for i=1 to n-1

for all (u, v) ! ERELAX(u, v)

return d

85

03. Februar 2009

Java- Einschub

Typen in Java

• Java ist eine streng typisierte Sprache

Definition:

Ein Typ oder ein Datentyp ist im Tupel eine Objektmenge mit auf dieser Menge definierten Operationen.

Typumwandlung

Definition:

Typumwandlung ist das Überführen eines Typs A in einen Typ B

Identische Überführung

Jeder Typ A kann in den Typen A überführt werden.

Weitende Umwandlung von Primitiven Datentypen

(implizit, passiert auch automatisch)

Umwandlung in größeren Datentyp.

Beispiel:

86

int i = 1234567890;f loat f = i ;

System . out . p r i n t l n ( i& ( int ) f ) ;// n i ch t 0 , da Umwandlung mit IEEE i s t e in paar S t e l l e n daneben

System . out . p r i n t l n ( i& f ) ;//wande l t i in f l o a t um, be ide g l e i c h we i t e n t f e r n t ; e r g i b t 0

Begrenzende Typumwandlung

(explizit, muss angekündigt werden)

Umwandlung von Referenzdatentypen

Von einer weiteren Typumwandlung einer Referenz A in eine Referenz B wird gesprochen, wenn

• A und B sind Klassen und B ist eine Oberklasse von A.

• A und B sind Interfaces und B ist ein Oberinterface von A.

• A ist eine Klasse und B ein Interface, welches von A implementiert wird.

Beispiel:

I n t eg e r i = new I n t eg e r ( 4 2 ) ;Number n = i ; // Number a l l g eme ine r a l s In t e g e r

Von einer begrenzenden Typumwandlung einer Referenz A in eine Referenz B wird genau dann gesprochen,wenn

87

• A und B sind Klassen und B ist eine Unterklasse von A.

• A und sind B Interfaces und B ist ein Unterface von A.

• B eine Klasse ist und A ein Interface, welches von B implementiert wird.

Beispiel:

Number n = new I n t eg e r ( 4 2 ) ;I n t eg e r i = ( In t eg e r ) n ;

88

10. Februar 2009

4.4.1.7 Der Algorithmus von Dijkstra (Zur Berechnung kürzester Wege)

Gegeben: G = (V,E) gerichtetKantengewichte ( : E % R>0 (wichtig!)s ! V

Gesucht: '(i) = Abstand von i ! V zu s * i ! V

for i ! Vd[i] = +2

d[s] = 0

Initialisiere PWS Q mit V , geordnet nach d Werten

89

B := "while Q 5= "

u := ExtractMin(Q)B := B 1 {u}

for all (u, v) ! ERELAX(u, v)

return d[];

Korrektheit:

Wir zeigen: Wenn die Anweisung “B := B 1 {u}” ausgeführt wird, dann ist d[u] = '(u).

Beweis durch Widerspruch:

Leicht zu sehen: d[s] = '(s) = 0, wenn s (als Erster) in B aufgenommen wird.

Sei u der erste Knoten, den der Alg. in B aufnimmt, wobei d[u] > '(u) ist (klar s 5= u) (7)

B ist nicht leer bevor u eingefügt wird.

p ist kürzester Weg von s nach u. (p geht von s ! B zu u /! B)

d.h. es existiert ein

y ! V : 1 Knoten auf p nicht in B

x ! V : Vorgänger von y auf p ! B

Wenn u in V eingefügt wird, gilt:

1. '(x) = d[x](weil u der erste Knoten ist, dessen d- Wert ungleich ' wird, wenn er rot wird.)

2. '(y) = d[y](wegen 1. und der Realisierung von x % y bei der Aufnahme von x in B)

Damit:d[y] = '(y)

$ '(u) y liegt vor u auf p, alle Kantengewichte " 0$ d[u] gilt immer

Da u = ExtractMin(Q) und y ! Q

d[y] " d[u]

90

Also d[y] = '(y) $ '(u) $ d[u] $ d[y]

damit d[y] = '(y) = '(u) = d[u] Widerspruch zur Annahme (7)

|E| · Kantenrelaxierungen (d-Update &DecreaseKey) , O(|E| · log |V |)

|V | · ExtractMin , O(|V | · log |V |)

91

12. Februar 2009

5 Minimal aufspannenden Bäumen (MST)

(minimum spanning tree = MST)

5.1 Berechnung

Gegeben: Ungerichteter , gewichteter Graph G = (V,E) (zusammenhängend)( : E % R>0

Gesucht: M / E mit der Eigenschaft, dass

1. (V,M) zusammenhängend ist (“M spannt G auf”)2. ((M) =

!e(M

((e) ist minimal

Beobachtung: M kann keine Kreise haben (mit anderen Worten: (V,M) ist ein Baum)

M: ((M) = 1 + 2 + 4 + 3 + 5 = 15

Die Algorithmen halten eine Menge A > E aufrecht, die die Eigenschaft hat, dass es einen MST (V,M) gibtmit A / M .

Falls e = {u, v} ! E die Eigenschaft hat, dass A1 {u, v} auch in einem MST von g enthalten ist, nennen wire sicher für A.

5.2 Generischer MST- Algorithmus

Setze A = "Solange es eine Kante e gibt, die sicher für A ist,

füge e zu A hinzureturn A

Korrektheit: klar

92

5.3 Begri"e

1. Ein Schnitt G = (V,E) ist eie Zerlegung V = SB

(V \S)

2. e = {u, v} kreuzt Schnitt S, falls u ! S und v ! V \S

3. A / E respektiert Schnitt S gdw. kein e ! A S kreuzt

Satz: A > E mit A > M , wobei (V,M) MST A respektiert Schnitt S > V .Dann ist eine leichteste Kante e ! E die S kreuzt, sicher.

93

IndexAADT, Baum, 39ADT, Definition, 25ADT, Knoten, 39Algorithmus, Amalyse, 6Algorithmus, E"zienz, 6Alignment, Alignment Problem, 67Alignment, Kosten, 67Alignment, Sequence Alignment Problem, 67Alignment, Zeichenketten, 69

BBaum, (2,4), 57, 61Baum, (2,4), Einfügen, 60Baum, (2,4), Löschen, 60Baum, (a,b), 61Baum, Anwendung, Spielbaum, 43Baum, Ausdrucks-, 42Baum, Binomial -, 36Baum, Breitensuche, 43Baum, Einfügen, 59Baum, heapgeordnet, Eigenschaften, 30Baum, heapgeordnet, Implementierung, 31Baum, Höhe, 57Baum, Implementierung, 40Baum, k-när, 40Baum, minimal aufspannend, 92Baum, minimal aufspannend, Berechnung, 92Baum, minimal aufspannend, kreuzen, 93Baum, minimal aufspannend, respektieren, 93Baum, minimal aufspannend, Schnitt, 93Baum, Rekursions-, 13Baum, Su"x-, 65Baum, Tiefensuche, 43Baum, Traversierung, 41Baum, Traversierung, inorder, 41Baum, Traversierung, inorder, Anwendung, 41Baum, Traversierung, postorder, 41Baum, Traversierung, preorder, 41

DDatenabstraktion, Vorteile, 25

GGeheimnisprinzip, 24Graph, Adjazenzliste, 73Graph, Adjazenzmatrixdarstellung, 73Graph, Endpunkt, 72Graph, gerichtet, 72Graph, gerichtet, Illustration, 72

Graph, Gewicht, 72Graph, Grundbegri!e, 72Graph, k. Wege, Abstandsfunktion, 76Graph, k. Wege, Algorithmus, Bellman- Ford, 85Graph, k. Wege, Algorithmus, Dijkstra, 89Graph, k. Wege, Eigenschaften, 76Graph, k. Wege, Floyd Warshall, Berechnung, 78Graph, k. Wege, Floyd Warshall, Formel, 77Graph, k. Wege, Floyd Warshall, Laufzeit, 80Graph, k. Wege, Relaxation, 83Graph, k. Wege, Relaxation, Eigenschaften, 83Graph, k. Wege, Startknoten, 83Graph, Kosten, 72Graph, Kosten, einfach, 73Graph, Kreis, 73Graph, kürzeste Wege, 76Graph, Operationen, 75Graph, stark zusammenhängend, 73Graph, ungerichtet, 72Graph, Weg, 72

HHashfunktion, faire, 49Hashfunktion, universell, 51Hashing, Codes, 45Hashing, Implementierung, 45Hashing, Laufzeit, 46Hashing, universell, 50Hashing, Verkettung, 45Heap, 31Heap, binär, 31Heap, binär, Implementierungen, 32Heap, Binomial-, 36Heap, Operationen, Implementierung, 38

IInterface, ADT Baum, 39Interface, Deklaration, 26Interface, Implementierung, 26Interface, Pflichten, 26Interface, Rechte, 26

JJava, Polymorphie, 35Java, Typen, 86Java, Typen, Definitition, 86Java, Typumwandlung, 86Java, Typumwandlung, begrenzt, 87Java, Typumwandlung, weitend, 86

94

KKante, sicher, 92Kosten, Alignment, 67Kosten, amortisierte, 22Kosten, Graph, 72Kosten, Rebalancierung, 61

LLaufzeit, asymptotisch, 9Lokalisieren, 38

NNotation, UP-, 42

OO- Notation, 10

PPatternmatching, String, 63PWS, ADT, 27PWS, Folge unsortierter Listen, 28PWS, Heap, 28PWS, Motivation, 27PWS, PQSort, 27PWS, verkettete Liste, 28PWS, VPWS, Operationen, 37

RRegistermaschine, 7Rekursion, 11

SSkip Liste, 53Skip Liste, Suchen, 54Sortieren - Heapsort, Laufzeit, 33Sortieren - Mergesort, 14Stack, 17Stack, Implementierung, 18Stack, Operationen, 17Su"xarray, 66

TTrie, 63Trie, komprimiert, 64Trie, Su"xarray, 66Trie, Su"xbaum, 66Trie, unkomprimiert, 64

WWörterbuch, geordnet, 53Wörterbuch, geordnet, Implementierung, 53Wörterbuch, Implementierung, 44Wörterbuch, Implementierung, Hashing, 45Wörterbuch, Operationen, 44

95