Pro Informatik 2009: Objektorientierte Programmierung Tag 17. Marco Block-Berlitz, Miao Wang Freie Universität Berlin, Institut für Informatik

Transkript

1 Tag 17 Marco Block-Berlitz, Miao Wang Freie Universität Berlin, Institut für Informatik

2 Agenda Tag 16 Datenstrukturen Abstrakte Datentypen, ADT Folge: Stack, Queue, Liste, ADT Menge: Bäume: Binärbäume, Suchbäume, AVL-Bäume, Prioritätswarteschlangen, Heap, Graphen ADTs in Java Tag 17 Sortieralgorithmen InsertionSort, BubbleSort, SelectionSort, ShellSort, MergeSort, QuickSort, Binary Tree Sort, HeapSort Untere Schranke für vergleichsbasierte Sortierverfahren, BucketSort, CountingSort, RadixSort Tag 18 Suchalgorithmen Binärsuche, Breitensuche, Tiefensuche, Backtracking Klausurvorbereitung Tag 19 Klausur Tag 20 Letzter Tag Weitere Projekte am Fachbereich, Klausurnachbesprechung, Grillen? 3

3 Sortieralgorithmen Suchen und Sortieren sind zwei Grunddisziplinen der Informatik. Ein Sortierverfahren ist ein Algorithmus, der dazu dient, eine Folge von Elementen in eine sortierte Folge zu bringen. Voraussetzung ist, dass auf der Menge der Elemente eine strenge schwache Ordnung definiert ist, z.b. die lexikographische Ordnung von Zeichenketten oder die numerische Ordnung von Zahlen. Es gibt eine Reihe von Sortierverfahren, die jedoch unterschiedlich effizient sind. Man unterscheidet zwischen stabilen und instabilen Sortierverfahren. Stabile Sortierverfahren sind solche, die die relative Reihenfolge von Elementen, die bezüglich der Ordnung äquivalent sind, nicht verändern. Instabile Verfahren garantieren dies nicht. Zudem unterscheidet man zwischen Sortierverfahren, die in-place (bzw. in-situ) arbeiten, d.h. die ohne oder nur mit einer konstanten kleinen Menge an zusätzlichen Speicherplatz arbeiten, und solchen, die dies nicht tun. Unter bestimmten Rahmenbedingungen arbeiten manche Verfahren äußerst effizient, z.b. bei kleineren Datenmengen oder bei größtenteils bereits vorsortierten Daten. 4

4 InsertionSort InsertionSort (Sortieren durch Einfügen) ist ein sehr einfaches Sortierverfahren. Es hat eine langsamere Laufzeit als die anderen bekannteren Sortierverfahren, dennoch bietet es einige Vorteile: sehr einfach zu verstehen und zu implementieren sehr schnell bei kleinen Datenmengen sehr schnell bei genügend vorsortierten Daten stabil (die Reihenfolge von schon sortierten Elementen ändert sich nach Sortierung nicht) in-place (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) online (kann Folge sortieren, während es sie erhält) 5

5 InsertionSort Idee Die zu sortierende Folge a 0,...,a n-1 wird am Anfang und nach jedem Iterationsschritt in zwei Folgen aufgeteilt: Der erste Teil a 0,...,a i-1 ist bereits (aufsteigend) sortiert, der zweite Teil a i,...,a n-1 bleibt noch unsortiert. Am Anfang bildet die leere Menge vorne den ersten Teil und die gesamte unsortierte Folge den zweiten Teil. Das Element a i wird nun als nächstes an die richtige Stelle in den bereits sortierten Teil eingefügt. Damit ist der sortierte Teil um ein Element größer geworden, sodass im nächsten Iterationsschritt dieses Verfahren wiederholt wird, bis zum Schluss alle Elemente im sortierten Teil sich befinden und die Folge sortiert ist. Applet: 6

6 InsertionSort Implementierung in Java: public class InsertionSort { public static void insertionsort (int[] a) { //Durchlaufe die Liste linear, vorderer Teil ist sortiert //Füge Element an richtige Stelle im sortierten Teil ein for (int i=0; i < a.length; i++) { insert (a, i); private static void insert (int[] a, int i) { int k = a[i]; //k ist das einzufügende Element int j = i; //Verschiebe alle Elemente > k eins nach rechts while (j!= 0 && a[j-1] > k) { a[j] = a[j-1]; j--; //Füge k an richtige Stelle ein a[j] = k; 7

7 InsertionSort Analyse Bei der Analyse von Sortieralgorithmen wird in der Regel die Anzahl der Vergleiche gezählt in Bezug auf die Eingabegröße n (= Anzahl der Elemente, die sortiert werden müssen). Die Anzahl der Vergleiche des Verfahren ist abhängig von der Anordnung der Elemente in der unsortierten Folge. Zusätzlich sind Verschiebungen nötig, falls auf einem Array gearbeitet wird, wo die Elemente nach dem neu eingefügten Element verschoben werden. Die Verschiebungen sind vergleichsweise teuer. Alle größeren Elemente müssen eins nach rechts rücken, um die Einfügeposition frei zu machen. Daher ist für das Einfügen lineare Zeit erforderlich. Im Best Case ist die Folge bereits sortiert, die Laufzeit beträgt dann O(n), da jedes einzufügende Element nur ein Vergleich mit dem Element links davon benötigt. Im Average und Worst Case beträgt die Komplexität O(n 2 ). Der Worst Case trifft ein, wenn das einzufügende Element stets an allererster Stelle eingefügt werden muss (z.b. bei einer invers sortierten Folge) und berechnet sich mit 8

8 BubbleSort BubbleSort (to bubble aufsteigende Blasen) ist ein ebenfallse ein einfacher Sortieralgorithmus. Den Namen verdankt er der Weise wie die Elemente nach und nach wie Blasen im Wasser nach hinten (bzw. vorne) wandern. BubbleSort ist sehr simpel zu verstehen, ist aber auch meist sehr ineffizient (besonders bei großen Datenmengen). sehr einfach zu verstehen und zu implementieren stabil (die Reihenfolge von schon sortierten Elementen ändert sich nach Sortierung nicht) in-place (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) 9

9 BubbleSort Idee Der Algorithmus durchläuft die zu sortierende Folge und vertauscht benachbarte Paare, die in der falschen Reihenfolge vorliegen. Dies garantiert das die großen Elemente nach und nach ans Ende der Folge wandern. Dieser Durchlauf wird solange wiederholt bis keine Vertauschungen mehr nötig sind und die Folge damit sortiert ist. Um die Geschwindigkeit zu verbessern bedarf es nur den Durchlauf bis zu den schon nach hinten gewanderten Elementen, da diese bereits an die richtige sortierte Position gewandert sind. Dadurch wird stets ein Element weniger geprüft, ändert aber insgesamt nichts an der Komplexität des Algorithmus. Applet: 10

10 BubbleSort Implementierung in Java: public class BubbleSort { public static void bubblesort (int[] a){ //äußere For-Schleife (so viele Durchläufe wie Elemente) for(int i=1; i<a.length; i++) { //innere For-Schleife (läuft bis schon platzierten Elementen) for(int j=0; j<a.length-i; j++) { //falls in falscher Reihenfolge, dann vertauschen if (a[j]>a[j+1]) swap(a, j, j+1); //vertauscht zwei Elemente im Array private static void swap (int[] a, int i, int j) { int h = a[i]; a[i] = a[j]; a[j] = h; 11

11 BubbleSort Analyse Die Komplexität von BubbleSort ist stark abhängig inwieweit die Elemente von ihrer richtigen sortierten Position entfernt sind. Im Best Case ist die Folge bereits sortiert und der Algorithmus benötigt einen Durchlauf und bricht danach ab, was eine Laufzeit von O(n) verursacht. Im Worst Case beträgt die Laufzeit jedoch O(n 2 ), wie man schön an der verschachtelten For-Schleife sehen kann. Es kann auch berechnet werden, indem man sich überlegt, dass ein Element nie mehr als n Positionen von der sortierten Position entfernt sein kann und sich nur um eine Position pro Iteration bewegt. Obwohl BubbleSort im Worst Case asymptotisch gleich schnell wie InsertionSort ist, unterscheiden sich die Anzahl der Vertauschungen in beiden Verfahren enorm. In der Praxis zeigt sich das BubbleSort viel langsamer läuft und sich als extrem ineffizient präsentiert. 12

12 SelectionSort SelectionSort (Sortieren durch Auswählen) ist vergleichbar mit InsertionSort und sehr intuitiv zu verstehen. Leider ist es asymptotisch nicht schneller als InsertionSort. sehr einfach zu verstehen und zu implementieren sehr schnell bei kleinen Datenmengen sehr schnell bei genügend vorsortierten Daten stabil (die Reihenfolge von schon sortierten Elementen ändert sich nach Sortierung nicht) in-place (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) 13

13 SelectionSort Idee Das Verfahren ist relativ einfach: Die zu sortierende Folge wird in zwei Teile aufgeteilt: eine bereits sortierte Folge und die restlich noch unsortierte Folge. In jedem Iterationsschritt wird das Minimum aus der unsortierten Folge bestimmt und mit dem ersten Element dieser unsortierten Folge vertauscht. Man beginnt mit der gesamten Folge als zu sortierende Folge und ist fertig, wenn alle Elemente sich in der sortierten Folge befinden und die Folge somit komplett sortiert ist. Damit das Verfahren stabil sortiert ist es nötig das Minimum nicht zu vertauschen sondern an die sortierte Folge anzuhängen, sodass es sich zwischen sortierter und unsortierter Folge befindet. Dies macht das Verfahren stabil, jedoch wird mehr Rechenzeit verbraucht, da Elemente im Array verschoben werden müssen. Applet: 14

14 SelectionSort Implementierung in Java: public class SelectionSort { public static void selectionsort (int[] a) { //durchlaufe die Folge... //und vertausche mit Minimum der unsortierten Folge for (int i=0; i<a.length; i++) { swap(a, i, minindex(a, i)); //finde den Index des Minimum nach Position i private static int minindex (int[] a, int i) { int m = i; //setze i as vorläufiges Minimum for (int j=i+1; j<a.length; j++) { //falls kleiner als das Minimum, dann neues Minimum if (a[j] < a[m]) m = j; return m; //vertauscht zwei Elemente im Array private static void swap (int[] a, int i, int j) { int h = a[i]; a[i] = a[j]; a[j] = h; 15

15 SelectionSort Analyse SelectionSort benötigt n-1 Durchläufe um jeweils das Minimum zu bestimmen. Beim ersten Mal benötigt das Bestimmen des Minimums n-1 Vergleiche, beim zweiten Mal n-2 usw. So kann man sich die Laufzeit des Algorithmus bestimmen als 16

16 ShellSort ShellSort ist ein von Donald L. Shell entwickelter und nach ihm benannter Sortieralgorithmus aus dem Jahre Er basiert auf dem Prinzip von InsertionSort und ist asymptotisch etwas schneller. basiert auf InsertionSort mit den Vor- und Nachteilen in-place (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) 17

17 ShellSort Idee InsertionSort ist sehr effizient bei genügend vorsortierten Daten, aber langsam, weil Elemente pro Iterationsschritt nur maximal um eine Position bewegt werden. ShellSort verbessert nun InsertionSort indem Elemente, die eine bestimmte Entfernung voneinander entfernt sind (gap size), vergleicht und sie notfalls vertauscht. Die gap size wird nach jeder Iteration verringert, sodass der nächste Iterationsschritt auf leicht vorsortierten Daten basiert. Um dies bildlich zu veranschaulichen, behilft man sich einer Matrixdarstellung mit k Spalten, wobei k die gap size repräsentiert. Jede Spalte wird dann separat mit dem InsertionSort sortiert. Dies geschieht vergleichsweise schnell auf diesen kleinen Datensätzen. Im nächsten Schritt wird die gap size verringert und der Algortihmus wiederholt. Im letzten Schritt liegt eine einspaltrige Matrix vor, worauf ein InsertionSort eine sortierte Folge garantiert und zudem schnell ablaufen sollte, da sie nun genügend vorsortiert sein müsste. Applet: 18

18 ShellSort Implementierung in Java: public class ShellSort { public static void shellsort (int[] a) { int i, j, k, h, t; //vordefinierte gute gap sizes (können verändert werden) int cols[] = {4711, 1968, 815, 271, 111, 41, 13, 4, 1; for (k=0; k<cols.length; k++) { //gap size auslesen h = cols[k]; //vertauschen, falls in falsche Reihenfolge for (i=h; i<a.length; i++) { j = i; t = a[j]; while (j>=h && a[j-h]>t) { a[j] = a[j-h]; j = j-h; a[j] = t; 19

19 ShellSort Analyse Die Laufzeit von ShellSort ist relativ schwer zu analysieren, wir ersparen uns hier die detaillierte Analyse. Die Laufzeiten von ShellSort gehen von O(n (log n) 2 ) bis O(n 1.5 ) je nach Implementation. Sie hängt vor allem von der Wahl der gap sizes ab. Die Folge 1, 3, 7, 15, 31, 63,..., 2k-1 führt zu einer Laufzeit von O(n 1.5 ), die Folge 1, 2, 3, 4, 6, 8, 9, 12, 16,..., 2p3q jedoch zu einer Laufzeit von O(n (log n) 2 ). Es kann gezeigt werden, dass die durchschnittliche Laufzeit bei etwa O(n 1.25 ) liegt, aber ein Beweis für ein O(n log n) im worst case wurde noch nicht gefunden. 20

20 MergeSort Den MergeSort Algorithmus haben wir bereits im Rahmen der Divide-and-Conquer Algorithmen kennen gelernt. MergeSort ist ein wohlbekanntes Sortierverfahren nach John von Neumann aus dem Jahre gute Komplexität stabil (die Reihenfolge von schon sortierten Elementen ändert sich nach Sortierung nicht) in-place möglich (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) online möglich (kann Folge sortieren, während es sie erhält) 21

21 MergeSort Idee Der Algorithmus besteht aus zwei Teilen, dem Aufteilen der zu sortierenden Folge in zwei kleinere Teilfolgen und das Zusammenfügen der entstandenen Teilfolgen bis wieder eine gesamte sortierte Folge entstanden ist. Das Aufteilen geschieht relativ einfach indem die Folge stets in zwei gleich große Hälften aufgeteilt werden bis die Teilfolgen klein genug sind um sie effizient zu sortieren (meist bei ein- oder zweielementrigen Folgen). Beim Zusammenfügen wird nach dem Reißverschlussprinzip gearbeitet, wobei jeweils das kleinste Element beider Folgen als nächstes in die zusammengefügte Folge eingefügt wird, sodass die Folge sortiert bleibt. MergeSort ist üblicherweise nicht in-place, aber es gibt zahlreiche trickreiche Implementierungen, die dieses verwirklichen. Applet: 22

22 MergeSort Implementierung in Java: public class MergeSort { public static void mergesort (int[] a) { mergesort(a, 0, a.length-1); private static void mergesort (int[] a, int l, int r) { //Rekursionsanker: a[l..r] ist leer oder hat nur ein Element if ( l>=r ) return; //Rekursionsschritt: a[l..r] ist nicht leer //teile in Teilfolgen und füge wieder zusammen int m = (l+r)/2; mergesort (a, l, m); mergesort (a, m+1, r); merge (a, l, m, r);... 23

23 MergeSort Implementierung in Java: Fortsetzung:... //fügt zwei Teilfolgen wieder zusammen private static void merge (int[] a, int l, int m, int r) { //Rekursionsanker: zweite Teilfolge ist leer if (m+1>r) return; int[] b = new int[a.length]; //erstelle Hilfsarray //kopiere a[l..m] nach b[l..m] for (int i=l; i!=m+1; i++) { b[i] = a[i]; //kopiere a[m+1..r] nach b[m+1..r] in umgekehrter Reihenfolge for (int i=m+1; i!=r+1; i++) { b[i] = a[r+m+1-i]; //füge b[l..m] und b[m+1..r] zu a[l..r] zusammen int k=l; int j=r; //Zeiger die von außen nach innen wandern for (int i=l; i!=r+1; i++) { if (b[k] <= b[j]) a[i] = b[k++]; else a[i] = b[j--]; 24

24 MergeSort Analyse Best, Average und Worst Case haben die gleiche Komplexität von O(n log n). MergeSort benötigt O(n) zusätzlichen Speicherplatz, falls es nicht in-place implementiert ist. Der Divide-Schritt geht in konstanter Zeit, der größere Aufwand ist in beim Zusammenfügen zu ermitteln. Beim Zusammenfügen müssen in jeder Ebene im worst case n Vergleiche durchgeführt werden. Es gibt log n Ebenen, daher ergibt sich eine Gesamtlaufzeit von O(n log n). Für Fortgeschrittene: Falls für einen Durchlauf einer Folge von n Elementen T(n) Zeit benötigt wird, dann benötigen wir zweimal die Zeit für eine Folge halber Länge (2T(n/2)) und die Zeit die Elemente von a nach b und zurück zu kopieren (n). Es ergibt sich eine Rekursionsformel T(n) = 2T(n/2) + n und T(1) = 0, welches sich mittels Master Theorem zu T(n) O(n log n) auflöst. 25

25 QuickSort Auch den QuickSort-Algorithmus kennen wir aus dem Divide-and-Conquer Prinzip. QuickSort wurde entwickelt von C. Antony R. Hoare. Genauso wie MergeSort ist Quicksort ein gutes Beispiel für das Teile-und-Herrsche Prinzip. QuickSort ist im worst case langsamer als MergeSort, im average case aber asymptotisch gleich schnell. Trotzdem ist QuickSort in der Praxis bedeutend schneller, weil die innere Schleife des Algorithmus auf den meisten Architekturen besonders effizient implementiert werden kann. Das Verfahren wird als in-place angesehen, obwohl die Rekursion zusätzlichen Stackspeicher benötigt. schnell, da innere Schleife effizient zu implementieren ist oft in der Prexis eingesetzt in-place (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) 26

26 QuickSort Idee Der QuickSort-Algorithmus ist ein typisches Beispiel für die Entwurfstechnik Divide-and-Conquer. Um eine Liste zu sortieren wird ein Pivotelement p ausgewählt und die Elemente der Liste in zwei neue Listen gespeichert, mit der Eigenschaft, dass in der ersten Liste die Elemente kleiner oder gleich p und in der zweiten Liste die Elemente größer p liegen. Mit den beiden Listen wird wieder genauso verfahren. Es gibt mehrere vielversprechende Strategien das Pivot-Element geschickt zu wählen, so dass der Algorithmus effizient abläuft. Im einfachsten Fall nimmt man das erste oder das letzte Element. Etwas besser ist es, das mittlere Element oder den Median zu wählen. Applet: 27

27 QuickSort Implementierung in Java: public class QuickSort { public static void quicksort (int[] a) { quicksort(a, 0, a.length-1); private static void quicksort (int[] a, int l, int r) { //Rekursionsanker: Liste ist leer if (l>=r) return; //Rekursionsschritt: Aufteilen und rekursives Sortieren int m = partition(a, l, r); quicksort(a,l,m-1); quicksort(a,m+1,r);... 28

28 QuickSort... Implementierung in Java: //Aufteilen des Arrays von l+1 bis r mit Pivot a[l] private static int partition (int[] a, int l, int r) { int i=l+1; //Zeiger am linken Rand int j=r; //Zeiger am rechten Rand int p = a[l]; //Pivot-Element //Zeiger bewegen sich nach innen oder Elemente werden vertauscht while (i<=j) { if (a[i]<=p) i++; else if (a[j]>p) j--; else swap(a,i,j); //vertausche Pivot-Element zwischen die Teilfolgen swap(a,l,j); //gebe die Position des Pivot-Elements zurück return j; //vertauscht zwei Elemente im Array private static void swap (int[] a, int i, int j) { int h = a[i]; a[i] = a[j]; a[j] = h; 29

29 QuickSort Analyse Wählen wir stets das erste Objekt als Pivot-Element, ist die Auswahl des Pivot-Elements in O(1) möglich. Im Best Case wird jedes Mal die Folge in zwei nahezu gleich große Teilfolgen aufgeteilt. Es finden, ähnlich wie bei MergeSort, n Vergleiche auf jeder Ebene statt bei log n Ebenen. Dies ergibt eine Laufzeit von O(n log n). Im Worst Case jedoch (falls die Liste invers sortiert ist) werden Teilfolgen der Länge 1 und n-1 erzeugt. In diesem Fall entartet der Rekursionsbaum zu einer linearen Kette von n verschachtelten Aufrufen. Jeder i-te Iterationsschritt muss O(n-i) Elemente durchlaufen, was folgende Laufzeit ergibt: 30

30 Binary Tree Sort Binary Tree Sort ist die Bezeichnung eine Menge an Daten mit Hilfe des binären Suchbaums zu sortieren. gute Komplexität stabil möglich (die Reihenfolge von schon sortierten Elementen ändert sich nach Sortierung nicht) in-place (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) online (kann Folge sortieren, während es sie erhält) Idee Die zu sortierende Elemente werden einfach in einem binären Suchbaum gespeichert. Um die Elemente in einer sortierten Reihenfolge zu erhalten, muss der Baum nur inorder traversiert werden. Analyse Das Einfügen eines Elements in einen binären Suchbaum benötigt O(log n) Zeit. Für n Elemente wären das insgesamt O(n log n) Zeit. Die Inorder-Traversierung benötigt nur O(n). Die Gesamtlaufzeit beträgt somit O(n log n). Applet: 31

31 HeapSort HeapSort ist ein sehr effizientes Sortierverfahren, 1964 entwickelt von Robert W. Floyd und J. W. J. Williams. Es ist eine Weiterentwicklung vom SelectionSort und ist mit einer Worst Case Laufzeit von O(n log n) einer der besten vergleichsbasierten Sortieralgorithmen. Es arbeitet in-place, sortiert aber nicht stabil. sehr effizient mit fast allen Datensätzen oft in der Praxis eingesetzt in-place (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) 32

32 HeapSort Idee HeapSort benutzt, wie der Name schon erahnen lässt, eine Heap Datenstruktur. In der einfachsten Ausführung werden die Elemente der zu sortierenden Folge nacheinander in einen Min-Heap eingefügt. Die Datenstruktur kümmert sich um die Anordnung der Elementen in einem partiell geordneten Baum, sodass man schnell das Minimum entfernen kann. Tut man dies bis der Heap leer ist, so erhält man die Elemente in der richtigen Reihenfolge als sortierte Folge. Leider ist dies kein in-place Verfahren. Für eine in-place Methode siehe die Beschreibung auf der Applet-Webseite (unten). Analyse Ein HeapSort, der nicht in-place arbeitet, benötigt n mal O(log n) zum Erstellen des Heaps und erneut n mal O(log n) um die Minima zu entnehmen. Das Resultat ist eine Laufzeit von O(n log n). Applet: 33

33 PAUSE 34

34 Geht es schneller als O(n log n)? Überblick der bisherigen Sortierverfahren und die Laufzeit im worst case InsertionSort O(n 2 ) BubbleSort O(n 2 ) SelectionSort O(n 2 ) ShellSort O(n 1,5 ) MergeSort O(n log n) QuickSort O(n 2 ), aber O(n log n) im average case Binary Tree Sort O(n log n) HeapSort O(n log n) Frage: Gibt es Verfahren, die noch schneller sind als O(n log n)? 35

35 Vergleichsbasierte Sortierverfahren Die bisherigen Sortierverfahren, die wir kennen gelernt haben, fallen unter die Kategorie universelle, vergleichsbasierte Sortierverfahren. Sie sind universell, weil sie auf jede beliebige Folge von Werten anwendbar sind, und die Laufzeit nur abhängig von der Anzahl der Werte ist und nicht von der Größe der Werte. Sie sind vergleichsbasiert, weil sie auf paarweisen Vergleichen der zu sortierenden Elemente basieren. Bei der Komplexitätsanalyse wird davon ausgegangen, dass der Aufwand zum Vergleich zweier Elemente konstant ist, sodass man beweisen kann, dass es eine untere Schranke Ω(n log n) f ür solche Verfahren gibt. 36

36 Untere Schranke für vergleichsbasierte Sortierverfahren Behauptung: Es gibt kein vergleichsbasiertes Sortierverfahren, das schneller arbeitet als O(n log n). Beweis: Ein Sortierverfahren soll die Folge X = (x 1, x 2,..., x n ) sortieren. Alle möglichen Permutationen von X könnten das Ergebnis darstellen, daher gibt es n! Möglichkeiten. Ein vergleichsbasiertes Verfahren kann pro Schritt nur entscheiden ob ein Wert x i größer oder kleiner als x j ist. Die Möglichkeiten lassen sich also in einem binären Entscheidungsbaum darstellen. Die Mindestanzahl von Schritten zu einem Blattknoten ist log(n!). Man kann log(n!) nach unten abschätzen durch Damit gilt 37

37 Untere Schranke für vergleichsbasierte Sortierverfahren Beispiel eines Entscheidungsbaums für die Folge (a, b, c): a<b? b<c? a<c? a,b,c a<c? b,a,c b<c? a,c,b c,a,b b,c,a c,b,a 3 Elemente 3! = 6 Blattknoten 38

38 Sortieren in linearer Zeit Es gibt einige Sortierverfahren, die nicht vergleichsbasiert arbeiten, und sind damit schneller als O(n log n). Jedoch haben sie andere Einschränkungen auf die Eigenschaften der Elemente, die sie sortieren. BucketSort CountingSort RadixSort 39

39 BucketSort Bucketsort ist ein nicht-vergleichsbasiertes Sortierverfahren, das eine Liste in linearer Laufzeit sortieren kann. Idee BucketSort verwaltet zum Sortieren der Folge a[1...n] eine weitere Folge b[0...m-1], welches m lineare verkettete Listen verwaltet, die Buckets. Die zu sortierenden Elemente werden in m Intervalle zerlegt und jedes Element landet in ihrem zugehörigen Bucket. Dort werden mehrere Buckets mit einem Standard-Verfahren (z.b. InsertionSort) sortiert. Zum Schluss werden die einzelnen Buckets hintereinander gehängt. Analyse Die Wahrscheinlichkeit, dass ein a[j] in die Liste b[i] kommt ist 1/n. BucketSort sortiert im average case in O(n). Im worst case jedoch O(n 2 ), wenn alle Elemente in einem bucket landen und zum Beispiel InsertionSort als Standard-Verfahren gewählt wird. 40

40 BucketSort Beispiel Sortiere Dezimalzahlen, wähle Buckets gemäß erster Ziffer nach dem Komma: a b 1 0,60 0 0,01 0,07 0,08 2 0,08 1 0,18 3 0,23 2 0,23 4 0, , ,18 5 0,58 7 0,01 6 0,60 0,68 8 0,84 7 0,71 9 0,68 8 0, ,

41 BucketSort Implementierung in Java: Nimmt die Wertigkeit des Elements als Index public class BucketSort { public static void bucketsort(int a[], int numbuckets) { // histogramm erstellen int buckets[] = new int[numbuckets]; //verteilen auf Buckets, Elemente werden einfachshalber nur hochgezählt for (int i = 0; i < a.length; i++) { buckets[a[i]]++; //zusammenhängen int x = 0; for (int i = 0; i < numbuckets; i++) { while (buckets[i] > 0) { a[x++] = i; buckets[i]--; 42

42 CountingSort CountingSort ist ein nicht-vergleichsbasiertes Sortierverfahren, das genauso wie BucketSort das Intervall der Werte der zu sortierenden Elemente ausnutzt. Idee Sei a[1...n] die Folge, die zu sortieren ist. Bestimme für jedes Element x in a die Anzahl der Elemente, die in der sortierten Reihenfolge vor x liegen und platziere damit x an die korrekte Stelle. Um CountingSort zu einem stabilen Sortierverfahren zu machen, wird das zu sortierende Feld von hinten aufgerollt und die jeweiligen Elemente an die richtige Position gesetzt. 43

43 CountingSort Beispiel A C C B

44 CountingSort Implementierung in Java: Sortiert Array a in b, mit Hilfsarray c public class CountingSort { public static void countingsort(int[] a, int numcells) { //temporäres Array erzeugen zum Zählen int[] c = new int[numcells]; // Indizes des Zahlen-Arrays durchgehen for(int i=0; i < c.length; i++) { // für jedes Vorkommen von a[i] wird c[a[i]] um eins erhöht c[a[i]] = c[a[i]] + 1; for(int i=1; i < c.length; i++) { c[i] = c[i] + c[i-1]; //c[i] gibt nun die Anzahl der Elemente <= i in a an int[] b = new int[a.length]; //füge Elemente an richtiger Stelle ein for(int i=a.length-1; i >= 0; i--) { b[c[a[i]]-1] = a[i]; c[a[i]] = c[a[i]] - 1; 45

45 CountingSort Analyse Sei n die Anzahl der zu sortierenden Elemente und m das Intervall der Zahlen. Dann ist leicht aus der Implementierung herzuleiten, dass die Laufzeit O(n+m) beträgt und damit linear ist. 46

46 RadixSort RadixSort ist ebenfalls ein nicht-vergleichbasiertes Sortierverfahren, welches auf CountingSort aufbaut. Voraussetzung für RadixSort ist, dass die Zeichen der zu sortierenden Daten aus einem endlichen Alphabet stammen, z.b. Buchstaben aus dem lat. Alphabet, Ziffern aus dem Dezimalsystem. Idee Für jedes Element x wird eine bestimmte Stelle x[i] untersucht. Zuerst werden die Elemente gemäß x[i] in Fächer verteilt (Partitionierung). Nach der Verteilung werden alle Daten nach aufsteigender Wertigkeit von x[i] aufgesammelt. Danach wird dies mit der nächsthöheren Stelle x[j] wiederholt, bis alle Stellen abgearbeitet sind. 47

47 RadixSort Beispiel Partitionieren nach Ziffer 3: Zusammensammeln: Partitionieren nach Ziffer 2: Zusammensammeln:

48 RadixSort Beispiel Zusammensammeln: Partitionieren nach Ziffer 1: Zusammensammeln:

49 RadixSort Analyse Sei n die Anzahl der zu sortierenden Elemente und m die maximale Anzahl an Stellen eines Elements. Für jede Stelle müssen alle n Elemente partitioniert und zusammengesammelt werden. Es ergibt sich also eine Gesamtlaufzeit von O(m*n). Nehmen wir an, dass m konstant ist, dann folgt daraus, dass RadixSort in linearer Zeit sortiert. 50