21. 4. 2011

Was bisher geschah
I
Algorithmen
I
Spezifikation
I
asymptotische Laufzeit
I
rekursive Algorithmen
I
Divide and Conquer
I
Dynamische Programmierung
87
Entwurfsebenen
Mathematik:
Algorithmik:
Programmierung:
Funktion
↓
Algorithmus
↓
(Unter-)Programm
Abstrakter Datentyp
↓
Algebra
(Konkreter Datentyp)
↓
Datenstruktur
↓
Typ, Klasse
88
Motivation
Aufgabe: Verwaltung einer Menge ganzer Zahlen, so das festgestellt
werden kann, ob eine Zahl darin enthalten ist und Zahlen hinzugefügt
und entfernt werden können.
Spezifikation NSet:
I
I
N
Wertebereiche (Sorten): , Menge, Wahrheitswert (Bool)
Operationen: finden, hinzufügen, entfernen
Operationen mit Typdeklaration (Signatur)
N
N
contains :
Menge × →
add, remove : Menge × →
isempty :
Menge →
emptyset :
I
Bool
Menge
Bool
Menge
Bedeutung der Operationen
t falls x ∈ M
contains(M, x) =
f sonst
add(M, x)
=
M ∪ {x}
remove(M, x) = M \ {x}
= ∅
t falls M = ∅
isempty(M) =
f sonst
emptyset
89
Formale Spezifikation
Spezifikation NSet’:
N, Menge, Wahrheitswert
I
Wertebereiche (Sorten):
I
Operationen: finden, hinzufügen, entfernen
Operationen mit Typdeklaration (Signatur)
N
N
contains :
Menge × →
add, remove : Menge × →
isempty :
Menge →
emptyset :
I
Bool
Menge
Bool
Menge
formale Beschreibung der Bedeutung der Operationen, z.B.
N
∀s ∈ Menge∀n ∈ N
∀s ∈ Menge∀n ∈ N
∀s ∈ Menge∀m, n ∈ N
∀s ∈ Menge∀n ∈ N
∀n ∈
isempty((emptyset) = t
: contains(emptyset, n) = f
: contains(add(s, n), n) = t
: contains(remove(s, n), n) = f
: add(add(s, n), m) = add(add(s, m), n)
: add(add(s, n), n) = add(s, n)
...
90
Abstrakte und konkrete Datentypen
Datentyp:
Menge von Werten mit Operationen auf diesen Werten
I
einfache Datentypen, z.B. |int,bool, float, ...|
I
zusammengesetzte Datentypen, z.B. Listen, Klassen
Abstrakter Datentyp (ADT): (formale Spezifikation)
I Menge von Sorten
I mehrsortige Signatur ΣF
I Menge von Axiomen Φ
ADT = (funktionale) Signatur ΣF + Axiome Φ
Konkreter Datentyp: ΣF -Algebra A mit A ∈ Mod(Φ)
(Struktur mit geeigneten Funktionen, so dass alle
Axiome erfüllt sind)
91
Beispiel: Boolesche Algebra
Abstrakter Datentyp Boolesche Algebra:
I Sorten: B
I Signatur:
t:
f:
¬:
B→
∨: B×B →
∧: B×B →
I
B
B
B
B
B
Axiome:

∀a∀b : a ∧ b = b ∧ a, ∀a∀b : a ∨ b = b ∨ a,



∀a∀b∀c : a ∨ (b ∧ c) = (a ∨ b) ∧ (a ∨ c),
Φ=
∀a∀b∀c : a ∧ (b ∨ c) = (a ∧ b) ∨ (a ∧ c),



¬(t = f), ∀a∀b : ¬(¬a ∨ b) ∨ ¬(¬a ∨ ¬b) = a







Konkrete Datentypen, z.B.
I ({0, 1}, max, min, 1 − x, 0, 1)
I (2{a} , ∪, ∩, , ∅, {a})
92
Wiederholung: mehrsortige Strukturen
Modellierung von Strukturen mit
S = {Si | i ∈ I} von
I
verschiedenen Sorten (Mengen)
Elementen
I
Operationen
I
Eigenschaften und Zusammenhänge zwischen
Operationen
Beispiele:
I
Folgen, add, remove, append, insert, reverse
∀x : reverse(reverse(xs)) = xs
I
Mengen, insert, contains, empty
∀x∀xs : empty(insert(x, xs)) = false
I
Vektorraum, smult,sprod,+,0,0v
∀v : smult(0,v) = 0v
93
Mehrsortige Strukturen
hier nur funktionale Strukturen (Algebren)
I
Sorten
I
Signatur Σ = (ΣF , ∅) (keine Relationssymbole)
S
ΣF -Algebra A = ({AS | S ∈ }, J·KA ) mit
S
I
für jede Sorte S ∈ eine nichtleere Menge AS
(Träger, Universum der Sorte)
I
für jedes Funktionssymbol f : Si1 . . . Sin → Si
eine Funktion Jf KA : Ai1 × · · · × Ain → Ai
Modell für Menge Φ von Sätzen:
ΣF -Algebra A, welche alle Sätze aus Φ erfüllt
94
Repräsentation durch Datenstrukturen
Mengen typische Operationen:
I Test auf Leerheit
I Einfügen, Löschen von Elementen
I Suche nach Element
I Vereinigung, Durchschnitt, Differenz
Folgen (z.B. Listen, Texte), typische Operationen:
I Einfügen, Löschen von Elementen
I Suche nach Element
I spezielle Elemente suchen (Min, Max, Median)
I Sortieren
I Verketten, Spiegeln
Funktionen (z.B. Wörterbücher), typische Operationen:
I Einfügen, Löschen von Argument-Wert-Paaren
I Suche nach dem Wert zu einem Argument
Graphen typische Operationen:
I Einfügen, Löschen von Knoten und Kanten
I Suche nach Knoten
I Suche nach Pfaden (z.B. kürzeste)
I Suche nach Teilgraphen (z.B. Gerüst)
95
Beispiel ADT Folge
Ziel: Datentyp zur Verwaltung einer endlichen Folge
(Zuordnung f : {1, . . . , n} auf Elemente) mit Operationen zum
Einfügen, Löschen und Lesen des Elementes an einer bestimmten
Stelle.
ADT (Spezifikation):
I
Sorten: Bool, Nat, Element, Folge
I
Signatur:
nil :
Folge
cons :
Element × Folge → Folge
head :
Folge → Element
tail :
Folge → Folge
isempty :
Folge → Bool
size :
Folge → Nat
add :
Folge × Element → Folge
remove : Folge × Element → Folge
get :
Folge × Nat → Element
reverse :
Folge → Folge
concat :
Folge × Folge → Folge
I
Axiome ?
96
(Ein möglicher) konkreter Datentyp für Folgen
Sorten:
I
Bool: {0, 1},
I
Nat:
I
Element: {a, b, c},
I
Folge:
{(x1 , . . . , xn ) | n ∈
N,
N ∧ ∀i ∈ {1, . . . , n} : xi ∈ {a, b, c}}
isempty(x) =
t falls x = ()
f sonst
emptyseq = ()
size((x1 , . . . , xn )) = n
add((x1 , . . . , xn ), y , i) = (x1 , . . . , xi−1 , y , xi , . . . , xn )
remove((x1 , . . . , xn ), y , i) = (x1 , . . . , xi−1 , xi+1 , . . . , xn )
get((x1 , . . . , xn ), y , i) = xi
97
Beispiel ADT Wörterbuch (Dictionary)
Ziel: Datentyp zur Verwaltung einer Menge (von Aufgaben,
Studenten, . . . ) mit Operationen zum Einfügen und Entfernen von
Elementen und Tests auf Enthaltensein eines Elementes und
Leerheit der Menge.
ADT (Spezifikation):
I
Sorten: Bool, Element, Menge
I
Signatur:
isempty :
Menge →
emptyset :
add :
Menge × Element →
remove :
Menge × Element →
contains : Menge × Element →
I
Bool
Menge
Menge
Menge
Bool
Axiome (alle ∀-quantifiziert: ∀s ∈ Menge, ∀E ∈ Element):


 contains(add(s, e)) = t, contains(remove(s, e)) = f,

isempty(add(s, e)) = f, add(add(s, e), e0 ) = add(add(s, e0 ), e),
Φ=


add(add(s, e), e) = add(s, e), . . .
+ Axiome der Booleschen Algebra
98
Konkrete Datentypen für Wörterbücher
einige Möglichkeiten:
I ungeordnete Folge (Aufzählung aller Elemente)
I
I
I
I
I
geordnete Folge (sortierte Aufzählung aller Elemente)
I
I
I
I
I
add O(1)
remove O(n)
contains O(n)
isempty O(1)
add O(n)
remove O(n)
contains O(log n)
isempty O(1)
Bitvektor (charakteristische Funktion)
I
I
I
I
add O(1)
remove O(1)
contains O(1)
isempty O(n)
99
Datenstrukturen zur Verwaltung mehrerer Daten
derselben Art
I
lineare Strukturen (Folge, Liste, Queue, Stack)
I
hierarchische Strukturen (Bäume)
I
Relationen (Graphen)
100