Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Informatik II, SS 2008 Algorithmen und Datenstrukturen Vorlesung 10 Prof. Dr. Thomas Ottmann Algorithmen & Datenstrukturen, Institut für Informatik Fakultät.

Ähnliche Präsentationen


Präsentation zum Thema: "Informatik II, SS 2008 Algorithmen und Datenstrukturen Vorlesung 10 Prof. Dr. Thomas Ottmann Algorithmen & Datenstrukturen, Institut für Informatik Fakultät."—  Präsentation transkript:

1 Informatik II, SS 2008 Algorithmen und Datenstrukturen Vorlesung 10 Prof. Dr. Thomas Ottmann Algorithmen & Datenstrukturen, Institut für Informatik Fakultät für Angewandte Wissenschaften Albert-Ludwigs-Universität Freiburg Sortierverfahren

2 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann2 Gegeben sind n Objekte, die über einen (ganzzahligen oder alphabetischen) Schlüssel identifiziert werden und im Hauptspeicher in einem Array abgelegt sind (interne Sortierverfahren). Aufgabe: Die Objekte sollen so umgeordnet werden, dass die Schlüssel aufsteigend sortiert sind. Vereinfachende Annahme: Die zu sortierenden Daten sind Buchstaben oder ganze Zahlen Sortieren: Aufgabenbeschreibung

3 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann3 Rahmen für Sortier-Verfahren Für die Darstellung der Verfahren wird im Folgenden der Einfachheit halber ein Array von Zeichen (char) sortiert. Wir verwenden ein simples Rahmen-Programm. class CharSort { public static void main (String args[]) { char [] a = "thequickbrownfoxjumpsoverthelazydog".toCharArray(); System.out.println ("Zeichen-Sortierprogramme\n"); System.out.println (a); System.out.print ("bubbleSort: "); Sorter.bubbleSort (a); System.out.println (a); } // main } // CharSort

4 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann4 Die Sorter-Klasse Die Sorter-Klasse vereint verschiedene Sortier-Algorithmen sowie Hilfs- Methoden: class Sorter { private final static void swap (char[] a, int i, int k){ char h = a[i]; a[i] = a[k]; a[k] = h; } // swap // verschiedene Sortier-Verfahren... } // Sorter Die Ausgabe eines Sortier-Laufs sieht dann etwa so aus: C:\algo>java CharSort Zeichen-Sortierprogramme thequickbrownfoxjumpsoverthelazydog bubbleSort: abcdeeefghhijklmnoooopqrrsttuuvwxyz

5 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann5 (1) Allgemeine Sortierverfahren: Zur Ermittlung der korrekten Anordnung sind nur Vergleichsoperationen zwischen Schlüsseln erlaubt, die richtige Reihenfolge wird durch Bewegungen der Schlüssel hergestellt. Bubblesort, Insertion Sort, Selection Sort, Heapsort, Quicksort, Mergesort, (2) Spezielle Sortierverfahren: Distribution Sort: Sortieren durch Fachverteilung, Radixsort Sortieren: Zahlreiche Lösungen

6 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann6 Untere Komplexitätsschranke für Sortierverfahren Satz. Jeder Sortier-Algorithmus für n Elemente, der ausschließlich auf Schlüssel-Vergleichen und Element-Vertauschungen beruht, hat eine worst- case Laufzeit Ω(n log n). Am Ende des Sortier-Vorgangs muss eine von n! Permutationen der n Elemente erzeugt worden sein. Jeder Ausgang eines Vergleiches liefert Informationen um die in Frage kommende Menge von Permutationen in zwei Teile zu zerlegen.

7 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann7 Kriterien zur Beurteilung verschiedener Verfahren Laufzeit: Anzahl ausgeführter Schlüsselvergleiche, Anzahl ausgeführter Bewegungen von Schlüsseln (bester, schlechtester, mittlerer Fall) Weitere Kriterien: Speicherbedarf (in situ?) Berücksichtigung von Vorsortierung Stabilität

8 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann8 Bubble Sort Wiederholung: Das Blasen-Aufstiegs-Verfahren static void bubbleSort (char[] a){ int hi = a.length-1; for (int k = hi; k > 0; k--){ boolean test = true; for (int i = 0; i a[i+1]) { swap (a, i, i+1); test = false; } if (test) break; } } // bubbleSort Beginnend mit dem höchsten Index wird das Array sortiert. Vorsortierung wird ausgenutzt Laufzeiten in O(n²) im worst und average case sowie Ο(n) im best case.

9 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann9 Bubblesort: Beispiel

10 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann10 Selection Sort (1) Suche das kleinste der verbleibenden Elemente und hänge es an den bisher sortierten Bereich (durch Tausch) an. Am Ende ist alles sortiert. static void selectionSort (char[] a){ int hi = a.length-1; for (int k = 0; k < hi; k++){ int min = minPos (a, k, hi); // finde minPos im Rest if (min != k) swap (a, min, k); // tausche es nach k } } // selectionSort private static int minPos (char[] a, int lo, int hi){ int min = lo; for (int i = lo+1; i <= hi; i++) if (a[i] < a[min]) min = i; return min; } // minPos

11 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann11 Selection Sort: Beispiel

12 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann12 Selection Sort (2) Äußere Schleifendurchläufe: (n - 1) Bestimmung von minPos (a,k,hi): (n - k) Vergleiche. Gesamtaufwand: O(n²) Vorteil: Nur (n - 1) Vertauschungen, besser als bei Bubble Sort. Nachteil: Bei Vorsortierung keine Verbesserung.

13 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann13 Insertion Sort (1) Das erste Element des noch unsortierten Bereiches wird genommen und in den schon sortierten an der richtigen Stelle (durch Tausch) eingefügt. Die bereits sortierten Elemente oberhalb der Einfügestelle müssen dazu je um eine Position verschoben werden. static void insertionSort (char[] a){ int hi = a.length-1; for (int k = 1; k 0) && (a[i-1] > x) ) ; i-- ) a[i] = a[i-1]; // rechts schieben a[i] = x; // einfuegen } } // insertionSort

14 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann14 Insertion Sort: Beispiel

15 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann15 Insertion Sort (2) Aufwand wieder in O(n²) im Mittel und im worst case. Es werden viele Vertauschungen ausgeführt. Vorsortierung ist von Vorteil.

16 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann16 Heapsort: Idee Effizientes Verfahren zum Sortieren (auch im worst case in O(n log n)) Prinzip: Sortieren durch wiederholtes Auswählen des Maximums (ähnlich Selection Sort) Besonderheit: Verwendung einer Datenstruktur Heap, welche die Bestimmung des Maximums effizient unterstützt Definition: Eine Folge F = (k 1, k 2,..., k n ) von Schlüsseln ist ein (Max-) Heap, wenn für alle i {1, 2, …, n/2} gilt: k i k 2i und k i k 2i+1. Bsp:

17 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann17 Heap-Bedingung

18 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann18 Veranschaulichung von Heaps Veranschaulichung des Heaps durch Binär-Baum mit Positionsnummern: Level i hat 2 i Knoten (außer u.U. dem letzten) Knoten sind von oben nach unten und von links nach rechts nummeriert. Knoten i hat Knoten 2i als linken und Knoten 2i + 1 als rechten Nachfolger und Knoten i/2 als Vorgänger (falls jeweils vorhanden). Aus der Heap-Bedingung k i k 2i und k i k 2i+1 folgt: Das Maximum steht an der Wurzel (an Index 1) und kann sofort entfernt werden. Doch wie erhält man wieder einen Heap für den Rest?

19 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann19 Heapsort: 2 Phasen Sortieren mit Hilfe eines Heaps: Phase 1: Verwandeln des gegebenen Arrays in einen Heap Phase 2: Iterieretes Extrahieren des Maximums (von Position 1), Tauschen des Elementes mit höchstem Index im nichtsortierten Teil an Position 1 und versickern lassen im Rest. Phase 2 wird n-Mal ausgeführt, jede Ausführung kostet höchstens O(log n) Schlüsselvergleiche. Wir werden zeigen: Phase 1 kann in Zeit O(n) ausgeführt werden. Gesamtlaufzeit von Heapsort: O(n log n)

20 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann20 Heapsort-Beispiel: Erster Schritt Extrahieren des größten Elementes (an Position 1) und tauschen an das rechte Ende des Arrays (höchster Index im nichtsortierten Teil)

21 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann21 Heapsort-Beispiel: Weitere Schritte Das Element von der größten verbleibenden Index-Position wird nach Pos. 1 bewegt und dann versickert. Sobald wieder ein Heap entstanden ist, kann das nächste Maximum entfernt werden, bis der Heap leer ist

22 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann22 Heapsort: Versickern von Elementen Versickern bedeutet: Vertauschen mit dem größeren der Nachfolger, solange dieser größer als das zu versickernde Element ist. Verfahren zum Versickern des ersten Elements in einem Array a in den Grenzen j und t: private static void percolate (char[] a, int j, int t){ int h; while ((h=2*j) a[h]) h++; // h: größerer // Nachfolger if (a[h] > a[j]) { // versickern nötig? swap (a, h, j); // ja: vertauschen j = h; // und weiter } else break; // nein: fertig } } // percolate Anzahl der Vergleiche und Vertauschungen, um ein Element in n Elementen zu versickern: O(log n)

23 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann23 Sortieren mit Hilfe eines Heaps: Erst muss ein Heap erstellt werden. Dann kann man immer wieder das jeweilige Maximum entnehmen. Da bei n Elementen diejenigen mit den Positionen n/2 + 1, …, n bereits die Heap-Bedingung erfüllen, kann man bei der Heap-Erstellung mit dem Versickern beim Element mit der Nr. n/2 beginnen. static void heapSort (char[] a){ int j, hi = a.length-1; for (j = hi/2; j >= 1;) // alle Pos. j = [n/2].. 1: percolate (a, j--, hi); // versickere im Array j... N for (j = hi ; j > 1;) { // alle Pos. j = n... 2: swap (a, 1, j); // vertausche Maximum nach j percolate (a, 1, --j); // versickere im Array 1... (j-1) } } // heapSort Frage: Wie aufwendig ist der Heap-Aufbau durch iteriertes Versickern? Heap-Aufbau: Implementation

24 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann24 Heapaufbau Niveau, #Knoten, Versick.-Aufwand/Knoten

25 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann25 Heapaufbau: Kosten Heap-Aufbau durch iteriertes Versickern: ² k = 32 k Knoten Anzahl der Knoten insgesamt: n = 2 k Anzahl der Vergleiche zum Aufbau: Der Heap-Aufbau erfolgt also in linearer Zeit.

26 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann26 Aufwand für Heapaufbau Gesamtaufwand = 2 0 2k (k-1) (k-2) + … + 2 (k-1 ) 2 = 2 S(k), mit S(k) = 2 0 k (k-1) (k-2) + … + 2 (k-1 )1 = 2 (n – k – 1) = O(n)

27 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann27 Heapsort: Mögliche Verbesserungen Laufzeit für Heap Sort insgesamt: O(n log n). Platzbedarf: n für das Array sowie zusätzlich: O(1). Frage: Kann Heap Sort noch verbessert werden? Beobachtungen: Der konstante Faktor c des Verfahrens hängt von der Tiefe ab, um die versickert werden muss. Im schlimmsten Fall wird immer das kleinste Element bis ganz unten versickert. Auch die erwartete Tiefe beim Versickern ist hoch. Pro Niveau, um das ein Element versickert wird, treten 2 Schlüsselvergleiche auf, um den größeren der Nachfolger zu bestimmen und um festzustellen, ob weiter versickert werden muss. Verbesserungsidee: Bestimme den größeren der Nachfolger eines Elementes mit einem Schlüsselvergleich. Versickere auf jeden Fall (auch wenn das Element zu groß ist). Unten angekommen, lasse das Element wieder aufsteigen, soweit nötig.

28 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann28 Bottom-Up Heap Sort (1) Bemerkung: Die gefundene Stelle für das Element stimmt mit derjenigen der Versickerungsprozedur überein. Satz. Das verbesserte Verfahren Bottom-up Heapsort benötigt zum Sortieren einer Folge von n Schlüsseln im schlechtesten Fall nur 1.5 n log n + 2n Schlüsselvergleiche. Im Mittel benötigt Bottom-up Heapsort nur n log n + O(n) Schlüsselvergleiche. static void bottomUpheapSort (char[] a){ int j, hi = a.length-1; for (j = hi/2; j >= 1;) percolateb (a, j--, hi); // versickere (mod) von j bis hi for (j = hi ; j > 1;) { swap (a, 1, j); // größeres nach j percolateb (a, 1, --j); // versickere (mod) } } // bottomUpheapSort

29 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann29 Bottom-Up Heap Sort (2) private static void percolateb (char[] a, int j, int t){ int h; while ((h=2*j) a[h]) h++; // h: größerer Nachfolger swap (a, h, j); // tausche auf jeden Fall j = h; // und weiter } bubbleUp (a, j); // tausche wieder zurück wenn nötig } // percolateb private static void bubbleUp (char[] a, int j){ char x = a[j]; // Position für x gesucht for (; j > 1 && a[j/2] < x; j/=2)// bis nach oben, falls nötig: a [j] = a [j/2]; // ziehe Elemente herunter a[j] = x; // positioniere x } // bubbleUp

30 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann30 Quicksort (1): Sortieren durch Teilen Divide-&-Conquer Prinzip Sehr gute Laufzeit im Mittel, schlechte Laufzeit im worst case. Quicksort Eingabe: unsortierte Liste L, Ausgabe: sortierte Liste Quicksort(L): if (|L| <= 1) return L else waehle Pivotelement p aus L L < = {a in L | a < p} L > = {a in L | a > p} return [Quicksort(L )] L in LL> Quicksort

31 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann31 Quicksort (2): Implementation class QuickSort extends SortAlgorithm { static void sort (Orderable A[]){ /* sortiert das ganze Array */ sort (A, 1, A.length-1); } static void sort (Orderable A[], int l, int r){ /* sortiert das Array zwischen Grenzen l und r */ if (r > l) { // mind. 2 Elemente in A[l..r] int i = divide(A, l, r); sort (A, l, i-1); sort (A, i+1, r); } static int divide (Orderable A [], int l, int r) { /* teilt das Array zwischen l und r mit Hilfe des Pivot-Elements in zwei Teile auf und gibt die Position des Pivot-Elementes zurueck */... }

32 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann32 Quicksort (3): Der Aufteilungsschritt divide(A; l; r): - liefert den Index des Pivotelements in A - ausführbar in Zeit O(r – l) l r

33 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann33 Quicksort (4): Implementation, Aufteilungsschritt static int divide (Orderable A [], int l, int r) { // teilt das Array zwischen l und r mit Hilfe // des Pivot-Elements in zwei Teile auf und gibt // die Position des Pivot-Elementes zurueck int i = l-1; // linker Zeiger auf Array int j = r; // rechter Zeiger auf Array Orderable pivot = A [r]; // das Pivot-Element while (true){ // "Endlos"-Schleife do i++; while (i < j && A[i].less(pivot)); do j--; while (i < j && A[j].greater(pivot)); if (i >= j) { swap (A, i, r); return i; // Abbruch der Schleife } swap (A, i, j); }

34 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann34 Quicksort (5): Analyse Günstigster Fall: Schlechtester Fall: log n T min = O(n log n) n T max = O(n 2 )

35 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann35 Quicksort (6): Wahl des Pivotelementes Die Wahl von w (das Pivot-Element) ist entscheidend für die Effizienz: Sind F l und F r annähernd gleich groß, resultiert Laufzeit in O(n log n). Eine gute Wahl von w wäre ein mittleres Element, allerdings aufwendig zu bestimmen. Ein einfacherer Ansatz ist die Wahl des (von der Größe her) mittleren von drei Elementen, die links, rechts und in der Mitte der Folge stehen. Dabei werden sie direkt schon sortiert, womit kleine Probleme (bis zur Größe 3) bereits gelöst sind.

36 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann36 Quicksort (7): Medium-of-Three Variante private static void quickSort (char[] a, int lo, int hi){ int li = lo; int re = hi; int mid = (li+re)/2; if (a[li] > a[mid]) swap(a, li, mid); // Kleines Problem if (a[mid] > a[re] ) swap(a, mid, re); // und Vorsortieren if (a[li] > a[mid]) swap(a, li, mid); // per Bubble Sort if ((re - li) > 2){ // Großes Problem: char w = a[mid]; // Divide: do{ while (a[li] w) re--; // suche re if (li <= re) swap (a, li++, re--); // vertausche } while (li <= re); // bis fertig if (lo < re) quickSort (a, lo, re); // Conquer links if (li < hi) quickSort (a, li, hi); // Conquer rechts } // Merge unnötig } // quickSort

37 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann37 Erfolgt die Aufteilung der Folgen jeweils gleichmäßig (best case), so gilt: T(n) = 2 T(n/2) + O(n) und damit T(n) = O(n log n) Im ungünstigsten Fall (worst case) liegt das Pivot-Element ganz links oder rechts: T(n) = T(1) + T(n - 2) + O(n) und dann T(n) = O(n 2 ) Mittelt man über sämtliche Permutationen von n Schlüsseln und nimmt an, dass die Wahl des Pivot-Elementes immer zufällig erfolgt (average case), so ergibt sich für die Anzahl von Schlüsselvergleichen: Quicksort (8): Laufzeit-Abschätzung

38 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann38 Merge-Sort (1) Merge-Sort ist wie Quicksort ein Divide-&-Conquer Verfahren, anders als dieses aber mit simplem Divide- und komplizierterem Merge-Schritt. Die Datensätze der zu sortierenden Folge werden, wenn sie nicht klein genug zum direkten Sortieren sind, in zwei annähernd gleich große Teilfolgen aufgeteilt. Die Teilfolgen werden nach dem gleichen Verfahren sortiert. Anschließend werden die sortierten Teilfolgen zusammengemischt (merge). Beim Mischen müssen jeweils nur die ersten Elemente beider Folgen verglichen werden, das kleinere wird entfernt und kommt in die Ergebnisfolge. Ist eine der Teilfolgen ganz ausgeschöpft, müssen die restlichen Elemente der verbleibenden Teilfolge nur noch umkopiert werden. Eine Teilfolge mit nur einem Element ist bereits sortiert.

39 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann39 Merge-Sort (2) Der nicht-rekursive Einstieg in Merge-Sort: static void mergeSort(char[] a){ int hi = a.length-1; mergeSort (a, 0, hi); // die rekursive Variante } // mergeSort Das Zusammen-Mischen der Teilfolgen kann nicht im gleichen Array erfolgen. Es wird ein Hilfs-Array in der Größe der Ergebnisfolge benötigt.

40 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann40 Merge-Sort (3): Implementation private static void mergeSort (char[] a, int lo, int hi){ if (lo hi) || (j < m) && (a[j] < a[k])) // lazy! temp[i++] = a[j++]; // von links else temp[i++] = a[k++]; // von rechts for (int i=0; i

41 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann41 Merge-Sort (4): Analyse Aufwandsabschätzung: Die Folgen werden in allen Fällen (best, worst, average) immer gleichmäßig aufgeteilt. Das Zusammen-Mischen erfordert einen linearen Aufwand in der Länge der Ergebnisfolge. Für die Laufzeit ergibt sich: T(n) 2 T(n/2) + O(n), also T(n) O(n log n) Platzbedarf: Es wird ein zweites Array benötigt sowie Speicherplatz (Stack) zur Verwaltung der rekursiven Aufrufe.

42 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann42 Merge-Sort (5): Optimierungsmöglichkeiten Optimierungsansätze: Der Merge-Sort Algorithmus – wie angegeben – ist übersichtlich und leicht verständlich. Er kann aber zu Lasten dieser Eigenschaften weiter optimiert werden. Wie bei Quicksort, könnten weitere einfache Fälle ( n {1, 2, 3, … } ) direkt behandelt werden. Das ständige Neu-Generieren (und Verwerfen) von Hilfs-Arrays verbraucht unnötig Zeit. Effizienter ist die (Wieder-) Verwendung eines einzigen Arrays der gleichen Größe wie das Ausgangs-Array. Zudem kann man Kopier-Operationen einsparen. Ist eine Teilfolge beim Mischen ausgeschöpft, kann der Rest der anderen ohne unnötige Abfragen umkopiert werden. Bemerkungen zur Anwendung: Im Vergleich zu anderen internen Sortierverfahren schneidet Merge-Sort nicht so gut ab, weshalb es selten tatsächlich eingesetzt wird. Gut an Merge-Sort ist sein garantiertes worst case Verhalten. Varianten von Merge-Sort werden häufig beim Externen Sortieren eingesetzt.

43 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann43 Distribution-Sort (1) Bisher betrachtete Sortierverfahren sind Allgemeine Verfahren: Die erlaubten Operationen sind Schlüsselvergleiche und Elementvertauschungen. Allgemeine Sortierverfahren benötigen im worst case immer Zeit in Ω(n log n), bei einigen kann O(n log n) garantiert werden. Distribution-Sort (Sortieren durch Fach-Verteilen) kommt ganz ohne Vergleiche aus. Dafür ist ein Zugriff auf die Struktur des Schlüssels erlaubt. Die zu sortierenden Elemente werden mehrfach nach jeweils einem Teil des Schlüssels in Fächer verteilt und wieder zusammengetragen. Vorbilder sind klassische mechanische Sortieranlagen etwa für Briefe nach Postleitzahlen.

44 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann44 Distribution-Sort (2) Nachteile: Es ist nicht ganz leicht, das Vorbild (Fach-Verteilen von Briefen) überhaupt auf den Rechner zu übertragen. Im konkreten Fall kann es schwer (oder sehr aufwendig) sein, das Verfahren an einen bestimmten Sortierschlüssel anzupassen. Vorteile: Die besondere Effizienz des Verfahrens. Die Laufzeit von Distribution-Sort ist linear in der Größe der Eingabe. Wenn anwendbar, ist Distribution-Sort auch in der Praxis den bisherigen Verfahren überlegen.

45 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann45 Distribution-Sort (3): Prinzip Prinzip beim Sortieren von Briefen: 1.Die letzte Ziffer der Postleitzahl sei die aktuelle Ziffer. 2.Verteile alle Briefe in 10 Fächer mit Nummern 1, 2,..., 10 entsprechend der aktuellen Ziffer. 3.Lege alle Briefe unter Beibehaltung der bisherigen Ordnung zusammen. 4.Ist die aktuelle Ziffer die erste Ziffer, dann sind alle Briefe fertig sortiert. Ist das nicht der Fall, wird die Ziffer links der aktuellen Ziffer zur neuen aktuellen Ziffer, und es geht weiter bei Schritt 2

46 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann46 Distribution-Sort: Beispiel 1 2 3, 2 3 1, 3 1 2, 1 2 4, 2 4 1, 4 1 2, 2 3 4, 3 4 2, 4 2 3

47 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann47 Distribution-Sort (3): Beispiel Beispiel für 3-stellige Postleitzahlen: Nach 3 (# der Ziffern) Durchgängen sind alle Zahlen sortiert.

48 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann48 Distribution-Sort (4) Probleme bei der Umsetzung: Man muss beachten, wie der Schlüssel aufgebaut ist (Folge von Ziffern, Bytes, Bits,... ) und ob die Sortierung nach den Teilen eine Sortierung der Schlüssel ergibt. Dies ist etwa für Zahlen in Zweierkomplement-Darstellung nicht gegeben, kann durch Anpassung aber erreicht werden. Bei Schlüsselzerlegung in Bytes z.B. benötigt man 256 Fächer, wovon jedes im Prinzip alle Datensätze aufnehmen können muss. Durch Vorinspektion kann aber die # der Datensätze für jedes Fach – und damit seine Index-Position im Array – ermittelt werden.

49 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann49 Distribution-Sort (5) count: - … a b c d e f g h … # # Distribution-Sort für char[] mit 256 Fächern (1 Durchgang): static void distributionSort (char[] a){ int hi = a.length-1; char[] b = new char[hi+1]; // Hilfs-Array zum Umkopieren int[] count = new int[256]; // Zaehler, 0 initialisiert for (int i=0; i = 0; i--) // von hinten nach vorne: b[--count[ (int) a[i] ]] = a[i]; // umsortieren von a nach b System.arraycopy(b,0, a,0, hi+1); // Array b nach a kopieren } // distributionSort

50 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann50 Der angegebene Algorithmus distributionSort interpretiert einzelne Zeichen (char) als Bytes, funktioniert also nur bei Codierungen im Bereich 0,..., 255. Bei längeren Schlüsseln, die wirklich zerlegt werden müssen, sind entsprechend mehr Durchgänge erforderlich. Die Anzahl der Durchgänge ist eine Konstante. Pro Durchgang werden linear viele Operationen ausgeführt. Die Komplexität des Verfahrens ist in O(n). Die Bedingung einer Zerlegbarkeit der Schlüssel in Teile, deren Sortierung die Ordnung auf den Schlüsseln erhält, muss erfüllbar sein, damit das Verfahren angewandt werden kann, wie etwa bei – 5-stelligen positiven Zahlen (Postleitzahlen) – Strings der Länge 20 (fest, aber beliebig) – ganzen und reellen Zahlen (nach Anpassung) Das Verfahren lässt sich noch weiter optimieren, etwa durch Vermeiden des Rückkopierens aus dem Hilfs-Array. Statt dessen wird in aufeinander folgenden Durchgängen die Rolle der beiden Arrays vertauscht. Distribution-Sort (6)

51 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann51 Distribution-Sort (7) Distribution-Sort für char[] mit 2 Fächern (8 Durchgänge, 1 pro Bit): static void distributionSortBit (char[] a){ int hi = a.length-1; char[] b = new char[hi+1]; // Hilfs-Array zum Umkopieren for (int j=0; j >>j) & 1 ]++; // Zeichen zaehlen in Fach for (int i=1; i = 0; i--) // von hinten nach vorne: b[--count[(a[i]>>>j) & 1]] = a[i]; //umsortieren: a->b char[] h = a; a = b; b = h; //Array-Referenzen umsetzen } //for } // distributionSortBit

52 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann52 Distribution-Sort (8) Distribution-Sort für char[] mit 2 Fächern (8 × 2 Durchgänge, ohne count-Array): static void distributionSortBit2 (char[] a){ int hi = a.length-1; char[] b = new char[hi+1]; // Hilfs-Array zum Umkopieren for (int j=0; j = 0; k--) // fuer k in {1,0} for (int i = hi; i >= 0; i--) // i Zeiger in a: if ((a[i]>>>j & 1) == k) // j-tes Bit == k? b [m--] = a [i]; // umsortieren a->b char[] h = a; a = b; b = h; // Array-Referenzen // umsetzen } //for } // distributionSortBit2

53 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann53 Auswahl von Sortier-Verfahren Welches ist das beste? Bei wenigen Datensätzen ( 1000) ist die Laufzeit kaum problematisch, das einfachste Verfahren kann bevorzugt werden (Insertion, Selection, Bubble,... ). Sind die Daten fast sortiert, sollte ein Verfahren genommen werden, das Vorsortierung ausnutzt (Insertion, Bubble,... ). Sind sehr viele zufällig sortierte Elemente häufig zu sortieren, ist der Aufwand zur Anpassung von Distribution-Sort gut investiert. Will man möglichst flexibel bleiben und hat keine Angst vor dem worst case, kann man Quick-Sort einsetzen. In den restlichen Fällen wird man Shell-Sort, Merge-Sort oder Heap-Sort wählen.


Herunterladen ppt "Informatik II, SS 2008 Algorithmen und Datenstrukturen Vorlesung 10 Prof. Dr. Thomas Ottmann Algorithmen & Datenstrukturen, Institut für Informatik Fakultät."

Ähnliche Präsentationen


Google-Anzeigen