Sortieren in Arrays. Kapitel 10

Transkript

1

2 Kapitel 10 Sortieren in Arrays Sortieralgorithmen gehören zu den am häufigsten angewendeten Algorithmen in der Datenverarbeitung. Man hatte daher bereits früh ein großes Interesse an der Entwicklung möglichst effizienter Sortieralgorithmen. Zu diesem Thema gibt es umfangreiche Literatur, nahezu jedes Buch über Algorithmen und Datenstrukturen beschäftigt sich mit Sortieralgorithmen, da sie besonders geeignet sind, Anfängern Programmiermethodik, Entwurf von Algorithmen und Aufwandsanalyse zu lehren. Wir erläutern die Sortieralgorithmen vor folgendem Hintergrund. Gegeben ist ein Datentyp Item. public class Item { int key; // data components and methods Objekte dieses Typs sind Karteikarten, z. B. aus einer Studentenkartei. Jede Karteikarte enthält neben den Daten (data components) einen Schlüssel (key) vom Typ int, z. B. die Matrikelnummer, nach denen sortiert oder gesucht werden kann. Die gesamte Kartei wird durch ein Array vec mit Grundtyp Item dargestellt. Wir reden daher im weiteren auch von Komponenten oder Elementen statt Karteikarten. Die Wahl von int als Schlüsseltyp ist willkürlich. Hier kann jeder andere Typ verwendet werden, für den eine vollständige Ordnungsrelation definiert ist, also zwischen je zwei Werten a,b genau eine der Relationen a < b, a = b, a > b gilt. Dies können z. B. auch Strings mit der lexikographischen Ordnung sein (Meier < Mueller), nur müsste dann der eingebaute Vergleich < von ganzen Zahlen durch eine selbstdefinierte Funktion zum Vergleich von Strings ersetzt werden. 1 1 Dies kann mit dem Interface Comparable (vgl. Abschnitt 7.3.7) realisiert werden. Die Klasse Item muss dazu die Methode public int compareto(object o) implementieren. Dabei ist das Item x kleiner als oder gleich dem Item y wenn x.compareto((object)y) <= 0 gilt. Alle Sortieralgorithmen nutzen dann die Abfrage x.compareto((object)y) <= 0 für den Vergleich von x und y. Version vom 30. Dezember

3 50 KAPITEL 10. SORTIEREN IN ARRAYS 10.1 Direkte Methoden Direkt bedeutet: Sortieren der Komponenten am Ort. Ein typisches Beispiel dafür ist Bubblesort Sortieren durch Austauschen: Bubblesort Bubblesort durchläuft das Array mehrmals von hinten nach vorn und lässt durch paarweise Vergleiche das kleinste Element der restlichen Menge zum linken Ende des Arrays wandern. Stellt man sich das Array senkrecht angeordnet vor, und die Elemente als Blasen, so steigt bei jedem Durchlauf durch das Array eine Blase auf die ihrem Gewicht (Schlüsselwert) entsprechende Höhe auf (vgl. Abbildung 10.1) j vec[j].key i= Abbildung 10.1: Phasen bei Bubblesort. Informell lässt sich Bubblesort wie folgt beschreiben: 1. Gegeben ist vec[] mit n Komponenten.. Das Array vec wird n 1 mal von hinten nach vorn durchlaufen. Ein Durchlauf heißt Phase. 3. Phase i läuft von Komponente j = n 1 bis j = i und vergleicht jeweils vec[j].key mit vec[j-1].key. Ist vec[j-1].key > vec[j].key so werden vec[j-1] und vec[j] getauscht. Die Korrektheit des Algorithmus ergibt sich direkt aus folgender Schleifeninvarianten, die nach jeder Phase gilt: Am Ende der Phase i ist vec[i-1].key der i-kleinste Schlüssel in vec und es gilt: vec[0].key vec[1].key... vec[i-1].key vec[j].key für j = i,i + 1,...,n 1. (10.1) Dies ist klar für die 1. Phase. Nimmt man die Richtigkeit für Phase i an (Induktionsvoraussetzung), so findet Phase i + 1 das kleinste Element in vec[i]...vec[n-1] und bringt es durch ggf. fortgesetzte Austauschoperationen an die Position i. Also gilt die Invariante auch nach Phase i (Induktionsschluss). Für i = n 1 folgt sofort die Korrektheit des Algorithmus.

4 10.1. DIREKTE METHODEN 51 Dies resultiert in die folgende Java Methode. /** * Sorts with bubblesort algorithm vec the array to be sorted NullPointerException if <code>vec</code> * is not initialized */ public static void bubblesort(item[] vec) throws NullPointerException { if (vec == null) throw new NullPointerException(); int n = vec.length; Item temp; int bottom; // bottom for each pass for (bottom = 1; bottom < n; bottom++) { for (int i = n-1; i >= bottom; i--) { if (vec[i-1].key > vec[i].key) { temp = vec[i-1]; vec[i-1] = vec[i]; vec[i] = temp; Wir berechnen nun den Worst Case Aufwand von Bubblesort nach der Anzahl der Vergleiche. Dazu betrachten wir die Vergleiche pro Phase. Sei n die Anzahl der Komponenten des Arrays. Phase 1 : n 1 Vergleiche Phase : n Vergleiche... Phase i : n i Vergleiche... Phase n 1 : 1 Vergleich Also gilt für die Anzahl C(n) der Vergleiche bei n Komponenten n 1 C(n) = (n ) + (n 1) = i=1 i = n(n 1). Folglich ist C(n) O(n ). Da die Vergleiche unabhängig von der Eingabe durchgeführt werden (auch bei einem bereits sortierten Array) gilt: C(n) = n(n 1) n 3 für n 3, also C(n) Ω(n ) und damit C(n) Θ(n ).

5 5 KAPITEL 10. SORTIEREN IN ARRAYS Offensichtlich kann dieser Algorithmus verbessert werden, wenn man sich merkt, ob in einer Phase überhaupt ein Austausch stattgefunden hat. Findet kein Austausch statt, so ist das Array sortiert und man kann abbrechen. Eine weitere Verbesserung besteht darin, sich in einer Phase die Position (Index) k des letzten Austausches zu merken. In den darauf folgenden Phasen müssen vec[0]...vec[k] nicht mehr überprüft werden. Schließlich kann man noch die Phasen abwechselnd von hinten nach vorn und von vorn nach hinten laufen lassen (Shakersort), um Asymmetrie zwischen leichten Elementen (gehen gleich ganz nach oben) und schweren Elementen (sinken jeweils nur um eine Position ab) zu durchbrechen. Diese Verbesserungen bewirken aber nur eine Verringerung der mittleren Anzahl der Vergleiche. Für den Worst Case lassen sich stets (Übung) Beispiele finden, die C(n) = n(n 1) Vergleiche benötigen. Es gilt also: Satz 10.1 Bubblesort erfordert Θ(n ) Vergleiche im Worst Case. Neben der Anzahl C(n) der Vergleiche ist für die Laufzeit auch die Anzahl A(n) der Zuweisungen (Assignments) von Arraykomponenten von großer Bedeutung, da sie außer den Schlüsseln noch weitere (ggf. große) Datenmengen enthalten. Offenbar kann jeder Vergleich einen Austausch und damit 3 Zuweisungen verursachen. Es gilt also A(n) 3 C(n). Beispiele zeigen, dass A(n) = 3 C(n) vorkommt. Also folgt: Satz 10. Bubblesort erfordert Θ(n ) Zuweisungen im Worst Case Sortieren durch direktes Auswählen: Selection Sort Wir geben zunächst eine informelle Beschreibung: 1. Gegeben ist vec[] mit n Komponenten.. Das Array vec wird n 1 mal von vorn nach hinten durchlaufen. Ein Durchlauf heißt Phase (pass). 3. Phase bottom sucht den Index minindx einer Komponente mit kleinstem Schlüsselwert im Bereich vec[bottom], vec[bottom+1],...,vec[n-1], mittels sequentieller Suche, und tauscht diese Komponente an die Stelle bottom. Es werden also vec[bottom] und vec[minindx] vertauscht. Die Korrektheit basiert hier auf derselben Invarianten wie bei Bubblesort. Es folgt eine Java Methode:

6 10.1. DIREKTE METHODEN 53 /** * Sorts with selectionsort algorithm vec the array to be sorted NullPointerException if <code>vec</code> * is not initialized */ public static void selectionsort(item vec[]) throws NullPointerException { if (vec == null) throw new NullPointerException(); int minindx; int bottom; int i; Item temp; int n = vec.length; // Index of smallest key in each pass // bottom for each pass for (bottom = 0; bottom < n-1; bottom++) { // INVARIANT (prior to test): // All vec[bottom+1..n-1] are >= vec[bottom] // && vec[0..bottom] are in ascending order // && bottom >= 0 minindx = bottom; for (i = bottom+1; i < n; i++) { // INVARIANT (prior to test): // vec[minindx] <= all // vec[0..i-1] // && i >= bottom+1 if (vec[i].key < vec[minindx].key) { minindx = i; temp = vec[bottom]; vec[bottom] = vec[minindx]; vec[minindx] = temp; Für das Beispiel aus Abbildung 10.1 ergeben sich die in Abbildung 10. dargestellten Zustände nach den einzelnen Phasen Für die Anzahl C(n) der Vergleiche ergibt sich analog zu Bubblesort: n 1 C(n) = i=1 (n i) = n(n 1),

7 54 KAPITEL 10. SORTIEREN IN ARRAYS Phase Array vec Input Abbildung 10.: Phasen bei Straight Selection Sort. da die sequentielle Suche in Phase i (Bestimmung des Minimum in n i + 1 Komponenten) gerade n i Vergleiche erfordert. Die Anzahl A(n) der Zuweisungen von Arraykomponenten ist jedoch deutlich geringer, da pro Phase maximal ein Austausch erfolgt. Also gilt A(n) 3(n 1) = O(n). Beispiele zeigen wieder, dass C(n) Θ(n ) und A(n) Θ(n) gilt Sortieren durch direktes Einfügen: Insertion Sort Diese Methode wird oft beim Kartenspiel genutzt. Die Arraykomponenten (Karten) werden gedanklich in eine Zielsequenz vec[0]...vec[i-1] (die Karten, die man bereits in der Hand hat) und die Quellsequenz vec[i]...vec[n-1] (die Karten für die eigene Hand, die noch verdeckt auf dem Tisch liegen) aufgeteilt. Dann lässt sich der Algorithmus folgendermaßen beschreiben: 1. Gegeben ist vec[] mit n Komponenten. Anfangs besteht die Zielsequenz aus vec[0] und die Quellsequenz aus vec[1]...vec[n-1].. Es finden n 1 Phasen i = 1,...,n 1 statt. 3. In Phase i wird die nächste Karte vec[i] der Quellsequenz genommen und an der richtigen Stelle (bzgl. vec[i].key) in die Zielsequenz vec[0]...vec[i-1] eingefügt. Die Korrektheit dieses Algorithmus folgt aus der folgenden Invariante: Nach jeder Phase i gilt vec[0].key vec[1].key... vec[i].key. (10.) Im Standardbeispiel ergeben sich die in Abbildung 10.3 dargestellten Zustände nach jeder Phase:

8 10.1. DIREKTE METHODEN 55 Phase Array vec Input Abbildung 10.3: Phasen bei Insertion Sort. Die Anzahl der Vergleiche hängt davon ab, wie das Einfügen in die Zielsequenz durchgeführt wird. Bei sequentieller Suche der Stelle (von links nach rechts) ergeben sich im Worst Case folgende Zahlen: Phase 1 : 1 Vergleich Phase : Vergleiche... Phase n 1 : n 1 Vergleiche In diesem Fall ist wiederum C(n) = n(n 1) O(n ). Da die Zielsequenz bereits aufsteigend sortiert ist, lässt sich statt der sequentiellen Suche die binäre Suche verwenden. Phase i erfordert dann (Zieldatei enthält i Elemente) gemäß Satz 6.1 höchstens logi + 1 Vergleiche. Also gilt dann: C(n) n 1 i=1 n 1 i=1 ( logi + 1) (log(n 1) + 1) = (n 1)(log(n 1) + 1) = (n 1)log(n 1) + (n 1) = O(nlogn) Bezüglich der Zahl A(n) der Zuweisungen von Arraykomponenten ist in beiden Varianten (sequentielle oder binäre Suche) eine Verschiebung der Komponenten der Quelldatei rechts von der Einfügestelle k um jeweils eine Stelle erforderlich, im schlimmsten Fall (k = 0) also i Verschiebungen in Phase i. Dies lässt sich mit i + 1 Zuweisungen realisieren: temp = vec[i]; for (j = i-1; j >= 0; j++) vec[j+1] = vec[j]; vec[0] = temp; Also ist A(n) n 1 i=1 (i + 1) = n i= i = ( = n(n+1) 1 O(n ). n i=1 i) 1

9 56 KAPITEL 10. SORTIEREN IN ARRAYS Das Beispiel des absteigend sortierten Arrays zeigt, dass dieser Fall auch eintritt, also A(n) Ω(n ) gilt. Straight Insertion (mit binärer Suche) ist also bezüglich der Anzahl der Vergleiche sehr gut (O(n log n)), aber bezüglich der Anzahl der Zuweisungen schlecht (Ω(n )). Die hier vorgestellten direkten Methoden sind mit ihrer Worst Case Laufzeit von Θ(n ) als sehr aufwendig einzustufen. Wir werden im Rest des Kapitels drei intelligentere Sortiermethoden kennen lernen, die im Mittel, und teilweise auch im Worst Case, mit O(n log n) Vergleichen und Zuweisungen auskommen. 10. Mergesort Mergesort teilt das zu sortierende Array in zwei gleichgroße Teilfolgen (Unterschied höchstens eine Komponente), sortiert diese (durch rekursive Anwendung von Mergesort auf die beiden Teile) und mischt die dann sortierten Teile zusammen Mischen sortierter Arrays Wir betrachten daher zunächst das Mischen von zwei bereits sortierten Arrays. Seien dazu vec1[] und vec[] bereits sortierte Arrays der Länge m bzw. n mit Komponenten vom Typ Item. Diese sind in das Array vec[] der Länge m + n zu verschmelzen. Dazu durchlaufen wir vec1 und vec von links nach rechts mit zwei Indexzeigern i und j wie folgt: 1. Initialisierung: i = 0; j = 0; k= 0;. Wiederhole Schritt 3 bis i = m oder j = n. 3. Falls vec1[i].key < vec[j].key, so kopiere vec1[i] an die Position k von vec und erhöhe i und k um 1. Andernfalls kopiere vec[j] an die Position k von vec und erhöhe j und k um Ist i = m und j < n, so übertrage die restlichen Komponenten von vec nach vec. 5. Ist j = n und i < m, so übertrage die restlichen Komponenten von vec1 nach vec. Bei jedem Wiedereintritt in die Schleife 3 gilt die Invariante vec[0].key... vec[k-1].key vec[k-1].key vec1[i].key... vec1[m-1].key vec[k-1].key vec[j].key... vec[n-1].key (10.3) Hieraus folgt sofort, dass vec am Ende aufsteigend sortiert ist. Als Beispiel betrachten wir die Arrays:

10 10.. MERGESORT 57 vec1: vec: Die dazugehörige Folge der Werte von i,j,k und vec bei jedem Wiedereintritt in die Schleife 3 ist in Abbildung 10.4 angegeben. Am Ende dieser Schleife ist i = 4 und Schritt 4 des Algorithmus wird ausgeführt, d. h. der Rest von vec, also die 7, wird nach vec übertragen. i j k vec Abbildung 10.4: Phasen bei Merge. Sei C(m, n) die maximale Anzahl von Schlüsselvergleichen und A(m, n) die maximale Anzahl von Zuweisungen von Komponenten beim Mischen. Vergleiche treten nur in der Schleife 3 auf, und zwar genau einer pro Durchlauf. Da die Schleife maximal m + n 1 mal durchlaufen wird, gilt C(m,n) m + n 1. Zuweisungen treten genau n+m mal auf, da jede Komponente von vec einen Wert bekommt. Also ist A(m,n) = m + n. Wir geben nun eine Java Methode für dieses Verfahren an, und zwar in der (später benötigten) Version, dass zwei benachbarte, bereits sortierte Teilbereiche eines Arrays vec gemischt werden und dann in demselben Bereich von vec aufsteigend sortiert gemischt stehen. Wir verlangen also folgendes Input/Output Verhalten: Input: vec left middle right mit den sortierten Bereichen vec[left]...vec[middle] und vec[middle+1]...vec[right]. Output: vec left right mit dem aufsteigend sortierten Bereich vec[left]...vec[right]. Dazu werden zunächst die beiden sortierten Bereiche auf lokale Arrays vec1 und vec kopiert, die dann in den entsprechenden Bereich von vec zurückgemischt werden.

11 58 KAPITEL 10. SORTIEREN IN ARRAYS Programm 10.1 merge /** * merges two sorted adjacent ranges of an array vec the array in which this happens left start of the first range middle end of the first range right end of the second range */ private static void merge(item[] vec, int left, int middle, int right) { int i, j; int m = middle - left + 1; // length of first array region int n = right - middle; // length of second array region // make copies of array regions to be merged // (only the references to the items) Item[] copy1 = new Item[m]; Item[] copy = new Item[n]; for (i = 0; i < m; i++) copy1[i] = vec[left + i]; for (j = 0; j < n; j++) copy[j] = vec[middle j]; i = 0; j = 0; // merge copy1 and copy into vec[left...right] while (i < m && j < n) { if (copy1[i].key < copy[j].key) { vec[left+i+j] = copy1[i]; i++; else { vec[left+i+j] = copy[j]; j++; //endif //endwhile if (j == n) { // second array region is completely handled, // so copy rest of first region while (i < m) { vec[left+i+j] = copy1[i]; i++; // if (i == m) do nothing, // rest of second region is already in place

12 10.. MERGESORT Sortieren durch rekursives Mischen: Mergesort Mit dieser Methode merge() ergibt sich dann sehr einfach folgende rekursive Variante von Mergesort. Programm 10. mergesort /** * Sorts with mergesort algorithm vec the array to be sorted NullPointerException if <code>vec</code> * is not initialized */ public static void mergesort(item vec[]) throws NullPointerException { if (vec == null) throw new NullPointerException(); mergesort(vec, 0, vec.length - 1); /** * sorts array by mergesort in a certain range <code>vec</code> the array in which this happens <code>first</code> start of the range <code>last</code> end of the range */ private static void mergesort(item[] vec, int first, int last) { if (first == last) return; // devide vec into equal parts int middle = (first + last) / ; mergesort(vec, first, middle); // sort the first part mergesort(vec, middle+1, last); // sort the second part merge(vec, first, middle, last); // merge the sorted parts Die public Methode mergesort(item[]) bekommt nur das Array übergeben und ruft die private Methode mergesort(item[], int, int) in den Grenzen 0 und vec.length-1 des Arrays vec auf. Die Korrektheit von mergesort(item[], int, int) ergibt sich sofort durch vollständige Induktion nach der Anzahl n = last - first + 1 der zu sortierenden Komponenten. Ist n = 1, also last=first (Induktionsanfang), so wird im Rumpf von mergesort() nichts gemacht und das Array vec ist nach Abarbeitung von mergesort() trivialerweise im Bereich first...last sortiert. Ist n > 1, so sind first...middle und middle+1...last Bereiche mit weniger als n Elementen, die also nach Induktionsvoraussetzung durch die Aufrufe mergesort(vec, first, middle) und

13 60 KAPITEL 10. SORTIEREN IN ARRAYS mergesort(vec, middle+1, last) korrekt sortiert werden. Die Korrektheit von merge() ergibt dann die Korrektheit von mergesort. Für das Standardbeispiel a ergibt der Aufruf mergesort(a,0,7) dann den in Abbildung 10.5 dargestellten Ablauf. Dabei beschreiben die Einrücktiefe die Aufrufhierarchie (Rekursionsbaum), und die Kästen die bereits sortierten Teile des Arrays. mergesort(a,0,7) mergesort(a,0,3) mergesort(a,0,1) mergesort(a,0,0) mergesort(a,1,1) merge(a,0,0,1) mergesort(a,,3) mergesort(a,,) mergesort(a,3,3) merge(a,,,3) merge(a,0,1,3) mergesort(a,4,7) mergesort(a,4,5) mergesort(a,4,4) mergesort(a,5,5) merge(a,4,4,5) mergesort(a,6,7) mergesort(a,6,6) mergesort(a,7,7) merge(a,6,6,7) merge(a,4,5,7) merge(a,0,3,7) Abbildung 10.5: Die Rekursion bei mergesort() Die Analyse von Mergesort Wir ermitteln nun den Worst Case Aufwand C(n) für die Anzahl der Vergleiche und A(n) für die Anzahl der Zuweisungen von mergesort() beim Sortieren eines Arrays mit n Komponenten.

14 10.. MERGESORT 61 Aus dem rekursiven Aufbau des Algorithmus ergeben sich sofort die folgenden Rekursionsgleichungen für C(n). C() = 1 C(n) = C(n) +C(n,n) für n > 1 In Worten: Das Sortieren eines -elementigen Arrays erfordert einen Vergleich. Das Sortieren eines Arrays der Länge n erfordert den Aufwand für das Sortieren von Arrays der Länge n (rekursive Aufrufe von mergesort() für die beiden Teile), also C(n), plus den Aufwand C(n,n) für das Mischen (Aufruf von merge()). Da C(n,n) = n 1, ist also C() = 1 C(n) = C(n) + n 1 für n > 1. (10.4) Um diese Rekursionsgleichung zu lösen, betrachten wir zunächst den Fall, dass n eine Zweierpotenz ist, etwa n = q. Dann ist n genau q mal durch ohne Rest teilbar und wir erhalten durch mehrfache Anwendung der Rekursionsgleichung C(n) = C( n ) + n 1 Wegen n = q und C() = 1 folgt hieraus = C( n ) + n 1 1 mal angewendet ( = C( n 4 ) + n ) n 1 = 4 C( n ) + n 3 mal angewendet ( 4 = 4 C( n 8 ) + n ) n 3 = 8 C( n ) + 3n 7 3 mal angewendet 8... (insgesamt q 1 mal anwenden) = q 1 C() + (q 1)n ( q 1 1) C( q ) = (q 1) q + 1. Wir verifizieren diese eher intuitive Vorgehensweise durch einen formalen Beweis mit vollständiger Induktion. Lemma 10.1 Ist n = q, so hat die Rekursionsgleichung 10.4 die Lösung C( q ) = (q 1) q + 1. Beweis: Der Beweis erfolgt durch vollständige Induktion nach q. Ist q = 1, so ist C( 1 ) = 1 und (q 1) q + 1 = 1 (Induktionsanfang). Also sei die Behauptung richtig für r mit 1 r q. Wir Eine Alternative ist die Verifikation durch Einsetzen der vermuteten Formel C( q ) = (q 1) q +1 in die Rekursionsgleichung und Nachrechnen der Gleichung. Dies führt auf die gleichen Beweisschritte.

15 6 KAPITEL 10. SORTIEREN IN ARRAYS schließen jetzt auf q + 1: C( q+1 ) = C( q ) + q 1 Rekursionsgleichung = [(q 1) q + 1] + q 1 Induktionsvoraussetzung = (q 1) q q q+1 1 = q q+1 + 1, was zu zeigen war. Bezüglich der Anzahl A(n) der Zuweisungen von Arraykomponenten ergibt sich ganz analog: A(n) = A(n) + Zuweisungen in merge() In merge() werden zunächst die Teile von vec nach vec1 und vec kopiert. Dies erfordert n Zuweisungen. Für das Mergen sind dann wieder A(n, n) = n Zuweisungen erforderlich. Also ergibt sich folgende Rekursionsgleichung: Der gleiche Lösungsansatz liefert für n = q A() = 4 A(n) = A(n) + 4 n für n > 1 (10.5) A(n) = q q. Wir betrachten nun den Fall, dass n keine Zweierpotenz ist. Dann unterscheiden sich die jeweiligen Teilarrays um maximal 1, vgl. Abbildung Abbildung 10.6: Rekursionsbaum von mergesort() für n = 6. Dies führt dazu, dass im zugehörigen Rekursionsbaum nicht alle Zweige bis auf die unterste Ebene reichen. Vervollständigt man (gedanklich) den Rekursionsbaum bis auf die unterste Ebene, so würde

16 10.3. BESCHLEUNIGUNG DURCH AUFTEILUNG: DIVIDE AND CONQUER 63 dies dem Rekursionsbaum für ein Array der Länge n entsprechen, wobei n die nächstgrößere Zweierpotenz nach n ist, also n = min{ r r n, r = 1,,... Sei q dieses Minimum. Dann ist q 1 < n q = n, also n = q 1 < n sowie q 1 < logn q. Also ist (wegen der Vervollständigung): Entsprechend folgt Wir erhalten also C(n) C(n ) = C( q ) = (q 1) q + 1 < (logn) n + 1 < (logn) n + 1 = nlogn + 1 = O(nlogn). A(n) A(n ) = A( q ) = (q + 1) q < (logn + )n < (logn + )n = nlogn + 4n = O(nlogn). Satz 10.3 mergesort() sortiert ein Array mit n Komponenten mit O(n log n) Vergleichen und Zuweisungen. Betrachten wir zum Abschluss noch den Rekursionsaufwand und die Rekursionstiefe. Für n = q ist die Rekursionstiefe gerade q = log n, für beliebige n ergibt sich aus der soeben durchgeführten Vervollständigungsüberlegung logn < log(n) = logn + 1 als Schranke für die Rekursionstiefe. Die Anzahl der rekursiven Aufrufe ergibt sich als Summe entlang der Schichten des Rekursionsbaums zu q i = q+1 1 = n 1 < 4n 1 = O(n). i=0 Rekursionsaufwand und Rekursionstiefe halten sich also in vernünftigen Grenzen Beschleunigung durch Aufteilung: Divide and Conquer Mergesort ist ein typisches Beispiel für die sogenannte Beschleunigung durch Aufteilung. Dieses Prinzip tritt oft bei der Konzeption von Algorithmen auf. Daher hat man Interesse an einer allgemeinen Aussage über die Laufzeit in solchen Situationen Aufteilungs-Beschleunigungs-Sätze Gegeben ist ein Problem der Größe a n mit der Laufzeit f (a n). Dieses zerlegt man in b Teilprobleme der Größe n mit Laufzeit f (n) pro Teilproblem, also b f (n) für alle Teilprobleme zusammen. Ist die

17 64 KAPITEL 10. SORTIEREN IN ARRAYS Laufzeit für das Aufteilen und das Zusammenfügen der Teillösungen durch c n beschränkt, so ergibt sich die folgende Rekursionsgleichung und der Satz 10.4 (Aufteilungs-Beschleunigungs-Satz) Seien a > 0, b, c natürliche Zahlen und sei folgende Rekursionsgleichung gegeben: f (1) c a f (a n) b f (n) + c n für n > 1 Dann gilt: f (n) O(n) O(n log n) O(n log a b ), falls a > b, falls a = b, falls a < b Beweis:: Für n = a q gilt f (n) c a n q i=0 ( ) b i a Dies zeigt man durch Induktion über q. Für q = 0 ist die Summe 1 und daher f (1) c a. Die Behauptung sei nun für q gezeigt. Dann ergibt sich im Induktionsschluss auf q + 1: f (a q+1 ) = f (a a q ) b f (a q ) + c a q (Rekursionsformel) = b c q ( ) b i a aq + c a q (Induktionsvoraussetzung) i=0 a = c b q ( ) b i a aq+1 a + c i=0 a a aq+1 = c q ( ) b i+1 a aq+1 + c i=0 a a aq+1 ( = c q+1 ( ) b i a aq+1 + 1) i=1 a = c ( ) b i a aq+1q+1. i=0 a Also ist f (n) c a n log a n i=0 ( ) b i. a Wir betrachten jetzt 3 Fälle:

18 10.3. BESCHLEUNIGUNG DURCH AUFTEILUNG: DIVIDE AND CONQUER a > b: Dann ist b a < 1 und daher log a n i=0 ( ) b i < a i=0 ( ) b i = a a a b, da die geometrische Reihe i=0 ( b a) i wegen b a < 1 gegen k 1 := 1 1 b a f (n) < c k 1 n f (n) O(n). a. a = b: Dann ist f (n) c log a n a n 1 = c i=0 a n(log a n + 1) = c a nlog a n + c a n. Für n a ist log a n 1 und daher 3. a < b: Dann ist f (n) c a nlog a n + c a nlog a n = c a nlog a n = ( c a log a ) nlog n O(nlog n). f (n) c log a n( ) b i a n i=0 a = c q ( ) b i a aq da n = a q a i=0 q = c a i=0b i a q i = c b q i a i a i=0 = c q a ) i c a ) i a bq < i=0( b a bq. i=0( b ( a ) i i=0 b ist wie in Fall 1 eine geometrische Reihe mit Wert k = b b a. Also ist f (n) < ck a bq = ck a blog a n = c k a nlog a b O(n log ab ). Hier wurde ausgenutzt, dass b log a n = (a log a b ) log a n = (a log a n ) log a b = n log a b. q = a a b konvergiert. Also ist Die Verallgemeinerung von n = a q auf beliebige n folgt analog zu der Verallgemeinerung auf beliebige n bei Mergesort. Offenbar ist der Fall gerade der auf Mergesort zutreffende Fall. Der Aufteilungs-Beschleunigungssatz wurde hier nur in einer speziellen Form bewiesen, um den Beweis einfacher zu halten. Wir geben nachstehend eine allgemeinere Version an und verweisen für den Beweis auf [CLRS01].

19 66 KAPITEL 10. SORTIEREN IN ARRAYS Satz 10.5 (Aufteilungs-Beschleunigungs-Satz, Allgemeine Version) Seien a > 0 und b > 0 natürliche Zahlen und sei die folgende Rekursionsgleichung gegeben: f (a n) = b f (n) + g(n). Dann hat f (n) folgendes asymptotisches Wachstum: 1. Ist g(n) = O(n log a b ε ) für eine Konstante ε > 0, so ist f (n) = Θ(n log a b ).. Ist g(n) = Θ(n log a b ), so ist f (n) = Θ(n log a b logn) 3. Ist g(n) = Ω(n log a b+ε ) für eine Konstante ε > 0, und ist b g( n a ) c g(n) für eine Konstante c < 1 und alle n n 0 (c,n 0 geeignet gewählt), so ist f (n) = Θ(g(n)). Die Unterscheidung erfolgt hier also nach dem Wachstum von g(n) im Verhältnis zu n log a b. Ist g(n) deutlich kleiner als n log a b (Fall 1), so bestimmt n log a b das Wachstum von f (n). Hat g(n) dasselbe Wachstum wie n log a b (Fall ), so kommt im Wachstum von f (n) ein logn Faktor dazu. Ist schließlich g(n) deutlich größer als n log a b und gilt die zusätzliche Regularitätsbedingung aus 3., so bestimmt g(n) allein die Größenordnung von f (n). Deutlich kleiner bzw. deutlich größer bedeutet dabei jeweils mindestens um einen polynomialen Faktor n ε. Beispiel f (3n) = 9 f (n) + n Hier ergibt sich aus der einfachen Version des Satzes (Fall 3) f (n) = O(n log 3 9 ) = O(n ). In der allgemeinen Version trifft Fall 1 zu, da g(n) O(n log a b 1 ) (also ε = 1), und man erhält f (n) = Θ(n log a b ) = Θ(n ).. f ( 3 n) = f (n) + 1 Hier ist g(n) = 1 und n log 3/ 1 = n 0 = 1. Also trifft Fall der allgemeinen Version zu, und man erhält f (n) = Θ(logn). 3. f (4n) = 3 f (n) + nlogn Hier ist g(n) = nlogn und n log a b = n log 4 3 = O(n 0,793 ). Also ist g(n) = Ω(n log a b+ε ) mit ε = 0,. Es würde also Fall 3. zutreffen, falls wir die Regularitätsbedingung für g(n) zeigen können. Es ist b f ( n a ) = 3 ( ( n 4) log n ) 4 < 3 4 nlogn, so dass die Regularitätsbedingung mit c = 3 4 gilt. Also folgt f (n) = Θ(nlogn). 4. f (n) = f (n) + nlogn Diese Rekursionsgleichung fällt nicht unter das allgemeine Schema, da g(n) = n log n zwar asymptotisch größer als n log a b = n ist, aber nicht um einen Faktor n ε. Dieser Fall fällt also in die Lücke zwischen Fall. und 3.

20 10.3. BESCHLEUNIGUNG DURCH AUFTEILUNG: DIVIDE AND CONQUER Multiplikation von Dualzahlen Als weitere Anwendung betrachten wir die Multiplikation von zwei n-stelligen Dualzahlen. Die traditionelle Methode erfordert Θ(n ) Bit Operationen. Durch Aufteilung und Beschleunigung erreicht man O(n log3 ) = O(n 1,59 ) Operationen. Dies ist nützlich bei der Implementation der Multiplikation beliebig langer Dualzahlen, z. B. in Programmpaketen, die mit den Standard long oder int Zahlen nicht auskommen. Seien x,y zwei n-stellige Dualzahlen, wobei n eine Zweierpotenz sei. Wir teilen x,y in zwei n -stellige Zahlen wie folgt: x = a b y = c d Dann ist xy = (a n + b)(c n + d) = ac n + (ad + bc) n + bd. Man hat die Multiplikation also auf 4 Multiplikationen von n -stelligen Zahlen und einige Additionen und Shifts (Multiplikationen mit n bzw. n ), die nur linearen Aufwand erfordern) zurückgeführt. Dies führt zur Rekursionsgleichung T (n) = 4 T ( n ) + c 0 n, mit der Lösung T (n) = Θ(n ), also ohne Gewinn gegenüber der traditionellen Methode. Die Anweisungen u := (a + b)(c + d) v := ac w := bd z := v n + (u v w) n + w führen jedoch zur Berechnung von z = xy mit 3 Multiplikation von Zahlen der Länge n bzw. n +1, da bei a + b bzw. c + d ein Übertrag auf die ( n + 1) -te Position entstehen könnte. Ignorieren wir diesen Übertrag, so erhält man ( n T (n) = 3T + c 1 n ) mit der gewünschten Lösung T (n) = Θ(n log 3 ). Um den Übertrag zu berücksichtigen, schreiben wir a + b und c + d in der Form a + b = α ā c + d = γ c

21 68 KAPITEL 10. SORTIEREN IN ARRAYS also a + b = α n + ā, c + d = γ n + c mit den führenden Bits α,γ und den n -stelligen Resten ā, c. Dann ist (a + b)(c + d) = αγ n + (αā + γ c) n + ā c. Hierin tritt nur ein Produkt von n -stelligen Zahlen auf (nämlich ā c). Der Rest sind Shifts bzw. lineare Operationen auf n -stelligen Zahlen (z. B. αā). Daher erhält man insgesamt die Rekursionsgleichung ( n T (n) = 3T + c n, ) wobei c n folgenden Aufwand enthält: Additionen a + b, c + d : n Produkt αγ : 1 Shift von αγ auf αγ n : n Produkte αā,γ c: n n Addition αā + γ c: + 1 Shift von αā,γ c um n Stellen: n Shift von v auf v n : n Addition u v w: ( n + 1) Shift von u v w um n Stellen: n Addition zu z: n Dieser Aufwand addiert sich zu 8,5 n + 9n für n. Also kann c als 9 angenommen werden. Als Lösung erhält man nach dem Aufteilung-Beschleunigungs-Satz T (n) = Θ(n log3 ) = Θ(n 1,59 ). Der Trick bestand also darin, auf Kosten zusätzlicher Additionen und Shifts, eine teure Multiplikation von n -stelligen Zahlen einzusparen. Die rekursive Anwendung dieses Tricks ergibt dann die Beschleunigung von Θ(n ) auf Θ(n 1,59 ). Für die normale Computerarithmetik (n = 3) zahlt sich dieser Trick nicht aus, jedoch bedeutet er für Computerarithmetiken mit beliebigstelligen Dualzahlen, die meist softwaremäßig realisiert werden, eine wichtige Beschleunigung. Das Verfahren lässt sich natürlich auch im Dezimalsystem anwenden. Wir geben ein Beispiel für n = 4: x = 417 y = 536 Dann ist a = 4, b = 17 und a + b = 59; c = 5, d = 36 und c + d = 88.

22 10.4. QUICKSORT 69 Es folgt u = (a + b)(c + d) = = 519 v = ac = 4 5 = 184 w = bd = = 61 xy = v (u v w) 10 + w = = = Auf ähnliche Weise wie die Multiplikation von Zahlen lässt sich auch die Multiplikation (großer) n n Matrizen beschleunigen, vgl. [CLRS01] Hier erhält man die Rekursionsgleichung T (n) = 7 T (n) + 14n mit der Lösung (gemäß Satz 10.5) Θ(n log7 ) = Θ(n,81 ), also eine Beschleunigung gegenüber der normalen Methode mit dem Aufwand Θ(n 3 ). Hier lassen sich noch weitere Beschleunigungen erzielen. Der momentane Rekord steht bei O(n,39 ), vgl. [CW87] Quicksort Quicksort basiert (im Gegensatz zu Mergesort) auf variabler Aufteilung des Eingabearrays. Es wurde 196 von Hoare entwickelt. Es benötigt zwar im Worst Case Ω(n ) Vergleiche, im Mittel jedoch nur O(n log n) Vergleiche, und ist aufgrund empirischer Vergleiche allen anderen O(n log n) Sortierverfahren überlegen Der Algorithmus Wir geben zunächst eine Grobbeschreibung von Quicksort an. 1. Gegeben ist vec[] mit n Komponenten.. Wähle eine beliebige Komponente vec[pivot]. 3. Zerlege das Array vec in zwei Teilbereiche vec[0]...vec[k-1] und vec[k+1]...vec[n-1] mit a) vec[i].key vec[pivot].key für i = 0,...,k 1 b) vec[k].key = vec[pivot].key c) vec[j].key > vec[pivot].key für j = k + 1,...,n Sofern ein Teilbereich aus mehr als einer Komponente besteht, so wende Quicksort rekursiv auf ihn an.

23 70 KAPITEL 10. SORTIEREN IN ARRAYS Die Korrektheit des Algorithmus folgt leicht durch vollständige Induktion. Die Aufteilung erzeugt Arrays kleinerer Länge, die nach Induktionsvoraussetzung durch die Aufrufe von Quicksort in Schritt 4. korrekt sortiert werden. Die Eigenschaften 3a) 3c) ergeben dann die Korrektheit für das gesamte Array. Im Standardbeispiel ergibt sich, falls man stets die mittlere Komponente wählt (gekennzeichnet durch *) die in Abbildung 10.7 dargestellte Folge von Zuständen (jeweils nach der Aufteilung). Die umrahmten Bereiche geben die aufzuteilenden Bereiche an. Input * Aufteilung * * 63. Aufteilung * Aufteilung * Output Abbildung 10.7: Phasen bei Quicksort. Wir betrachten nun die Durchführung der Aufteilung im Detail. Da sie rekursiv auf stets andere Teile des Arrays vec angewendet wird, betrachten wir einen Bereich von lobound bis hibound. Grobbeschreibung der Aufteilung 1. Gegeben ist vec und der Bereich zwischen lobound und hibound.. Wähle eine Komponente vec[pivot]. 3. Tausche vec[pivot] mit vec[lobound]. 4. Setze Indexzeiger loswap auf lobound+1 und hiswap auf hibound. 5. Solange loswap < hiswap wiederhole: 5.1 Inkrementiere ggf. loswap solange, bis vec[loswap].key > vec[lobound].key. 5. Dekrementiere ggf. hiswap solange, bis vec[hiswap].key vec[lobound].key. 5.3 Falls loswap < hiswap, so vertausche vec[loswap] und vec[hiswap], und inkrementiere bzw. dekrementiere loswap und hiswap um jeweils Tausche vec[lobound] und vec[hiswap]. Abbildung 10.8 illustriert diese Aufteilung. l und h geben die jeweilige Position von loswap und hiswap an, das gewählte vec[pivot] Element. Bei jedem Eintritt in die Schleife 5 gilt die Invariante: vec[i].key vec[pivot].key für i = lobound...loswap 1, vec[j].key > vec[pivot].key für j = hiswap hiBound, loswap < hiswap vec[loswap-1].key vec[pivot].key vec[hiswap+1].key. (10.6)

24 10.4. QUICKSORT 71 Input Schritt * Schritt 3 53* Schritt 4 53* 4 l h Am Ende von * l h Am Ende von 5. 53* l h Schritt * l h 63 Am Ende von * l h 63 Am Ende von 5. 53* l h 63 Schritt * lh 7 63 Schritt * 7 63 Abbildung 10.8: Die Aufteilung bei Quicksort im Detail. Beim Austritt gilt zusätzlich loswap hiswap, vec[hiswap].key vec[pivot].key, (10.7) so dass der Tausch in Schritt 6 die Pivot -Komponente genau an die richtige Stelle tauscht. Lemma 10. Enthält der aufzuteilende Bereich m Komponenten, so ist die Anzahl der Vergleiche von Komponenten für die Aufteilung m 1. Beweis: Da loswap und hiswap nach einem Austausch inkrementiert bzw. dekrementiert werden, wird jedes anderen Elemente genau einmal mit dem Pivotelement verglichen. Dies ergibt m 1 Vergleiche. Es folgt eine Java Methode dieses Algorithmus. Programm 10.3 quicksort /** * Sorts with quicksort algorithm vec the array to be sorted NullPointerException if <code>vec</code> * is not initialized */ public static void quicksort(item[] vec) throws NullPointerException { if (vec == null) throw new NullPointerException(); quicksort(vec, 0, vec.length - 1);

25 7 KAPITEL 10. SORTIEREN IN ARRAYS /** * sorts array by quicksort in a certain range vec the array in which this happens lobound start of the range hibound end of the range */ private static void quicksort(item[] vec, int lobound, int hibound) { int loswap, hiswap; int pivotkey, pivotindex; Item temp, pivotitem; if (hibound - lobound == 1) { // Two items to sort if (vec[lobound].key > vec[hibound].key) { temp = vec[lobound]; vec[lobound] = vec[hibound]; vec[hibound] = temp; return; pivotindex = (lobound + hibound) / ; // 3 or more items to sort pivotitem = vec[pivotindex]; vec[pivotindex] = vec[lobound]; vec[lobound] = pivotitem; pivotkey = pivotitem.key; loswap = lobound + 1; hiswap = hibound; do { while (loswap <= hiswap && vec[loswap].key <= pivotkey) // INVARIANT (prior to test): // All vec[lobound+1..loswap-1] // are <= pivot && loswap <= hiswap+1 loswap++; while (vec[hiswap].key > pivotkey) // INVARIANT (prior to test): // All vec[hiswap+1..hibound] // are > pivot && hiswap >= loswap-1 hiswap--; if (loswap < hiswap) { temp = vec[loswap]; vec[loswap] = vec[hiswap]; vec[hiswap] = temp; loswap++; hiswap--;

26 10.4. QUICKSORT 73 // INVARIANT: All vec[lobound..loswap-1] are <= pivot // && All vec[hiswap+1..hibound] are > pivot // && (loswap < hiswap) --> // vec[loswap] <= pivot < vec[hiswap] // && (loswap >= hiswap) --> vec[hiswap] <= pivot // && lobound <= loswap <= hiswap+1 <= hibound+1 while (loswap < hiswap); vec[lobound] = vec[hiswap]; vec[hiswap] = pivotitem; if (lobound < hiswap-1) // or more items in 1st subvec quicksort(vec, lobound, hiswap-1); if (hiswap+1 < hibound) // or more items in nd subvec quicksort(vec, hiswap+1, hibound); Der Rekursionsaufwand von Quicksort Da die Aufteilung (im Unterschied zur Mergesort) variabel ist, hat der Rekursionsbaum bei Quicksort i. a. Teilbäume unterschiedlicher Höhe. Im Standardbeispiel ergibt sich der in Abbildung 10.9 dargestellte Baum. QuickSort(vec,,4) QuickSort(vec,1,4) QuickSort(vec,0,4) QuickSort(vec,0,7) Abbildung 10.9: Rekursionsbaum zu Quicksort. QuickSort(vec,6,7) Man sieht, dass der Baum am tiefsten wird, wenn als Vergleichselement jeweils das kleinste oder größte Element des aufzuteilenden Bereiches gewählt wird. In diesem Fall entartet der Rekursionsbaum zu einer Liste (keine Verzweigungen). Die Rekursionstiefe kann also bis zu n 1 betragen. Wir zeigen durch Induktion, dass auch die Anzahl R(n) der rekursiven Aufrufe bei einem Arraybereich der Länge n höchstens n 1 beträgt. Für n = 1 erfolgt kein Aufruf, also gilt R(1) = 0 (Induktionsanfang). Für n > 1 bewirkt der erste Aufruf eine Aufteilung in Bereiche mit n 1 und n Komponenten, wobei n 1 + n = n 1 gilt, da die

27 74 KAPITEL 10. SORTIEREN IN ARRAYS Vergleichskomponente weg fällt. Also sind n 1,n < n und man erhält R(n) = 1 + R(n 1 ) + R(n ) 1 + (n 1 1) + (n 1) (Induktionsvoraussetzung) = n 1 + n 1 < n 1. Also ist R(n) n Der Worst Case Aufwand von Quicksort Vergleiche von Schlüsseln treten bei Quicksort nur bei den Aufteilungen auf. Dabei muss jeder andere Schlüssel mit dem Vergleichsschlüssel verglichen werden, also erfolgen bei einem Bereich von n Komponenten mindestens (und mit Lemma 10. sogar genau) n 1 Vergleiche. Wird nun jeweils der größte bzw. kleinste Schlüsselwert als Vergleichsschlüssel gewählt, so verkleinert sich der Bereich jeweils nur um ein Element und man erhält: (n 1) + (n ) = Also gilt für die Worst Case Anzahl C(n) von Vergleichen: C(n) = Ω(n ). n(n 1) Vergleiche Der mittlere Aufwand von Quicksort Quicksort ist also im Worst Case schlecht. Erfahrungsgemäß ist Quicksort aber sehr schnell im Vergleich zu anderen Ω(n ) Sortierverfahren wie Bubblesort. Dies liegt daran, dass der Worst Case nur bei wenigen Eingabefolgen auftritt. Man wird daher Quicksort gerechter, wenn man nicht den Worst Case betrachtet, sondern den Aufwand über alle möglichen Eingabefolgen mittelt, also den mittleren Aufwand C(n) bei Gleichverteilung aller n! Reihenfolgen der Schlüssel 1,,..., n betrachtet. Gleichverteilung bedeutet hier, dass jede Reihenfolge (Permutation) der Werte 1,...,n mit dem gleichen Gewicht (nämlich 1) in das Mittel eingeht. 3 Als Vergleichsbeispiel betrachten wir das Würfeln mit einem Würfel mit den Augenzahlen 1,,...,6. Dann ergibt sich die mittlere Augenzahl bei Gleichverteilung zu = 3,5. Die mittlere Schrittlänge beim Mensch-ärgere-dich-nicht beträgt also 3, 5; der Worst Case (bzgl. Weiterkommen) jedoch nur 1. Für n = 3 ergeben sich bei Quicksort 3! = 6 Permutationen, nämlich 13, 13, 13, 31, 31, 31. Die Anzahl der Vergleiche pro Permutation beträgt (gemäß der Implementation in Programm 10.3) 3 In der Terminologie der Wahrscheinlichkeitstheorie sagt man, dass jede Reihenfolge mit der gleichen Wahrscheinlichkeit 1/n! auftritt (daher der Name Gleichverteilung), und man nennt C(n) auch die erwartete Anzahl der Vergleiche.

28 10.4. QUICKSORT 75, 4, 4, 4, 4,. Der mittlere Aufwand beträgt also Worst Case von 4 Vergleichen. 3! = 10 3 Vergleiche gegenüber dem Sei Π die Menge aller Permutationen von 1,...,n. Für π Π sei C(π) die Anzahl von Vergleichen, die Quicksort benötigt, um π zu sortieren. Dann ist C(n) = 1 n! C(π). π Π Wir werden jetzt C(n) nach oben abschätzen. Dafür teilen wir die Menge Π aller Permutationen in die Mengen Π 1,Π,...,Π n, wobei Π k = {π Π das Vergleichselement hat den Wert k. Für n = 3 ergibt sich Π 1 = {13,31, Π = {13,31 und Π 3 = {13,31. In Π k ist das Vergleichselement fest vorgeschrieben, die anderen Komponenten können jedoch in jeder Reihenfolge auftreten. Also ist Π k = (n 1)! für k = 1,...,n. Für alle π Π k ergibt die erste Aufteilung in Quicksort die Teilarrays bestehend aus einer Permutation π 1 von 1,,...,k 1 und einer Permutation π von k + 1,...,n (da ja das Vergleichselement gerade k ist). Z(π) sei die Anzahl der Vergleiche mit der π in die Teile π 1 und π zerlegt wird. Dann ist für alle π Π k C(π) = Z(π) +C(π 1 ) +C(π ). Dabei ist Z(π) n (in der Implementation in Programm 10.3, vgl. Lemma 10.). Summiert über alle π Π k, so ergibt sich wegen Π k = (n 1)!: π Π k C(π) = Hierin ist wegen Lemma 10. [Z(π) +C(π 1 ) +C(π )] = Z(π) + π Π k π Π k {{ =:S 1 S 1 π Π k n = n(n 1)! = n!. π Π k C(π 1 ) {{ =:S + π Π k C(π ) {{ =:S 3 Wenn π alle Permutationen aus Π k durchläuft, entstehen bei π 1 alle Permutationen von 1,...,k 1, und zwar jede (n 1)!/(k 1)! mal, da Π k ja insgesamt (n 1)! Permutationen enthält, und wegen der Arbeitsweise des Aufteilungsalgorithmus (und der Gleichverteilung der Permutationen in Π k jede Permutation von 1,...,k 1 gleich häufig entsteht. Also ist S = (n 1)! (k 1)! C(π 1 ) π 1 Permutation von 1,...,k 1 = (n 1)! C(k 1).

29 76 KAPITEL 10. SORTIEREN IN ARRAYS Entsprechend folgt S 3 = (n 1)! C(n k). Durch Zusammensetzen aller Gleichungen bzw. Ungleichungen ergibt sich C(n) = 1 n! C(π) = 1 n! 1 n! = n! n! π Π n k=1 n k=1 n k=1 n 1 π Π k C(π) = 1 n! n k=1 (S 1 + S + S 3 ) (n! + (n 1)! C(k 1) + (n 1)! C(n k)) 1 + (n 1)! n! = n n k=0c(k) 1 n = n + n n 1 k=0 C(k). n k=1 n 1 k=0 C(k 1) + C(k) (n 1)! n! n k=1 C(n k) Wir haben damit eine Rekursionsgleichung für C(n) gefunden. Beachtet man noch die Anfangswerte C(0) = C(1) = 0, C() = 1 so ist C(n) n + n n 1 k= C(k) für n. Lemma 10.3 Für die Lösung r(n) der Rekursionsgleichung r(n) = n + n n 1 r(k) für n k= mit den Anfangswerten r(0) = r(1) = 0, r() = 1 gilt für alle n r(n) nlnn. 4 Beweis: Der Beweis erfolgt durch vollständige Induktion nach n mit dem Ansatz r(n) nlnn, wobei die Konstante c während des Beweises ermittelt wird. Induktionsanfang: Für n = ist r() = 1. Andererseits ist c ln c 1,39. Also gilt der Induktionsanfang für c 1. Induktionsvoraussetzung: Die Behauptung gelte für, 3,..., n 1. 4 ln = log e n (natürlicher Logarithmus).

30 R(n) = n c n QUICKSORT 77 Schluss auf n: r(n) = n + n 1 n r(k) k= n + n 1 n c k ln k k= (nach Induktionsvoraussetzung) Um diesen Ausdruck weiter nach oben abzuschätzen, betrachten wir die Funktion f (x) = xlnx. Dann ist n 1 k= k lnk gerade der Flächeninhalt der schattierten Fläche unter der Kurve f (x), siehe Abbildung Also gilt: n 1 k lnk k= n = x = n xlnx dx lnx n n n x dx (partielle Integration) lnn ln [n 4 1] lnn n 4 66 KAPITEL 10. SORTIEREN IN ARRAYS f(x) = x ln x n 1 n x Abbildung Abbildung 10.10: 10.10: Verlauf Verlaufvon vonf(x) f = x ln x. x. = c n ln n + n c 4 n {{ =:R(n) c n ln n falls R(n) 0. Nun ist

31 78 KAPITEL 10. SORTIEREN IN ARRAYS Hieraus folgt Nun ist r(n) n + n n + c n n 1 c k lnk = n + c k= n ( ) n n lnn 4 = n + c c nlnn 4 n = c nlnn + n c n {{ =:R(n) c nlnn falls R(n) 0. R(n) = n c n 0 für c. n 1 k lnk k= Aus dem Lemma folgt: Satz 10.6 Für die mittlere Anzahl C(n) der Vergleiche zum Sortieren eines n-elementigen Arrays mit Quicksort gilt C(n) O(nlogn). Beweis: Aus C(n) r(n) und Lemma 10.3 folgt für alle n. C(n) nlnn = n logn loge = loge nlogn Also ist C(n) O(nlogn) mit der O-Konstanten loge 1,386. Entsprechend kann man für die mittlere Anzahl A(n) von Zuweisungen beweisen (Übung) A(n) = O(nlogn). Quicksort arbeitet also im Mittel beweisbar sehr schnell, und dies wird auch in allen Laufzeituntersuchungen bestätigt. Quicksort ist der Sortieralgorithmus, den man verwenden sollte.

32 10.5. HEAPSORT Heapsort Heapsort basiert im Gegensatz zu Mergesort und Quicksort nicht auf dem Prinzip der Aufteilung, sondern nutzt eine spezielle Datenstruktur (den Heap), mit der wiederholt auf das größte Element eines Arrays zugegriffen wird. Es ähnelt damit eher einem verbesserten Selection Sort Die Grobstruktur von Heapsort Ein Heap (auch Priority Queue genannt) ist eine abstrakte Datenstruktur mit folgenden Kennzeichen: Wertebereich: Eine Menge von Werten des (homogenen) Komponententyps. Alle Komponenten besitzen einen Wert (Schlüssel). Operationen: 1. Einfügen einer Komponente.. Zugriff auf die Komponente mit dem größten Wert. 3. Entfernen der Komponente mit dem größten Wert. 4. Änderung des Wertes einer Komponente. Statt des größten Wertes wird auch oft der kleinste Wert in. und 3. genommen. Bei der Anwendung in Heapsort sind die Komponenten von vec die Elemente des Heaps, und die Schlüssel vec[i].key sind die Werte. Dann arbeitet Heapsort nach folgender Idee: Grobstruktur von Heapsort 1. Gegeben sei das Array vec[] mit n Komponenten.. Initialisiere den Heap mit den Komponenten von vec. 3. for i := n 1 downto 0 do 3.1 Greife auf das größte Element des Heaps zu. 3. Weise diesen Wert der Arraykomponente vec[i] zu. 3.3 Entferne das größte Element aus dem Heap. Die Korrektheit des Algorithmus ist offensichtlich, und auch die Ähnlichkeit zu Selection Sort. Um zu einem schnellen Algorithmus zu kommen, muss man den Heap so implementieren, dass die benötigten Operationen schnell ausgeführt werden können. In Heapsort sind dies die Operationen (in Schritt 3.1) und 3 (in Schritt 3.3), die jeweils n mal nacheinander ausgeführt werden. Hinzu kommt das Initialisieren des Heaps in Schritt. Wir brauchen offenbar nicht alle Heapoperationen (4 wird nicht benötigt) und die anderen Operationen nur in bestimmter Reihenfolge (Einfügen nur bei der Initialisierung, Zugriff und Entfernen

33 80 KAPITEL 10. SORTIEREN IN ARRAYS stets nacheinander). Daher werden wir keinen allgemeinen Heap verwenden (vgl. dazu [CLRS01]), sondern die benötigten Heapoperationen direkt im Array vec implementieren, und zwar so, dass gilt: Worst Case-Aufwand der hier gewählten Heap Implementation Initialisierung in O(n). Zugriff auf das größte Element in O(1). Entfernen des größten Elements in O(logn). Dabei werden sowohl Vergleiche als auch Zuweisungen von Arraykomponenten berücksichtigt. Hieraus folgt sofort: Satz 10.7 Der Worst Case Aufwand zum Sortieren eines n-elementigen Arrays mit Heapsort beträgt O(nlogn) Die Implementation des Heaps Die Grundidee besteht darin, sich das Array vec als binären Baum vorzustellen, wobei die Komponenten der Reihe nach in die Schichten 0,1,... von links nach rechts angeordnet werden. Für das Standardbeispiel vec = ergibt sich so der in Abbildung dargestellte Baum Abbildung 10.11: Array als Heap. Für einen Knoten v in einem binären Baum bezeichnet man die von v aus über eine gerichtete Kante erreichbaren Knoten als Söhne und nennt v den Vater dieser Söhne. Bei Söhnen unterscheidet man (bzgl. einer gegebenen Darstellung) zwischen linkem und rechtem Sohn. Mit diesen Bezeichnungen gelten für den Baum zu einem Heap folgende Eigenschaften:

34 10.5. HEAPSORT 81 Lemma 10.4 a) vec[0] ist die Wurzel des Baumes. b) Der linke Sohn von vec[i] (falls vorhanden) ist vec[i+1]. c) Der rechte Sohn von vec[i] (falls vorhanden) ist vec[i+]. d) Nur Knoten vec[i] mit i n haben Söhne. Beweis: Übung. Wir sagen, dass vec die Heapeigenschaft (heap ordering) erfüllt, wenn für i = 0,...,n 1 gilt: vec[i].key vec[i+1].key falls i + 1 < n vec[i].key vec[i+].key falls i + < n Für jeden Knoten vec[i] mit einem oder zwei Söhnen ist also der key-wert der Söhne nicht größer als der des Vaters. Hieraus ergibt sich direkt: Lemma 10.5 Erfüllt vec die Heapeigenschaft, so gilt: a) vec[0].key ist der größte auftretende Schlüsselwert. b) Entlang jeden Weges von einem Blatt zu der Wurzel sind die Schlüsselwerte aufsteigend sortiert. Erfüllt vec die Heapeigenschaft, so kann also auf die größte Komponente vec[0] in O(1) Zeit zugegriffen werden. Wenn wir sie entfernen, so haben beide Teilbäume noch die Heapeigenschaft. Wenn wir dann ein neues Element an die Wurzel stellen (einfügen), so müssen wir die Heapeigenschaft wieder herstellen. Dazu verwenden wir die Funktion heapify(). Sie setzt voraus, dass die Heapeigenschaft bereits im Bereich vec[top+1]...vec[bottom] gilt, fügt vec[top] hinzu und ordnet die Komponenten so um, dass hinterher die Heapordnung im Bereich vec[top]...vec[bottom] gilt. Dazu werden folgende Schritte ausgeführt: 1. Ermittle den größeren der beiden Söhne (child) von top (falls keine Söhne existieren, so ist die Heapeigenschaft trivialerweise erfüllt, falls nur ein Sohn existiert, so nehme diesen).. Vergleiche vec[child] mit vec[top]. Falls vec[child].key > vec[top].key so tausche vec[top] und vec[child]. 3. Wende heapify() rekursiv auf child an.