Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Vorlesung 15. Januar 2009.

Ähnliche Präsentationen


Präsentation zum Thema: "Vorlesung 15. Januar 2009."—  Präsentation transkript:

1 Vorlesung 15. Januar 2009

2 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 TU München, 2009

3 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 TU München, 2009

4 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 TU München, 2009

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

25 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 TU München, 2009

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

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

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

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

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

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

32 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 TU München, 2009

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

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

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

36 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 TU München, 2009

37 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 TU München, 2009

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

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

40 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 TU München, 2009

41 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 TU München, 2009

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

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

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

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

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

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

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

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

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

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

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

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

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

55 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 TU München, 2009

56 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 TU München, 2009

57 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 TU München, 2009

58 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 TU München, 2009

59 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 TU München, 2009

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

61 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 TU München, 2009

62 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 TU München, 2009

63 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 TU München, 2009

64 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 TU München, 2009

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

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

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

68 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 TU München, 2009

69 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 TU München, 2009

70 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: ^i. Stefan TU München, 2009

71 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 TU München, 2009

72 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 TU München, 2009

73 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 TU München, 2009

74 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 TU München, 2009

75 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 TU München, 2009

76 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 TU München, 2009

77 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 TU München, 2009

78 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 TU München, 2009

79 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 TU München, 2009

80 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 TU München, 2009

81 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 TU München, 2009

82 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 TU München, 2009

83 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 TU München, 2009

84 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!) = ] { (132)} {(231)} Stefan TU München, 2009

85 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 TU München, 2009

86 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 TU München, 2009

87 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 TU München, 2009

88 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 TU München, 2009

89 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 TU München, 2009

90 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 TU München, 2009

91 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 TU München, 2009

92 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 TU München, 2009

93 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 TU München, 2009

94 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 TU München, 2009


Herunterladen ppt "Vorlesung 15. Januar 2009."

Ähnliche Präsentationen


Google-Anzeigen