Algorithmen und Datenstrukturen

advertisement
Was bisher geschah
I
Algorithmen
I
Spezifikation
I
rekursive Algorithmen
I
asymptotische Laufzeit
I
Sortieren von Folgen
77
Entwurfsebenen
Mathematik
Algorithmik
Programmierung
Funktion
↓
Algorithmus
↓
(Unter-)Programm
Abstrakter Datentyp
↓
Algebra
(Konkreter Datentyp)
↓
Datenstruktur
↓
Typ, Klasse
78
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)
79
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})
80
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
81
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
82
Beispiel ADT Menge
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:
leer :
Menge →
leeremenge :
add :
Menge × Element →
remove :
Menge × Element →
contains :
Menge × Element →
I
Bool
Menge
Menge
Menge
Bool
Axiome (alle allquantifiziert: ∀s ∈ Menge, ∀E ∈ Element):


 contains(add(s, e)) = t, contains(remove(s, e)) = f,

leer(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
83
Konkreter Datentyp für Mengen
Sorten:
I
Bool: {0, 1},
I
Element:
I
Menge: {M | M ⊆ ∧ |M| ∈ }
(alle endlichen Mengen natürlicher Zahlen)
N,
N
N
leer(M) =
1 falls M = ∅
0 sonst
leeremenge = ∅
add(M, x) = M ∪ {x}
remove(M, x) = M \ {x}
1 falls x ∈ M
contains(M, x) =
0 sonst
84
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:
leer :
Folge →
leerefolge :
size :
Folge →
add :
Folge × Element × Nat →
remove :
Folge × Nat →
get :
Folge × Nat →
I
Bool
Folge
Nat
Folge
Folge
Element
Axiome ?
85
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}}
leer(l) =
1 falls l = ()
0 sonst
leerefolge = ()
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
86
Spezielle Folgen
add, remove und get nur an festgelegten Positionen
(kein Index als Parameter)
ADT (Spezifikation):
I
Sorten: Bool, Nat, Element, Folge
I
Signatur:
leer :
Folge →
leerefolge :
add0 :
Folge × Element →
remove0 :
Folge →
get0 :
Folge →
Bool
Folge
Folge
Folge
Element
Stack (LIFO)
andere Namen: add 7→ push remove 7→ pop, get 7→ top
leer(leerefolge) = t, leer(push(s, e)) = f,
Φ=
pop(push(s, e)) = s, top(push(s, e)) = e
Queue (FIFO)
andere Namen: add 7→ enqueue, remove 7→ dequeue,
get 7→ front
87
Datenstrukturen zur Verwaltung mehrerer Daten
derselben Art
I
lineare Strukturen (Folge,Queue, Stack, Liste)
I
hierarchische Strukturen (Bäume)
I
Relationen (Graphen)
88
Repräsentation durch Datenstrukturen
Folgen (z.B. Listen, Texte), typische Operationen:
I Einfügen, Löschen von Elementen
I Suche nach einem Element
I spezielle Elemente suchen (Min, Max, Median)
I sortieren
Funktionen (z.B. Wörterbücher), typische Operationen:
I Einfügen, Löschen von Argument-Wert-Paaren
I Suche nach dem Funktionswert eines gegebenen
Wertes
Mengen typische Operationen:
I Vereinigung, Durchschnitt, Differenz
I Suche nach Element
I Test auf Leerheit
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)
89
Herunterladen