Sortieren durch Mischen (Mergesort; John von Neumann 1945)

Transkript

1 Sortieren durch Mischen (Mergesort; John von Neumann 1945) Gegeben folgendes Feld der Größe Die beiden "Hälften" sind hier bereits vorsortiert! Wir können das Feld sortieren, indem wir jeweils von der ersten oder der zweiten Hälfte ein Element wegnehmen, je nachdem, welches "dran" ist,... und die weggenommenen Elemente in ein anderes Feld kopieren Mischen (Merge) Vorsortierte Teilreihen Falls die beiden Hälften nicht schon sortiert sind, dann müssen sie eben vorher sortiert werden. Wie? Durch Mischen der jeweiligen Hälften (also Viertel). Und wenn die auch nicht schon sortiert sind? Dann werden eben wiederum die jeweiligen Hälften (also Achtel) gemischt, usw. bis man bei Feldern der Größe Eins angelangt ist und die sind ja stets sortiert. Mergesort beruht auf dem "Teile und herrsche" Prinzip

2 Mergesort Mergesort bei der Arbeit algorithm mergesort (F) -> FS Eingabe: eine zu sortierende Folge F Ausgabe: eine sortierte Folge FS if F einelementig then return F else teile F in der Mitte in F1 und F2; F1:= mergesort(f1); Rekursion F2:= mergesort (F2); F:= merge(f1,f2); fi return F;

3 Implementierung in C++ algorithm mergesort (F) -> FS Eingabe: eine zu sortierende Folge F Ausgabe: eine sortierte Folge FS if F einelementig then return F else teile F in der Mitte in F1 und F2; F1:= mergesort(f1); F2:= mergesort (F2); F:= merge(f1,f2); fi return F; void mergesort(int f[],int from,int to ) { // Eingabe: eine zu sortierende Folge f // Ausgabe: eine sortierte Folge fs if (from+1 == to) // einelementig return; else int mid = (from+to)/2; // teile mergesort(f, from, mid); mergesort(f, mid, to); merge(f, from, mid, to); return;

4 Algorithmus merge in Pseudocode procedure merge (F1,F2) -> F Eingabe: zwei zu sortierende Folgen F1, F2 Ausgabe: eine sortierte Folge F F:= leere Folge; while F1 oder F2 nicht leer do Entferne das kleinere der Anfangselemente aus F1 bzw. F2 Füge dieses Element an F an od; Füge die verbliebene nichtleere Folge F1 oder F2 an F an; return F; void merge( int f[], int from, int mid, int to ) { /* Eingabe: 2 Folgen F1:=F[from...mid), F2:=F[mid...to) */ Ausgabe: eine sortierte Folge F vector<int> b; // temporary field b int i1 = from; // next element in F1 int i2 = mid ; // next element in F2 while (i1 < mid && i2 < to) { if (a[i1] < f[i2]) b.push_back(f[i1++]); else b.push_back(f[i2++]); while (i1<mid) b.push_back(f[i1++]); while (i2 < to) b.push_back(f[i2++]); // copy back from the temporary field b for (int j = 0; j < b.size(); j++) f[from + j] = b[j]; return;

5 Mergesort - Komplexität und Eigenschaften void mergesort(int f[],int from,int to ) { if (from+1 == to) return; int mid = (from+to)/2; // sort the first and the second half mergesort(f, from, mid); mergesort(f, mid, to); merge(f, from, mid, to); T(N/2) T(N/2) 3N gesucht: T(N) =? Merge: je Element 1Vergleich 1 Kopieren in Hilfsarray 1 zurück kopieren = 3 N T(2 0 ) = 0 T(2 1 ) = 2 T(2 0 ) = T(2 2 ) = 2 T(2 1 ) = 2(3 2 1 ) = T(2 3 ) = 2 T(2 2 ) = 2 ( ) = T(2 4 ) = 2 T(2 3 ) = 2 ( ) = T(2 k ) = 3 2 k k T(N) 3 N log 2 N Lösung T(N) = 2 T(N/2) + 3 N Eigenschaften Mergesort Zeitkomplexität: Sensibel bzgl. Eingabevertlg: In-situ-Verfahren: Zus.Speicherbedarf: stabil: O(NlogN) nein nein N ja

6 Sortieren durch rekursives Zerlegen - Quick-Sort Quicksort (Nach C.A.R. Hoare, 1960) zerlegt, wie Mergesort, eine Folge rekursiv in Teilfolgen (Prinzip "Teile u. herrsche"), vermeidet dabei aber den Mischvorgang und benötigt dadurch weniger Resourcen Grundidee In einem Feld wird willkürlich ein Referenzelement (Pivot-Element) ausgesucht Alle anderen Elemente werden neu angeordnet: Größere Elemente rechts und kleinere bzw. gleich grosse Elemente links vom Referenzelement. Dadurch wird das Trennelement an die richtige Position gebracht. Danach wird die gleiche Zerlegung rekursiv auf das linke und rechte Teilfeld angewendet, d.h. wieder das Referenzelement aus diesen Teilfeldern an die richtige Stelle gebracht. Dies wird solange wiederholt, bis es nichts mehr zu zerlegen gibt: 0 oder 1 Element im Teilfeld! Zum Schluss ist das Feld vollständig sortiert. Zerlegen des Feldes (partition) Pivot-Element (willkürlich immer rechts aussen) Feld PE vorher linkes Teilfeld PE rechtes Teilfeld nachher

7 Quicksort - Pseudocode algorithm QuickSort( f, li, re ) Eingabe: Eine zu sortierende Folge f, die untere und obere Grenze if re>li+1 then Bestimme Position p des Pivot-Elements pn:= Zerlege(f, li, re, p); QuickSort( f, li, pn); QuickSort( f, pn+1, re ); fi Der Zerlege- Algorithmus (rechts) leistet die eigentliche Sortierarbeit algorithm Zerlege (F,li,re,p) -> pn Eingabe: zu zerlegende Folge F, untere und obere Grenze li, re Position p des Pivot-Elements pn:=li; // neue, vorläufige Position des Pivot-Elements pe:=f[p]; Tausche F[p] und F[re-1]; // Pivot-Element aus dem Arbeitsbereich nehmen for i:=li to re-2 do if F[i]<=pe then Tausche F[pn] und F[i]; pn:=pn+1; fi od Tausche F[re-1] und F[pn]; //Pivot-Element an seine endgültige Stelle return pn;

8 Quicksort bei der Arbeit Pivot-Element (willkürlich immer rechts aussen) linkes Teilfeld Feld PE vorher PE rechtes Teilfeld algorithm Zerlege (F,li,re,p) -> pn Eingabe: zu zerlegende Folge F, untere und obere Grenze li, re Position p des Pivot-Elements pn:=li; // neue, vorläufige Position des PE pe:=f[p]; Tausche F[p] und F[re-1]; for i:=li to re-2 do if F[i]<=pe then Tausche F[pn] und F[i]; pn:=pn+1; fi od Tausche F[re-1] und F[pn]; return pn; nachher Ebene 0 Ebene 1 Ebene 2 Ebene

9 Eigenschaften von Quicksort Quicksort ist ein Teile-und-Herrsche-Verfahren. Verarbeitet Daten "in situ" Ist nicht stabil benötigt im ungünstigsten Fall (=bereits sortiert) ca. N 2 /2 Vergleiche O(N 2 ) Im Idealfall (Halbierung der Teilfelder mit jeder Rekursion) O(N logn) Pivot-Element ist stets Median des Teilfelds nach dem Zerlegen Pivot-Element zufällig 1.39 O(NlogN) also ca. 40% schlechter als Idealfall Zuviel Overhead für kleine Teilfelder Es gibt viele Varianten

10 Sortieralgorithmen der STL STL stellt 3 generische Sortieralgorithmen zur Verfügung: sort, stable_sort und partial_sort. Alle sind als Funktions-Template typunabhängig implementiert. Vorbedingung: physikalisch sequentielle Container (z.b C-Field, string, vector, ) Verwendete Ordnungsrelation: operator< für den Elementtyp (default) oder benutzerdefiniert (Predicate-Objekt; siehe PG2) oder Predicate-Funktion Eigenschaft Zeitkomplexität sort partial_sort stable_sort O(N log N) bis O(N 2 ) O(N log N) O(N log N) bis O(N (log N) 2 ) Speicherkomplexität O(log N) O(1) O(N) in-situ ja ja ja Stabilität nein nein ja Hybrid-Sort (mit Quicksort) heap-sort- Prinzip merge-sort- Prinzip stable_sort ist etwa 40% langsamer als sort

11 Anwendung zu std::sort - Aufsteigend sortieren #include <iostream> #include <algorithm> #include "Time.h" using namespace std; void main() { const int MAX = 10; int iarr[max]; for( int i=0; i<max; ++i ) iarr[i] = i; random_shuffle( &iarr[0], &iarr[max] ); for( int i=0; i<max; ++i ) cout << iarr[i] << ' '; cout << endl; std::sort( &iarr[0], &iarr[max] ); for( int i=0; i<max; ++i ) cout << iarr[i] << ' '; cout << endl; unsortiert 17:05:44 01:27:01 14:55:11 15:36:27 09:02:24 21:22:52 23:38:56 11:06:47 16:09:18 19:19:47 // Adresse des ersten bzw. past-the-end Elements sortiert 01:27:01 09:02:24 11:06:47 14:55:11 15:36:27 16:09:18 17:05:44 19:19:47 21:22:52 23:38:56 Sortieren eines int-c-arrays Rational fractions[max]; for(int i=0; i<max; ++i ) fractions[i] = Rational( rand()%2000, rand()% ); for(int i=0; i<max_i; ++i ) { cout << fractions[i] << endl; cout << endl; std::sort( &fractions[0], &fractions[max_i] ); Sortieren eines Rational-C-Arrays for(int i=0; i<max; ++i ) {cout << fractions[i] << endl; cout << endl; Die Aufrufsyntax für sort und stable_sort ist identisch

12 Absteigend sortieren Alle Sortieralgorithmen brauchen eine Sortierhilfe. Diese ist im Standardfall (aufsteigende Sortierung) der '<'-Operator (s. Beispiel) Standardfall: Aufsteigende Sortierung //Sortieren im Bereich [from,to) void selectionsort( int a[], int from, int to) { int i, j, min; for( i = from; i < to ; ++i) { min = i; for( j=i+1; j < to; ++j) if( a[j] < a[min] ) min = j; swap( a[i], a[min] ); Universelle Sortieralgorithmen verwenden nicht '<' oder '>' sondern eine Vergleichsfunktion (z.b. compare), die ein Vergleichsergebnis vom Typ bool liefert (Predicate-Funktion) bool compare( int a1, int a2 ) { return (a1>a2); Absteigende Sortierung //Sortieren im Bereich [from,to) void selectionsort( int a[], int from, int to) { int i, j, min; max; for( i = from; i < to ; ++i) { min max = i; i; for( j=i+1; j < to; ++j) if( a[j] < > a[min] a[max] )) min max = = j; j; swap( a[i], a[min] a[max] ); ); //Sortieren im Bereich [from,to) void selectionsort( int a[], int from, int to) { int i, j, sel; for( i = from; i < to ; ++i) { sel = i; for( j=i+1; j < to; ++j) if( compare(a[j], a[sel]) ) sel = j; swap( a[i], a[sel] );

13 Anwendung zu std::sort - aufsteigend bzw. absteigend sortieren Es gibt mehrere Möglichkeiten ein Predicate an einen Algorithmus zu übergeben. Die Details werden erst in PG2 besprochen. Hier soll nur die Anwendung gezeigt werden. #include <iostream> #include <algorithm> #include "Rational.h" using namespace std; Gleiches Beispiel wie zuvor! Predicate-Funktionen bool less(const Rational& r1, const Rational& r2 ) { return (r1<r2); bool greater less(const Rational& r1, const Rational& r2 ) { return (r2<r1); void main() { const int MAX = 10; Hier werden nur die Namen der Predicate-Funktionen übergeben Rational fractions[max]; for( int i=0; i<max; ++i ) fractions[i] = Rational().setRandom(0,1); random_shuffle( &fractions[0], &fractions[max] ); for ( i=0; i<max; ++i ) cout << fractions[i] << ' '; cout << endl; std::sort( &fractions[0], &fractions[max], less ); for ( i=0; i<max; ++i ) cout << fractions[i] << ' '; cout << endl; std::sort( &fractions[0], &fractions[max], greater ); for ( i=0; i<max; ++i ) cout << fractions[i] << ' '; cout << endl; Aufsteigend sortieren Absteigend sortieren

14 Vergleich gemessener Laufzeiten N BubbleSort ms ms ms 45 min 76 h InsertionSort ms ms 6081 ms 10 min 17 h SelectionSort ms ms ms 20 min 33 h Mergesort ms ms ms ms ms Heapsort ms ms ms 313 ms 6451 ms Quicksort ms ms ms ms 1823 ms std::sort ms ms ms ms 2249ms Komplexität stabil in situ O(N 2 ) O(N 2 ) O(N 2 ) - O(N logn) - O(N logn) - O(N logn) - O(N logn) - Plattform: Intel X86 Prozessor, 1,66 GHz, Release-Konfiguration

15 Aufgabe: vector-container mit Rational-Objekten sortieren Lösen Sie die Aufgabe "Sortieren eines Rational-Feldes" (siehe oben) mit Hilfe eines vectors