1 kapitel 5: von datenstrukturen zu abstrakten datentypen 5.1 zur erinnerung: datenstrukturen in...

Download 1 Kapitel 5: Von Datenstrukturen zu Abstrakten Datentypen 5.1 Zur Erinnerung: Datenstrukturen in Pascal Listenverarbeitung in Pascal 5.2 Abstrakte Datentypen

Post on 06-Apr-2015

103 views

Category:

Documents

1 download

Embed Size (px)

TRANSCRIPT

  • Folie 1
  • 1 Kapitel 5: Von Datenstrukturen zu Abstrakten Datentypen 5.1 Zur Erinnerung: Datenstrukturen in Pascal Listenverarbeitung in Pascal 5.2 Abstrakte Datentypen und Objektorientierung Brche als ADT Implementierung - objektorientiert Brche als ADT Implementierung - funktional 5.3 Geordnete lineare Zusammenfassungen: Listen bzw. Folgen Cons-Zelle als Basisklasse Statisch-funktionale Listenimplementierung Listenimplementierung mit Objektmethoden 5.4 Stacks und Queues Zustandsorientierte Stack-Implementierung 5.5 Priority Queues 5.6 Find and Merge 5.6.1 Implementierung mit Arrays 5.6.2 Implementierung mit Bumen
  • Folie 2
  • 2 Implementierung von Queues: Mit doppelt verketteter Liste als Zeigerstruktur Doppelt verkettet, da man auf beide Enden der Liste zugreifen muss. In einem Array Problem: Einfgen am Ende und Entfernen am Anfang fhrt dazu, dass die Queue durch den Array wandert. Lsung: Zyklisch in einem Array
  • Folie 3
  • 3 Anwendungen von Queues Realisierung von Warteschlangen, besonders in Betriebssystemen, z.B. Prozesse, Nachrichten, Druckauftrge.
  • Folie 4
  • 4 5.5 Priority Queues: Mengen mit Insert und Deletemin Priority Queues: Warteschlangen, in denen die Elemente Prioritten haben. Es knnen Elemente mit beliebiger Prioritt eingefgt werden und es wird immer das (ein) Element mit der hchsten Prioritt entnommen. Anwendungen/Beispiele: Patienten im Warteraum einer Krankenhausambulanz Betriebssysteme, bes. Multiuser-Betriebssysteme
  • Folie 5
  • 5 Oft knnen verschiedene Elemente gleiche Prioritt haben: fhrt zu Multisets (Multimengen) Multisets: Mengen mit Duplikaten (aber ohne Ordnung der Elemente, also keine Listen/Folgen). Beispiel: {|1,3,3,7,7,7,10|} auch notiert als: {(1,1),(3,2),(7,3),(10,1)} Zu einer Menge S sei M(S) die Menge aller Multimengen mit Elementen aus S. In Priority Queues: Prioritten = natrliche Zahlen Hhere Prioritt = kleinere Zahl (dann gibt es automatisch eine hchste Prioritt).
  • Folie 6
  • 6 Datentyp fr die Priority Queue, algebraische Spezifikation: algebra pqueue sorts pqueue, elem ops empty: pqueue isempty: pqueue boolean insert: pqueue elem pqueue deletemin: pqueue pqueue elem sets pqueue = M(elem) functions empty = {} isempty (p) = (p={}) insert (p,e) = p {|e|} deletemin (p) = (p',e) mit e = min(p) und p'=p\{|e|} falls p {}, undefiniert sonst end pqueue.
  • Folie 7
  • 7 Implementierung von Priority Queues Z.B. mit partiell geordneten Bumen. Ein partiell geordneter Baum (Heap) ist ein knotenmarkierter binrer Baum (T, m) (hier ist T der Baumgraph und m die Markierungsfunktion der Knoten), in dem fr jeden Teilbaum (T ',m) mit der Wurzel x gilt: fr alle y aus T ' ist m(x) m(y) In der Wurzel steht also jeweils das Minimum eines Teilbaumes. Analog mglich: Ordnung umgekehrt, also in jeder Wurzel eines Teilbaums das Maximum.
  • Folie 8
  • 8 Definition Heap Speziellere Definition eines Heap: partiell geordneter Binrbaum, der links- vollstndig ist, d.h. die Ebenen werden von der Wurzel her gefllt, und jede Ebene von links nach rechts. Auerdem: Implementierung in einem Array, in dem die Knoten in dieser Reihenfolge abgelegt werden.
  • Folie 9
  • 9 Teilheap Ein Teil T [ i..k ] ( 0 i k n ) heit Teilheap, wenn gilt: fr alle j aus {i,...,k} ist m(T [ j ]) m(T [ 2j ]) falls 2j k und m(T [ j ]) m(T [ 2j+1]) falls 2j+1 k Ist T [i+1..n] bereits ein Teilheap, so kann man durch Einsinkenlassen des Elements T [ i ] die Heapeigenschaft erweitern.
  • Folie 10
  • 10 Aufbau des Heaps Zum Aufbau des Heaps werden die Elemente zunchst in die Ebenen unterhalb der Wurzel eingebracht und zwar maximal 2 j Elemente in die Ebene j (j = 0,..., k-1). Jedes Einsinkenlassen eines Elementes kostet den Aufwand O(k-1) = O(ld n), also bei n Elementen O(n ld n). Eine genauere Betrachtung zeigt, dass der Aufwand pro Element in jeder j-Ebene nur O(k-j-1) ist. Also erhlt man allgemein 1 2 k-2 + 2 2 k-3 +... + (k-1) 2 0 2 k-1 i > 0 i / 2 i = 2 k = O(n) Hat man nun das oberste Element entfernt, so wird das letzte Element an seine Stelle gebracht und durch Einsinken- lassen (pro Ebene zwei Vergleiche und eine Vertauschung) die Heapeigenschaft wiederhergestellt. Dies kostet einen Aufwand von O(ld n).
  • Folie 11
  • 11 Entfernen des minimalen Elementes aus einem Heap und Wiederherstellung der Heapeigenschaft Algorithmus deletemin (h) {lsche das minimale Element aus dem Heap h und gib es aus} Entnimm der Wurzel ihren Eintrag und gib ihn als Minimum aus. Nimm den Eintrag der letzten besetzten Position im Baum, lsche diese Position und setze ihren Eintrag in die Wurzel ein. Sei p die Wurzel, und seien q und r die Shne der Wurzel Solange Shne q oder r existieren und (m(p) > m(q) oder m(p) > m(r) ) gilt: {vertausche p mit dem Sohn mit dem kleineren Eintrag. Setze q und r auf die neuen Shne dieses Knotens.} e gilt: {Vertausche die Eintrge in p und q, setze q auf p und p auf den Vater von p.}">
  • 12 Einfgen in einen Heap: Algorithmus insert (h, e) {fge einen neuen Knoten q mit Eintrag e in den Heap h ein} erzeuge einen neuen Knoten q mit Eintrag e; fge q auf der ersten freien Position in der untersten Ebene ein; falls die unterste Ebene voll besetzt ist, beginne eine neue Ebene. Sei p der Vater von e; Solange p existiert und m(p) > e gilt: {Vertausche die Eintrge in p und q, setze q auf p und p auf den Vater von p.}
  • Folie 13
  • 13 Sei n die Zahl der Knoten des Heap. Aufwand fr das Entfernen des minimalen Elementes: O(log n). fr das Einfgen eines neuen Knotens: O(log n). Denn ein Heap hat Hhe [log 2 (n+1)] + -1 Aufwand fr das Aufbauen des Heap durch wiederholtes Einfgen von Knoten: O(n log n). Wir haben gesehen, dass man einen Heap in O(n) Schritten aufbauen kann, wenn diese Elemente von Anfang an alle bekannt sind.
  • Folie 14
  • 14 5.6 Partitionen von Mengen mit Find und Merge Sei S eine Menge, P eine Partition von S, also eine Menge von Teilmengen von S, die paarweise disjunkt sind und zusammen die Menge S ergeben. (Zwei Elemente von S heien quivalent, wenn sie zur gleichen Komponente gehren.) Wir wollen: find: bei Eingabe eines Elementes die Komponente finden, zu der es gehrt, merge: bei Eingabe (der Namen oder von Elementen) zweier Komponenten diese verschmelzen.
  • Folie 15
  • 15 Datentyp, algebraisch spezifiziert: algebra partition sorts partition, compname, elem ops empty : partition addcomp: partition compname elem partition merge : partition compname compname partition find : partition elem compname sets compname=Menge von Komponentennamen (aus einer Menge CN) partition={(c i,S i ) | 1 i n, c i Komponentenname, S i Teilmenge von elem, i j c i c j und S i, S j elementfremd.}
  • Folie 16
  • 16 functions empty bildet auf die leere Partition ab (dann ist auch die partitionierte Menge S die leere Menge!) Sei p:={(c 1,S 1 ),..., (c n,S n )} eine Partition, S = Vereinigung der S i, und C= {c 1,..., c n }, C Komp. N. Sei a aus CN\C, x nicht in S enthalten. addcomp (p,a,x) =p U {(a,{x})} Seien a und b Elemente aus C mit den zugehrigen Komponenten A und B, d ein Name aus CN\C oder d=a bzw. d=b. merge (p,a,b) = (p \ {(a,A), (b,B)}) U {(d,A U B)} Sei x ein Element aus S. find (p,x) = a mit (a,A) aus p und x aus A. end partition.
  • Folie 17
  • 17 5.6.1 Implementierung mit Arrays Fall elem := {1,..., n} und compname = {1,..., n}. Wir benutzen zwei Arrays der Gre n. 1.Adjazenzmatrix (components): enthlt die Komponentennamen und zu jedem ein Element der Komponente (wenn dies 0, dann Komponente leer). 1.Inzidenzmatrix (elems): enthlt die Elementnamen, zu jedem den Namen der zugehrigen Komponente und ein weiteres Element der Komponente (wenn dies 0, dann kein noch nicht erfasstes Element der Komponente). Man erhlt fr jede Komponente eine verkettete Liste!
  • Folie 18
  • 18 p = {(2,{1,2,4,5}), (3,{3}), (6,{6})}. S = {1,2,3,4,5,6}. components compname Vertreter (0 unbenutzt) verlinkt mit 10 21mit 1 33mit 3 40 50 66mit 6 Beispiel elemscompnamenextelem 122 224 330 (entspricht NIL) 425 520 660
  • Folie 19
  • 19 Algorithmus find: Zeit O(1). Algorithmus merge (p, a, b); {verschmelze die Komponenten von a und b in der Partition p} Durchlaufe fr a die zugehrige Liste in der Inzidenzmatrix elems und setze fr jedes Element der Liste den zugehrigen Komponentennamen compname auf b; Sei j der Name des letzten Elements dieser Liste; Fhre dann die folgenden Umbenennungen durch. elems[j].nextelem:= components[b].firstelem; components[b].firstelem:=components[a].firstelem; components[a].firstelem:=0; end merge.
  • Folie 20
  • 20 Aufwand fr merge: O(n). Aufwand fr n-1 merge-Anweisungen: Klar: O( i=1n i) = O(n). Kann verbessert werden zu: O(n log n): Schlage immer die kleinere Komponente zur greren! Dann immer eine (mindestens) Verdoppelung der Gre der Komponente eines Elements. Amortisierte worst-case Laufzeit von merge: O(log n).
  • Folie 21
  • 21 5.6.2 Implementierung mit Bumen Wir benutzen: ein Array mit den Elementen und fr jedes Element einen Knoten in einem Baum, sowie zu jeder Komponente eine Baumstruktur. Name einer Komponente: das Element in der Wurzel des Baums.
  • Folie 22
  • 22 Implementation mit Bumen elems 1-> 1 2-> 2-> 1 3-> 3 -> K3 -> 3 4-> 4-> 2-> 1 -> K2 -> 1 5-> 5-> 2-> 1 6-> 6 -> K6 -> 6 Hier wird jede Komponente durch einen Baum dargestellt, dessen Knoten die Elemente der Komponente sind. Dann ist elems ein array[1..n] von diesen Bumen. Die Verweise fhre

Recommended

View more >