Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach...
Transcript of Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach...
![Page 1: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/1.jpg)
![Page 2: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/2.jpg)
Interfaces
Definition des Interface
Intuition:- verbindliche “Verträge” zwischen Programmierern- Schnittstellen/Tasten zur “Bedienung” einer Softwarekomponente
Implementation des Interface
Benutzung des Interface
![Page 3: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/3.jpg)
Definition des Interface
Implementation des Interface
Benutzung des Interface
public interface Feedable{boolean isHungry ();void feed (int howMuch, int FoodType);
}
Text
public class Dragon implements Feedable{boolean isHungry (){return true;}void feed (int howMuch, int FoodType){// Erhoehe Energie, Kolik, Fauche ...}
}
int feedHoney (int howMuch, Feedable Whom){int i = howMuch;While (Whom.isHungry() && i > 0) {Whom.feed(1, Feedable.HONEY); i--;}return i;
}
void someMethod (Object creature){...Feedable eater1 = (Feedable) creature;if (eater1.isHungry()) ......}
![Page 4: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/4.jpg)
Implementation des Interface
• Interfaces ermöglichen mehrfach Vererbung:
• einerseits, weil eine abgeleitete Klasse Interfaces implementieren kann,
• andererseits, weil eine Klasse mehrere Interfaces implementieren kann.
• Beispiel:
class Dragon extends FlyingMonster implements Feedable, FireSpitting {
...
}
• Die implementierten Interfaces werden als Komma-separiert aufgezählt.
![Page 5: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/5.jpg)
Implementation des Interface
• Das Interface StrictComparable kann von jeder Klasse implementiert werden, welche die Methode isLargerThan implementiert hat.
• Das kann Probleme bereiten:
public interface StrictComparable { public boolean isLargerThan(StrictComparable ThanWho);}
public class Dragon implements StrictComparable { public int getVolume(){return Volume;}... public boolean isLargerThan(StrictComparable ThanWho) { return (this.getVolume() > ThanWho.getVolume());}...}
![Page 6: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/6.jpg)
Implementation des Interface
• Das Interface StrictComparable kann von jeder Klasse implementiert werden, welche die Methode isLargerThan implementiert hat.
• Das kann Probleme bereiten:
public interface StrictComparable { public boolean isLargerThan(StrictComparable ThanWho);}
public class Dragon implements StrictComparable { public int getVolume(){return Volume;}... public boolean isLargerThan(StrictComparable ThanWho) {otherDragon = (Dragon) ThanWho; return (this.getVolume() > otherDragon.getVolumen());}...}
![Page 7: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/7.jpg)
Implementation des Interface
Eine Klasse muss alle Methoden, der von ihr implementierten Interfaces, implementieren.(Eine Taste auf der Fernbedienung kann nichts bewirken,
aber sie darf nicht zu einem Laufzeitfehler führen.)
![Page 8: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/8.jpg)
Definition des Interface
Implementation des Interface
Benutzung des Interface
public interface Feedable{boolean isHungry ();void feed (int howMuch, int FoodType);
}
Text
public class Dragon implements Feedable{boolean isHungry (){return true;}void feed (int howMuch, int FoodType){// Erhoehe Energie, Kolik, Fauche ...}
}
int feedHoney (int howMuch, Feedable Whom){int i = howMuch;While (Whom.isHungry() && i > 0) {Whom.feed(1, Feedable.HONEY); i--;}return i;
}
void someMethod (Object creature){...Feedable eater1 = (Feedable) creature;if (eater1.isHungry()) ......}
![Page 9: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/9.jpg)
Definition des Interface
public interface Feedable{
//Definition der konstanten Felderint HONEY = 0;int DRAGON = 1;int RABBIT = 2;
//Definition der Methodenköpfeboolean isHungry ();void feed (int howMuch, int FoodType);
}
Text
Alle konstanten Felder eines Interfaces sind automatisch static und final, und besitzen die Sichtbarkeit des Interfaces.
![Page 10: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/10.jpg)
Definition des Interface
public interface Feedable{
//Definition der konstanten Felderint HONEY = 0;int DRAGON = 1;int RABBIT = 2;
//Definition der Methodenköpfeboolean isHungry ();void feed (int howMuch, int FoodType);
}
Text
Alle Methoden eines Interfaces erhalten automatisch die Sichtbarkeit des Interfaces, in der Regel public.
![Page 11: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/11.jpg)
Definition des Interface
Text
Interfaces können selbst andere Interfaces erweitern, und sogar mehrere. Diese werden als Komma-separierte Liste hinter das Schlüsselwort extends geschrieben.
Interfaces können keine Klassen erweitern (aber Klassen implementieren Interfaces.)
![Page 12: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/12.jpg)
Definition des Interface
Implementation des Interface
Benutzung des Interface
public interface Feedable{boolean isHungry ();void feed (int howMuch, int FoodType);
}
Text
public class Dragon implements Feedable{boolean isHungry (){return true;}void feed (int howMuch, int FoodType){// Erhoehe Energie, Kolik, Fauche ...}
}
int feedHoney (int howMuch, Feedable Whom){int i = howMuch;While (Whom.isHungry() && i > 0) {Whom.feed(1, Feedable.HONEY); i--;}return i;
}
void someMethod (Object creature){...Feedable eater1 = (Feedable) creature;if (eater1.isHungry()) ......}
![Page 13: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/13.jpg)
Benutzung des Interface
Text
int feedHoney (int howMuch, Feedable Whom){int i = howMuch;While (Whom.isHungry() && i > 0) {Whom.feed(1, Feedable.HONEY); i--;}return i;
}
void someMethod (Object creature){...Feedable eater1 = (Feedable) creature;if (eater1.isHungry()) ......}
![Page 14: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/14.jpg)
Benutzung des Interface
Text
int feedHoney (int howMuch, Feedable Whom){int i = howMuch;While (Whom.isHungry() && i > 0) {Whom.feed(1, Feedable.HONEY); i--;}return i;
}
void someMethod (Object creature){...Feedable eater1 = (Feedable) creature;if (eater1.isHungry()) ......}
Ein Interface kann überall dort verwendet werden, wo ein Datentypen erwartet wird.
![Page 15: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/15.jpg)
Fortsetzung: Sortieren
![Page 16: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/16.jpg)
31 55 18 98 62 11 22 70
98 70 62 55 31 22 18 11
![Page 17: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/17.jpg)
31 55 18 98 62 11 22 70
98 70 62 55 31 22 18 11
Sortieren heisst eine Permutation der Arrayindizes suchen.
![Page 18: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/18.jpg)
31 55 18 98 62 11 22 70
98 70 62 55 31 22 18 11
1 2 3 4 5 6 7 81 2 3 4 5 6 7 8
![Page 19: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/19.jpg)
31 55 18 98 62 11 22 70
98 70 62 55 31 22 18 11
1 2 3 4 5 6 7 8
12 34 5 678
![Page 20: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/20.jpg)
12 34 5 678
⇡ : [n] ! [n]
Sn := {⇡ : [n] ! [n]|⇡(i) 6= ⇡(j)8i 6= j}
⇡ =
✓1, 2, . . . , n4, 8, . . . , 6
◆
⇡ = (4, 8, . . . , 6)
Permutation
Symmetrische Gruppe
![Page 21: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/21.jpg)
Sn := {⇡ : [n] ! [n]|⇡(i) 6= ⇡(j)8i 6= j}
Symmetrische Gruppe
Gruppenaxiome: Ein Paar (G, ⊙) aus einer Menge G und einer Verknüpfung ⊙: G x G ⟶G, a x b ⟼ a ⊙ b, heisst Gruppe falls gilt:
1. Abgeschlossenheit von G unter ⊙.2. Assoziativität von ⊙, d.h. (a ⊙ b) ⊙ c = a ⊙ (b ⊙ c).3. Existenz eines neutralen Elementes e∊G:
a ⊙ e (= e ⊙ a) = a, für alle a∊G.4. Für jedes a∊G existiert ein Inverses in a-1∊G, d.h.
a-1 ⊙ a (= a ⊙ a -1) = e.
![Page 22: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/22.jpg)
Sn := {⇡ : [n] ! [n]|⇡(i) 6= ⇡(j)8i 6= j}
Symmetrische Gruppe
Die Verknüpfung auf der Symmetrischen Gruppe ist die Hintereinanderausführung zweier Permutationen.
Gruppen sind im Allgemeinen nicht abelsch, d.h. es gilt i.A. kein Kommutativgesetz. Auch die Symmetrische Gruppe (für jedes (n > 2) ist nicht kommutativ. Z.B.:
(1, 3, 2) (2, 1, 3) = (2, 3, 1) aber (2, 1, 3) (1, 3, 2) = (3, 1, 2)
Eine minimale erzeugenden Menge für die Sn ist die Menge der Transpositionen, d.h. der Vertauschung zweier Elemente.
![Page 23: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/23.jpg)
31 55 18 98 62 11 22 70
98 70 62 55 31 22 18 11
1 2 3 4 5 6 7 81 2 3 4 5 6 7 8
![Page 24: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/24.jpg)
31 55 18 98 62 11 22 70
98 70 62 55 31 22 18 11
1 2 3 4 5 6 7 8
12 34 5 678
![Page 25: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/25.jpg)
12 34 5 678
⇡ = (4, 8, 5, 2, 1, 7, 3, 6)
Das zu sortierende Array definiert die Permutation bereits. Der Sortieralgorithmus muss sie möglichst schnell erkennen.
![Page 26: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/26.jpg)
⇡ = (4, 8, 5, 2, 1, 7, 3, 6)
Das zu sortierende Array definiert die Permutation bereits. Der Sortieralgorithmus muss sie möglichst schnell erkennen.
Die Sn hat n! Elemente. Der Algorithmus muss alle unterscheiden können.
![Page 27: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/27.jpg)
Sortieralgorithmen, die auf paarweisen Vergleichen beruhen definieren einen Entscheidungsbaum.
Erster Vergleich
Zweiter Vergleich, wenn linkes kleiner
Zweiter Vergleich, wenn rechtes kleiner
![Page 28: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/28.jpg)
Je nachdem welche Instanz gegeben ist, nimmt der Algo einen anderen Weg durch den Baum.Ein Blatt in einem Baum ist Knoten mit Grad 1.Die Blätter dieses Baumes entsprechen den möglichen Endzuständen des Algorithmus. Angenommen ein Algo erreicht für zwei verschiedene Eingaben dasselbe Blatt. Dann kann er beide Eingaben nicht unterscheiden, und gibt daher in beiden Fällen dieselbe Permutation wieder. Mindestens eine Sortierung ist daher falsch. Erster
Vergleich
Zweiter Vergleich, wenn linkes kleiner
Zweiter Vergleich, wenn rechtes kleiner
![Page 29: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/29.jpg)
Je nachdem welche Instanz gegeben ist, nimmt der Algo einen anderen Weg durch den Baum.Ein Blatt in einem Baum ist Knoten mit Grad 1.Die Blätter dieses Baumes entsprechen den möglichen Endzuständen des Algorithmus. Angenommen ein Algo erreicht für zwei verschiedene Eingaben dasselbe Blatt. Dann kann er beide Eingaben nicht unterscheiden, und gibt daher in beiden Fällen dieselbe Permutation wieder. Mindestens eine Sortierung ist daher falsch. Erster
Vergleich
Zweiter Vergleich, wenn linkes kleiner
Zweiter Vergleich, wenn rechtes kleiner
Folglich muss der Baum jedes Algos mindestens soviele Blätter haben, wie es Permutationen gibt: n!
![Page 30: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/30.jpg)
Die Höhe des Baumes entspricht der WorstCase Anzahl an Vergleichen.
Die durschnittliche Höhe eines Blattes
entspricht der AverageCase Anzahl an
Vergleichen (bei Gleichverteilung auf
den n! Eingaben).
Der Baum muss nicht balanziert
sein.
![Page 31: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/31.jpg)
Also: Wie hoch ist ein binärer Baum mit n! mindestens (WorstCase), und wie hoch ist ein durschnittliches Blatt in ihm mindestens (AverageCase)?
s
m m
![Page 32: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/32.jpg)
Also: Wie hoch ist ein binärer Baum mit n! mindestens (WorstCase), und wie hoch ist ein durschnittliches Blatt in ihm mindestens (AverageCase)?
s
s+1 s+1
m-1
![Page 33: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/33.jpg)
Also: Wie hoch ist ein binärer Baum mit n! mindestens (WorstCase), und wie hoch ist ein durschnittliches Blatt in ihm mindestens (AverageCase)?
s
s+1 s+1
m-1
Wenn m > s+1 ist, dann sinkt die durchschnittliche Höhe durch so ein Umhängen.
![Page 34: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/34.jpg)
Also: Wie hoch ist ein binärer Baum mit n! mindestens (WorstCase), und wie hoch ist ein durschnittliches Blatt in ihm mindestens (AverageCase)?
s
s+1 s+1
m-1
Wenn m > s+1 ist, dann sinkt die durchschnittliche Höhe durch so ein Umhängen.
Folglich hat ein möglichst balancierter Baum (d.h., bei dem je zwei Blatthöhen sich höchstens um 1 unterscheiden) die geringste AverageCase (und wie man sich leicht überlegt auch WorstCase) Höhe.
![Page 35: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/35.jpg)
Also: Wie hoch ist ein binärer Baum mit n! mindestens (WorstCase), und wie hoch ist ein durschnittliches Blatt in ihm mindestens (AverageCase)?
s
s+1 s+1
m-1
Wenn m > s+1 ist, dann sinkt die durchschnittliche Höhe durch so ein Umhängen.
Folglich hat ein möglichst balancierter Baum (d.h., bei dem je zwei Blatthöhen sich höchstens um 1 unterscheiden) die geringste AverageCase (und wie man sich leicht überlegt auch WorstCase) Höhe.
Ein möglichst balancierter Baum mit Höhe h hat zwischen 2h-1 +1 und 2h-1 viele Blätter.Also muss gelten 2h-1 < n! < 2h.
![Page 36: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/36.jpg)
Auflösen nach h und kurzes Rechnen gibt:
h � log2(n!) � log2((n/2)(n/2)) = log2(2
(n/2)(n/4)(n/2)) =
=n
2+ log2((n/4)
(n/2)) =
n
2+
n
2+ log2((n/8)
(n/2)) = · · · =
=1
2· n · blog2(n� 1)c = 1
4· n · blog2(n)c 2 ⇥(nlog(n))
![Page 37: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/37.jpg)
Auflösen nach h und kurzes Rechnen gibt:
⌦(nlog(n))
Damit gilt, dass jeder Sortieralgorithmus, der auf paarweisen Vergleichen beruht, sowohl im schlechtesten Fall als auch im Durchschnitt eine Anzahl Vergleiche erfordert, die in liegt.
Satz: Untere Komplexitätsschranke
h � log2(n!) � log2((n/2)(n/2)) = log2(2
(n/2)(n/4)(n/2)) =
=n
2+ log2((n/4)
(n/2)) =
n
2+
n
2+ log2((n/8)
(n/2)) = · · · =
=1
2· n · blog2(n� 1)c = 1
4· n · blog2(n)c 2 ⇥(nlog(n))
![Page 38: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/38.jpg)
Merge Sort, rekursiv
mergeSortINPUT: Ein Array arr und zwei Indizes first und last.OUTPUT: Der von first bis last sortierte Array arr. IF (first = last) STOP ELSE middle = (first + last) / 2
mergeSort(arr, first, middle) mergeSort(vec, middle+1, last) merge(vec, first, middle, last)
Implementiere merge mit zwei Arrayvariablen, in die zunächst die beiden Arrayteile kopiert werden.
![Page 39: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/39.jpg)
218 KAPITEL 9. SORTIEREN IN ARRAYS
schließen jetzt auf q+1:
C(2q+1) = 2 ·C(2q)+2 ·2q �1 Rekursionsgleichung= 2 · [(q�1)2q +1]+2 ·2q �1 Induktionsvoraussetzung= (q�1)2q+1 +2+2q+1 �1= q ·2q+1 +1,
was zu zeigen war.
Bezuglich der Anzahl A(n) der Zuweisungen von Arraykomponenten ergibt sich ganz analog:
A(2n) = 2 ·A(n)+ Zuweisungen in merge()
In merge() werden zunachst die Teile von vec nach vec1 und vec2 kopiert. Dies erfordert 2n Zu-weisungen. Fur das Mergen sind dann wieder A(n,n) = 2n Zuweisungen erforderlich. Also ergibt sichfolgende Rekursionsgleichung:
A(2) = 4 A(2n) = 2 ·A(n)+4 ·n fur n > 1 (9.5)
Der gleiche Losungsansatz liefert fur n = 2q
A(n) = 2q2q .
Wir betrachten nun den Fall, dass n keine Zweierpotenz ist. Dann unterscheiden sich die jeweiligenTeilarrays um maximal 1, vgl. Abbildung 9.6.
0 1 2 3 4 5
0 1 2 3 4 5
0 1 3 42 5
0 1 3 4
Abbildung 9.6: Rekursionsbaum von mergeSort() fur n = 6.
Dies fuhrt dazu, dass im zugehorigen Rekursionsbaum nicht alle Zweige bis auf die unterste Ebenereichen. Vervollstandigt man (gedanklich) den Rekursionsbaum bis auf die unterste Ebene, so wurde
Merge Sort, rekursiv
![Page 40: Interfaces - coga.tu-berlin.de fileImplementation des Interface • Interfaces ermöglichen mehrfach Vererbung: • einerseits, weil eine abgeleitete Klasse Interfaces implementieren](https://reader031.fdocuments.us/reader031/viewer/2022040706/5e06ffc042ae66224d2a0840/html5/thumbnails/40.jpg)
Merge Sort, rekursiv
216 KAPITEL 9. SORTIEREN IN ARRAYS
mergeSort(vec, middle+1, last) korrekt sortiert werden. Die Korrektheit von merge() ergibtdann die Korrektheit von mergeSort().
Fur das Standardbeispiel
a 63 24 12 53 72 18 44 35
ergibt der Aufruf mergeSort(a,0,7) dann den in Abbildung 9.5 dargestellten Ablauf. Dabei be-schreiben die Einrucktiefe die Aufrufhierarchie (Rekursionsbaum), und die Kasten die bereits sortier-ten Teile des Arrays.
mergeSort(a,0,7) 63 24 12 53 72 18 44 35mergeSort(a,0,3) 63 24 12 53 72 18 44 35mergeSort(a,0,1) 63 24 12 53 72 18 44 35mergeSort(a,0,0) 63 24 12 53 72 18 44 35mergeSort(a,1,1) 63 24 12 53 72 18 44 35merge(a,0,0,1) 24 63 12 53 72 18 44 35
mergeSort(a,2,3) 24 63 12 53 72 18 44 35mergeSort(a,2,2) 24 63 12 53 72 18 44 35mergeSort(a,3,3) 24 63 12 53 72 18 44 35merge(a,2,2,3) 24 63 12 53 72 18 44 35
merge(a,0,1,3) 12 24 53 63 72 18 44 35mergeSort(a,4,7) 12 24 53 63 72 18 44 35mergeSort(a,4,5) 12 24 53 63 72 18 44 35mergeSort(a,4,4) 12 24 53 63 72 18 44 35mergeSort(a,5,5) 12 24 53 63 72 18 44 35merge(a,4,4,5) 12 24 53 63 18 72 44 35
mergeSort(a,6,7) 12 24 53 63 18 72 44 35mergeSort(a,6,6) 12 24 53 63 18 72 44 35mergeSort(a,7,7) 12 24 53 63 18 72 44 35merge(a,6,6,7) 12 24 53 63 18 72 35 44
merge(a,4,5,7) 12 24 53 63 18 35 44 72merge(a,0,3,7) 12 18 24 35 44 53 63 72
Abbildung 9.5: Die Rekursion bei mergeSort().
9.2.3 Die Analyse von Mergesort
Wir ermitteln nun den Worst Case Aufwand C(n) fur die Anzahl der Vergleiche und A(n) fur dieAnzahl der Zuweisungen von mergeSort() beim Sortieren eines Arrays mit n Komponenten.