Sortieren. Thomas Röfer. Permutationen Naives Sortieren Sortieren durch Einfügen, Auswählen, Vertauschen, Mischen QuickSort Comparator

Transkript

1 Unverstät Bremen Sorteren Thomas Röfer Permutatonen Naves Sorteren Sorteren durch Enfügen, Auswählen, Vertauschen, Mschen QuckSort Comparator

2 Unverstät Bremen Rückblck Suchen Identtät/Flache/Tefe Glechhet Lneare Suche Bnäre Suche a b null null 2 null null Aufwand Asymptotsche Komplextät Typsche Aufwandsklassen Z(n) V(n) M(n) I(n) O(1) O(1) : : swap() swap() O(log O(log n) n) : : bnarysearch() bnarysearch() O(n) O(n) : : lnearsearch() lnearsearch() O(n O(n log log n) n) : : mergesort() mergesort() O(n²) O(n²) : : selectsort() selectsort() O(n!) O(n!) : : navesort() navesort() PI2: Sorteren 2

3 Unverstät Bremen Permuteren nach Djkstra Zel Ene Funkton, de aus ener gegebenen Permutaton de jewels nächste erzeugt Voraussetzung: Es exstert ene Ordnungsrelaton zwschen den Elementen der zu permuterenden Folge Algorthmus Folge a 0 a n1 Fnde das letzte a, das klener als a +1 st Fnde das letzte a j, das größer als a st Vertausche de beden Drehe de Rehenfolge der Elemente ab a +1 um Aufwand Im Mttel O(1) m Mttel werden nur 1,76 Elemente durchsucht und umgedreht PI2: Sorteren 3

4 Unverstät Bremen Permuteren nach Djkstra PI2: Sorteren

5 Unverstät Bremen Permuteren nach Djkstra class class Permutaton Permutaton nextperm(comparable[] nextperm(comparable[] a) a) nt ; nt ; for( for( a.length a.length 2; 2; 0 0 && && a[].compareto(a[+1]) a[].compareto(a[+1]) 0; 0; ) ) ; ; f( f( nt j; nt j; for(j for(j a.length a.length 1; 1; a[j].compareto(a[]) a[j].compareto(a[]) 0; 0; j) j) ; ;,, j); j); reverse( reverse( + + 1, 1, a.length a.length 1); 1); PI2: Sorteren prvate prvate reverse( reverse( Comparable[] Comparable[] nt nt l, l, nt nt r) r) whle(l whle(l r) r) l++, l++, r); r); swap(object[] swap(object[] o, o, nt nt nt nt b) b) Object Object temp temp o[a]; o[a]; o[a] o[a] o[b]; o[b]; o[b] o[b] temp; temp;

6 Unverstät Bremen Sorteren Defnton Ene sorterte Folge S st ene Permutaton ener Folge T S perm(t) S bezechnet man als aufstegend sortert, wenn jedes Element größer oder glech senem Vorgänger n der Folge st s 0 s 1... s n1 S bezechnet man als abstegend sortert, wenn jedes Element klener oder glech senem Vorgänger n der Folge st s 0 s 1... s n1 Sorterkrterum Es wrd mmer nach enem Sorterkrterum sortert (Sorterschlüssel) Der Sorterschlüssel kann sch aus mehreren Telen zusammensetzen z.b. Name, Vorname, Telefonnummer Je komplexer der Sorterschlüssel, desto komplexer de zum Sorteren notwendgen Vergleche Indzes Zu ener Menge von Daten können mehrere sorterte Indzes vorgehalten werden PI2: Sorteren 6

7 Unverstät Bremen Naves Sorteren Algorthmus Erzeuge so lange Permutonen, bs ene entsprechend dem Krterum sortert st Aufwand Bester Fall: O(n) vorsortert Schlechtester Fall: O(½ n n!) O(n n!) erst letzte Permutaton st sortert NchtSorterthet wrd m Mttel nach der Hälfte der Vergleche festgestellt Durchschnttlcher Fall: O(½ n n! / 2) O(n n!) Sorterte Folge wrd nach der Hälfte der Permutatonen gefunden NchtSorterthet wrd m Mttel nach der Hälfte der Vergleche festgestellt PI2: Sorteren navesort( navesort( Comparable[] Comparable[] a) a) whle(!sorted(a)) Permutaton.nextPerm(a); prvate prvate boolean boolean sorted( sorted( Comparable[] Comparable[] a) a) for(nt 1; a.length; for(nt 1; a.length; ++) ++) f(a[].compareto(a[1]) f(a[].compareto(a[1]) return false; return false; return return true; true; 7

8 Unverstät Bremen Sorteren durch Enfügen PI2: Sorteren 8

9 Unverstät Bremen Sorteren durch Enfügen Algorthmus Füge alle Elemente der Rehe nach n ene ursprünglch leere Folge sortert en Problem be Rehungen: Enfügen heßt, dass alle Elemente hnter der Enfügeposton verschoben werden müssen Aufwand Doppelter Specherplatzverbrauch Bester Fall: O(n) vorsortert Schlechtester Fall: O(n²) rückwärts sortert Durchschnttlcher Fall: O(½ n²) O(n²) Ensorteren m Mttel n der Mtte nsertsort(comparable[] nsertsort(comparable[] a) a) Comparable[] Comparable[] b b (Comparable[]) a.clone(); (Comparable[]) a.clone(); for(nt for(nt 0; 0; b.length; b.length; ++) ++) nt j ; nt j ; whle(j whle(j 0 0 && && a[j a[j 1].compareTo(b[]) 1].compareTo(b[]) a[j] a[j] a[j a[j 1]; 1]; j; j; a[j] a[j] b[]; b[]; PI2: Sorteren 9

10 Unverstät Bremen Sorteren durch Auswählen PI2: Sorteren

11 Unverstät Bremen Sorteren durch Auswählen Algorthmus Falls nur noch en Element übrg st, st de Folge sortert. Ansonsten Suche nach dem klensten Element und stelle es an den Anfang, sortere den Rest. Aufwand In jedem Durchgang wrd en Element ausgewählt Um das Element auszuwählen, müssen m Mttel n/2 Elemente durchsucht werden Durchschnttlcher Fall: O(½ n n) O(½ n 2 ) O(n 2 ) selectsort(comparable[] selectsort(comparable[] a) a) for(nt for(nt 0; 0; a.length a.length 1; 1; ++) ++) for(nt for(nt j j + + 1; 1; j j a.length; a.length; ++j) ++j) f(a[].compareto(a[j]) f(a[].compareto(a[j]),, j); j); swap(object[] swap(object[] o, o, nt nt nt nt b) b) Object Object temp temp o[a]; o[a]; o[a] o[a] o[b]; o[b]; o[b] o[b] temp; temp; PI2: Sorteren 11

12 Unverstät Bremen BubbleSort PI2: Sorteren

13 Unverstät Bremen BubbleSort Algorthmus Gehe der Rehe nach durch alle Elemente und vertausche zwe jewels aufenander folgende, wenn hre Rehenfolge falsch st Wederhole des so lange, bs kene Vertauschungen mehr notwendg snd Aufwand Günstgster Fall: O(n) vorsortert Schlechtester Fall: O(n²) rückwärts sortert (maxmale Anzahl von Vertauschungen) Durchschnttlcher Fall: O(n²) m Mttel ½ n² Vertauschungen PI2: Sorteren bubblesort(comparable[] a) a) boolean boolean swapped; swapped; do do swapped false; swapped false; for(nt for(nt j 1; 1; j a.length; a.length; ++j) ++j) f(a[j].compareto(a[j 1]) 1]) j, j, j 1); 1); swapped swapped true; true; whle(swapped); whle(swapped); 13

14 Unverstät Bremen Sorteren durch Mschen PI2: Sorteren 1

15 Unverstät Bremen Sorteren durch Mschen Algorthmus Enthält de Folge ken oder nur en Element, st se sortert Ansonsten Tele de Folge n zwe glech große Hälften Sortere de Hälften Msche de sorterten Hälften weder zusammen Mschen Vergleche de beden ersten Elemente der Hälften Entnmm das klenere von beden und füge es dem Ergebns hnzu Wederhole so lange, bs bede Hälften leer snd Aufwand Folge kann log 2 (n) mal n Hälften zerlegt werden Auf jeder Ebene der Zerlegung werden alle Elemente enmal gemscht: O(n) Insgesamt (n jedem Fall): O(n log n) Platzkomplextät: 2 n Elemente bem Mschen PI2: Sorteren 1

16 Unverstät Bremen Sorteren durch Mschen class push(object) Object pop() Object top() nt length() mergesort( mergesort( q) q) f(q.length() f(q.length() 1) 1) q2 q2 new new (); (); balance(q, balance(q, q2); q2); return return merge(mergesort(q), merge(mergesort(q), else else return return q; q; mergesort(q2)); mergesort(q2)); prvate prvate balance( balance( q2) q2) whle(q1.length() whle(q1.length() q2.length()) q2.length()) q2.push(q1.pop()); q2.push(q1.pop()); prvate prvate merge( merge( q2) q2) q new (); q new (); whle(q1.length() 0 q2.length() whle(q1.length() 0 q2.length() f(q2.length() 0 q1.length() 0 f(q2.length() 0 q1.length() 0 && && ((Comparable) ((Comparable) q1.top()) q1.top()) else else.compareto(q2.top()).compareto(q2.top()) q.push(q1.pop()); q.push(q1.pop()); q.push(q2.pop()); q.push(q2.pop()); return return q; q; PI2: Sorteren 16

17 Unverstät Bremen QuckSort PI2: Sorteren

18 Unverstät Bremen QuckSort Ungünstge Vorsorterung PI2: Sorteren 18

19 Unverstät Bremen QuckSort Algorthmus Enthält de Folge ken oder nur en Element, st se sortert Ansonsten entnmm en Element (das sog. PvotElement), blde ene neue Lste aus allen kleneren Elementen und lasse dese sorteren, blde ene neue Lste aus allen größeren Elementen und lasse dese sorteren, Hänge de sorterte Lste der kleneren Elemente, das gewählte Element und de sorterte Lste der größeren Elemente anenander und lefere dese zurück. Aufwand Günstgster Fall: O(n log n) bede Tellsten snd jewels glech lang Schlechtester Fall: O(n 2 ) Ene der Tellsten st mmer leer Wenn als PvotElement mmer das erste verwendet wrd, st des be Vorsorterung der Fall! Durchschnttlcher Fall: O(n log n) Bewes sehe Ottmann / Wdmayer Ken zusätzlcher Specherbedarf be Sorterung enes Arrays! PI2: Sorteren 19

20 Unverstät Bremen QuckSort ener Warteschlange qucksort( qucksort( q) q) f(q.length() f(q.length() Comparable Comparable pvot pvot (Comparable) (Comparable) q.pop(); q.pop(); q1 q1 new new (), (), q2 q2 new new (); (); splt(q, splt(q, pvot, pvot, q2); q2); qucksort(q1); qucksort(q1); qucksort(q2); qucksort(q2); jon(q, jon(q, pvot, pvot, q2); q2); splt( splt( q, q, Comparable Comparable pvot, pvot, q2) q2) whle(q.length() whle(q.length() f(pvot.compareto(q.top()) f(pvot.compareto(q.top()) q1.push(q.pop()); q1.push(q.pop()); else else q2.push(q.pop()); q2.push(q.pop()); jon( jon( q, q, Object Object pvot, pvot, q2) q2) whle(q1.length() whle(q1.length() q.push(q1.pop()); q.push(q1.pop()); q.push(pvot); q.push(pvot); whle(q2.length() whle(q2.length() q.push(q2.pop()); q.push(q2.pop()); PI2: Sorteren 20

21 Unverstät Bremen QuckSort mt Arrays qucksort qucksort PI2: Sorteren 21

22 Unverstät Bremen QuckSort qucksort(comparable[] qucksort(comparable[] a) a) qucksort2( qucksort2( 0, 0, a.length); a.length); prvate prvate qucksort2(comparable[] qucksort2(comparable[] nt nt bottom, bottom, nt nt top) top) f(bottom + 1 top) f(bottom + 1 top) bottom, bottom, (top (top + + bottom) bottom) / / 2); 2); Comparable Comparable pvot pvot a[bottom]; a[bottom]; nt bottom + 1, nt bottom + 1, j top 1; do do j top 1; whle( top && a[].compareto(pvot) ++; whle( top && a[].compareto(pvot) ++; whle(j whle(j bottom bottom && && a[j].compareto(pvot) a[j].compareto(pvot) j; j; f( f( j) j),, j); j); whle( whle( j); j); 1, 1, bottom); bottom); qucksort2( qucksort2( bottom, bottom, 1); 1); qucksort2( qucksort2(,, top); top); PI2: Sorteren 22

23 Unverstät Bremen Schnttstelle Comparator Motvaton De Schnttstelle Comparable legt nur genau ene Ordnungsrelaton für ene Klasse fest De Schnttstelle Comparator erlaubt de Defnton belebger weterer Ordnungsrelatonen Genersche Schnttstellen nterface ComparableT nterface ComparatorT new ComparatorStrng() publc nt compare(strng Strng b) return a.compareto(b); mport mport java.utl.comparator; java.utl.comparator; selectsort(object[] selectsort(object[] Comparator Comparator c) c) for(nt for(nt 0; 0; a.length a.length 1; 1; ++) ++) for(nt for(nt j j + + 1; 1; j j a.length; a.length; ++j) ++j) f(c.compare(a[],a[j]) f(c.compare(a[],a[j]),, j); j); selectsort(strng[] selectsort(strng[] s) s) selectsort(s, selectsort(s, new new Comparator() Comparator() ); ); publc publc nt nt compare(object compare(object Object Object b) b) return return ((Strng) ((Strng) a).compareto(b); a).compareto(b); PI2: Sorteren 23