Algorithmen und Datenstrukturen 10

Transkript

1 28. Juni 2012

2 1 Besprechung Blatt 9 Fragen 2 ADT Allgemein Beispiele 3 Generics Motivation & Beispiel Type Erasure Wrapper-Klassen und (Un-)Boxing 4 Datentypen Verkettete Listen und Binärbäume Binary Heaps 5 Vorbereitung Blatt 10 Hinweise

3 Fragen Fragen zu Blatt 9?

4 Allgemein Schema eines ADTs adt [Name] sorts [Verwendete Datentypen] ops [Methodensignaturen] axs [Axiome] end [Name]

5 Allgemein Operationstypen 3 Operationstypen: 1 (Primär-)Konstruktoren (Operationen zum Erreichen jedes möglichen Zustands, minimale Anzahl) 2 Hilfskonstruktoren (alles andere was den ADT zurückgibt) 3 Projektionen (andere Rückgabewerte) ADT-Konstruktoren werden meist durch Java-Konstruktoren abgebildet. Java-Methoden sind auch möglich, diese müssen bei Primärkonstruktoren static sein.

6 Allgemein Primärkonstruktoren, Normalform Primärkonstruktoren benötigen keine eigenen Axiome werden durch die Verwendung in den anderen Operationen definiert Normalform Objekt, das durch eine minimale Zahl von Primärkonstruktoren dargestellt ist.

7 Beispiele Queue: T Gesucht: ADT mit den Methoden create enqueue dequeue empty head tail Beachte: Für die Definition des ADTs ist es egal, ob man enqueue oder dequeue rekursiv definiert. Wir definieren dequeue rekursiv.

8 Beispiele QUEUE: T ops create: -> QUEUE enqueue: T x QUEUE -> QUEUE dequeue: QUEUE -> QUEUE empty: QUEUE -> BOOL head: QUEUE -> T axs A1: empty(create()) = TRUE A2: empty(enqueue(x, q)) = FALSE A3: head(create()) = ERROR oder NULL A4: head(enqueue(x, q)) = x falls empty(q) = TRUE = head(q) sonst A5: dequeue(create()) = ERROR oder NULL A6: dequeue(enqueue(x, q)) = q falls empty(q) = TRUE = enqueue(x, dequeue(q)) sonst

9 Beispiele ADT auswerten (Queue : int) tail(enqueue(head(enqueue(27, dequeue(enqueue(42, enqueue(13, create))))), enqueue(99, enqueue(5, create)))) = tail(enqueue( head(enqueue(27, dequeue(enqueue(42, enqueue(13, create))))), enqueue(99, enqueue(5, create)) )) Bei tail interessiert nur das zuletzt hinzugefügte Element! = head(enqueue(27, dequeue(enqueue(42, enqueue(13, create))))) Jetzt von innen nach außen auflösen: = head(enqueue(27, dequeue(enqueue(42, [13])))) = head(enqueue(27, dequeue([13, 42]))) = head(enqueue(27, [42])) = head([42, 27]) = 42

10 Beispiele STACK: T ops create: -> STACK push: T x STACK -> STACK pop: STACK -> STACK top: STACK -> T empty: STACK -> BOOL axs A1: empty(create()) = TRUE A2: empty(push(x, s)) = FALSE A3: pop(create()) = ERROR oder NULL A4: pop(push(x, s)) = s A5: top(create()) = ERROR oder NULL A6: top(push(x, s)) = x A7: push(top(s), pop(s)) = s falls s!= create() push wird bereits ueber die anderen Axiome definiert

11 Motivation & Beispiel Listenklassen in der Java API Problemstellung: Man möchte einer Speicherstruktur dynamisch Daten hinzufügen und entfernen. Bisher: Manuelles Erstellen und Kopieren von Arrays Besser: Möglichkeiten der Java API nutzen List v = new ArrayList(); v.add("foo"); // add "foo" v.add("bar"); // add "bar" v.set(5, "bla"); // IndexOutOfBoundsException System.out.println(v.get(0)); // print "foo" v.remove(0); // remove "foo" System.out.println(v.get(0)); // print "bar"

12 Motivation & Beispiel Generische Listenklassen Probleme einer ArrayList: List v = new ArrayList(); v.add("foo"); Integer i = (Integer)v.get(0); // runtime error Der selbe Code mit Generics: List<String> v = new ArrayList<String>(); v.add("bar"); Integer i = v.get(0); // compiler error Generics dienen der Übersichtlichkeit, Fehlersuche und Performance. Die Java API stellt komplett implementierte generische Datenstrukturen für viele Anwendungsfälle bereit!

13 Motivation & Beispiel Zeit für ein Beispiel!

14 Motivation & Beispiel public class Array<T> implements Comparable<Array<T>> { private Object[] array; public Array(int n) { array = new Object[n]; public T get(int i) { return (T)array[i]; // Cast von Object nach T } public void set(int i, T o) { array[i] = o; } // vergleicht nur die Laengen, nicht die Elemente! public int compareto(array<t> other) { return array.length - other.array.length; } }

15 Type Erasure Type Erasure Generics werden in Java durch Type Erasure umgesetzt. Dabei passiert beim Kompilieren im Prinzip folgendes: alle generischen Typen (z.b. T) werden durch den Basistyp (meist Object) ersetzt an allen Stellen, wo außerhalb der Klasse gen. Parametertypen verwendet werden, werden entsprechende Casts hinzugefügt die Casts werden dabei (also beim Kompilieren) geprüft, wodurch ClassCastExceptions zur Runtime verhindert werden

16 Type Erasure Type Erasure ArrayList<Integer> list = new ArrayList<Integer>(); list.add(5); int value = list.get(5); Nach Type Erasure: ArrayList<Object> list = new ArrayList<Object>(); list.add((integer)5); int value = (Integer)list.get(5); Nach dem Kompilieren wird trotz unterschiedlichen Typparametern die selbe Klasse verwendet. Die Werte der Typparameter sind zur Laufzeit nicht mehr bekannt.

17 Type Erasure Folgen von Type Erasure: statische Variablen und Methoden werden geteilt entsprechend können diese keine gen. Klassentypen enthalten die Bedingung obj instanceof T ist nicht möglich auf generischen Typen sind keine Konstruktor-Aufrufe und nur Methodenaufrufe des Basistyps möglich Es können auch keine Arrays eines gen. Typs angelegt werden. Als Workarround kann man ein Object[]-Array verwenden, jedoch müssen dann intern Casts nach T hinzugefügt werden. ( Beispiel)

18 Wrapper-Klassen und (Un-)Boxing Wrapper-Klassen Generic Type Parameter erlauben nur Object und dessen Unterklassen als Argument ValueTypes erben nicht von Object (boolean, char, int,...) stattdessen müssen sogenannte Wrapper-Klassen verwendet werden (Boolean, Char, Integer,...) dabei wird der ValueType in die Klasse eingepackt ( Boxing ) class Integer { int value; } // probably useful Methods

19 Wrapper-Klassen und (Un-)Boxing Boxing und Unboxing Vorsicht: Obwohl es sich um Klassen handelt, weisen Wrapper-Klassen keine typische Referenzsemantik auf (Stichwort: Immutable Objects) Ausführliches Rechenbeispiel: Integer a = new Integer(5), b; b = a; a += 5; // a = a + 5; // a is now 10, b is still 5 Zeile 3: 1 a wird implizit nach int konvertiert (unboxing) 2 die Rechnung wird ausgeführt 3 10 wird implizit nach Integer konvertiert, dabei wird eine neue Instanz erstellt (boxing)

20 Verkettete Listen und Binärbäume Einfach verkettete Liste Listenelemente bestehen aus Wert (Referenz oder Werttyp selbst) Referenz zum nächsten Element Listenklasse besteht aus Referenz zum ersten Listenelement oder Sentinel Optional: Variable zum Mitzählen der Elementanzahl beim Hinzufügen / Entfernen (spart späteres nachzählen)

21 Verkettete Listen und Binärbäume Doppelt verkettete Liste Listenelemente bestehen aus Wert (Referenz oder Werttyp selbst) Referenz zum nächsten Element Referenz zum vorherigen Element Listenklasse besteht aus Referenz zum ersten Listenelement oder Sentinel Optional: Variable zum Mitzählen der Elementanzahl beim Hinzufügen / Entfernen (spart späteres nachzählen) Optional, wenn die Liste keinen Ring bildet: Referenz zum letzten Listenelement (z.b. für umgekehrte Iteratoren)

22 Verkettete Listen und Binärbäume Binärbäume Können entweder in einem Array (kompakter) oder mit Zeigern (variable Größe) implementiert werden. So könnte ein Element aussehen: class BinBaumElement<T> { BinBaumElement left; T value; BinBaumElement right; } Oberklasse wie bei Listen, Kopfelement durch die Wurzel ersetzen.

23 Verkettete Listen und Binärbäume Index des Kind- / Vaterelements in Binärbäumen (wenn der Array ab Index 0 gefüllt wird) linkes Kind: 2i + 1 rechtes Kind: 2i + 2 Vater: (i 1)/2 (eigentlich die Formel für das linke Kind, beim rechten ist das Ergebnis 0,5 zu viel. Aber: Integer-Division)

24 Binary Heaps Binary Heaps Binärbaum Vaterelement immer kleiner / größer als beide Kinder immer balanciert (im Gegensatz zu Suchbäumen) Mit Heaps können Vorrangwarteschlangen (priority-queues) effizient umgesetzt werden, da das Element mit der höchsten Priorität schnell gefunden wird.

25 Binary Heaps Einfügen in einen Max-Heap neues Element hinten an den Heap anhängen solange das Vaterelement kleiner ist, neues Element mit dem Vaterelement tauschen (Hochblubbern) Achtung: Bevor man auf Vater- oder Kindelemente zugreift, muss man prüfen, ob diese auch existieren!

26 Binary Heaps Herausnehmen aus einem Max-Heap gewünschtes Element aus dem Heap nehmen hinterstes Element an die freie Stelle verschieben wenn das Vaterelement kleiner ist solange das Vaterelement kleiner ist, tausche das Element mit dem Vaterelement (Hochblubbern) sonst solange das größere Kindelement größer ist, tausche mit diesem (Versickern) Bemerkung: Die if-else-bedingung dient nur der Übersicht. Sie ist überflüssig, da sich die Schleifen gegenseitig ausschließen. Beim für einen Heap üblichen Entfernen des Wurzelelements kann natürlich nur der Versickern-Fall eintreten.

27 Hinweise 10.1 Compiler-Warnungen bei Generics Befehl zum Anzeigen der Warnungen: javac -Xlint:unchecked filename.java Nicht alle Warnungen können behoben werden (v.a. bei Arrays: Generic Array-Creation, Cast eines Object-Arrayelements in den Generic-Type). Andere sollten behoben werden (z.b. fehlende Typparameter). Warnungen können unchecked ) vor Variablen-, Methoden- und Klassendeklarationen für den entsprechenden Bereich unterdrückt werden. Der Bereich sollte immer minimal gewählt werden (nie auf die gesamte Klasse).

28 Hinweise 10.2 Stack vs. Stack auf Heap Rekursion aufmalen und die Variablenbelegungen und Veränderungen grob dazu skizzieren bewirkt wunder dabei bedenken, dass mit jedem Methodenaufruf neue lokale Variablen angelegt werden

29 Hinweise 10.3a) Beispiel equals-methode public class Auto { private String farbe; // never null private int tueren = 5; } public boolean equals(object o) { if (o == null) return false; if (!(o instanceof Auto)) return false; Auto a = (Auto)o; return farbe.equals(a.farbe) && tueren == a.tueren; } Beim delegieren von equals-aufrufen auf NullPointer aufpassen!

30 Hinweise 10.3b) Vergleiche mit dem Comparable Interface es gibt keine Vergleichsoperatoren für Referenztypen das Comparable<T>-Interface definiert die compareto(t other)-instanzmethode Rückgabewert (this ist die aufrufende Instanz): < 0: this ist kleiner als other == 0: die Elemente sind gleich (entspricht equals) > 0: this ist größer als other a.compareto(b) >= 0 ist also im Prinzip a >= b Vergleichsoperator einfach zwischen die 2 Objekte schieben Details in der API.

31 Hinweise 10.4 MergeQueue den Aufbau einer Liste klar vor Augen haben die Funktionalität einer Liste kann direkt in den Listenelementen integriert sein ADTs direkt übernehmen, sind mehrere Definitionen gegeben, muss in der Methode zwischen den verschiedenen Fällen unterschieden werden