Algorithmen und Programmierung

Transkript

1

2

3 Algorithmen und Programmierung Daniel Waeber Semester 3

4

5 Inhaltsverzeichnis 1 Analyse von Algorithmen Laufzeit von Algorithmen Experimentelle Analyse Theoretische Analyse von Algorithmen Pseudo-Code Random Accesss Machsine Laufzeit eines Algorithmus Wachstum der Laufzeit O-Notation O-Notation HOWTO MEGA-Beispiel Rekursionsbäume Rekursion in der Registermaschine Datenstrukturen Datenstruktur Stack Indirekte Anwendung von Stapeln Dynamisierung Array-basierter Datenstrukturen Implementierung Datenabstraktion Einschränkung der Sichtbarkeit bei der klassenbasierten Datenabstraktion Abstrakter Datentype (ADT) Explizite Schnittstellenbeschreibung Anonyme Klassen Polymorphe Typsystem Vererbung (inheritance) Erweiterung (extension) Schnittstellenvererbung Mehrfachvererbung Typ-Verträglichkeit Verdecken, Ersetzen und Identifizieren von Methoden und Attributen bei Namenskollisionen Abstakte Klassen Object Generizität Eigenschaften ADTs - Anwendungen - Implementierungen ADT Prioritätswarteschlange we proudly present: Knauers List-Sort Implementierung: Heap Folgerung/Anwendung

6 3.1.4 Erweiterung des ADT Prioritätswarteschlange Binomial Heap Bäume ADT Baum Implementierung von Bäumen Spezialfall - Binäre Bäume Implementierung von Binären Bäumen durch Arrays Lokalisieren von Einträgen im Datenstrukturen Algorithmen auf Bäumen Baumtraversierung Wörterbücher(Dictonary) Abstrakter Datentyp Implementierung Hashing (Streuspeicherung) Hasing mit Verkettung ADT Geordnete Wörterbücher Implementierung Binäre Suchbäume Balancierte Suchbäume (2-4-Bäume, Rot-Schwarz-Bäume)

7 Kapitel 1 Analyse von Algorithmen Definition: Ein Algorithmus ist eine Schritt-für-Schritt Anweisung, mit dem ein Problem in endlich vielen Schritten lösbar ist. Frage nach Korrektheit und Effizienz des Algorithmus. 1.1 Laufzeit von Algorithmen im Allgemeinen transformieren Algorithmen eine Eingabe in eine Ausgabe die Laufzeit eines Algorithmus hängt typischerweise von der Eingabe-Grö se ab die Bestimmung der mittleren Laufzeit eines Algorithmus ist mathematisch oft sehr anspruchsvoll (selbst experimentell schwierig) Analyse der Laufzeit im schlechtesten Fall ( worst case ) Experimentelle Analyse Implementation des Algorithmus. Messung der Laufzeit des Programms auf Eingaben verschiedener Grö se und Struktur Theoretische Analyse von Algorithmen Statt einer konkreten Implementierung verwenden wir eine abstraktere Beschreibung. (Pseudo Code) Charakterisierung der Laufzeit als Funktion der Länge der Eingabe Dabei werden alle Eingaben der Länge n berücksichtigt Pseudo-Code abstrakte Beschreibung eines Algorithmus strukturierter als prosaische Beschreibung weniger detailierter als Java Programm Algorithm arraymax (a, n) Input : Feld A von n ganzen Zahlen Output: Ein grösstes Element in A currentmax A[ 0 ] 5

8 for i=0 to n 1 do if A[ i ] > currentmax then currentmax A[ i ] return currentmax Psedo-Code im Detail: Kontrollflussanweisungen for...do while...do repeat...until if...then...else... Deklarationen Methodenaufrufe f(arg1, arg2,...) Rückgabe return Ausdrücke Zuweisung Gleichheitstest = Random Accesss Machsine Rechenkern arithmetische Ausdrücke +,,,/ Kontrollflussoperatoren bedingte/unbedingte Sprünge konstante Zeit pro Operation linear organisierter Speicher mit wahlfreiem Zugriff jede Zelle speichert beliebige Zahl auf Zellen kann über ihre Adresse in konstanter Zeit zugegriffen werden unendlich gro ser Speicher primitive Operationen des Pseudocodes können in konstant vielen RAM-Anweisungen realisiert werden Laufzeit eines Algorithmus Definition: A Algorithmus (implementiert auf einer RAM) I Eingabe fuer A T A (I) = Anzahl der elementaren RAM Op. die A auf I durchfuehrt, Laufzeit von A auf I T A (n) = max(t A (I)) (I Eingabe der Groesse n) worst case Laufzeit von A

9 Algorithm double (x) Input : x N Output: 2x y 2 x return y LOAD 0,0 MULT 0,2 STORE 0,0 RET Algorithm double (x) y x y y+x return y Algorithm double (x) z x for i 1 to x do z z+1 return z Da jede Zeile in 5 RAM-Operationen übersetzt werden kann, kann die Laufzeit auch in Pseudocode berechnet werden Wachstum der Laufzeit Eine vernünftige Änderung des Maschinenmodells verändert die Laufzeit von Algorithmen nur um einen konstanten Faktor. Asymptotische Laufzeit berücksichtigt keine konstanten Faktoren und keine Terme niederer Ordnung. Wir interessieren uns daher für das asymptotische Wachstum von T A (n) O-Notation Definition: f(n) O(g(n)) def n 0 c 0 : f(n) c g(n) n n 0 Beispiel: 12n 4 = O(n) 12n 4 12 n n 2 = O(n) nein Definition: f = Ω(g) gdw. g = Ω(f) O-Notation HOWTO 1. Falls f(n) = d i=0 a in i (a d 0) f(n) = O(n d ) 2. Wir sagen 2n = O(n) statt 2n = O(n 2 ) 3. Wir sagen O(n) statt O(3n 6)

10 Beispiel: Gegeben eine Folge von n Zahlen X[0],, X[n 1]. Berechne die Folge A[0],,A[n 1], wobei A[i] = 1 i+1 (X[0] + + X[i]) Algorithm PrefixAverage (X, n) Input : X[0],...,X[n 1] Output: [0],...,A[n 1],mitA[i] = (X[0],...,X[i) A leeres Feld mit n Zellen // n for i=0 to n 1 // n sum 0 // n for j=0 to i // n (n + 1)/2 sum sum + X[ j ] // n (n + 1)/2 A[ i ] sum i+1 // n return A // 1 T pa (n) = O(n + n + n + n(n+1) 2 + n(n+1) 2 + n + 1) = O(n 2 ) Algorithm Pr3f1x4v3r4g3 (X, n) Input : X[0],...,X[n 1] Output: [0],...,A[n 1],mitA[i] = (X[0],...,X[i) A Feld mit n Zellen // 1 sum A[ 0 ] // 1 for 1 to n 1 // n 1 sum sum + X[ i ] // n 1 A[ i ] sum / ( i +1) // n 1 return A // 1 T p4 (n) = O( (n 1) + (n 1) + (n 1) + 1) = O(n) MEGA-Beispiel Wie löse ich ein Problem, wenn ich wei s, wie ich ein einfacheres Problem löse? Beispiel: n! = n i; n! = i=0 { n (n 1)! n > 0 1 n = 0 Algorithm fact (n) Input : n Output: n! if (n=0) then // 1 return 1 // 1 else return n fact (n 1) // 1 + T(n 1) Sei T fact die Laufzeit von fact. T fact (0) c T fact (n) c + T fac (n 1) T fact (n) c + T fact (n 1) (1.1) c + (c + T fact (n 2) (1.2) 3c + T fact (n 3) (1.3) kc + T fact (n k) (1.4)

11 (Beweis mit vollständiger Induktion über k) T fact (n) cn + T fact (0) cn + c = O(n) Rekursionsbäume Algorithm Summe(A, n) Input : Feld A von n Elementen Output: Summe über A if n=1 return A[ 0 ] else return A[ n]+summe(a, n 1) Aufruf durch C.K. ;) Summe(A,5) Summe(A,4) Summe(A,3) Summe(A,2) Summe(A,1) Beispiel: { Potenzieren p(x,n) = x n wobei x,n N 1 n = 0 p(x,n) = x p(x,n 1) n 1 Es geht aber besser, da x 2n = (x n ) 2 bzw. x 2n+1 = x(x n ) 2 1 n = 0 p(x,n) = (x k ) 2 = p(x, n 2 ) n = 2k x(x k ) 2 = x p(x, n 1 2 ) n = 2k + 1 Algorithm Power(x, n) Input : x,n N Output: x n if n=0 then return 1 else if n gerade then y Power(x, n 2 ) return y y else y Power(x, n 1 2 ) return y y x

12 lineare Rekursion O(log n) Power(x,n) Power(x,n/2) Power(x,n/4)... Power(x,1) T(x,n) O(1) + T(x, n 2 ) falls n gerade T(x,n) O(1) + T(x, n 2 ) falls n ungrade Algorithm Power(x, n) Input : x,n N Output: x n if n=0 then return 1 else if n gerade then return Power(x, n 2 ) Power(x, n 2 ) else y Power(x, n 1 2 ) return Power(x, n 1 2 ) Power(x, n 1 2 ) x # Op auf Schicht log n: c n # Op auf Schicht log n 1: c n/2 # Op auf Schicht log n k: c n/2 k Insgesamt: log n k=0 c n 2 k = c log n k=0 1 2 k c n Beispiel: Verfahren zum Summieren der Einträge eines Feldes. Algorithm Sum(A, i, n) Eingabe : F eldavonzahlenmitindexiundanzahln Ausgabe : A[i] + A[i + 1] A[i + n] if n=1 return A[ i ] return Sum( i, n/2)+sum( i+n/2,(n+1)/2) Allgemein: # Op c log n i=0 2i = O(n)

13 Beispiel: Fibonacci Zahlen: F 0 = 0;F 1 = 1;F i = F i 1 + F i 2 Algorithm Fib ( i ) Eingabe i Ausgabe F( i ) if ( i =0) then return 0 if ( i =1) then return 1 return f ib ( i 1)+ f ib ( i 2) Schlechte Idee! Sei T(k) die Anzahl der rekursiven Aufrufe von Fib(k) T(0) = 1 T(1) = 1 T(2) = 1 + T(O) + T(1) T(k) = 1 + T(k 1) + T(k 2) F k 1 Da F k 2F k 2 hat man ein exponentielles Wachstum. F[0]=0 F[1]=1 F[ i ]=undef für 1 < i < n Algorithm Fib ( i ) Eingabe i Ausgabe F( i ) if F[ i ]=undef then F[ i ] = Fib ( i 1) + Fib ( i 2) return F[ i ] Beispiel für dynamisches Programmieren geht auch direkt über lineare Rekursion Übung Noch ( besser: ) ( ) Fi Fi 1 F = i 2 = F i 1 F i 1 ( ) ( Fi 1 F i 2 d.h. v i = ( M v ) i 1 = M k v i k 1 mit v 1 = ; v 0 i = M i 1 v 1 M i 1 kann mittels sukz. Quadrieren in O(log(i)) berechnet werden! Rekursion in der Registermaschine Algorithm main x 5 subroutine1 (x) Algorithm subroutine1 ( i ) k i+1 )

14 subroutine2 (k) Algorithm subroutine2 ( j )... merken, welche Unterroutine gerade ausgeführt wird main subroutine1 subroutine2 Die Liste der laufenden Unterroutinen wird auf einem Methodenstapel (nach dem LIFO Prinzip) verwaltet Beim Aufruf einer neuen Methode legen wir auf den Stapel eine Datensatz der angibt, wer der Aufrufer ist, welche Rücksprungadresse ist zu verwenden und was sind die Werte der lokalen Variablen. ermöglicht Rekursion! Speicherabbild: System code Main code Subrotine code 1.2 Datenstrukturen Datenstruktur Stack Verwaltung eine Menge von Objekten nach LIFO Prinzip (im Moment soll der Stack nur ganze Zahlen beinhalten) erforderliche Operationen einfügen (push) füge das Argument der push-operation zu Menge verwalteten der Objekte hinzu extrahieren (pop) entfernt und liefert das letzte Element (isempty?) liefert true, wenn Stack leer ist (top) liefert das oberste Element ohne es zu entfernen Vorschau auf die algebraische Spezifikation Pop(Push(S,x)) = (S;x) Implementierung von Stacks mittels Feldern (Arrays)

15 x x x top Allozieren eines Felds F der Größe M eine Zeigervariable z zeigt auf den ersten freien Eintrag in F ein push(x) speichert x in F[z] und setzt z z + 1 Falls z = M melde Fehler Stapel voll ein pop liefert F[z 1] und setzt z z 1 Falls z < 0 melde Fehler Stapel leer geht gut, solange nicht das Maximum M erreicht wird class IntArrayStack { int F [ ] ; int z ; int M; IntArrayStack ( int m){ M = m; z = 0; F = new int [M] ; int pop () throws EmptyStackException { if ( z == 0) throw... return F[ z ] ;... Analyse: Linearer (in der Anzahl der in der Struktur verwalteten Objekte (M)) Platzbedarf O(1) für push + pop evtl. Ω(M) Zeit bei Initialisierung Problem/Einschränkung: Maximalgröße des Stapels muss bei Initialisierung bekannt sein Implementierungspezifische Ausnahmen! Implementierung von Stacks mittels verketteten Listen einfach verkettete Liste einfügen und entfernen am Anfang der Liste effektiv möglich head next next next next data data data data

16 Einfügen/Löschen am Anfang der Liste in O(1) am besten am 2. Element einfügen und vertauschen, damit Referenzen nicht zerstört werden. Einfügen/Löschen am Ende der Liste in Θ(n) Implementierung des Stapels Element im Stapel werden in der entsprechenden Reihenfolge in der e.v. Liste gespeichert. Dabei wird das oberste Element im Stapel am Anfang der Liste gespeichert. Platzbedarf Θ(n) Laufzeit push/pop/top O(1) Indirekte Anwendung von Stapeln als Hilfsstruktur in anderen Datenstrukturen beim Entwurf von Algorithmen Beispiel: ^ < <-- <-- <-- < > Gegeben ist Feld X[0],,X[n 1] Berechnen für 0 i n 1 S[i] S[i] = maximale Anzahl von aufeinanderfolgenden unmittelbaren Element vor X[i], sodass X[j] X[i] Algorithm Span1(X,n) Eingabe: Feld X mit n Zahlen Ausgabe: Feld S S <- Neuse Feld von n Zahlen mit 0 for i=0 to n-1 do for j=0 to i do if X[i-j] <= X[i] then S[i]+=1 else break return S Analyse Auf benötigt der Algorithmus Θ(n 2 ) Es geht auch besser Abarbeiten von X von links nach rechts Wir speichern in einem Stack die Indizes der sichtbaren Elemente Am Index i

17 hole Elemente aus dem Stapel, bis X[j] > X[i] (pop) Setze S[i] = i j Lege i auf den Stack (push) Algorithm Span2(X,n) S <- Neues Feld von n Zahlen A <- neuer leerer Stapel for i=0 to n-1 do while(!isempty(a) && X[top(A)] <= X[i]) pop(a) if(isempty(a)) then S[i] = i+1 else S[i] = i-top(a) push(a,i) Da nur n-mal gepushed wird, können wir nur n-mal popen. lineare Laufzeit 1.3 Dynamisierung Array-basierter Datenstrukturen Ziel: Stapel mit Arrays implementieren, aber die Größe der Struktur soll beliebig sein. Idee: Wir haben zu jeden Zeitpunkt ein Feld, in dem die Elemente des Stapels abspeichert sind. Wenn der Platz in dem Feld nicht mehr ausreicht, um alle Elemente des Stapels aufzunehmen, dann legen wir ein neues Feld (doppelter Größe) an und kopieren das alte Feld an dessen Anfang. push x x x x x x x push x x x x x x x x x x x x x x x Diese Struktur hat im worst-case ein schlechtes Laufzeitverhalten, da es push-operationen gibt, mit Ω(n) Laufzeit. (n = # Elemente im Stapel) ABER: Jede Folge von n push/pop Operationen benötigt O(n) Zeit Eine pop-operation benötigt im worst-case O(1) Zeit. D.h. alle pop-operationen Zusammen in einer Folge von n push/pop Operationen benötigen O(n) viel Zeit. Wir betrachten Folge von n push-operationen. Kosten # push m Kosten/Op < 2/op < 2/op < 2/op < 2/op

18 Die 2 i -te push-operation benötigt O(2 i ) Alle anderen { push-operationen benötigen O(1) O(2 mit T i ) fallsk = 2 i k O(1) sonst log n +1 log n n Gesamtzeit für n push-operationen: T k = ( T 2 i) + O(n) = O( 2 i ) + O(n) = k=0 O(2 log n +1 1) + O(n) = O(n) Jede Folge von n push-operationen erfordert O(n) Laufzeit Amortisierte Kosten von O(1) Definition: Gegeben sei eine Datenstruktur, und eine Folge von n Operation, bei der insgesamt m Elemente manipuliert werden. Der Zeitbedarf für diese n Operationen sei T(n, m). Dann nennen wir T(n,m) n die amortisierten Kosten pro Operation. Beispiel: Stack mit Operation mpop(k) k N entfernt k Elemente vom Stapel. Kosten für mpop(k) sind O(k) Op Kosten für Op. Sparbuch push push push push mpop(2) push push mpop(3) Amortisierte Kosten der beiden Operationen sind O(1) Beweis: mit Buchhaltermethode Wir nehmen an, eine push-op kostet 1e, eine mpop(k)-operation kostet ke Wir behaupten, dass folgendes Zahlungsschema jede Folge von n-operationen bezahlen kann: push-op. erhält 2e mpop-op. erhält 0e (daraus folgt, das die Gesamtkosten der Folge n2e sind. Der Grund ist der, dass mpop(k) nur dann aufgerufen werden kann, wenn k Elemente vorher mit push auf den Stapel gelegt wurden. Von jeder dieser k push Operationen ist noch 1e übrig. (mit dem anderen wurde die push-operation bezahlt) k=0 k=0

19 Kapitel 2 Implementierung 2.1 Datenabstraktion Definition: Geheimnisprinzip: Kenntnis der Spezifikation eines Moduls/Systems ist notwendige und hinreichende Voraussetzung für dessen korrekte Benutzung. Beispiel: Prozedurale Abstraktion reguläre Benutzung einer Prozedur ist ihr Aufruf zum Aufruf einer Prozedur ist nur die Kenntnis ihrer Signatur nötig es ist dem Aufrufer nicht möglich auf lokale Variablen zuzugreifen er muss die Spezifikation kennen Definition: Datenabstraktion ist die Anwendung des Geheimnisprinzips auf die Darstellung komplexere Datenstrukturen: ein zusammengesetztes Datenobjekt ist nicht direkt manipulierbar über prozedurale Schnittstelle manipulierbar, die geeignete Operationen zur Verfügung stellt. Beispiel: Implementierung von Stacks mit Feldern. class Stack { int max = 100; Object [ ] S = new Object [max ] ; int t=0; void push ( Object o) throws Exception { if ( t==max) throw new Exception ( ) ; S [ t++]=o ; Object pop () { direkte Manipulation von Attributen möglich!! Stack s = new Stack ( ) ; s. t++; 17

20 public class Stack { private int max = 100; private Object [ ] S = new Object [max ] ; private int t =0; public void push ( Object o) throws Exception { if ( t==max) throw new Exception ( ) ; S [ t++]=o ; public Object pop () { Einschränkung der Sichtbarkeit bei der klassenbasierten Datenabstraktion Das Klassenkonzept unterstützt die Zusammenfassung von Daten und den sie manipulierenden Operationen (in einer syntaktischen Form) In Java kann das Verbergen der internen Repräsentation durch Sichtbarkeitmodifikationen public, protected, private erreicht werden. Sie steuern die Sichtbarkeitbereiche von Methoden und Attributen. public: überall sichtbar protected: innerhalb des eigenen Paketes + in den Unterklassen default: innerhalb des eigenen Paketes private: nur innerhalb der umschließenden Klasse 2.2 Abstrakter Datentype (ADT) Definition: Menge von Objekten zusammen mit Menge von Operation auf diesen Objekten Ein Typ, dessen Objekte nur über die Operationen seiner Schnittstelle manipuliert werden können. (und eben nicht durch direkten Zugriff auf die Daten/Attribute) Üblicherweise gehört zum ADT auch Spezifikation der Fehlerreaktion der Operation Beispiel: ADT Stack kann beliebeige Objekte speichern Einfügen/Löschen nach dem LIFO-Prinzip Operationen: push(object): Füge ein Element ein Object pop(): Entferne und liefere das zuletzt eingefügte Element zurück Fehlerspezifikation Stapel-Unterlauf: pop liefert Stapel-Unterlauf, falls es mit leerem Stapel aufgerufen wird.

21 REALE WELT reale Objekte mit realen Operationen Modellierung MODELL abstraktes Objekt Operationen Implementierung DATENSTRUKTUR mit Methoden Vorteile Implementierung unabhängig vom Modell Sicherheit: Objekte können nicht in ungültige Zustände gebracht werden. Flexibilität: Code kann unabhängig vom benutzten Code entwickelt werden Komfort: Benutzer abstrahiert von Repräsentation Explizite Schnittstellenbeschreibung Zur Schnittstelle von Stack: die Operationen müssen dem Quelltext der Klasse heraus gesucht werden die Implementierung der Methoden wird nicht vor dem Benutzer verborgen Klasse ist nur für de Erzeugung von Objekten nötig, nicht für die Benutzung interface StackI { void push ( Object o) throws... ; Object pop () throws... ; Object top () throws... ; boolean is empty () throws... ; Attribute können nur als Konstanten vereinbart werden Methoden haben nur einen leeren Rumpf

22 keine Konstruktoren Sichtbarkeit ist standardmäßig public public c l a s s ArrayStack implements S tack { private int t =0; private Object [ ] S=new Object [... ] public void push ( Object x){... public class ListStack implements Stack { private class Item{ Object value ; Item next ; public void push ( Object y){... Im Programm: MyStack s = new MyStack(); // Festlegung auf konkrete Implementierung Stack s = new MyStack(); // zwar korrekt, aber andere Implementierung verwendbar Stack s = new Stack(); // geht nicht; Pflichten bei Implementierung einer Schnittstelle Alle Schnittstellen-Methoden müssen public sein. Alle Schnittstellen-Methoden müssen implementiert werden. Java unterstützt auch unvollständige(abstract) Klassen Rechte Parameternamen können beliebig verändert werden. Ergebnistyp verkleinern ist erlaubt. Exeptions dürfen direkt behandelt werden. (aber keine Zusätzlichen dürfen geworfen werden) beliebige weitere Attribute und Methoden erlaubt. Schnittstelle kann als Datentyp verwendet werden (Variablen, Parameter, Ergebnisse), aber keine Objekte davon erzeugen. Satz: Eine Klasse kann auch mehrere Schnittstellen implementieren class Dreieck implements Konvex, Polygon Falls zwei Schnittstellen eine identische Methode deklarieren, wird dies durch eine Implementiert überschrieben.

23 Code-Style: Als Typebezeichner in der Regel Schnittstellentypen verwenden, Klassentypen nur bei Erzeugung mit new verwenden. Benutzer weiß nicht einmal wie die Implementierung heißt, kennt nur die Schnittstelle. Beispiel: Integer-Stack void add( Stack S) { s. push( ( Integer ) s. pop () + ( Integer ) s. pop ( ) ) ; Problem Keine Konstruktoren in Schnittstellen Mögliche Lösung. ( abstract factory pattern ) class StackFactory { public static Stack createstack (){ return new MyStack ( ) ; 2.3 Anonyme Klassen interface Funktion { double von(double x ) ; class xq implements Funktion { public double von(double x){ return x x ; Funktion f= new xq ( ) ; f. von ( 3 ); new Funktion (){ public double von(double x){return 2 x. von ( 5 ); 2.4 Polymorphe Typsystem Vielgestaltigkeit Definition: ein und derselbe Prozedurname kann sich auf verschiedene Prozeduren beziehen. In Java: Universelle Poymorphie

24 Universelle Polymorphie Parametrische Polymorphie (Generizitaet) Einschluss-Polymorphie (Vererbung) Vererbung (inheritance) Erweiterung (extension) Klasse (oder Schnittstelle) Y wird als Erweiterung der Klasse X vereinbart und erbt damit die Eigenschaften von X. class X { Text von X class Y extends X { Text von Y // entspricht fast // class Y { Text von X ; Text von Y Sprechweise: Y heißt Unterklasse/Spezialisierung von X X heißt Oberklasse/Verallgemeinerung von Y class Konto{ int nummer; int geld void einzahlen ( int menge) {... boolean abheben( int menge) {... class VerzinstesKonto extends Konto { int zinssatz void berechezins () {... class A { class B extends A{ class C extends B{ class D extends B{

25 A B C D Schnittstellenvererbung interface X {Text von X interface Y extends X {Text von Y // entspricht fast // interface Y {Text von X; Text von Y <<interface>> Y <<interface>> X class A extends B implements I { class C extends A { // C implementiert somit auch I Mehrfachvererbung bei Klassen in Java nicht möglich, bei Schnittstellen schon. interface I extends X,Y,Z {

26 2.4.4 Typ-Verträglichkeit Idee: Ist Y Unterklasse von X, kann ein Y-Objekt wie ein X-Objekt benutzt werden (da es alle Eigenschaften eines X-Objektes hat.) Definition: Wir nennen einen Klassentype Y mit einem Klassentyp X verträglich, wenn Y Unterklasse (direkt oder indirekt) von X ist. Konto a = new VerzinstesKonto ( ) ; a. einzahlen ( ) a. berechnezins ( ) ; // gibt statischen Fehler, da Konto Objekte die Methode nicht Definition: Statischer Typ einer Variable ist der vereinbarte Variablentyp Dynamischer Typ einer Variable ist der Typ des Objektes, auf das verwiesen wird. Der dynamisch Typ ist immer mit dem statischen Typ verträglich. Typanpassung (casting) Konto a = new VerzinstesKonto ( ) ; a. einzahlen (a ) ; Verzinsteskonto s = ( Verzinsteskonto ) a ; // stat. Type von s i s t Verzinstes Konto s. berechnezins ( ) ; // kuerzer (( VerzinstesKonto ) a ). berechnezins ( ) ; Typkorrektheit bei der Typanpassung: (dynamisch Überprüfung, ggf. ClassCastException) ist Korrekt, wenn der dynamische Typ von x B oder ein Untertyp von B ist. A x ; (B)x ; Typkorrektheit bei Vergleichen(Verweisen): ist typkorrekt gdw. der stat. Typ von a ein Untertype von b ist oder wenn einer ein Schnittstellentyp ist. a == b Prüfen des dynamischen Typs x instanceof A typkorrekt genau dann wenn der stat. Typ von x Untertype von A ist (oder umgekehrt) oder wenn einer ein Schnittstellentyp ist. liefert true genau dann wenn der dyn. Typ von x ein Untertyp von A ist. Konto a = new VerzinstesKonto ( ) ; Konto b = new Konto ( ) ; a instanceof VerzinstesKonto // true a instanceof Konto // true b instanceof VerzinstesKonto // false

27 2.4.5 Verdecken, Ersetzen und Identifizieren von Methoden und Attributen bei Namenskollisionen vertikale Kollisionen : bei Attributen, Klassen, Schnittstellen: verdecken (hiding); class A{ int m; class B extends A { float m; bei Methoden verschiedene Signaturen: überladen (overloading) class A { f ( int x){ class B extends A { f ( float x) { B x = new B( ) ; x. f ( 1 ) ; // f aus A x. f ( 1. 2 ) ; // f aus B gleiche Signatur: beide Statisch: verdecken beide nicht statisch: ersetzen sonst Fehler zur Übersetzungszeit Sichtbarkeit verdeckender Namen darf nicht geringer sein, als die der verdeckten, ersetzten Eigenschaften class C { boolean x ; static int n ; char y ; static void op () { n=1; class D extends C { float n ; // verdeckt statisches int n static int x ; // verdeckt boolean x char y ; // verdeckt char y static void op () { n=1; // geht nicht, da n nicht static

28 Verhindern von Ersetzen/Verdecken Unterklassenbildung verhindern final class C {... ; verhindert das Ersetzen von op() in Unterklasse final void op () { ; class A{ void op1 () { op2 ( ) ; void op2 () { class B extends A { void op2 () { new B( ). op1 ( ) ; // andere Funktionalitaet als op () von A // verhaelt sich anders als erwartet Vererbung zwischen Schnittstellen: interface I { String label = I ; interface J extends I { String label = J ; class C implements J { print ( label ) // gibt J aus Verdecken statischer Methoden class A { static void p() { print ( A ) ; class B extends A { static void p() { print ( B ) ; A a = new B( ) ; // statisch nicht stat. a. p ( ) ; // A B new B( ). p() // B B ((A)new B( ) ). p () // A B ((B)a ). p ( ) ; // B B Abstakte Klassen Definition: Eine Klasse heißt abstrakt, wenn mind. eine ihre Methoden nicht implementiert ist. Diese muss, wie die Klasse selbst als abstract deklariert werden. Instanziierung nicht möglich, aber als Typ bzw. Oberklasse verwendbar.

29 abstract class Muster{ float x, float y ; void bewege ( float dx, float dy){... abstract float flaeche ( ) ; class Quadrat extends Muster{ float s ; float flaeche (){ return s s ; class Kreis extends Muster{ float r ; float flaeche (){ return Math. PI r r ; abstract class A{ abstract void m1( ) ; void op () {.. ; void op2 () {.. ; class B extends A{ void m1( ) {... ; abstract class C extends A{ void m1( ) {... ; abstract m2 ( ) {... ; abstract class D extends A{ void m2( ) {... ; class E extends A{ void m2( ) {... ; Object Die Klasse Object aus java.lang ist implizit Oberklasse jeder Klasse. class Object { public String tostring () {... ; // Textuelle Beschreibung public boolean equals ( Object x) {... ; // Gleichheit der Referenzen protected Object clone () {... // l i e f e r t flache Kopie throws CloneNotSupportedException {... ; protected f i n a l i z e () {... ; // von Speicherbereinigung aufgerufen

30 Psudo-Generizität mittel Object Stack s = new Stack ( ) ; String t = teest ; s. push (( Object ) t ) ; String u = ( String ) s. pop ( ) ; 2.5 Generizität Stack integerstack = new ArrayStack ( ) ; // b i t t e nur fuer Integer verwenden integerstack. push ( abc ) ; // i s t erlaubt, da Objekt Typvariablen interface Stack<T> { void push (T x ) ; T pop ( ) ; class MyStack<T> implements Stack<T>{... Stack<Integer > istack = new MyStack<Integer >(); istack. push ( abc ) ; // Typfehler String!= Integer class C{ static <T> T blah ( Stack <T> s, T t ){ C.< Interger >blah (new Stack<Integer > new Integer ( 3 ) ) ; C. blah (new Stack<Integer > new Integer (3)) // Automatisch mit Integer aufgerufen Eigenschaften istack hat Type Stack < Integer >. Number ist Obertyp von Integer, aber Stack < Number > ist nicht Obertyp von Stack < Integer > Number n = new Integer (4); Stack<Number> s = new MyStack<Integer >() // sonst wuerden Probleme auftauchen : s. push (new Double ( 1. 2 ) ) ; Was ist also Obertyp von Stack < Integer >, Stack < String >? Nicht Stack < Object >, sondern Stack <? >? ist ein Joker und bedeutet unbekannter Typ. null hat den Typ?. // Fehler Stack<?> s = new MyStack<String >(); // ok s. push (new Integer ( 3 ) ) ; // Fehler s. push ( abc ) ; // Fehler s. pop ( ) ; // Erlaubt! Wird ein Objekt

31 Stack<? extends Number> s ; Number n = s. pop ( ) ; // Stack von Untertyp Number // ok Stack<? super Number> s ; // Stack mit Obertyp Number p. push ( Integer ( 5 ); // Geht p. pop ( ) ; // Object Zusaetzliche Schnittstellen sind Erlaubt: <? extends Number & Interface1 & Interface2> Technisch: Java Compiler prüft Typsicherheit und entfernt danach alle Typinformationen. Intern wird Object verwendet. new Vector ( ) ; new Vector<Object >(); // raw type // besser, aber das gleiche x instence of T; // immer true T x = new T( ) ; // geht auch nicht. T[ ] x = new T [ ] ; // geht auch nicht. T x = (T) y // Warning static <T extends Object & Compareable<? super T>> T max( Collection <? extends T> c ) ; Spaßveranstaltung: Schluss, schon um 15:09

32

33 Kapitel 3 ADTs - Anwendungen - Implementierungen 3.1 ADT Prioritätswarteschlange Geg: n ganze Zahlen x 1,,x n mit x i + x j i j Ges: Sortierung π : {1,,n {1,,n mit x π(1) < x π(2) < < x π(n) Angenommen, wir haben eine ADT, der eine Menge S von n Zahlen unter folgenden Operationen verwaltet: f indmin() liefert min S deletemin() S S \ min S init(x) S X Dann kann X mit X = n wie folgt sortiert werden: S. i n i t (X) for i = 1... n do print S. findnmin ( ) ; S. deletemin ( ) ; Die Laufzeit ist T(init(X)) + n(t(findmin()) + T(deletemin())) we proudly present: Knauers List-Sort Implimentierung als verkettete Liste Sortieren mit dieser Implementierung: O(n) + n(o(n) + O(n)) = O(n 2 ) Implimentierung als Folge unsortierter Listen + Folge der Minima dieser Listen Implementierung: Heap Einfügen suche den freien Platz speichere das neue Element an diesem Platz 31

34 stelle Ordnung wieder her: wenn wir einen neuen Schlüssel k einfügen, kann die Heap-Ordnung verletzt werden. wir stellen diese dadurch wieder her, dass wir k auf dem Pfad zur Wurzel mit Schlüsseln vertauschen, die größer sind da der Heap die Höhe log(n + 1) hat, werden dafür nur O(log n) Schritte benötigt. Löschen aus einem Heap entferne das Element Wurzel vertausche zunächst den Schlüssel der Wurzel mit dem Schlüssel des letzten Knotens herstellen der Heap-Eigenschaft: vertausche (von der Wurzel ausgehend), das aktuelle Element mit dem m Minimum seiner Kinder, solange k < m die Anzahl der Vertauschungen ist durch die Höhe beschränkt, also O(log n) Flache Implementierung über Arrays Wir können einen Heap mit n Elementen in einem Feld der Länge n abspeichern. Für den Knoten mit Index i wird das linke Kind bei Index 2i das rechte Kind bei Index 2i + 1 gespeichrt das letzte Element ist bei Index n gespeichert, die erste freie Position im Feld ist n + 1 Dynamisierung durch iteriertes Verdoppeln/Halbieren, sodass man eine amortisierte Laufzeit für insert/deletemin 1 2*1 2* *2 2*2+1 3*2 3*2+1 k *k 2*k+1 2k 2k+1

35 3.1.3 Folgerung/Anwendung Wenn wir ADT Prioritätswarteschlange mit binären Heaps implementieren, können wir in O(n log n) Zeit sortieren Heapsort Aufbau des Heaps durch n-faches insert O(n log n) Sortieren, in dem man n-mal deletemin aufruft O(n log n) Erweiterung des ADT Prioritätswarteschlange Ziel: effiziente Implementierung der Operation meld(p,q) liefert PWS in der alle Objekte der PWS P und Q gespeichert sind Binomialheaps Heaps implementiert mit Binomialbäumen Baum i + 1 entsteht durch das hinzufügen des Baums i an die Wurzel Beispiel: Elemente nur in verschiedenen Bäumen jede Zahl kann man aber nur in log n Baume aufteilen Bsp: 13 = Binomial Heap Ein Binomialheap für n Elemente speichert diese in einer Folge von Binomialbäumen Die binomialen Teilbäume sind Heap-geordnet in dieser Folge gibt es keine zwei Bäume von gleichem Grad diese Folge besteht aus O(log n) Bäumen, deren Grade eindeutig durch n bestimmt sind (Binärdarstellung) die Wurzel der Bäume sind in einer verketteten Liste gespeichert, die nach Grad sortiert wird.

36 Verschmelzen von Binomialheaps P,Q P: Q: P = 7 (1110) Q = 10 (0101) P (10001) >< >: durchlaufe die Wurzellisten von P und Q (angefangen bei kleinstem Grad) zu jedem Zeitpunkt gibt es maximal einen Baum C, der als Übertrag aus dem vorherigen Schritt weitergereicht wird sei A der aktuelle Binomialbaum von P; B der aktuelle von Q kein C C 8 8 >< min(b) < min(a) mache A zum Kind der Wurzel von B >< deg(a) = deg(b) erzeuge somit einen B i+1 und füge ihn in die Liste des Ergebnisses >: sonst umgekert deg(a) < deg(b) schreibe A in die Wurzelliste von P Q und ersetzte A durch das nächste Element >: deg(a) > deg(b) symetrisch 8 n deg(a) = deg(b) = deg(c) = i schreibe A in die Wurzelliste von P Q min(c) > min(b) mache C zum kind von Bsonst umgekerht >< deg(c) < min(deg(a), deg(b)) schreibe C in die Wurzellist von P Qes gibt keinen neuen Uebertrag mehr deg(c) = deg(a) < deg(b) verschmelze C und A und erzeuge damit einen neuen B i+1, der als neuer Uebertrag fungiert. Ersetze ferne A durch das naechste Element in der Wurzellist von P >: deg(c) = deg(b) < deg(a) analog Das Verschmelzen von zwei Binomialheaps die je n Elemente speichern, kann in O(log n) Zeit erfolgen. Binäre Addition Einfügen in Binomialheap zum Einfügen eines Elementes x in Binomealheap P erzeugen wir einen Binomialheap Q der Größe 1 mit Element x und verschmelzen diesen mit P. dies geht also in O(log n) Löschen Suchen des Minimums in der Wurzelliste ( O(log n)) Sei A der Binomialbaum, der das min. speichert. Entferne A aus dem Binomialheap Dies liefert einen neuen Bin.Heap P

37 Ist A ein Bin.Baum von Grad i, so sind die Kinder seiner Wurzel Binom. Bäume von Grad 0,1,,i 1 all diese koennen in O(log n) Zeit in einer Wurzellist neue verkettet werden, sodass ein neuer Bin.Heap Q entsteht. rufe meld(p,q) auf ( O(log n)) Insgesamt wird also O(log n) Zeit für deletemin benötigt. 3.2 Bäume w mathematisch zusammenhängender Graph ohne Kreise infomatisch gerichteter Graph T = (V, E) Wurzel w V jeder Knoten v V {W hat einen Vorgänger p(v) (u,v) E v heißt Nachfolger von u Blätter/externe Knoten = Knoten ohne Kinder Tiefe eines Knoten = Länge des Pfades von w nach v Höhe (des Baumes) = max. Tiefe eines Knotens Ordnung auf den Kindern eines Knotens ADT Baum ADT Knoten Speichert ein Objekt Item (vom Typ E) Manipulation/Zugriff durch Methoden: setitem(e x) E getitem() Methoden auf Baum Zugriff auf Wurzel: Knoten getroot()

38 generische Methoden int size() boolean isempty() List < E > getelements() List < Knoten > getn odes() Knoten getparent(knoten p) List < Knoten > getchildren(knoten p) boolean isleaf(knoten p) boolean isroot(knoten p) Implementierung von Bäumen Knoten u speichert (Referenzen auf) das mit u assoziierte Objekt (vom Typ E) Vorgänger von u die Liste der Kinder von u Platzbedarf zum Speichern von n Knoten ist O(n) Spezialfall - Binäre Bäume Jeder Knoten hat max. 2 Kinder In einem proper/sauber/wohlen/...binärbaum hat jeder Knoten genau 2 Kindern Bei geordneten Binärbäumen sprechen wir von linken und rechten Kindern Bei Implementierung können die Referenzen auf Kinder direkt im Knoten gespeichert werden Implementierung von Binären Bäumen durch Arrays Baum der Höhe h wird in Feld mit 2 h+1 1 Elementen gespeichert. Die Wurzel wird im 1-ten gespeichert. Das linke (rechte) Kind des Knotens das beim i-ten Eintrag gespeichert ist, wird beim 2i-ten (2i + 1-ten) Eintrag gespeichert Achtung: Schlimmstenfalls wird Ω(2 n ) Platz benötigt Lokalisieren von Einträgen im Datenstrukturen Prinzipiell können wir die ganz Struktur nach einem Objekt das wir entfernen wollen durchsuchen. ineffizient

39 Beispiel: für Modifikationen entfernen eines Elements erniedrigen der Priorität eines Eintrags in einem PWS Lösung Einträge in der Datenstruktur wissen wo sie gespeichert sind. PQEntry insert (Key k, Item x) P QEntry speichert: Priorität des Objektes Gespeichertes Objekt Position des Eintrags in der Struktur PQEntry p o 1 PQEntry P O Algorithmen auf Bäumen Arithmetische Ausdrücke mit ganzen Zahlen binäre Operationen +,, ganze Zahlen rekursiv definiert x Z ist ein arithmetischer Ausdruck e,f arithmetische Ausdrücke (e + f),(e f),(e f) sind Ausdrücke zu arithmetischen Ausdrücken können wir Ausdrucksbäume definieren ((2+5)-(7*12)) - + *

40 3.2.7 Baumtraversierung inorder besuche erst alle linken Teilbäume d. Wurzel, dann die Wurzel, dann alles im rechten. preorder erst die Wurzel, dann linken, dann rechten postorder erst linken, dann rechten dann Wurzel Zeichnung von Bäumen use graphviz G H E F B A D A B C C J D E J K I K Knoten A B C D E F G H I J K Tiefe inorder Num Dies gibt schon die Koordinaten des Knotens an: x(v) = inorder-nummer von v y(v) = Tiefe von v I H G F Laufzeit Bei allen Traversierungen wird jeder Knoten nur O(1) mal besucht. Dieses Verfahren benötigt daher O(n) Zeit. 3.3 Wörterbücher(Dictonary) Abstrakter Datentyp modelliert eine Ansammlung von Einträgen. Jeder Eintrag besteht aus einem Schlüssel und einem Datum. In dieser Sammlung von Einträgen wollen wir (effizient) nach Einträgen mit gegebenem Schlüssel suchen. (verschiedene Einträge können den gleichen Schlüssel haben.) Beispiel: Telefonbuch, Symboltabelle, DNS-Listen Methoden f ind(keyk) Liefert einen Eintrag aus dem Wörterbuch, dessen Schlüssel k ist, falls dieser existiert. findall(key k) Liefert eine Liste aller Einträge deren Schlüssel k ist.

41 insert(key k,data d) Fügt ein Eintrag mit Schlüssel k und Datum d zu dem Wörterbuch hinzu. delete(entry e) Löscht den Eintrag e aus der Struktur. entries() Liefert Liste mit allen Einträgen Implementierung 1. Verkettete Liste Laufzeiten auf WB. mit n Einträgen Platzbedarf Θ(n) find O(n) insert O(1) delete O(1) Hashing (Streuspeicherung) Eine Hashfunktion h bildet Schlüssel aus einer Menge U(Schlüsseluniversum) in ein Intervall [0,,N 1] N Beispiel: für eine H.fk. N [0,,N 1]: h(x) = x mod N h(x) nennt man dem Hashwert des Schlüssels x Eine Hashtabelle für eine Schlüsseluniversum U besteht aus eine Hfk. h: U [0,,N] einen Array (Hashtabelle der Größe N) Idee: Eintrag mit Schlüssel k U wird bei T(h(k)) gespeichert. Beispiel: Hashfunktion für U = Zeichenketten N = 1000 Eine Hfn wird üblicherweise als Komposition von zwei Funktionen dargestellt 1. h 1 : U N 2. h 2 : N [0,,N 1] Idee: h 2 soll die Schlüssel möglichst gleichmäßig in [0,,N 1] verteilen. Oft verwendete Hashcodes Speicheradressen: interpretiere die Adresse von k als eine ganze Zahl. Casten auf Integer. (für Schlüssel deren Länge beschränkt ist: float, byte,...) Für Schlüssel unbeschränkter Länge, Partitionieren in kleine Teile, casten zu int und Aufsummierung Oft verwendete Kompressionsfunktionen h 2 (x) = x mod N dabei wählt man üblicherweise N als Primzahl h 2 (x) = (ax + b) mod N wobei a,b N mit a 0 mod N

42 3.3.4 Hasing mit Verkettung Idee Eintrag mit Schlüssel k soll in H.Tab T an Pos h(k) gespeichert werden. Kollision Einträge e 1,e 2 mit Schlüssel k 1,k 2 mit h(k 1 ) = h(k 2 ) Lösung Jeder Eintrag T[i] zeigt auf eine verkettete Liste, in der alle Einträge gespeichert sind, mit h(k) = i Universum U und Tabelleneinträge S n := S << U =: u Hashfunktion h : U [0,,N 1] Tabelle T mit N eintragen w 1 2 a b u _ h(x) _ x y N z einfügen/löschen eines Eintrags e mit Schlüssel k find (k) Analyse berechne i = h(k) füge e in L[i] ein / lösche e aus L[i] berechne i = h(k) traversiere L[i] um alle e L[i] zu finden deren Schlüssel k ist. Platzbedarf zum Speichern von n Elementen: O(n + N) Laufzeit (bei n gespeicherten Elementen) find: O(n) im worst case! Zu x U sei C S (x) := {y S h(x) = h(y) Beobachtung: Falls h in O(1) Zeit ausgerechnet werden kann, dann ist die Laufzeit von find, insert, delete O(1 + C s (x)) Bem: Im schlechtesten Fall ist C s (x) = n Nach dem Schubfach-Prinzip gibt es im Fall n k N mindestens ein x S mit C S (x) k Mittlere Laufzeit von Hashing h sei fest, S wird zufällig (gleichverteilt) aus U gewählt. Wahrscheinlichkeit W = {S sup U S = n ) 1 ( u Die Wahrscheinlichkeit von S supu ist p S = 1 W = n Für festes x U betrachten wir C S (x)(zufallsvariable) Wir wollen den Erwartungswert E[C S (x)] = p S C S (x) = 1 W S W C S (x) S W

43 C S (x) = y Sh(x)=h(y) 1 = Damit: E[C S (x)] = 1 W NR: 1 W y Uh(x)=h(y) S W y Uh(x)=h(y) i S (y) mit i S (y) = = 1 W y Uh(x)=h(y) { 1 y S 0 y / S i s (y) i S (y) = E[i S (y)] = Pr(i S (y) = 1) 0 + Pr(i S (y) = 0) 0 = Pr(y S) S W u 1 n 1 Pr(y S) = u n Damit: E[C S (x)] = 1 A 1 A = n u y Uh(x)=h(y) n u h 1 (h(x)) = {y U h(x) = h(y) Definition: Eine Hashfunktion h : U [0,,N 1] ist fair, wenn für alle i [0,,N 1] gilt: {y U h(y) = i u N Beispiel: U = {0,,u 1 h : x x mod N ist fair Falls h fair ist, gilt E[C S (x)] n u (1 + u N ) = n N + n u Belegungsfaktorβ Zusammenfassung Für eine faire Hashfunktion ist die erwartete Laufzeit der Operationen f ind, insert und delete für ein festes x U bezüglich einer unter Gleichverteilung gewählten Menge S supu mit n = S O(1 + n N ) Bemerkungen mit N = Θ(n) erhalten wir O(1) erwartete Laufzeit falls n a priori nicht bekannt ist, kann durch sukzessives Verdoppeln/Halbieren der Tabellengröße eine amortisierte erwartete Laufzeit erreicht werden. alternativer Ansatz universelles Hashing 3.4 ADT Geordnete Wörterbücher U ist total geordnet: < U weitere Methoden first() last() next(e) prev(e)

44 3.4.1 Implementierung Beispiel: U = N S = {17,3,12,1,4,7,9, Suchen mittels Binärersuche in O(log n) Nachfolger : Suchen + nächstes Feld O(log n) Vorgaenger : Suchen + nächstes Feld O(log n) Problem: Einfügen+Löschen erfordert Σ(n) Zeit Binäre Suchbäume Ein binärer Suchbaum für eine Menge S speichert in den inneren Knoten Elemente aus S. Die Blätter (externe Knoten) dienen als Platzhalter. Darüber hinaus gilt die Suchbaumeigenschaft. Bem: Zu einem inneren Knoten u bezeichnet key(u) den bei u gespeicherten Schlüssel. Sei v ein innerer Knoten, u ein innerer Knoten aus dem linken, w ein innerer Knoten aus dem rechten Teilbaum unter v. Dann gilt: key(u) u key(v) u key(w) Beispiel: Suche Suche nach k U durchläuft einen Pfad im Suchbaum, ausgehend von der Wurzel. Welcher Knoten als nächster besucht wird, hängt vom Vergleich zwischen k und dem Schlüssel des aktuellen Knotens u ab. 1. k = key(u) Suche erfolgreich beendet, gib u aus 2. k < Key(u) Such im linken Teilbaum weiter 3. k > Key(u) Such im rechten Teilbaum weiter Einfügen Suche nach dem Schlüssel unter dem wir einfügen wollen Falls die Suche bei einem inneren Knoten terminiert, gibt es bereits einen Eintrag unter diesem Schlüssel. Diesen überschreiben wir. Sonst terminiert die Suche bei einem externen Knoten. In dem Fall expandieren wir diesen in einen inneren Knoten, bei dem wir den neuen Schlüssel speichern (dieser innere Knoten erhält zwei externe Knoten als Kinder) Löschen eines Schlüssels k 1. Suchen Knoten der k speichert Fall 1 u hat mindestens ein externes Kind: Knoten kann entfernt werden und der Teilbaum unter diesem an seine Stelle eingefügt werden.

45 Fall 2 u hat keine externen Kinder Suche den internen Knoten w, der u in einer Inorder-Traversierung folgt kopiere die Daten von w nach u entferne w und sein linkes Kind Bem: key(w) ist der Nachfolger von k w kann gefunden werden, indem wir im rechten Teilbaum unter w nach links gehen das linke Kind von w ist immer ein externer Knoten. Analyse Platzbedarf zum Speichern von n Elementen: O(n) Laufzeit für die Operationen proportional zur Höhe des Baumes Höhe von binären Suchbäumen Im schlechtesten Fall Θ(n) Analyse der Suchzeit im Mittel Wir betrachten folgendes Experiment: Wähle zufällig unter Gleichverteilung ein Element w, als Wurzel des Suchbaums. Wir bauen auf die gleiche Art für alle Element < w rekursiv einen Suchbaum = 13 Die innere Pfadlänge eines Baumes ist die Summe der Tiefen aller inneren Knoten Sie entspricht der Summe der Suchzeite nach den im dem Baum gespeicherten Schlüsseln. Beispiel: i n C n = (n 1) = Θ(n 2 ) C n = k 1 i=0 i 2i = Θ(k 2 k ) = Θ(n log n) Die mittlere erwartete innere Pfadlänge C n in einem Baum mit n Knoten:

46 n 1 C n = (i {{ 1 + n {{ i) + C i 1 + C n i = (n 1) (C i + C n i 1 ) n links rechts i=1 {{ Warscheinlichkeit n n n i=1 (C i 1 + C n i ) = C i 1 + C n i = 2 n i=1 C i 1 i=1 {{ C 0 +C 1 + +C n 1 i=1 {{ C n 1 +C n 1 + +C 0 C n = (n 1) + 2 n nc n = (n 1)n + 2 n C i 1 (3.1) i=1 n C i 1 (3.2) i=1 n+1 (n + 1)C n+1 = n(n + 1) + C i 1 (3.3) i=1 (n + 1)C n+1 nc n = n(n + 1) n(n 1) + 2C n = 2n + 2C n (3.4) (n + 1)C n+1 = nc n + 2n + 2C n = (n + 2)C n + 2n (3.5) C n+1 C n 2n = + (3.6) n {{ + 2 n {{ + 1 (n + 1)(n + 2) B n+1 B n Also B n+1 = B n + 2n (n+1)(n+2) 2(n+1) (n+1)(n+2) = 2 n+2 B n+1 = B n + 2 n+2 = B n n n+2 B 0 + n i=0 2 i+2 2 n 1 0 i+2di 2,8log n C n = O(n log n) Einschub: Randomisiertes Quicksort Aufgabe: Gegeben S N mit S = n, sortiere S Algorithmus Wahle s 0 S zufällig Teile S auf in S < = {s S s < s 0 und S > = {s S s > s 0 Sortiere S <, gib s 0 aus, sortiere S >

47 1 2 3 Beispiel: Laufzeit n Laufzeit n log n Analyse: Erwartungswert der Laufzeit (bzgl. aller möglicher Zufallsentscheidungen) D n : erwartete Laufzeit zum Sortieren eine Menge der Größe n D n c n + n 1 i=1 1 n (D i + D n 1 1 ) Wie vorher D n = O(n log n) Balancierte Suchbäume (2-4-Bäume, Rot-Schwarz-Bäume) Mehrweg-Suchbäume Ein Mehrweg-Suchbaum für eine Schlüsselmenge S hat folgende Struktur jeder innere Knoten hat d 2 Kinder und speichert d 1 Elemente aus S Für einen internen Knoten, der die Kinder v 1,,v d hat und der die Schlüssel k 1,,k d 1 speichert, gilt: die Schlüssel im Teilbaum mit Wurzel v 1 sind alle < k 1 die Schlüssel im Teilbaum mit Wurzel v d sind alle > k d 1 die Schlüssel im Teilbaum mit Wurzel v i sind alle > k i 1 und < k i Die Blätter sind Platzhalter Bem: Suchen analog zum binären Fall. Laufzeit ist O(Höhe Grad) Inorder Traversierung: analog zu binären Suchbäumen. Laufzeit ist O(n) 30

48 (2,4)-Bäume Ein (2,4)-Baum ist ein Mehrweg Suchbaum, bei dem jeder interne Knoten 4 Kinder hat und alle Blätter die gleiche Tiefe haben Lemma: Die Höhe eines 2-4 Baumes der n Schlüssel speichert ist Θ(log n) Einfügen Beispiel: Einfügen 9: Einfügen 30: Reparieren: v 1,,v 5 seien Kinder, k 1,,k 4 Schlüssel von v ersetzen v durch v : 3 Knoten mit Schlüssel k 1,k 2, Kinder v 1,v 2,v 3 v : 2 Knoten mit Schlüssel k 4, Kinder v 4,v 5 k 3 wird in die Mutter von v eingefügt. (evtl wird dabei eine neue Wurzel erzeugt) Evtl. kann nun die Mutter von v überlaufen Analyse Suchen kostet O(log n) Zerteilen eines Knotens geht in O(1) Überlaufen propagiert zur Wurzel hin, dh. es gibt nur O(log n) Überlaufe. Dh. Einfügen kann in O(log n) Zeit erfolgen

49 Löschen Betrachte den Fall, dass der Knoten aus dem wir löschen nur Blätter als Kinder hat. (Ansonsten ersetzen wir den zu löschenden Schlüssel durch seinen Vorgänger und entfernen an dessen alter Position) Löschen von 9, 27, Löschen kann einen Unterlauf erzeugen (v wird zu eine 1-Knoten mit 1 Kind und 0 Schlüsseln)