Vorlesung 15. Januar 2009

Stefan Schmid @ TU München, 2009 Was bisher geschah... Algorithmen und Datenstrukturen Analyse von Algorithmen: mit Referenzmaschine „Registermaschine“ Wichtige Kriterien: Zeit (Anzahl Schritte) und Platz (Speicher) Kostenmodelle: - uniform (Anzahl Elementarschritte, Anzahl Zellen) - logarithmisch (bezgl. Maximale Operanden / Werte) - kann grossen Unterschied machen! Analysen: worst-case vs average-case vs best-case Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Sortierproblem Eingabe: Sequenz s = <e1,…,en> mit Ordnung <= auf den Schlüsseln key(ei) (Beispiel: ) Ausgabe: Sequenz s´ = <e´1,…,e´n>, so dass key(ei)<=key(ei+1) für alle 1<=i<n und s´ eine Permutation von s ist (Beispiel: ) 5 10 1 14 3 19 1 3 10 14 19 5 Bisher: Selection Sort und Insertion Sort - beide quadratische Laufzeit - O(n2) und (n2), also (n2) In der heutigen Vorlesung werden wir das problem studieren, wie man eine Menge von Elementen sortieren kann. Wir nehmen an, dass wir zu Beginn eine beliebige Sequenz von Elementen haben. Das Ziel eines Sortieralgorithmus ist es, die Sequenz zu sortieren dass gilt, dass die neue Sequenz eine Permutation der alten ist, und jedes Element höchstens so gross ist wie das nachfolgende („aufsteigend sortiert“). Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel Achtung: Prinzip gleich wie VL, aber leicht anders (von links nach rechts)! i j 5 10 19 1 3 14 j Element grösser => weiter Prinzip: Suche Minimum im Feld rechts von i und füge es bei i ein. (Ausgabesequenz = vorne am Array) Laufe ganzes Feld nach rechts durch, swappe mit i-Position wann immer ein neuer Rekord! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 5 10 19 1 3 14 j Element grösser => weiter Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 5 10 19 1 3 14 j Element kleiner => swap! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 10 19 5 3 14 j Element kleiner => swap! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 10 19 5 3 14 j Element grösser => weiter! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 10 19 5 3 14 j Element grösser => i++; j=i+1! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 10 19 5 3 14 j Element grösser => weiter Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 10 19 5 3 14 j Element kleiner => swap! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 5 19 10 3 14 j Element kleiner => swap! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 5 19 10 3 14 j Element kleiner => swap! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 3 19 10 5 14 j Element kleiner => swap! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 3 19 10 5 14 j Element grösser => i++; j=i+1! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 3 19 10 5 14 j Element kleiner => swap! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 3 10 19 5 14 j Element kleiner => swap! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 3 10 19 5 14 j Element kleiner => swap! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 3 5 19 10 14 j Element kleiner => swap! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 3 5 19 10 14 j Element grösser => i++; j=i+1! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 3 5 19 10 14 j Element kleiner => swap! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 3 5 10 19 14 j Element grösser => i++; j:=i+1! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 3 5 10 19 14 j Element kleiner => swap! Stefan Schmid @ TU München, 2009

Selection Sort: Beispiel j 1 3 5 10 14 19 Fertig!  Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel Achtung: Prinzip gleich wie VL, aber leicht anders! j i 5 10 19 1 3 14 j Element kleiner als j+1 Element => weiter Prinzip: Für immer grössere i, lasse i-tes Element „runterblubbern“, soweit bis Nachfolger kleiner => alles links von i ist sortiert! (Ausgabesequenz = vorne am Array) Laufe Feld nach links durch soweit wie nötig, swappe mit Nachbarposition wann immer ein neuer Rekord! Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel j i 5 10 19 1 3 14 j Element kleiner als j+1 Element => weiter Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel j i 5 10 19 1 3 14 j Element kleiner als j+1 Element => weiter Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel j i 5 10 19 1 3 14 j Element grösser => swap Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel j i 5 10 1 19 3 14 j Element grösser => swap Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel j i 5 1 10 19 3 14 j Element grösser als (j+1) Element => swap Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel j i 5 1 10 19 3 14 j Element grösser als (j+1) Element => swap Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel j i 1 5 10 19 3 14 j Element grösser als (j+1) Element => swap Die 1 ist ganz „runtergeblubbert“! Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel j i 1 5 10 19 3 14 j Element grösser als (j+1) Element => swap Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel j i 1 5 10 3 19 14 j Element grösser als (j+1) Element => swap Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel j i 1 5 3 10 19 14 j Element grösser als (j+1) Element => swap Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel j i 1 3 5 10 19 14 j Element kleiner als (j+1) Element => weiter Die 3 „blubberte“ nur an zweitunterste Stelle. Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel j 1 3 5 10 19 14 j Element grösser als (j+1) Element => swap Die 14 „blubbert“ nur eine Stelle weit. Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel j i 1 3 5 10 14 19 Stefan Schmid @ TU München, 2009

Insertion Sort: Beispiel j i 1 3 5 10 14 19 Rest ok, alles schon sortiert gegen links => fertig!  Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Mergesort Idee: zerlege Sortierproblem rekursiv in Teilprobleme, die separat sortiert werden und dann verschmolzen werden 10 5 19 1 14 3 rekursiv 5 10 19 1 3 14 merge 1 3 5 10 14 19 Die Frage ist nun, ob‘s noch besser geht, d.h., ob man noch schneller sortieren kann irgendwie? Wir werden nun einen super schnellen Sortieralgorithmus kennenlernen, der auf dem „divide-and-conquer“ Prinzip beruht: das heisst, wir zerlegen das Sortierprobleme rekursiv in Teilprobleme, lösen die, und MERGEN dann die sortierten Teilsequenzen. Zum Beispiel hier: wir teilen das Array in der Mitte, sortieren die linke und die rechte Seite rekursiv, und mergen dann die beiden Teile zu einem ganz sortierten Array! Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Beispiel (Wikipedia) Beim rekursiven Abstieg passiert nichts! Hier noch ein Beispiel das ich auch auf Wikipedia gefunden habe: wir teilen das Array solange weiter in kleinere Probleme, bis nur noch einzelne Elemente da sind. Jene sind per Definition sortiert. Danach mergen wir die zusammen zu immer grösseren sortierten Arrays. Erst beim Aufstieg wird sortiert (via merge)! Stefan Schmid @ TU München, 2009

Zwei sortierte Felder mergen j k m 5 10 19 1 3 14 merge Stefan Schmid @ TU München, 2009

Zwei sortierte Felder mergen 5 10 19 1 3 14 merge 1 Stefan Schmid @ TU München, 2009

Zwei sortierte Felder mergen 5 10 19 1 3 14 merge 1 Stefan Schmid @ TU München, 2009

Zwei sortierte Felder mergen 5 10 19 1 3 14 merge 1 3 Stefan Schmid @ TU München, 2009

Zwei sortierte Felder mergen 5 10 19 1 3 14 merge 1 3 Stefan Schmid @ TU München, 2009

Zwei sortierte Felder mergen 5 10 19 1 3 14 merge 1 3 5 Stefan Schmid @ TU München, 2009

Zwei sortierte Felder mergen 5 10 19 1 3 14 merge 1 3 5 Stefan Schmid @ TU München, 2009

Zwei sortierte Felder mergen 5 10 19 1 3 14 merge 1 3 5 10 Stefan Schmid @ TU München, 2009

Zwei sortierte Felder mergen 5 10 19 1 3 14 merge 1 3 5 10 Stefan Schmid @ TU München, 2009

Zwei sortierte Felder mergen 5 10 19 1 3 14 merge 1 3 5 10 14 Stefan Schmid @ TU München, 2009

Zwei sortierte Felder mergen 5 10 19 1 3 14 merge 1 3 5 10 14 Stefan Schmid @ TU München, 2009

Zwei sortierte Felder mergen 5 10 19 1 3 14 merge 1 3 5 10 14 19 Stefan Schmid @ TU München, 2009

Zwei sortierte Felder mergen 5 10 19 1 3 14 merge 1 3 5 10 14 19 Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Mergesort Theorem 5.2: Mergesort benötigt O(n log n) Zeit, um eine Folge der Länge n zu sortieren. Beweis: T(n): Laufzeit bei Folgenlänge n T(1) = (1) und T(n) = T(bn/2c) + T(dn/2e) + (n) aus Übungsaufgabe: T(n)=O(n log n) Wie gross ist die Laufzeit von Mergesort? Man kann beweisen dass das in n log n Zeit geht! Und zwar haben wir folgende rekursive Form für die Laufzeit: (Rekursion über Feldgrösse) Ein Feld mit nur einem Element ist in konstanter Zeit sortiert Ein Feld mit n Elementen: wir rufen Mergesort zweimal mit halber Grösse auf (DIVIDE), und dann mergen wir die beiden Sachen, das geht in linearer Zeit (an jeder Stelle machen wir einen Vergleich und dann wird ein Index weitergerückt). Daraus folgt einfach: die Laufzeit ist n log n Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Quicksort Idee: ähnlich wie Mergesort, aber Aufspaltung in Teilfolgen nicht in Mitte sondern nach speziellem Pivotelement unsortiert! 10 5 19 1 14 3 ordne nach <10 und >10 5 1 3 10 19 14 rekursiv Nachdem wir nun wissen, was wir höchstens erwarten können von einem Sortieralgo, schauen wir noch einer der berühmtesten Algorithmen an, welcher auch in der Praxis oft verwendet wird! => Quicksort! Eigentlich ist er ähnlich wie Mergesort. Die Idee ist dass wir ein Pivotelement (ein spezielles Element) wählen, und dann alle Elemente die kleiner sind (unsortiert) in die Arrayfelder links tun und alle die grösser sind in die Arrayfelder rechts! Danach machen wir die beiden Hälften rekursiv genauso! Anders als bei Mergesort wo wir beim rekursiv runtergehen erst mal gar nichts machen, machen wir hier diese Aufteilung auf die beiden Seiten. Man ist also hier „ganz unten in der Rekursion“ fertig! Quicksort hat schlechtere Laufzeit im Worst-Case als Mergesort wie wir sehen werden, aber in der Praxis ist es schneller. Insbesondere vermeiden wir hier unnötige Kopieroperationen, da wir kein zweites Array brauchen! 1 3 5 10 14 19 Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Quicksort Procedure Quicksort(l,r: Integer) // a[l..r]: zu sortierendes Feld if r>l then v:=a[r]; i:=l-1; j:=r repeat // ordne Elemente nach Pivot v repeat i:=i+1 until a[i]>=v repeat j:=j-1 until a[j]<=v if i<j then a[i] $ a[j] until j<=i a[i] $ a[r] Quicksort(l,i-1) // sortiere linke Teilfolge Quicksort(i+1,r) // sortiere rechte Teilfolge Der Code sieht so aus: wir wählen als Pivotelement (gemäss dem wir die Hälften machen) ganz rechts. Dann gehen wir von links nach rechts bis wir einen Wert grösser als v (Pivot) gefunden haben. Danach gehen wir von rechts nach links bis wir einen Wert kleiner gleich v gefunden haben, dann swappen wir die beiden. i bedeutet Invariante dass links davon nie ein Element grösser als v, j ist Invariante dass rechts nie davon kleiner. Das machen wir solange bis j <= i. Dann sortieren wir rekursiv. Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Quicksort: Quicksort i: gehe solange nach links bis grösser als Pivot j: gehe solange nach rechts bis kleiner als Pivot => dann mache swap! Hier ein Beispiel für Quicksort: wir beginnen mit Index i links und Index j rechts, und gehen solange weiter bis i bei einem grösser als Pivos und j bei einem kleiner als Pivot, dann machen wir Swap, etc. Bis i>j => dann rekrusiv. Jetzt rekursiv beide Hälften mit QS! Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Quicksort: Beispiel j i Pivot! 5 10 19 1 3 14 i++, dann i: gehe solange nach rechts bis >= Pivot j--, dann j: gehe solange nach links bis <= Pivot Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Quicksort: Beispiel j i Pivot! 5 10 19 1 3 14 i<j => ok => swap! Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Quicksort: Beispiel j i Pivot! 5 10 3 1 19 14 i++ solange bis >= Pivot j-- solange bis <= Pivot Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Quicksort: Beispiel j i Pivot! 5 10 3 1 19 14 i<j : falsch => kein swap mehr! Nun noch Pivos an Position i swappen! Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Quicksort: Beispiel Pivot ist an richtiger sortierter Position! Wird nicht mehr ändern! 5 10 3 1 14 19 Sortiere rekursiv! Sortiere rekursiv! Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Quicksort Problem: im worst case kann Quicksort (n2) Laufzeit haben (wenn schon sortiert) Lösungen: wähle zufälliges Pivotelement (Laufzeit O(n log n) mit hoher W.keit) berechne Median (Element in Mitte) ! dafür Selektionsalgorithmus (Kap 5.5) Was ist die Laufzeit von Quicksort? Sieht jemand eine schlechte Sequenz? Wenn das Array bereits sortiert ist, ist die Laufzeit sehr schlecht! Die Laufzeit ist quadratisch wenn wir in jedem Step eine grosse „Hälfte“ für QS Rekursion haben, d.h., wenn Pivotelement die Elemente nicht schön in zwei gleich grosse Teile teilt! Wenn Pivot immer das grösste Element (ganz rechts gewählt: wenn sortiert immer max), wird eine Hälfte immer n-1 gross sein, also haben wir ungefähr n Rekursionstiefen und jede Rekursion kostet n viel Zeit (muss mit i ganz nach rechts laufen). Man kann zeigen, dass Quicksort aber recht gut ist, wenn man ein zufälliges Element als Pivot nimmt (resp. im Average Case): mehr als n log n kann man nicht erwarten, und das ist ist ja bekanntlich optimal. Auch wenn man sonst das Pivot intelligent wählt, kann man effizienter sein, z.B. wenn man das Pivot „in der Mitte wählt“, das heisst als Median der links und recht gleichviele Elemente hat. Stefan Schmid @ TU München, 2009

Quicksort: Worst-Case Pivot 1 1 3 5 10 14 19 Sortiere rekursiv! Stefan Schmid @ TU München, 2009

Quicksort: Worst-Case Pivot 2 1 3 5 10 14 19 Sortiere rekursiv! Stefan Schmid @ TU München, 2009

Quicksort: Worst-Case Pivot 3 1 3 5 10 14 19 Sortiere rekursiv! Stefan Schmid @ TU München, 2009

Quicksort: Worst-Case Pivot 3 1 3 5 10 14 19 Insgesamt n Rekursionen, jede Rekursion erfordert I (für i=1..n) Vergleiche mit Pivotelement => O(n2) Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Veranschaulichung (1) Falls Pivot immer in der Mitte: O(log (n)) viele Stufen ... Wieviele Vergleiche sind nötig pro Stufe? Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Veranschaulichung (2) Falls Pivot immer in der Mitte: n-1 Vergleiche mit Pivot ~ 2 * n/2 Vergleiche mit Pivots ~ 4 * n/4 Vergleiche mit Pivots ... Tiefe i: 2^i Subarrays der Grösse n/2^i. Bereits fixierte Pivots: 1+2+4+...+2^i. Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Veranschaulichung (2) Falls Pivot immer am Rand landet: n-1 Vergleiche mit Pivot n-2 Vergleiche mit Pivot n-3 Vergleiche mit Pivot ... Auch auf jeder Stufe ca. n Vergleiche! Was ist der Unterschied?? Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Veranschaulichung (3) Falls Pivot immer am Rand landet: O(n) Stufen -- nur ein neues fixes Element pro Stufe! ... Tiefe i: 1 Subarray der Grösse n-i. Bereits fixierte Pivots: i. Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Heap: DeleteMin Achtung: Min Heap! 3 18 5 8 5 8 10 9 12 15 10 9 12 15 11 18 11 Invariante: H[k] ist minimal für Teilbaum von H[k] : Knoten, die Invariante eventuell verletzen Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Heap: DeleteMin 18 5 5 8 18 8 10 9 12 15 10 9 12 15 11 11 Invariante: H[k] ist minimal für Teilbaum von H[k] : Knoten, die Invariante eventuell verletzen Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Heap: DeleteMin 5 5 18 8 9 8 10 9 12 15 10 18 12 15 11 11 Invariante: H[k] ist minimal für Teilbaum von H[k] : Knoten, die Invariante eventuell verletzen Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Untere Schranke Permutation  der Eingabefolge: Menge S: Eingabefolge: 1 3 5 10 14 19  Ein Sortieralgorithmus muss fähig sein, aus jeder beliebigen Anfangssequenz ein sortiertes Feld zu erstellen, d.h. die entsprechende Permutation vorzunehmen! 10 5 19 1 14 3 Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Untere Schranke Wenn der Algorithmus sortieren kann, kann er auch die Permutation  ausgeben (u.u.). 1 3 5 10 14 19  D.h. jeder Sortieralgorithmus kann jede Permutation der Eingabesequenz erzeugen. 10 5 19 1 14 3 Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Untere Schranke Beliebiger vergleichsbasierter Algo als Entscheidungsbaum: = Menge aller Permutationen e1<e2?  = 1 [ 2 Zeit ja nein 1 2 e3<e4? e5<e6? Die Schwierigkeit beim Beweisen von unteren Schranken ist es, dass man über alle möglichen Algorithmen argumentieren muss die Vergleiche anwenden! Die Idee für die untere Schranke ist nun, dass wir jeden beliebigen Algorithmus der ein Array der Grösse n sortieren kann als Entscheidungsbaum darstellen können. Bei diesem Baum läuft die Zeit von oben nach unten, und jeder Knote im Baum entspricht einem Vergleich von zwei Elementen. Schlussendlich muss jeder Sortieralgorithmus auch die Permutation ausgeben können, die vom unsortierten zum sortierten Feld führt. Zu Beginn, an der Wurzel des Baumes, sind noch alle Permutationen möglich. Bei jedem inneren Knoten wird die Anzahl möglicher Permutationen in zwei kleinere mögliche Permutationsmengen aufgeteilt, welche sich unterscheiden ob e1 nun grösser als e2 ist oder nicht. FRAGE: Sine diese Mengen disjunkt? Ja! Kann eine der beiden leer sein? Ja, dann ist der Vergleich aber redundant (dann wurden vorher schon die Permutationsmengen durch einen solchen Vergleich getrennt)! Das heisst, mit jedem Vergleich kommen nur noch die Permutationen in Frage, die die beiden Elemente gemäss diesem Vergleichresultat anordnen. Beispiel: Algo für sortieren von 3 Zahlen 1,2,3: Mengen {(1,2,3)(1,3,2)(2,1,3)(2,3,1)(3,1,2)(3,2,1)}. Algo der Position 1 mit Position 2 vergleicht nachher Sets: {(1,2,3)(1,3,2)(2,3,1)} und {(2,1,3)(3,1,2)(3,2,1)}. i : Permutationsmenge, die Bedingungen bis dahin erfüllt Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Untere Schranke Beliebiger vergleichsbasierter Algo als Entscheidungsbaum: 1 e1<e2? 1 = 2 [ 3 Zeit ja nein 2 3 e3<e4? e5<e6? Die Menge der Permutationen die das noch erfüllen wird immer kleiner. i : Permutationsmenge, die Bedingungen bis dahin erfüllt Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Untere Schranke Beliebiger vergleichsbasierter Algo als Entscheidungsbaum:   = {p1, p2} e1<e2? Zeit ja nein p1 p2 1 2 Der Algorithmus ist fertig, wenn die Permutation eindeutig ist: Dann ist man beim Blatt angelangt im Entscheidungsbaum. Das heisst: Jeder deterministische Sortieralgorithmus wird in einer anderen Reihenfolge die Vergleiche machen während der Ausführung, man kann die Abarbeitung der möglichen Permutationen immer so darstellen. pi : eindeutige Permutation der Eingabefolge Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Untere Schranke Beliebiger vergleichsbasierter Algo als Entscheidungsbaum:   = {p1, p2} e1<e2? Zeit ja nein p1 p2 1 2 Wieviele Blätter muss der Entscheidungsbaum haben? Wieviele Blätter muss Entscheidungsbaum haben? Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Untere Schranke Beliebiger vergleichsbasierter Algo als Entscheidungsbaum:   = {p1, p2} e1<e2? Zeit ja nein p1 p2 1 2 Soviele wie es Permutationen gibt! Jedes Blatt entspricht einer Permutation! Es gibt n! Permutationen, also n! Blätter! Wie folgt nun daraus die Laufzeit? Jede Instanz / Inputsequenz führt zu einem anderen Pfad in diesem Baum! (D.h., der deterministische Algorithmus gibt die Struktur des Entscheidungsbaums vor, welcher Pfad gewählt wird hängt von der Inputsequenz ab!) Mindestens n! viele Blätter! Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Untere Schranke Beliebiger vergleichsbasierter Algo als Entscheidungsbaum: Baum der Tiefe T: Höchstens 2T Blätter 2T >= n! , T >= log(n!) = (n log n) Zeit e.g., O() folgt aus n! ¸ (n/e)n Wie folgt nun daraus die Laufzeit? Jede Instanz / Inputsequenz führt zu einem anderen Pfad in diesem Baum! (D.h., der deterministische Algorithmus gibt die Struktur des Entscheidungsbaums vor, welcher Pfad gewählt wird hängt von der Inputsequenz ab!) Ein Baum der Tiefe T kann aber höchstens 2^T Blätter haben. Daraus folgt dass die Tiefe des Baumes – und somit die Laufzeit im Worst-Case: falls man nämlich bei dieser Frequenz soweit kommt – n log n Vergleiche braucht! => Das heisst, jeder vergleichsbasierte Algorithmus has mindestens n log n Vergleiche nötig im worst-case! Jeder vergleichsbasierte Algo hat (n log n) Laufzeit Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Beispiel Ein Algo für Arrays der Grösse 3: {(123),(132),(213),(231),(312),(321)} Position 1 < Position 2 Position 2 < Position 1 {(123),(132),(231)} {(213), (312),(321)} p2 < p3? { (132),(231)} ... {(123)} p1 < p3? Um (132) zu sortieren braucht dieser Algo 3 Vergleiche! [log(3!) = 2.58...] { (132)} {(231)} Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Also einwenig konkreter: Wir gehen durch die ganze Inputsequenz s durch, und fügen jedes Element e von s an der entsprechenden Stelle ein. (Wichtig: wir machen pushback, dadurch bleibt Reihenfolge von Elementen mit gleicher Zahl gleich wie im Input! => Stabilität) Die Ausgabe ist dann das Sequenz dieser Vektoren. Was ist die Laufzeit? Wir gehen duch alle Elemente von s durch => kostet n (pushback geht jeweils in konstanter Zeit) Danach fügen wir noch die Elemente zusammen, d.h. wir „konkatenieren“ (verketten) alle non-empty Buckets => kostet k (falls k >> n müssen wir viele leere Buckets Durchlaufen am Schluss um die Schlussordnung zu erstellen, deshalb hier noch +K) Das ist also schneller als sortieren wenn der Wertebereich K der Elemente asymptotisch kleiner ist als n log n. Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Hier noch ein Beispiel aus dem Buch. Wir machen die Buckets Beachte, dass k-Sort stabil ist, d.h. Elemente mit gleichem Key bleiben in gleicher Reihenfolge wie im Input. Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Radixsort Ideen: Benutze Repräsentation der Schlüssel K-adische Darstellung der Schlüssel Sortiere Ziffer für Ziffer gemäß KSort Behalte Ordnung der Teillisten bei Als letztes betrachten wir noch ein spezielles Sortierverfahren, das Radixsort genannt wird. Radixsort benutzt ein k Sort für jede Stelle. Konkret z.B. beim Zehnersystem (k=10) sortieren wir die Zahlen Ziffern weise, und behalten dabei die Ordnung der bereits erzeugten Teillisten bei. Wir benutzen also die Stabilitätseigenschaft von k-Sort (dass Elemente mit gleichem Key in gleicher Reihenfolge bleiben wie beim Input). Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Radixsort Procedure Radixsort(s: Sequence of Element) for i:=0 to d-1 do KSort(s,i) // sortiere gemäß keyi(x) // mit keyi(x) = (key(x) div Ki) mod K, // d.h. kleinste Ziffer zuerst! Laufzeit: O(d(n+K)) Falls maximale Zahlengröße O(log n), dann alle Zahlen <= nd für konstantes d. In diesem Fall Laufzeit für n Zahlen sortieren O(n). Bei d-ären Zahlen geht es also so: wir sortieren nach immer grösseren Ziffern mit KSort und behalten Teilordnungen bei. Wieso ist das korrekt? Induktion über sortierte Kolonne! Was ist die Laufzeit von diesem Algorithmus? Wir haben d Aufrufe von KSort, also d mal (n+K). Falls d konstant ist (konstante Anzahl Stellen) und K in O(n) ist (Alphabet höchstens so gross wie Sequenzlänge), ist Laufzeit in O(n). Oder anders gesagt: Falls die Zahlen in der Sequenz höchsten O(log n) viele Bits haben => dann sind die Zahlen also höchsten n^d gross für eine Konstante d. Das heisst, wir haben maximal d viele Stellen von Zahlen die maximal n gross sind => d = const, K = n => O(n) Also doch noch relativ grosser Sequenzraum möglich zu sortieren in linearer Zeit, nicht nur n, sondern polynomiell! Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Radixsort Beispiel (Ziffern des Zehnersystems, K=10): Ordnung nach Einerstelle: 12 203 3 74 24 17 112 1 2 3 4 5 6 7 8 9 Schauen wir ein Beispiel an fürs Zehnersystem: gegeben diese Inputsequenz, sortieren wir nach der letzten Stelle (Einerstelle). Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Radixsort Ergebnis nach Einerstelle: Ordnung nach Zehnerstelle: 12 112 203 3 74 24 17 1 2 3 4 5 6 7 8 9 Nun sortieren wir noch nach der Zehnerstelle. Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Radixsort Ergebnis nach Zehnerstelle: Ordnung nach Hunderterstelle: 203 3 12 112 17 24 74 1 2 3 4 5 6 7 8 9 Als nächstes sortieren wir nach der Zehnerstelle. Dabei behalten wir die Reihenfolge der Zahlen mit gleicher Zehnerstelle bei! Reihenfolge von Zahlen mit gleicher Zehnerstelle behalten wir bei! (Stabilität von k-Sort!) Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Radixsort Ergebnis nach Hunderterstelle: Sortiert! 3 12 17 24 74 112 203 Zauberei??? Nun machen wir das gleiche noch für die Hunderterstelle, und schon ist alles ganz sortiert! Stefan Schmid @ TU München, 2009

Stefan Schmid @ TU München, 2009 Radixsort 3135 < 3146 Korrektheit: Für jedes Paar x,y mit key(x)<key(y) gilt: es existiert i mit keyi(x)<keyi(y) und keyj(x)=keyj(y) für alle j>i (j wächst gegen links: kleine Stellen zuerst) Schleifendurchlauf für i: poss(x)<poss(y) (poss(z): Position von z in Folge s) Schleifendurchlauf für j>i: Ordnung wird beibehalten wegen pushBack in KSort Wieso funktioniert das? Wir können folgende Beobachtungen machen: Für jedes Schlüsselpaar bei welchem Schlüssel x kleiner ist als Schlüssel y gilt dass es eine Stelle gibt, bei dem der erste Schlüssel kleiner ist, und bei allen höheren Stellen sind sie gleich. Beim Schleifendurchgang i werden diese beiden Zahlen dann richtig sortiert, bei den höheren Stellen bleibt dann ihre Reihenfolge dank der Stabilität bestehen. Das ganze folgt also sozusagen über Induktion über die Stellen. Stefan Schmid @ TU München, 2009

Radixsort: Beispiel Wikipedia Input Phase 1 Phase 2 Hier zum Schluss noch ein Beispiel von Wikipedia. Wir machen k-Sort nach einer Stelle nach der anderen und lassen bestehende Sequenz solange es möglich ist. Phase 3 Output Stefan Schmid @ TU München, 2009