QuickSort ist ein Sortieralgorithmus, der auf der Idee des Teile & Beherrsche beruht, und das gegebene Array an Ort und Stelle (in place) sortiert

Transkript

1 4.3.6 QuickSort QuickSort ist ein Sortieralgorithmus, der auf der Idee des Teile & Beherrsche beruht, und das gegebene Array an Ort und Stelle (in place) sortiert QuickSort teilt das gegebene Array anhand eines Werts darin, dem sogenannten Pivot, in zwei Teile auf, so dass alle Werte im linken Teil kleiner gleich und alle Werte im rechten Teil größer als der Pivot sind und ruft sich dann rekursiv auf den beiden Teilen auf 94

2 Vertauschen von zwei Werten in einem Array Wir führen eine Hilfsfunktion ein, um in einem gegebenen Array a die Werte an den Indizes i und j zu vertauschen 1 void swap(int[] a, int i, int j) { 2 int t = a[i]; 3 a[i] = a[j]; 4 a[j] = t; 5 } 95

3 Partitionieren eines Arrays anhand eines Pivots Gegeben ein Array a und einen Wert a[p] darin, dem Pivot, wie können wir das Array so umstellen, dass alle Werte, die kleiner gleich als der Pivot sind links davon und alle größeren Werte rechts vom Pivot stehen? a Pivot a Die Reihenfolge der Werte in den Teilen links und rechts vom Pivot soll hierbei keine Rolle spielen 96

4 Partitionieren eines Arrays anhand eines Pivots Eine elegante Methode, um ein gegebenes Array anhand eines Pivots zu partitionieren. d.h. aufzuteilen, funktioniert wie folgt stelle den Pivot ans Ende des Arrays durchlaufe die Werte im Array und zähle wie viele Werte kleiner gleich dem Pivot bereits beobachtet wurden wird ein Wert kleiner gleich dem Pivot beobachtet, stellt man ihn hinter die bisher beobachteten Werte, die kleiner gleich als der Pivot sind stelle den Pivot hinter die Werte, die kleiner gleich sind als er 97

5 Partitionieren eines Arrays anhand eines Pivots 1 int partition(int[] a, int l, int r, int p) { 2 int pn = l; 3 int pv = a[p]; 4 5 // Stelle Pivot ans Ende 6 swap(a, p, r); 7 8 // Stelle Werte kleiner als Pivot nach rechts 9 for ( int i = l; i < r; i++) { 10 if (a[i] <= pv) { 11 swap(a, pn, i); 12 pn++; 13 } 14 } // Stelle Pivot an richtige Stelle 17 swap(a, r, pn); return pn; 20 } 98

6 Partitionieren eines Arrays anhand eines Pivots Beispiel: Partitionieren des folgenden Arrays mittels des Aufrufs partition(a, 0, 6, 5) a Pivot a pn = 0 Pivot ans Ende a pn = 1 a pn = 1 a pn = 1 a pn = 2 99

7 Partitionieren eines Arrays anhand eines Pivots Beispiel: Partitionieren des folgenden Arrays mittels des Aufrufs partition(a, 0, 6, 5) a pn = 2 Pivot a pn = 3 a pn = 3 Pivot hinter Werte, die kleiner gleich sind Das Partitionieren eines gegebenen Arrays der Länge n erfolgt in linearer Laufzeit O(n) 100

8 QuickSort QuickSort sortiert einen gegebenen Teilbereich a[l]... a[r] eines gegebenen Arrays a, indem es den letzten Wert a[r] als Pivot verwendet, den Teilbereich partitioniert und sich auf beiden Teilen aufruft Ist der betrachtete Teilbereich leer (d.h. l > r), so gibt es nichts zu tun 101

9 QuickSort Wir verwenden folgende Funktion zum Sortieren eines gegebenen Teilbereichs a[l]... a[r] 1 int[] qsort(int[] a, int l, int r) { 2 if (r > l) { 3 int p = r; 4 int pn = partition(a, l, r, p); 5 qsort(a, l, pn - 1); 6 qsort(a, pn + 1, r); 7 } 8 return a; 9 } Das gesamte Array können wir dann wie folgt sortieren 1 int[] quicksort(int[] a) { 2 return qsort(a, 0, a.length - 1); 3 } 102

10 QuickSort Beispiel: Sortieren des folgenden Arrays a a a Pivot Wert an richtiger Stelle a a a

11 Laufzeit von QuickSort Der schlechteste Fall, bei Wahl des Pivot als letzter Wert im zu sortierenden Bereich, tritt bei QuickSort dann ein, wenn wir es auf ein bereits sortiertes Array anwenden Beispiel: a Der rechte Teilbereich ist in diesem Fall immer leer und der linke Teilbereich wird in jedem Schritt um einen Wert verkleinert 104

12 Laufzeit von QuickSort Damit wird zuerst ein Teilbereich der Größe n partitioniert Dann ein Teilbereich der Größe (n - 1) Letztlich ein Teilbereich der Größe 1 Das Partitionieren jedes Teilbereichs erfordert lineare Laufzeit, so dass insgesamt 3 1 c 2 n n Befehle ausgeführt werden und die Laufzeit in O(n 2 ) liegt 105

13 Laufzeit von QuickSort Im schlechtesten Fall hat QuickSort damit quadratische Laufzeit wie die einfachen Sortierverfahren Ungünstig ist es für QuickSort, wenn sich die beiden Teilbereiche stark in ihrer Größe unterscheiden Günstig ist es für QuickSort, wenn die beiden Teilbereiche nahezu die gleiche Größe besitzen 106

14 Laufzeit von QuickSort Wüssten wir, dass die beiden Teilbereiche eines Arrays der Größe n nach Partitionierung jeweils Größe n/2 besitzen, so ließe sich die Laufzeit wiederum mittels folgender Rekurrenz beschreiben n n T (n) =T + T + n 2 2 Wir wissen bereits (vgl. Laufzeit von MergeSort), dass die Laufzeit dann in O(n log n) wäre 107

15 Laufzeit von QuickSort Nehmen wir an, dass die Werte im gegebenen Array in einer zufälligen Reihenfolge stehen (d.h. alle ihre Permutationen gleich wahrscheinlich sind), so können wir bestimmen wie groß die beiden Teilbereiche im Mittel sind, d.h. den Erwartungswert ihrer Größe bestimmen 108

16 Laufzeit von QuickSort Beispiel: Betrachte Arrays mit den Werten {1, 4, 7} Links: 2 / Rechts: 0 Pivot Links: 1 / Rechts: Links: 2 / Rechts: Links: 0 / Rechts: Links: 1 / Rechts: 1 Links: 0 / Rechts: 2 Mittelwert Links: 1 / Mittelwert Rechts: 1 109

17 Laufzeit von QuickSort Man kann zeigen, dass bei zufälliger Reihenfolge der Werte im Array, die erwartete Größe der beiden Teilbereiche n/2 beträgt Im mittleren Fall (average case), d.h. über alle möglichen Eingaben, verhält sich QuickSort ähnlich zu MergeSort und man sagt, dass es erwartete Laufzeit in O(n log n) 110

18 Robuste Implementierung von QuickSort Um dieses günstige Verhalten sicherzustellen, wählen viele Implementierungen den Pivot zufällig 1 int[] qsort(int[] a, int l, int r) { 2 if (r > l) { 3 int p = random(l, r); // Zufallszahl in {l,...,r} 4 int pn = partition(a, l, r, p); 5 qsort(a, l, pn - 1); 6 qsort(a, pn + 1, r); 7 } 8 return a; 9 } QuickSort ist ein sehr robustes, in der Praxis weit verbreitetes Sortierverfahren, das z.b. in Java in den Methoden java.util.array.sort() zum Einsatz kommt 111

19 4.3.7 CountingSort CountingSort ist ein Sortierverfahren, welches nicht auf Vergleichen von Werten beruht, sondern zählt wie oft jeder Wert im gegebenen Array vorkommt Kommen im gegebenen Array nur wenige verschiedene Werte jedoch wiederholt vor, so kann CountingSort mit besserer Laufzeit sortieren als vergleichende Sortierverfahren 112

20 CountingSort Wir beschreiben CountingSort für den Spezialfall, dass ein Array bestehend aus natürlichen Zahlen {0, 1, } zu sortieren ist CountingSort lässt sich mit Hilfe einer geeigneten Datenstruktur (z.b. Hashtabelle) für beliebige Datentypen und Werte implementieren 113

21 CountingSort 1 int[] countingsort(int[] a) { 2 // Maximum bestimmen 3 int max = -1; 4 for ( int i = 0; i < a.length; i++) { 5 if (max < a[i]) { 6 max = a[i]; 7 } 8 } 9 10 // Werte zä hlen 11 int[] counts = new int[max + 1]; 12 for ( int i = 0; i < a.length; i++) { 13 counts[a[i]]++; 14 } // Sortiertes Array erzeugen 17 int i = 0; 18 for ( int j = 0; j < counts.length; j++) { 19 for ( int k = 0; k < counts[j]; k++) { 20 a[i] = j; 21 i++; 22 } 23 } return a; 26 } 114

22 CountingSort Beispiel: Sortieren des folgenden Arrays a max = 4 counts a

23 Laufzeit von CountingSort CountingSort durchläuft das gegebene Array zweimal, um das Maximum zu bestimmen und die darin enthaltenen Werte zu zählen Die Laufzeit des Initialisierens und des abschließenden Durchlaufens des Arrays von Zählern (counts) hängt vom maximalen Wert m ab Insgesamt hat CountingSort damit Laufzeit in O(n + m), welche besser als die der sortierenden Verfahren ist, sofern m << n log n gilt 116

24 Zusammenfassung QuickSort als robustes Sortierverfahren, welches auf der Idee Teile & Beherrsche beruht und im schlechtesten Fall Laufzeit in O(n 2 ), im erwarteten Fall jedoch Laufzeit O(n log n) hat CountingSort als nicht-vergleichendes Sortierverfahren, welches, wenn das gegebene Array nur wenige verschiedene Werte enthält, dieses in Laufzeit O(n + m) sortieren kann 117

25 Literatur [1] H.-P. Gumm und M. Sommer: Einführung in die Informatik, Oldenbourg Verlag, 2012 (Kapitel 4) [2] T. H. Cormen, C. E. Leiserson, R. Rivest und C. Stein: Algorithmen Eine Einführung, Oldenbourg Verlag, 2009 (Kapitel 2) 118