6 Folien/Blatt - Chair 11: ALGORITHM ENGINEERING

Überblick
Abstrakte Datentypen und
Datenstrukturen
Professor Dr. Petra Mutzel
Lehrstuhl für Algorithm Engineering, LS11
Fakultät für Informatik, TU Dortmund
• ADT Sequence
• ADT Stack
• ADT Queue
• ADT Dictionary
Realisierung mit
- Feldern
- verketteten Listen
• Theoretische Laufzeitanalyse
3. VO
DAP2
SS 2008
Petra Mutzel
15. April 2008
DAP2 SS08
1
Petra Mutzel
DAP2 SS08
2
Motivation
Abstrakte Datentypen
„Warum soll ich hier bleiben?“
Grundlage für alles Weitere!!!
• Ein abstrakter Datentyp (ADT) besteht aus
einem Wertebereich (d.h. einer Menge von
Objekten) und darauf definierten Operationen.
„Das kenne ich ja schon alles!“
• Die Menge der Operationen bezeichnet man
auch als Schnittstelle des Datentyps.
Auch die Analyse?
Tipp: Beliebte Klausuraufgabe: „Realisieren Sie
den ADT XXX mit einfach verketteten Listen
der Form YYY (nicht ringförmig). Analyse!“
Petra Mutzel
DAP2 SS08
• Eine Datenstruktur ist eine Realisierung bzw.
Implementierung eines ADT.
3
Der ADT Sequence
DAP2 SS08
4
Operationen des ADT Sequence
• Wertebereich: Menge aller endlichen Folgen
eines gegebenen Grundtyps.
• S=<a1,a2,…,an>
Petra Mutzel
• INSERT(val x, pos p): pos
– Einfügen eines Elements x vor dem Element an
Position p
Leere Sequenz: < >
• INSERT(x,pos(ai)): S=<a1,a2,…ai-1,x,ai,…,an>
• INSERT(x,nil): S=<a1,a2,…,an,x>
• Operationen:
• DELETE(pos p)
– Im folgenden betrachten wir die Sequence
S=<a1,a2,…,an> mit Grundtyp val
– Löscht das Element an Position p (p≠nil).
• DELETE(pos(ai)): S=<a1,a2,…ai-1,ai+1,…,an>
Petra Mutzel
DAP2 SS08
5
Petra Mutzel
DAP2 SS08
6
1
Operationen des ADT Sequence
Realisierung durch Felder
• Interne Repräsentation:
• GET(int i): val
– Gibt das Element an i-ter Stelle zurück (1≤i≤n)
– Speicherung als Array der Dimension maxN
– Position wird durch Feldindex angegeben
• GET(i): ai
• Leeres Feld: n:=0
• CONCATENATE(Seq S´)
– Hängt die Sequence S´ hinten an S an (müssen
gleichen Grundtyp besitzen)
1
• CONCATENATE(S´): Falls S´=<a´1,a´2,…,a´m>,
dann: <a1,a2,…an,a´1,…,a´m>
Petra Mutzel
DAP2 SS08
2 3
i
n
a1 a2 a3
… ai
… an
7
Petra Mutzel
2 3 4 5 6 7
D A 2
P
n=
8 9 10
– Speicherung als doppelt verkettete Liste
– vorwärts und rückwärts ringförmig verkettet
I S T G U T
Procedure INSERT(val x, int t):int
if n=maxN then throw Overflow Exc.
for i:=n downto t { A[i+1]:=A[i] }
A[t]:=x
n:=n+1
return t
Petra Mutzel
head
DAP2 SS08
a1
x
…
…
a1
Laufzeitanalyse des ADT Sequence
Best-Case
a2
an
…
• Leere Liste: head→nil
• 1-elementige Liste: head
p
q
…
a2
9
Beispiel: INSERT(x,p):q
a1
8
• Interne Repräsentation:
maxN
Realisierung der Operationen: s. TeX-Folien bzw. Skript
head
DAP2 SS08
Realisierung durch Listen
Beispiel: INSERT(P,3):3
1
maxN
an
Realisierung der Operationen:
s. TeX-Folien bzw. Skript
Ausschnitt:
…
if head=nil then head:=q.next:=q.prev:=q else
if p=head then head:=q
if p=nil then p:=head // hinten einfügen = vor head
q.next:=p; q.prev:=p.prev
q.next.prev:=q.prev.next:=q …
Operation
Felder
Average-Case
Worst-Case
Listen Felder
Listen
Initialisierung Θ(1)+Alloc Θ(1)
Θ(1)+Alloc Θ(1)
INSERT
Θ(1)
Θ(1)
Θ(n)
Θ(1)
DELETE
Θ(1)
Θ(1)
Θ(n)
Θ(1)
GET
Θ(1)
Θ(1)
Θ(1)
Θ(n)
CONCAT
Θ(1+S´.n) Θ(1)
Θ(1+S´.n) Θ(1)
⇒ bei Einfügen und Entfernen: Listen besser als Arrays
2
Der ADT Stack
Operationen des ADT Stack
„Stack“: Stapelspeicher, LIFO-Speicher
• PUSH(val x)
• Wertebereich: Menge aller endlichen Folgen
eines gegebenen Grundtyps.
Leerer Stack: < >
• S=<a1,a2,…,an>
• PUSH(x): S=<a1,a2,…an,x>
• POP() : val
– Gibt das oberste Element des Stacks zurück und
entfernt es (n>0).
• Operationen:
– Im folgenden betrachten wir den Stack
S=<a1,a2,…,an> mit Grundtyp val
Petra Mutzel
– Legt ein neues Element x auf den Stack
• POP(): an
• ISEMPTY() : bool
DAP2 SS08
14
– Gibt true zurück, falls S leer ist; sonst false.
Beispiel: PUSH(P)
Realisierung des ADT Stack durch Felder
1
• Interne Repräsentation:
2 3 4 5 6 7
D A 2
– Speicherung als Array der Dimension maxN
– Position wird durch Feldindex angegeben
P
2 3
i
n
a1 a2 a3
… ai
… an
Procedure PUSH(val x)
if n=maxN then throw Overflow Exception
n:=n+1
A[n]:=x
maxN
wie bei ADT Sequence, nur einfacher (s. Skript)
Petra Mutzel
DAP2 SS08
Realisierung der Operationen: s. TeX-Folien bzw. Skript
16
Beispiel: PUSH(x)
Realisierung des ADT Stack durch Listen
• Interne Repräsentation:
head
– Speicherung als doppelt
einfach verkettete Liste
– vorwärts und rückwärts ringförmig verkettet
an an
an-1
an-1
• Leere Liste: head→nil
• 1-elementige Liste: head
Petra Mutzel
…
…
a1 a1
nil
a1
DAP2 SS08
an
an-1
…
a1
nil
p
head
maxN
I S T G U T
• Leeres Feld: n:=0
1
n=
8 9 10
nil
18
x
Procedure PUSH(val x)
var SListEl p:=new SListEl
p.value:=x
p.next:=head
head:=p
Realisierung der Operationen: s. TeX-Folien bzw. Skript
3
Queue
Der ADT Stack
Laufzeitanalyse des ADT Stack
Worst-Case , Best-Case, Average Case
„Stack“:
„Queue“:
Stapelspeicher,
Warteschlangen,
LIFO-Speicher)
FIFO-Speicher
Operation
Felder
Listen
Θ(1)+Alloc
Θ(1)
• Wertebereich: Menge aller endlichen Folgen
eines gegebenen Grundtyps.
ISEMPTY
Θ(1)
Θ(1)
• S=<a1,a2,…,an>
PUSH
Θ(1)
Θ(1)
• Operationen:
POP
Θ(1)
Θ(1)
Initialisierung
LeererQueue:
Stack: < >
– Im folgenden betrachten wir
den
Stack S=<a1,a2,…,an> mit Grundtyp val
die
Queue:
⇒ falls maxN bekannt: Arrays besser, da dynamische
Speicherallokierung (wie
Listen) langsamer
ist. 20
Petrabei
Mutzel
DAP2 SS08
Queue
Operationen des ADT Stack
Petra Mutzel
22
Realisierung des ADT Queue durch Felder
• Interne Repräsentation:
• PUSH(val
x)
PUT
– Speicherung als Array der Dimension maxN
– Trick: Queue ist zyklisch im Feld gespeichert
– Position wird durch Feldindizes front und back
angegeben
– Legt ein neues Element x oben
auf
den der
Stack
an das
Ende
Queue
• PUSH(x):
PUT
S=<a1,a2,…an,x>
• GET
POP() : val
1
– Gibt das oberste
Stacks zurück und
erste Element des
der Queue
entfernt es (n>0).
p
2 3
a5 a6
• GET
POP(): an1
– Gibt true zurück, falls S leer ist; sonst false.
Beispiel: PUT(P)
2 3 4 5 6 7
T G U
2 TI
8 9 10
D A 2
back
m=
maxN+1
maxN+1
a1 a2 a3 a4
back
• ISEMPTY() : bool
1
DAP2 SS08
front
Bei maxN Feldern wäre back=front, wenn Array „voll“,
aber „back=front“ ist Abbruchbedingung
für SS08
leere Liste24
Petra Mutzel
DAP2
Realisierung des ADT Queue durch Listen
• Interne Repräsentation:
– Speicherung als einfach verkettete Liste
– Zeiger head und tail auf Anfang und Ende
I S
front
P
Procedure PUT(val x)
A[back]:=x
if back=m then back:=1 else back:=back+1
if front=back then throw Overflow Exception
Realisierung der Operationen: s. Skript
head
a1
…
a2
an
tail
Petra Mutzel
DAP2 SS08
nil
26
4
Beispiel: PUT(x)
Laufzeitanalyse des ADT Queue
Worst-Case , Best-Case, Average Case
p
head
a1
…
a2
Operation
an
tail
x
nil
nil
Procedure PUT(val x)
var SListEl p:=tail
tail:=new SListEl
tail.value:=x; tail.next:=nil
if head=nil then head:=tail else p.next:=tail
Felder
Listen
Θ(1)+Alloc
Θ(1)
ISEMPTY
Θ(1)
Θ(1)
PUT
Θ(1)
Θ(1)
GET
Θ(1)
Θ(1)
Initialisierung
Vergleichen Sie diese Tabelle mit der von ADT Stack
Realisierung der Operationen: s. Skript
Operationen des ADT Dictionary
Der ADT Dictionary
• INSERT(K k,V v)
„Dictionary“: Wörterbuch
– Falls k nicht schon in D ist, dann wird ein neuer
Schlüssel k mit Wert v in D eingefügt, andernfalls
wird der Wert des Schlüssels k auf v geändert.
• Wertebereich: D⊆KxV, wobei K Schlüssel (key)
bezeichnet und V die Werte. Dabei ist jedem k∈K
höchstens ein v∈V zuordnet.
• Operationen:
– Einfügen, Entfernen, Suchen (s. nächste Folie)
– Im folgenden sei Q ein Dictionary vor Anwendung
der Operationen.
Petra Mutzel
DAP2 SS08
30
INSERT(k,v): Falls k neu: D:=D ∪ (k,v),
sonst
D:=D \ (k,v´) ∪ (k,v)
• DELETE(K k)
– Entfernt Schlüssel k mit Wert aus D (falls k in D)
• SEARCH(K k): V
– Gibt den bei Schlüssel k gespeicherten Wert
zurück (falls k in D)
Der ADT Dictionary
• Wörterbuchproblem: Finde eine
Datenstruktur mit möglichst effizienten
Implementierungen für die Operationen
eines Dictionary.
• Naive Lösung: als Paar von Feldern:
→ Lineare Laufzeit für alle Operationen
• Im Laufe der Vorlesung: einige weitaus
bessere Verfahren!
Petra Mutzel
DAP2 SS08
32
5