Überblick. 5.1 Sequentielles Suchen. 5 Suchen und Sortieren

Transkript

1 Überblick 5 Suchen und Sortieren 5.1 Sequentielles Suchen 5.2 Binäres Suchen 5.3 Was ist Sortieren? Wie schwer ist es? 5.4 Einige Typen von Sortieralgorithmen 5.5 Einfache Sortieralgorithmen mit Zeitaufwand!(n 2 ) 5.6 Eine untere Schranke "(n log n) 5.7 Quicksort 5.8 Merge Sort 5.9 Ist es möglich, in linearer Zeit zu sortieren? 5.10 Sortiernetzwerke Sequentielles Suchen Gegeben: Menge von n Elementen, z.b. ganze Zahlen, abgespeichert in einem Array int[] a; // a.length = n Problem: Ist ein vorgegebenes Element x im Array a enthalten? Einfachste Lösung: Sequentielles (oder lineares) Durchsuchen des Arrays Triviales Beispiel für einen inkrementellen Algorithmus, der jeweils ein Datenobjekt nach dem anderen bearbeitet. Bei erfolgreicher Suche wird der Index i, 0! i < a.length, zurückgegeben, an dessen Position x steht. i = 1 signalisiert erfolglose Suche. 5-2

2 Algorithmus für sequentielles Suchen int find(int[] a, int x) { int i = a.length - 1; while ((i >= 0) && (x!= a[i])) // Position (1) i--; // Position (2) return i; && (and mit SCE) wertet den booleschen Ausdruck von links nach rechts aus und bricht die Auswertung ab, sobald der Wert des booleschen Ausdrucks feststeht: Auswertung von (i >= 0) zu false verhindert, daß auf ein nicht existierendes Arrayelement (z.b. a[ 1]) zugegriffen wird. Invarianten bringen das für den Nachweis der formalen Korrektheit des Algorithmus Wesentliche zum Ausdruck, nämlich: In jeder Iteration der while-schleife wird das Teilarray, von dem bekannt ist, daß es x nicht enthält, um ein Element vergrößert. 5-3 Invarianten und formale Korrektheit Folgende Invariante gilt an Position (1): (I) (0! i < a.length)! (" k, i! k: a[k] " x) Invariante (I) gilt trivialerweise beim ersten Durchlauf der while- Schleife und bleibt wahr in jedem nachfolgenden Durchlauf. Folgende Bedingung gilt an Position (2): (II) (" k, i < k: a[k] " x)! ((i = 1) # ((0! i < a.length)! (a[i] = x))) Bedingung (II) besagt, daß der Algorithmus auf zwei Arten terminiert: i = 1 signalisiert, daß das ganze Array erfolglos durchsucht wurde. x wurde an der Arrayposition i gefunden. Formaler Korrektheitsbeweis muß zeigen, daß die Schleife wirklich terminiert: i wird mit einem ganzzahligen Wert " 0 initialisiert. i wird in jedem Schleifendurchlauf um 1 erniedrigt, muß also nach einer endlichen Anzahl von Durchläufen negativ werden. 5-4

3 Einsatz eines Platzhalters Boolescher Ausdruck zur Kontrolle der while-schleife enthält zwei Bedingungen: (i >= 0) und (x!= a[i]) Erster Term ist verzichtbar, falls sichergestellt ist, daß x immer gefunden wird, bevor der Suchindex i das Array a verläßt, d.h. i < 0 wird. Idee: Erweitere das Array um eine Zelle und speichere die eigentlichen n Elemente an den Positionen 1, 2,, n. Benutze a[0] beim Suchprozess, indem das zu suchende Element x als Platzhalter (sentinel) zu Beginn des Suchprozesses in a[0] gespeichert wird $ Suchprozess stoppt spätestens bei a[0] $ i > 0 % erfolgreiche Suche i = 0 % erfolglose Suche int find(int[] a, int x) { int i = a.length - 1; a[0] = x; while (x!= a[i]) i--; return i; 5-5 Aufwand für sequentielles Suchen Annahme: n Elemente im Array gespeichert Schlimmster Fall tritt ein bei erfolgloser Suche: Gesamtes Array wird durchlaufen $ Zeitaufwand T(n) #!(n) Erfolgreiche Suche: Annahme: Alle im Array enthaltenen Elemente besitzen gleiche Wahrscheinlichkeit, daß nach ihnen gesucht wird $ durchschnittliche Anzahl Iterationen der while-schleife bei erfolgreicher Suche = 1!( n) = n +1 n 2 Sequentielles Suchen benötigt!(n) Zeit sowohl im schlimmsten als auch im durchschnittlichen Fall. 5-6

4 Suchen für beliebige Objekttypen Falls Datenobjekte vom Typ Element sind, so sollte die Klasse Element die Methode public boolean equals(object obj) bereitstellen, die true zurückgibt, falls das aufrufende Objekt und das übergebene Objekt gleich sind im Sinne der Anwendung: class Element {... public boolean equals(object obj) { Stellt die Klasse Element die Methode equals nicht bereit, so wird die entsprechende Methode der Klasse Object verwendet, die true zurückgibt, falls beide Objektreferenzen gleich sind! Sequentieller Suchalgorithmus: int find(object[] a, Object x) { int i = a.length - 1; while ((i >= 0) && (! x.equals(a[i]))) i--; return i; Binäres Suchen Im Array a abgespeicherte Datenelemente seien geordnet bezüglich einer dem Wertebereich der Datenelemente zugrunde liegenden Ordnungsrelation!: " k, 0! k < n 1: a[k]! a[k + 1] Suche kann beschleunigt werden, da ein Vergleich des Suchelementes x mit einem Arrayelement mehr Information gibt als im ungeordneten Fall: x " a[m] schließt nicht nur a[m], sondern auch alle Elemente zur einen oder anderen Seite von m aus: x < a[m] $ " i # m: a[i] " x x > a[m] $ " i! m: a[i] " x a[m] < x m Falls a[m] > x m kann x nicht enthalten sein in 5-8

5 Algorithmus für binäres Suchen int find(int[] a, int x) { int i = 0; int j = a.length - 1; while (i <= j) { // Position (1) int m = (i + j) / 2; if (x < a[m]) j = m - 1; else if (x > a[m]) i = m + 1 else // x = a[m] // Position (2) return m; // Position (3) return -1; 5-9 Invarianten, formale Korrektheit Folgende Invariante gilt an Position (1): (I) (i! j)! (" k, 0! k < i: a[k] < x)! (" k, j < k < a.length: a[k] > x) Invariante (I) gilt trivialerweise beim ersten Durchlauf der while-schleife und bleibt wahr in jedem nachfolgenden Durchlauf. Folgende Bedingung gilt an Position (2): (II) a[m] = x Folgende Bedingung gilt an Position (3): (III) (i = j + 1)! (" k, 0! k < i: a[k] < x)! (" k, j < k < a.length: a[k] > x) i = j + 1 $ Unsicherheitsintervall ist leer! In jedem Schleifendurchlauf wird i erhöht oder j erniedrigt $ nach endlich vielen Schleifendurchläufen wird i > j $ Algorithmus terminiert. 5-10

6 Zeitaufwand Algorithmus funktioniert für jede Wahl von m mit i! m! j, ist aber am effizientesten für m = (i + j) / 2. Zeitaufwand im schlimmsten Fall: &log 2 n' Schleifendurchläufe, d.h. T(n) #!(log n) Beispiel Interface für Comparable<T> Binäres Suchen Falls Datenobjekte vom Typ Element int sind, find(int[] so sollte die a, Klasse int x) { int i = 0; Element das int j = a.length - 1; interface Comparable<T> while (i <= j) { aus java.lang implementieren, das die Methode int m = (i + j) / 2; public int compareto(t o); if (x < a[m]) x = 25 j = m - 1; enthält. Der Aufruf else if (x > a[m]) x.compareto(o) i = m gibt 4 für 6x < 7o eine 16 negative int, 29 für x = o den Wert else 0 und // x = a[m] für x > o eine positive int zurück. return m; class Element implements Comparable<Element>{ return -1; i... m i m ixi iim j public int compareto(element o) {... int[] a = {3,4,6,7,16,23,25,29;... int xi = find(a, 25); 5-12

7 Binäres Suchen für beliebige Objekttypen int find(comparable<t>[] a, Comparable<T> x) { int i = 0; int j = a.length 1; while (i <= j) { int m = (i + j) / 2; int comp = x.compareto(a[m]); if (comp < 0) j = m 1; else if (comp > 0) i = m + 1 else // comp = 0 return m; return 1; Was ist Sortieren? Wie schwer ist es? Motivation: Binäres Suchen in geordneten Mengen ist sehr viel schneller als sequentielles Suchen in ungeordneten Mengen. Sortieren ist neben Suchen eine der am häufigsten ausgeführten Operationen. Gegeben sei eine Folge S von n Elementen x 1, x 2,, x n, die einem Wertebereich X entstammen, auf dem eine totale Ordnung! definiert ist, d.h. eine Relation, die die folgenden Axiome erfüllt:! ist reflexiv: " x ( X: x! x! ist antisymmetrisch: " x, y ( X: x! y! y! x $ x = y! ist transitiv: " x, y, z ( X: x! y! y! z $ x! z! ist total: " x, y ( X $ x! y # y! x Sortieren ist ein Prozess, durch den eine Folge x i1, x i2,, x in erzeugt wird, so daß (i 1, i 2,, i n ) eine Permutation der ganzen Zahlen von 1 bis n ist und folgende Eigenschaft gilt: " k, 1! k! n 1: x ik! x ik

8 Sortieren = Finden einer Permutation Beispiel: Sortierung der Folge x 1 = 9, x 2 = 4, x 3 = 13, x 4 = 2, x 5 = 21, x 6 = 15, x 7 = 2, x 8 = 5, x 9 = 11 erzeugt die Folge x 4 = 2, x 7 = 2, x 2 = 4, x 8 = 5, x 1 = 9, x 9 = 11, x 3 = 13, x 6 = 15, x 5 = 21 die durch die Permutation (4, 7, 2, 8, 1, 9, 3, 6, 5) der Ausgangsfolge festgelegt wird. Abstrakte Formulierung: Sortieren besteht im Auffinden einer spezifischen Permutation (oder einer unter einigen wenigen Permutationen, wenn Elemente gleiche Werte haben dürfen) aus n! möglichen Permutationen der n gegebenen Elemente Randbedingungen Menge S der zu sortierenden Elemente gegeben in einer Datenstruktur, die S implizit ordnet, aber nicht notwendigerweise bzgl. der gewünschten Ordnung!. Typische Sortierprobleme: S gegeben in Array mit direktem Zugriff auf jedes Element (z.b. a[i] im Array a) oder sequentieller Datei (z.b. Magnetband) mit sequentiellem Zugriff (z.b. durch Zeiger auf gegenwärtige Position). Generierung des Resultats in der gleichen Datenstruktur. Zugriffsoperationen der zugrunde liegenden Datenstruktur bestimmen, welche Sortieralgorithmen möglich sind. 5-16

9 Eigenschaften von Sortieralgorithmen Ein Sortieralgorithmus sortiert in place, falls während seines Ablaufs zu jedem Zeitpunkt höchstens eine konstante Anzahl zu sortierender Elemente außerhalb der Datenstruktur gespeichert wird. Ein Sortieralgorithmus heißt stabil, falls nach der Sortierung die ursprüngliche Anordnung gleicher Elemente erhalten bleibt: 8, 6', 2', 1, 6", 2", 9 % 1, 2', 2", 6', 6", 8, 9 ist stabil 8, 6', 2', 1, 6", 2", 9 % 1, 2", 2', 6', 6", 8, 9 ist nicht stabil 5-17 Sortieralgorithmen Die meisten Sortieralgorithmen sind Verfeinerungen der folgenden Idee: ) while (* (i, j): i < j! a[i] > a[j]) a[i] :=: a[j]; :=: bezeichnet den Austauschoperator! Zwei Typen von Operationen sind zum Sortieren notwendig: Sammeln von Information über die Ordnung der gegebenen Elemente Ordnen der Elemente, z.b. durch Vertauschen zweier Elemente Ziel bei der Entwicklung eines effizienten Sortieralgorithmus: Minimierung der Anzahl Operationen beider Typen $ Vermeide, redundante Informationen zu sammeln! Versuche, Elemente so selten wie möglich zu bewegen! 5-18

10 Nicht-deterministische Algorithmen Beispiel: Nicht-deterministischer Algorithmus ) erlaubt beim Sortieren von x 1 = 5, x 2 = 2, x 3 = 3, x 4 = 4, x 5 = 1 (+) eine der folgenden 7 Austauschoperationen: x 1 :=: x i für 2! i! 5 und x j :=: x 5 für 2! j! 4 Zustand (+) könnte entstanden sein durch exotische Strategie, die von der Mitte zu den beiden Enden sortiert, und es könnte bekannt sein, daß eine einzige Austauschoperation x 1 :=: x 5 den Sortierprozeß abschließen würde. Der nicht-deterministische Algorithmus ) bietet jedoch keine Möglichkeit, dieses Wissen auszudrücken und zu nutzen. $ Kein Nicht-Determinismus! Zu entwickelnde Kontrollstruktur muß sorgfältig die Reihenfolge der auszuführenden Operationen festlegen, um die bereits gesammelten Informationen möglichst optimal zu nutzen! 5-19 Intrinsische Komplexität Grenzen der Optimierung: Ohne irgendwelche bereits vorhandene Informationen muß jedes Element mindestens einmal inspiziert und i. a. mindestens einmal bewegt werden $ mindestens "(n) primitive Operationen sind notwendig. Sammeln von Informationen nur durch Beantworten binärer Fragen (z.b. ja/nein Fragen, Vergleich zweier Elemente mit Antwort! oder >) $ mindestens n log 2 n Fragen sind notwendig (siehe Abschnitt 5.6) $ "(n log n) ist untere Schranke in diesem Berechenbarkeitsmodell. Umordnen von Elementen: durchschnittlicher Abstand eines Elementes von seiner korrekten Position $ n / 3 (siehe Abschnitt 4.7). Transfer eines Elementes kann z.b. durch 1 Schritt der Länge n / 3 oder n / 3 Schritte der Länge 1 erfolgen. Umordnung nur durch Austausch benachbarter Elemente $ durchschnittlich!(n 2 ) Austauschoperationen sind nötig $ Kurze Schritte nicht ausreichend für effizienten O(n log n) Algorithmus! 5-20

11 Praktische Aspekte Objekte statt Elemente Unsere Annahme: Zu sortierende Elemente entstammen einem total geordneten Wertebereich. In der Praxis wird die Ordnung der Elemente häufig direkt durch Schlüssel bestimmt, die Bestandteil der zu sortierenden komplexen Datenobjekte sind, die neben dem Schlüssel noch weitere Daten umfassen, z.b. Konten mit Schlüssel Kontonummer. indirekt aus den Eigenschaften der Objekte abgeleitet, z.b. Rechtecke, die durch ihre Seitenlängen gegeben sind und nach ihrem Flächeninhalt geordnet werden. Vergleichsoperatoren =, <,! müssen bei Implementierung in der Regel durch Methoden ersetzt werden, Realisierung in JAVA über interface Comparable<T> (siehe 5.2) Sortiergeneratoren, Sortierbibliotheken Partiell sortierte Mengen Einige Typen von Sortieralgorithmen Inkrementelle Algorithmen: Insertion Sort (Sortieren durch Einfügen) Selection Sort (Sortieren durch Auswahl) partitionieren die Menge der zu sortierenden Elemente in zwei disjunkte Teilmengen, dargestellt durch Tupel SORTED und UNSORTED: Initialisierung: SORTED = (); UNSORTED = (x 1, x 2,, x n ); Schleife: for (int i = 1; i! n; i++) Transferiere ein Element aus UNSORTED an seine korrekte Position in SORTED. 5-22

12 Insertion Sort und Selection Sort Hauptunterschied zwischen Insertion Sort und Selection Sort: In welcher der beiden Mengen wird die meiste Arbeit während des Sortierens verrichtet? Insertion Sort: Entferne das erste (oder am leichtesten zugreifbare) Element aus UNSORTED und durchsuche SORTED, um seine korrekte Position zu finden. Selection Sort: Durchsuche UNSORTED, um das nächste an SORTED anzuhängende Element zu finden Beispiel für Insertion Sort Initialisierung: SORTED = (); UNSORTED = (25, 23, 3, 16, 4, 7, 29, 6); i 1 2 (23, 25) (3, 16, 4, 7, 29, 6) i = (3, 23, 25) (16, 4, 7, 29, 6) SORTED (25) (3, 16, 23, 25) sortiert sortiert sortiert sortiert sortiert sortiert unsortiert unsortiert (3, 4, 16, 23, 25) (3, 4, 7, 16, 23, 25) (3, 4, 7, 16, 23, 25, 29) (3, 4, 6, 7, 16, 23, 25, 29) UNSORTED (23, 3, 16, 4, 7, 29, 6) (4, 7, 29, 6) (7, 29, 6) (29, 6) (6) () 5-24

13 Beispiel für Selection Sort Initialisierung: SORTED = (); UNSORTED = (25, 23, 3, 16, 4, 7, 29, 6); i 1 2 (3, 4) (25, 23, 16, 7, 29, 6) i = (3, 4, 6) (25, 23, 16, 7, 29) SORTED (3) (3, 4, 6, 7) sortiert sortiert sortiert sortiert sortiert sortiert unsortiert (3, 4, 6, 7, 16) (3, 4, 6, 7, 16, 23) (3, 4, 6, 7, 16, 23, 25) (3, 4, 6, 7, 16, 23, 25, 29) UNSORTED (25, 23, 16, 4, 7, 29, 6) (25, 23, 16, 29) (25, 23, 29) (25, 29) (29) () 5-25 Insertion Sort und Selection Sort SORTED und UNSORTED teilen sich ein Array, die Grenze zwischen beiden wird durch einen Index i festgelegt, der mit steigender Anzahl sortierter Elemente zunimmt. Insertion Sort: Füge im i-ten Schritt das i-te Element in die Folge der ersten (i 1) Elemente ein. 1 2? i 1 i n! x! x sortiert unsortiert Selection Sort: Selektiere im i-ten Schritt das kleinste unter den n i + 1 noch nicht sortierten Elementen und bewege es an die i-te Position. 1 2 i n! x x = minimum(a[i],, a[n]) sortiert unsortiert Insertion Sort und Selection Sort erfordern wahlfreien Zugriff auf die Elemente, daher werden beide Verfahren für das interne Sortieren im Hauptspeicher verwendet. 5-26

14 Merge Sort Merge Sort (Sortieren durch Mischen) verarbeitet (Teil-) Folgen von Elementen sequentiell $ Merge Sort ist sehr gut geeignet für externes Sortieren auf Sekundärspeichermedien, die nur sequentiellen Zugriff effizient unterstützen (z.b. Festplatten) oder erlauben (z.b. Magnetbänder). Merge Sort ist auch gut geeignet für internes Sortieren. Idee: Verschmelze zwei sortierte Folgen von Elementen, genannt Läufe (runs), in eine längere sortierte Folge: Lese von jedem der beiden Läufe das jeweils nächste Element, vergleiche die beiden Elemente miteinander und hänge das kleinere der beiden Elemente an die Ausgabefolge Externer Merge Sort A B Prozessor 1&3 2&4 Prozessor 1&3&2&4 Prozessor liest zwei Magnetbänder (oder sequentielle Dateien) A und B. A enthält Läufe 1 und 2, B Läufe 3 und 4. Prozessor verschmilzt Läufe 1 und 3 in einen einzigen Lauf 1&3 auf Band C und Läufe 2 und 4 in einen einzigen Lauf 2&4 auf Band D. In einem zweiten Merge-Schritt werden Läufe 1&3 und 2&4 in einen einzigen Lauf 1&3&2&4, d.h. in eine sortierte Folge, verschmolzen. 5-28

15 Radix Sort Radix Sort (Sortieren durch Verteilen, Distribution Sort) beruht nicht auf Vergleich und Vertauschung von Elementen, sondern auf deren Darstellung in einem Stellenwertsystem (z.b. Dezimalsystem). benutzt primitive arithmetische Operationen wie "extrahiere die k-te Ziffer". Beispiel: 3-ziffrige Zahlen im Zahlensystem zur Basis Verteile zu sortierende Zahlen auf 4 Folgen gemäß ihrer rechten Ziffer und hänge die so entstehenden Folgen aneinander. Wiederhole diesen Prozess für die mittlere und dann für die linke Ziffer Radix Sort zu sortierende Folge: verteile verteile bezüglich bezüglich der rechten der rechten Ziffer Ziffer zu sortierende Folge: verteile bezüglich 023 verteile der mittleren bezüglich Ziffer der mittleren Ziffer zu sortierende Folge: verteile verteile bezüglich 322 bezüglich der linken der linkenziffer Ziffer sortierte Folge:

16 5.5 Einfache Sortieralgorithmen mit Zeitaufwand!(n 2 ) Array von n Elementen, z.b. ganze Zahlen: int[] a; // a.length = n Sortiere die Elemente von a in aufsteigender Reihenfolge. In place Algorithmen benutzen bei der Sortierung neben dem Array a höchstens O(1) weiteren Speicherplatz. Insertion Sort: void insertionsort(int[] a) { for (int i = 1; i < a.length; i++) { int tmp = a[i]; int j = i - 1; while ((j >= 0) && (tmp < a[j])) { a[j + 1] = a[j]; j = j - 1; a[j + 1] = tmp; Insertion Sort ist stabil! Austausch 0 1 j i n 1 sortiert unsortiert 5-31 Insertion Sort v best, v average, v worst bezeichne die Anzahl Vergleichsoperationen in der Bedingung der while-schleife, a best, a average, a worst die Anzahl Durchläufe des Rumpfes der while-schleife, d.h. die Anzahl Austauschoperationen, im besten, durchschnittlichen und schlimmsten Fall. v best = n!1 v average = inv average + (n!1) = n2 + 3 "n! 4 4 n!1 v worst = # i = n2! n 2 i=1 a best = 0 a average = inv average = n2! n 4 a worst = " i = n2! n 2 inv average bezeichnet die durchschnittliche Anzahl Inversionen in einer Permutation (siehe Abschnitt 4.7) Insertion Sort ist im besten Fall ein!(n) Algorithmus, im durchschnittlichen und schlimmsten Fall ein!(n 2 ) Algorithmus. Binäres Suchen der korrekten Einfügeposition von a[i] im bereits sortierten Teil würde die Zeitkomplexität nicht verbessern! n!1 i=1 5-32

17 Interface Comparable<T> Falls Datenobjekte vom Typ Element sind, so sollte die Klasse Element das interface Comparable<T> aus java.lang implementieren, das die Methode public int compareto(t o); enthält. Der Aufruf x.compareto(o) gibt für x < o eine negative int, x = o den Wert 0 und für x > o eine positive int zurück. class Element implements Comparable<Element>{... public int compareto(element o) { Insertion Sort für beliebige Objekttypen public static <T extends Comparable<T>> void insertionsort(t[] a) { for (int i = 1; i < a.length; i++) { T tmp = a[i]; int j = i 1; while ((j >= 0) && (tmp.compareto(a[j]) < 0)) { a[j + 1] = a[j]; j = j 1; a[j + 1] = tmp; 5-34

18 Selection Sort void selectionsort(int[] a) { for (int i = 0; i < a.length - 1; i++) { int minindex = i; for (int j = i+1; j < a.length; j++) if (a[j] < a[minindex]) minindex = j; swap(a, i, minindex); void swap(int[] a, int i, int j) { int tmp = a[i]; a[i] = a[j]; a[j] = tmp; minindex 0 i j n 1 sortiert unsortiert Obige in place Implementierung von Selection Sort ist nicht stabil! 5-35 Selection Sort Die von Selection Sort zu verrichtende Arbeit ist immer gleich, es gibt keinen besten, durchschnittlichen oder schlimmsten Fall. Sei v die Anzahl Vergleiche von Elementen, a die Anzahl Austauschoperationen. n!2 v = " (n!1! i) = n2! n 2 i=0 a = n!1 Selection Sort benötigt immer einen Zeitaufwand von!(n 2 ). 5-36

19 5.6 Eine untere Schranke "(n log n) Zweiwertige binäre Fragen: Antwort ja / nein, true / false Häufige Art einer zweiwertigen Frage: x! y? Satz: Jeder Sortieralgorithmus, der die Information über die Anordnung der Elemente nur über zweiwertige Fragen und nichts anderem bezieht, benötigt im Durchschnitt (d.h. im Mittel über alle n! Permutationen) und somit auch im schlimmsten Fall mindestens n log 2 (n + 1) n / ln 2 Vergleiche. Somit ist die Zeitkomplexität eines solchen Algorithmus im durchschnittlichen und im schlimmsten Fall "(n log n). Beweis: Darstellung eines solchen Sortieralgorithmus durch einen binären Entscheidungsbaum: Interner Knoten repräsentiert binäre Frage. Blatt entspricht einem möglichen Resultat des Entscheidungsprozesses Eine untere Schranke "(n log n) Fortsetzung Beweis: Entscheidungsbaum muß jede der möglichen n! Permutationen der Eingabedaten von jeder anderen unterscheiden $ Entscheidungsbaum hat mindestens n! Blätter, mindestens eines für jede Permutation! Beispiel: Sortierung von drei Elementen x, y und z durch Vergleiche zwischen jeweils zwei Elementen yes x! y? no yes y! z? y! z? no yes no x! y! z x! z? x! z? yes no yes no z < y < x x! z < y z < x! y y < x! z y! z < x 5-38

20 Eine untere Schranke "(n log n) Fortsetzung Beweis: Durchschnittliche Anzahl binärer Fragen, die ein gegebener Sortieralgorithmus benötigt = durchschnittliche Tiefe der Blätter des Entscheidungsbaums Lemma (siehe nächste Folie) $ durchschnittliche Tiefe # log 2 n! n n " % log 2 n! = log 2! i # $ & ' = ( log i 2 i=1 i=1 ) (n +1)* log 2 (n +1) + n ln 2 + log (n +1) 2 = n * log 2 (n +1) + n ln 2 Im Durchschnitt werden also mindestens n log 2 (n + 1) n / ln 2 binäre Fragen benötigt, d.h. die Zeitkomplexität eines solchen Sortieralgorithmus beträgt "(n log n) im durchschnittlichen und daher auch im schlimmsten Fall Eine untere Schranke "(n log n) Lemma: In einem binären Baum mit k Blättern beträgt die durchschnittliche Tiefe der Blätter mindestens log 2 k. Beweis: durch Widerspruch! Annahme: Die Behauptung trifft nicht zu! Der binäre Baum T sei das Gegenbeispiel mit der kleinsten Anzahl Knoten. Fall I: T = w T besteht aus einem einzigen Knoten $ die Tiefe dieses einzigen Blattes ist 0, die durchschnittliche Tiefe ist also mindestens log 2 1 = 0 $ Behauptung trifft auf T zu $ T kann nicht nur aus einem einzigen Knoten bestehen. 5-40

21 Eine untere Schranke "(n log n) Fortsetzung Beweis: w Fall II: T = T' Wurzel w von T hat nur ein Kind $ T' enthält weniger Knoten, aber alle k Blätter von T, die in T' eine geringere durchschnittliche Tiefe haben als in T $ T' ist Gegenbeispiel mit geringerer Anzahl Knoten als T $ Widerspruch zur Wahl von T $ Wurzel w von T kann nicht nur ein Kind haben. Fall III: T = w T L T R Wurzel w von T hat zwei Kinder: k L > 0 Blätter im linken Teilbaum T L, k R > 0 Blätter im rechten Teilbaum T R mit k = k L + k R 5-41 Eine untere Schranke "(n log n) Fortsetzung Beweis: T Gegenbeispiel mit kleinster Anzahl Knoten $ k L Blätter von T L k R Blätter von T R haben durchschnittliche Tiefe von mindestens log 2 k L log 2 k R $ die durchschnittliche Tiefe der k Blätter von T beträgt mindestens k L k! log k L + k 2 k L + R! log R k L + k 2 k R +1 (") R (+) nimmt minimalen Wert log 2 k für k L = k R = k / 2 an $ durchschnittliche Tiefe der k Blätter von T beträgt mindestens log 2 k $ Widerspruch zur Wahl von T als Gegenbeispiel! Fall I, II, III $ Behauptung des Lemmas! 5-42

22 5.7 Quicksort C. A. R. Hoare: Quicksort, Computer Journal 5(1), (1962). Quicksort kombiniert divide & conquer mit einer effizienten Strategie, die Elemente mit nur wenigen Austauschoperationen zu bewegen. divide: Partitioniere das Array in zwei disjunkte Teile, die "kleinen" Elemente auf der linken Seite und die "großen" Elemente auf der rechten Seite. conquer: Sortiere jedes der zwei Teilarrays rekursiv. combine: Keine Arbeit notwendig, um die beiden Teillösungen zu einer Lösung des Gesamtproblems zu kombinieren. kleine Elemente große Elemente 5-43 Quicksort Effizienz von Quicksort hängt entscheidend davon ab, daß die in der divide-phase entstehenden Teilarrays sich in der Größe nicht allzu stark unterscheiden! Wähle einen Schwellenwert m $ Definiere klein als! m, groß als # m kleine Elemente! m große Elemente # m 5-44

23 Quicksort Partitioniere ein zu sortierendes Teilarray a[l.. R] durch einen links-nach-rechts Durchlauf L-R (durch Inkrementierung eines Index i ) und einen gleichzeitigen rechts-nach-links Durchlauf R-L (durch Dekrementierung eines Index j ). L i! m # m L-R stoppt, sobald das erste Element mit a[ i ] " m angetroffen wird. R-L stoppt, sobald das erste Element mit a[ j ]! m angetroffen wird. Nach Stop beider Durchläufe $ a[ i ] :=: a[ j ] (Austausch) und setze die Durchläufe fort. j < i $ Partitionierung ist beendet. Rufe Quicksort rekursiv auf für! a[l.. j ] falls j > L " # a[ i.. R] falls i < R j R 5-45 Quicksort zu Beispiel: sortierende Folge: (25, 23, 3, 16, 4, 7, 29, 6) Partitionierung Partitionierung mit mit m m = = i j i j i 16 i i 4 ij 23 ij 29 j 25 j i j j i j 5-46

24 Quicksort Wahl des Schwellenwertes muß die Korrektheit und die Effizienz von Quicksort sicherstellen! Korrektheit: {x i : x i! m = $ oder {x j : x j " m = $ $ Quicksort terminiert nicht! $ Forderung: min(x i )! m! max(x i ) Effizienz: m sollte nahe am Median liegen! Der Median einer Menge von n Elementen ist das Element m, so daß gleich viele (bis auf eins) Elemente links und rechts von m liegen. Wie findet man den Median von n Elementen? Der exakte Median kann im schlimmsten Fall in O(n) Zeit bestimmt werden: M. Blum, R. W. Floyd, V. R. Pratt, R. L. Rivest, R. E. Tarjan: Time bounds for selection, Journal of Computer and System Sciences 7(4), (1972) Quicksort Bei Verwendung des exakten Medians werden die zu sortierenden Elemente in zwei gleich große Teilmengen aufgeteilt $ Zeitaufwand T(n) von Quicksort beträgt ( ) + a!n + b T(n) = 2!T n 2 und man erhält T(n) = a n log 2 n + (T(1) + b) n b d.h. vom theoretischen Standpunkt aus betrachtet benötigt Quicksort selbst im schlimmsten Fall nur!(n log n) Zeit. Aber: Die multiplikative Konstante des Algorithmus zum Auffinden des Medians ist sehr groß $ a ist sehr groß $ Quicksort ist in der Praxis nicht sehr effizient, falls der exakte Median benutzt wird! Es lohnt sich nicht, den hohen Aufwand zum Auffinden des exakten Medians zu treiben! 5-48

25 Quicksort Techniken zur Bestimmung eines vermuteten Medians, der eine akzeptable Approximation liefert: Ein Arrayelement in fixer Position, z.b. a[(l + R) / 2]. Vorsicht: Benutze kein Element nahe a[l] oder a[r], da dies zu Ineffizienz im Falle von partiell sortierten Elementen führt. Ein Arrayelement in zufällig gewählter Position $ gibt gute Resultate! Den Median von drei oder fünf Elementen an fixen oder zufällig gewählten Positionen. Den Mittelwert des kleinsten und größten Elementes $ erfordert zusätzlichen Durchlauf zu Beginn, danach kann der Mittelwert für jedes Teilarray während des vorherigen Aufteilungsprozesses bestimmt werden Quicksort: Rekursive Implementierung void quicksort(int[] a, int L, int R) { int m = a[(l + R) / 2]; // min(a[l],, a[r])! m! max(a[l],, a[r]) int i = L; int j = R; while (i <= j) { // a[l],, a[i 1]! m! a[j + 1],, a[r] while (a[i] < m) i = i + 1; // a[l],, a[i 1]! m! a[i] while (m < a[j]) j = j - 1; // a[j]! m! a[j + 1],, a[r] if (i <= j) { swap(a, i, j); // i! j $ a[i]! m! a[j] i = i + 1; j = j - 1; // a[l],, a[i 1]! m! a[j + 1],, a[r] // else i > j $ i = j + 1 $ exit if (L < j) quicksort(a, L, j); if (i < R) quicksort(a, i, R); 5-50

26 Implementierung von Quicksort Initialer Aufruf: quicksort(a, 0, a.length - 1); mit a.length > 1 garantiert, daß L < R in jedem rekursiven Aufruf von quicksort gilt! Quicksort ist ein in place Algorithmus! Quicksort ist nicht stabil! Für sehr kleine Arrays (n! 20) ist Quicksort nicht so effizient wie Insertion Sort. Quicksort rekursiv $ Quicksort wird sehr häufig für kleine Arrays aufgerufen! In der Praxis: Modifikation von Quicksort, so daß für kleine Teilarrays Insertion Sort aufgerufen wird! 5-51 Analyse von Quicksort T(n) sei der von Quicksort benötigte Zeitaufwand $ T(n) = T(k) + T(n k) + a n + b (+) wenn das Array aufgeteilt wird in ein Teilarray mit k Elementen und ein Teilarray mit n k Elementen. Konstante b: Kosten für den Aufruf von Quicksort für das zu sortierende Array. a n: Kosten für die Partitionierung. T(k) und T(n k): Kosten der rekursiven Aufrufe für die beiden Teilarrays. 5-52

27 Analyse von Quicksort Beispiel: Aufteilung mit m = i j i j j i $ von Quicksort benötigter Zeitaufwand T(n) = T(k) + T(n k 1) + a n + b Diese Rekurrenz hat gleiche asymptotische Lösung wie (+), daher Beschränkung auf (+). T(n) = T(k) + T(n k) + a n + b (+) 5-53 Analyse von Quicksort Verhalten im besten Fall: Partitionierung des Arrays in zwei gleich große Teilarrays $ T(n) = 2!T n 2 Abschnitt 4.6 $ ( ) + a!n + b T(n) = a n log 2 n + (T(1) + b) n b = a n log 2 n + g(n) mit g(n) # O(n) $ Quicksort's Zeitkomplexität im besten Fall ist!(n log n). 5-54

28 Analyse von Quicksort Verhalten im schlimmsten Fall: Partitionierung des Arrays in ein Teilarray mit n 1 Elementen und ein Teilarray mit einem Element $ T(n) = T(1) + T(n 1) + a n + b Substitution: T(n 1) = T(1) + T(n 2) + a (n 1) + b $ T(n) = 2 T(1) + T(n 2) + a n + a (n 1) + 2 b Wiederholte Substitution ergibt T(n) = n!t(1) + a! n2 + n " 2 + b!(n "1) 2 $ Quicksort's Zeitkomplexität im schlimmsten Fall ist!(n 2 ) Analyse von Quicksort Durchschnitt über alle n! Permutationen ist schwer zu ermitteln, daher Analyse des Verhaltens im typischen Fall, d.h. unter der Annahme: Für alle k, 1! k < n, ist die Wahrscheinlichkeit 1 / (n 1), daß das Array aufgeteilt wird in Teilarrays der Größen k und n k. Verhalten im typischen Fall: Der im Durchschnitt von Quicksort benötigte Zeitaufwand wird beschrieben durch T(n) = 1 n!1 n!1 " (T(k ) +T(n! k )) + a # n + b = 2 " T(k ) + a # n + b n!1 k=1 Lösung durch trial-and-error (Abschnitt 4.5): T(n) = (ln 4) a n log 2 n + g(n) mit ln 4 # und g(n) # O(n) $ Quicksort's asymptotisches Verhalten ist im typischen Fall nur etwa 40% schlechter als im besten Fall $ Quicksort's Zeitkomplexität im typischen Fall ist!(n log n). n!1 k=1 5-56

29 5.8 Merge Sort Bisher: Interne Sortieralgorithmen mit direktem Zugriff auf jedes Element! Annahme bei der Algorithmenanalyse: Zugriff auf a[i] ist primitive Operation mit konstanten Kosten, d.h. unabhängig von i und n. Annahme gilt nicht für Sekundärspeichermedien wie Festplatten oder Magnetbänder! Externes Sortieren: Zu sortierende Elemente sind in einer sequentiellen Datei (File) gespeichert. Zu jedem Zeitpunkt kann man über einen Zeiger nur auf genau ein Element zugreifen. Zugriff auf andere Elemente erfordert Neupositionierung des Zeigers in der Datei. Zeiger kann nur in einer Richtung (vorwärts) oder in beide Richtungen (vorwärts und rückwärts) wandern Externer Merge Sort Annahme: Zeit zur Repositionierung des Zeigers ist proportional zur zurückgelegten Distanz. Annahme begünstigt Algorithmen, die nur benachbarte Elemente verarbeiten (vergleichen, austauschen). benachteiligt Algorithmen, die wahlfreien Zugriff auf die Elemente benötigen (z.b. Quicksort). f k bezeichne das k-te Element, das in Datei f gespeichert ist. Ein Lauf (Run) ist eine sortierte Teilfolge von Elementen f i, f i+1,, f j, die aufeinanderfolgend in Datei f gespeichert sind und für die f k! f k+1 für alle k mit i! k! j 1 gilt. Verfügbarer Puffer im Hauptspeicher mit Kapazität m Elemente 5-58

30 Externer Merge Sort Externer Sortieralgorithmus, basierend auf dem Prinzip des Merge Sort: Initiale Phase: Erzeuge im Hauptspeicher initiale Läufe der Länge m (evtl. weniger Elemente im letzten Lauf) und speichere die Läufe in Datei f. Kopierphase (Copy): Kopiere die Hälfte der Läufe von f in Datei g, die andere Hälfte in Datei h. Verschmelzungsphase (Merge): Verschmelze jeden Lauf von g mit genau einem Lauf von h und schreibe den resultierenden Lauf nach f. Wiederhole Kopier- und Verschmelzungsphase, bis f nur noch einen einzigen Lauf enthält Externer Merge Sort Realisierung der initialen Phase: Lese aus Eingabedatei e die m Elemente e r m+1, e r m+2,, e r m+m in den Puffer (r = 0, 1, ). Sortiere die Elemente im Puffer mit einem internen Sortierverfahren (z.b. Quicksort). Schreibe den so erzeugten r-ten Lauf in die Datei f, die den gleichen physischen Speicherbereich belegen kann wie die ursprüngliche Datei e. $ f ist partiell sortiert: " k, r m + 1! k < r m + m: f k! f k+1 Jeder Copy-Merge-Zyklus halbiert die Anzahl Läufe: copy g: s/2 Läufe merge f: s Läufe f: s/2 Läufe h: s/2 Läufe Nach &log 2 (n/m)' Copy-Merge-Zyklen besteht f aus einem einzigen Lauf, der die sortierte Folge aller Elemente darstellt. 5-60

31 Interner Merge Sort void mergesort(int[] a, int L, int R) { int M = (L + R) / 2; if (L < M) mergesort(a, L, M); if (M + 1 < R) mergesort(a, M + 1, R); merge(a, L, M, R); 5-61 Interner Merge Sort void merge(int[] a, int L, int M, int R) { int[] b = new int[r L+1]; int i = L; int j = M + 1; int k; for (k = L; k <= R; k++) if ((i > M) ((j <= R) && (a[j] < a[i]))) { b[k L] = a[j]; j = j + 1; else { b[k L] = a[i]; i = i + 1; for (k = L; k <= R; k++) a[k] = b[k L]; 5-62

32 Interner Merge Sort Interner Merge Sort ist kein in place Algorithmus, da er ein zusätzliches Array benötigt. Interner Merge Sort ist stabil! Interner Merge Sort ist ein divide & conquer Algorithmus: divide 3 2 divide divide merge merge merge 5-63 Interner Merge Sort Zeitaufwand T(n) = 2!T n 2 ( ) + a!n + b Abschnitt 4.6 $ T(n) = a n log 2 n + (T(1) + b) n b = a n log 2 n + g(n) mit g(n) # O(n) $ Zeitkomplexität von Merge Sort ist in jedem Fall!(n log n). 5-64

33 5.9 Ist es möglich, in linearer Zeit zu sortieren? Untere Schranke "(n log n) gilt für Sortieralgorithmen, die Information über die Anordnung der Elemente nur über zweiwertige Fragen und nichts anderem beziehen! Diese untere Schranke gilt nicht unbedingt für andere Situationen! Beispiel 1: Sortieren einer Permutation Sortieren einer Permutation der ganzen Zahlen von 1 bis n in!(n) Zeit durch Speichern des Elementes i im Arrayelement mit Index i 1. Beispiel 2: Counting Sort Annahme: Jedes der n zu sortierenden Elemente ist eine ganze Zahl zwischen 0 und k 1. Idee: Bestimme für jedes Element x die Anzahl der Elemente! x $ Jedes Element kann direkt an seine korrekte Position im Ausgabearray gebracht werden Counting Sort void countingsort(int[] a, int k) { int[] b = new int[a.length]; int[] c = new int[k]; int i; for (i = 0; i < k; i++) c[i] = 0; for (i = 0; i < a.length; i++) c[a[i]] = c[a[i]] + 1; // c[i] enthält jetzt die Anzahl Elemente = i for (i = 1; i < k; i++) c[i] = c[i] + c[i - 1]; // c[i] enthält jetzt die Anzahl Elemente! i for (i = a.length - 1; i >= 0; i--) { b[c[a[i]] - 1] = a[i]; c[a[i]] = c[a[i]] - 1; for (i = 0; i < a.length; i++) a[i] = b[i]; 5-66

34 Counting Sort Counting Sort ist kein in place Algorithmus. Counting Sort ist stabil! Zeitkomplexität von Counting Sort ist!(n + k). Counting Sort wird in der Praxis eingesetzt, wenn k # O(n) $ Zeitkomplexität!(n) Sortieren in linearer Zeit? Widersprechen Beispiele 1 & 2 der unteren Schranke "(n log n)? Nein, da das Sammeln von Informationen durch das Stellen von (in den Zugriffen auf die einzelnen Arrayelemente versteckten) Fragen erfolgt, die mächtiger sind als binäre Fragen: n-wertige Fragen im Beispiel 1, k-wertige Fragen im Beispiel 2. Jede k-wertige Frage entspricht log 2 k binären Fragen. Wird dieser Umtauschfaktor berücksichtigt, so sind die Zeitkomplexitäten der obigen Algorithmen!(n log n) im Beispiel 1 und!(n log k + k) im Beispiel

35 Radix Sort Beispiel 3: Radix Sort Annahme: Die zu sortierenden Elemente sind ganze Zahlen bestehend aus höchstens d Ziffern, wobei die Ziffernpositionen von 1 bis d durchnumeriert sind. Die am weitesten rechts stehende Ziffer hat Position 1, die am weitesten links stehende Ziffer Position d. Die Basis des Zahlensystems sei b, d.h. 0! z < b für jede Ziffer z. Implementierung: void radixsort(int[] a, int d) { for (int i = 1; i <= d; i++) Sortiere die Elemente im Array a mit Hilfe eines stabilen Sortieralgorithmus bzgl. Ziffer i. Verwendung von Counting Sort $ Zeitkomplexität!(d n + d b) $ Zeitkomplexität!(n), falls d und b als Konstante angesehen werden Sortiernetzwerke Bisher: Sortieralgorithmen für sequentielle Maschinen, auf denen alle Operationen, z.b. Vergleiche und Austauschoperationen, nacheinander von einem Prozessor ausgeführt werden. Änderung des Berechnungsmodells $ Neubetrachtung der Algorithmen Beispiel: Multiprozessorarchitekturen Aufteilung der Arbeit? Synchronisation der Prozessoren? Austausch von Daten? Ziel: Erkenntnis, daß Algorithmen redesigned werden müssen, wenn sich das zugrundeliegende Berechnungsmodell ändert. 5-70

36 Sortiernetzwerke Komparatoren sind Prozessoren, die Werte auf zwei Eingabekanälen vergleichen und sie an zwei Ausgabekanäle weitergeben, so daß der kleinere Wert auf dem oberen Ausgabekanal, der größere Wert auf dem unteren Ausgabekanal erscheint. x y Komparator min(x, y) max(x, y) Anordnung von Komparatoren innerhalb eines Netzwerks, daß aus n waagerecht verlaufenden Kanälen besteht. Vertikale Verbindungen zwischen den Kanälen repräsentieren Komparatoren. Zahlen repräsentieren Eingabewerte, die durch das Netzwerk wandern und miteinander verglichen werden: Sortiernetzwerke Ein Netzwerk von Komparatoren ist ein Sortiernetzwerk, wenn es jede Eingabekonfiguration sortiert. Eingabekonfiguration besteht aus verschiedenen Elementen $ obda: Eingabekonfigurationen sind Permutationen der Zahlen 1, 2,, n Netzwerk, daß duplikatfreie Eingabekonfigurationen sortiert, sortiert auch Konfigurationen mit Duplikaten. (4, 1, 3, 2) wird nicht korrekt sortiert: $ kein Sortiernetzwerk!

37 Sortiernetzwerke Wieviele Komparatoren werden benötigt, wie sollten sie plaziert werden? Sortiernetzwerk für 4 Elemente: k 1 k 2 k 3 k 4 k 5 Wie kann man feststellen, ob ein gegebenes Netzwerk korrekt sortiert? Ausschöpfendes Testen ist allenfalls für kleine Netzwerke möglich. Netzwerke mit regelmäßiger Struktur erlauben gewöhnlich einen einfacheren Korrektheitsbeweis. Beispiel: k 1, k 2 und k 3 plazieren das kleinste Element auf dem obersten Kanal. k 1, k 2 und k 4 plazieren das größte Element auf dem untersten Kanal. Die mittleren beiden Elemente verbleiben auf den beiden mittleren Kanälen und werden durch k 5 in die richtige Reihenfolge gebracht Sortiernetzwerke Entwurfsprinzipien für die Entwicklung großer Sortiernetzwerke? Abbildung eines Sortieralgorithmus, der für sequentielle Maschine entwickelt wurde, in ein Sortiernetzwerk im allgemeinen nicht direkt möglich, da Netzwerke ein eingeschränkteres Berechnungsmodell darstellen: Sequentieller Sortieralgorithmus führt Vergleiche in Abhängigkeit vom Ausgang vorheriger Vergleiche durch, Sortiernetzwerk macht immer die gleichen Vergleiche für alle Eingabekonfigurationen. Aber: gleiche grundlegende Designprinzipien, die beim Entwurf sequentieller Algorithmen eingesetzt werden, treffen auch auf parallele Algorithmen zu. 5-74

38 Sortiernetzwerke Divide & Conquer: Plaziere zwei Sortiernetzwerke für jeweils n Kanäle übereinander und kombiniere sie in ein Sortiernetzwerk mit 2 n Kanälen durch Hinzufügen eines Merge-Netzwerks, daß ihre Ausgaben verschmilzt. Die rigide Struktur von Komparatornetzwerken kompliziert die Kombination von Netzwerken! Inkrementeller Algorithmus: Plaziere einen n-ten Kanal unter ein Sortiernetzwerk mit n 1 Kanälen und schalte diesem Netzwerk eine Kaskade von Komparatoren vor oder nach, die diesen Kanal in das existierende Netzwerk einbinden Sortiernetzwerke Insertion Sort: Elemente auf den oberen n 1 Kanälen bereits sortiert $ Element auf dem untersten Kanal wandert nach oben in die richtige Position: Sortiernetzwerk für n 1 Elemente Induktion Selection Sort: Das größte Element wandert zuerst nach unten, dann werden die restlichen Elemente sortiert: Sortiernetzwerk für n 1 Elemente Induktion 5-76

39 Sortiernetzwerke Komparatoren können zur Minimierung der Anzahl Berechnungsstufen an ihren Kanälen entlang verschoben werden unter der Voraussetzung, daß die Topologie des Netzwerkes sich nicht ändert. Diese Kompression reduziert sowohl Insertion Sort als auch Selection Sort auf das folgende Netzwerk:!(n 2 ) Komparatoren, Zeitkomplexität 2 n 3 #!(n) 5-77 Zusammenfassung Sequentielles Suchen in Array in!(n) Zeit Binäres Suchen in geordnetem Array in!(log n) Zeit Sortierproblem Verschiedene Typen von Sortieralgorithmen Einfache Algorithmen mit Zeitaufwand!(n 2 ): Insertion Sort, Selection Sort Untere Schranke "(n log n) Quicksort mit durchschnittlichem Zeitaufwand!(n log n), im schlimmsten Fall!(n 2 ) Interner Merge Sort mit Zeitaufwand!(n log n) im schlimmsten Fall Sortieren in linearer Zeit? Counting Sort, Radix Sort Ausblick: Heapsort ist ein nicht stabiler, in place Sortieralgorithmus mit Zeitaufwand!(n log n) im schlimmsten Fall. 5-78