Informatik I 3. Kapitel. Sortierverfahren. Sortierverfahren. Sortierverfahren. Rainer Schrader. 28. Mai 2008

Transkript

1 Informat I 3. Kaptel Raner Schrader Zentrum für Angewandte Informat Köln 8. Ma 008 / / en bedeutender Tel der ommerzell genutzten Rechenzet wrd für Sorteren verwendet daraus resultert en Bedarf nach guten Glederung Vorbemerungen allgemene untere Schranen spezelle gegeben: Folge von Datensätzen a, a,..., a n, de Datensätze enthalten Schlüsselfelder,,..., n, auf den Schlüsseln st ene Ordnungsrelaton erlärt gesucht: Permutaton π : {,,..., n} {,,..., n} mt π() π()... π(n). 3 / 4 /

2 Man unterschedet: nternes Sorteren: alle Daten snd m Hauptspecher externes Sorteren: Daten legen auf Seundärspechern spezelle : ledglch Schlüsselverglech erlaubt allgemene : wetere Operatonen snd erlaubt Glederung Vorbemerungen allgemene untere Schranen spezelle 5 / 6 / Verenfachungen de Schlüssel snd natürlche Zahlen wr dentfzeren de Datensätze mt hren Schlüsseln: A().ey A() Laufzetmessung Anzahl der Schlüsselvergleche (Comparsons C) Anzahl der Bewegungen von Datensätzen (Movements M) m besten Fall C mn (n), M mn (n) m schlechtesten Fall C max (n), M max (n), gewünschtes Ergebns nach dem Sorteren: A() A()... A(n) m Durchschnttsfall C avg (n), M avg (n), wobe der Durchschntt wrd über alle n! möglchen Anfangsanordnungen gebldet wrd. 7 / 8 /

3 Glederung Vorbemerungen allgemene selecton sort (Sorteren durch Auswahl) nserton sort (Sorteren durch Enfügen) bubble sort (Blasensorterung) quc sort heap sort merge sort Sorteren durch Auswahl (selecton sort) suche lensten Schlüssel Poston j {,,..., n} vertausche A() mt A(j ), suche lensten Schlüssel n {, 3,..., n}, Poston j, vertausche A() mt A(j ),... untere Schranen spezelle 9 / 0 / Bespel: Programmszze A() A() A(3) A(4) A(5) for = to n- do // Bestmme Poston des Mnmums unter A(),...,A(n) mnpos = for j = + to n do f (A(j) < A(mnpos)) mnpos = j // (*) end do // Vertausche t = A(mnpos) // wäre egentlch (**) A(mnpos) = A() // ncht nötg, (**) A() = t // wenn = mnpos (**) end do / /

4 Analyse Vergleche n (*): Xn Xn C mn (n) = C max (n) = C avg (n) = (n ) = = Bewegungen n (**): = = n(n ) M mn (n) = M max (n) = M avg (n) = 3(n ) = Θ(n) = Θ(n ) Satz ann de Mnmum-Poston n der jewelgen Restfolge effzenter bestmmen werden? Antwort: NEIN, wenn man nur Vergleche zulässt, denn: Jeder Algorthmus zur Bestmmung des Mnmums von n Schlüsseln, der allen auf Schlüsselverglechen basert, muss mndestens n Schlüsselvergleche durchführen. 3 / 4 / Satz Jeder Algorthmus zur Bestmmung des Mnmums von n Schlüsseln, der allen auf Schlüsselverglechen basert, muss mndestens n Schlüsselvergleche durchführen. Bewes: Wettampf zwschen Schlüsseln, von zwe Schlüsseln und j ( j) schedet der größere aus, be jedem Wettampf schedet en Telnehmer aus, wr benötgen n Wettämpfe zur Ermttlung des Segers. Ensatz von selecton sort falls Bewegungen von Datensätzen teuer, Vergleche zwschen Schlüsseln bllg. 5 / 6 /

5 Glederung Vorbemerungen allgemene selecton sort (Sorteren durch Auswahl) nserton sort (Sorteren durch Enfügen) bubble sort (Blasensorterung) quc sort heap sort merge sort berets m letzten Kaptel behandelt, aber etwas bessere Implementerung: untere Schranen spezelle 7 / 8 /. for = to n do. ey = A() // füge A() n de sorterte Folge A(...-) en 3. j = - 4. whle (j > 0 und A(j) > ey) do 5. A(j+) = A(j) 6. j = j- end whle 7. A(j+) = ey end do for = to n do ey = A() // füge A() n de sorterte Folge A(...-) en j = A(0) = ey // Trc, um de whle-schlefe // zu verenfachen whle (A(j-) > ey) do // (*) // Verschebe A(j) = A(j-) // (**) j = j - end whle A(j) = ey // (**) end do 9 / 0 /

6 Analyse C mn (n) = n, M mn (n) = (n ) C max (n) = P n = = Θ(n ), (schon sortert) Defnton Se π =,,..., n ene Permutaton von n verschedenen Zahlen en Paar (, j ) heßt Inverson von π, falls < j und > j, Inversonszahl I(π): de Gesamtanzahl der Inversonen von π M max (n) = P n = ( + ) = Θ(n ) (umgeehrt sortert) Durchschnttsfall: Bespel: se π = (5, 6,, ) Inversonen treten auf be (5, ), (5, ), (6, ) und (6, ) somt st de Inversonszahl I(π) = 4. / / Defnton Se π =,,..., n ene Permutaton von n verschedenen Zahlen en Paar (, j ) heßt Inverson von π, falls < j und > j, Inversonszahl I(π): de Gesamtzahl der Inversonen von π, de Permutaton ˆπ = n, n,..., st de Reflexon von π. π = (5, 6,, ) ˆπ = (,, 6, 5). Lemma Se π ene Permutaton auf {,,..., n} und ˆπ de Reflexon von π. Dann st jede Inverson von n, n,..., entweder ene Inverson von π oder ene Inverson von ˆπ. Bewes: trval. De Inversonszahl st en Maß für de Vorsorterthet von π: 0 für ene aufstegend sorterte Folge, P n n(n ) = (n ) = = Θ(n ) für ene abstegend sorterte Folge. Also glt I(π) + I(ˆπ) = n(n ). 3 / 4 /

7 bezechne S n de Menge aller Permutatonen auf {,,..., n} dann st de durchschnttlche Anzahl der Inversonen gegeben durch A(n) = X I(π), n! π S n ebenso glt A(n) = X I(ˆπ) n! π S n damt folgt: Satz De durchschnttlche Anzahl der Inversonen ener Permutaton auf {,,..., n} st Bewes: n(n ) 4. A(n) = X (I(π) + I(ˆπ)) n! π S n = X n(n ) n! π S n = n(n ) 5 / 6 / Analyse des Durschnttsfalls von nserton_sort for = to n do ey = A() // füge A() n de sorterte Folge A(...-) en j = A(0) = ey // Trc, um de whle-schlefe // zu verenfachen whle (A(j-) > ey) do // (*) // Verschebe A(j) = A(j-) // (**) j = j - end whle A(j) = ey // (**) end do Analyse des Durschnttsfalls von nserton_sort für jedes Element n wrd de whle-schlefe n (*) durchlaufen (A(j-) ) beendet de Schlefe Anzahl der Abbrüche = n be (A(j-) > ) wrd der Schlefendurchlauf fortgesetzt (A(j-) > ) entsprcht enendeutg ener Inverson der Engabefolge Anzahl der Nchtabbrüche = Anzahl der Inversonen 7 / 8 /

8 Insgesamt glt also: C avg (n) = (n ) + {z } Abbrüche n(n ) 4 {z } Inversonen (n + 4)(n ) = 4 = Θ(n ) de quadratsche Laufzet hängt zusammen mt der Anzahl der Inversonen st dese len, etwa O(n), so läuft nserton_sort n lnearer Zet 9 / 30 / Glederung Vorbemerungen allgemene selecton sort (Sorteren durch Auswahl) nserton sort (Sorteren durch Enfügen) bubble sort (Blasensorterung) quc sort heap sort merge sort bubble sort (Blasensorterung) wederholtes Vertauschen benachbarter Datensätze (falls nötg), von lns nach rechts, dann dasselbe von lns bs zur vorletzten Poston, usw. seht aus we aufstegende Luftblasen untere Schranen spezelle 3 / 3 /

9 Bespel: bubble_sort for = n down to for j = to do f (A(j-) > A(j)) do // (*) vertausche A(j) und A(j-) // (**) end f end do end do / 34 / Analyse: Vergleche n (*): C mn (n) = C max (n) = C avg (n) = Bewegungen n (**): M mn (n) = 0 nx ( ) = = n(n ) = Θ(n ) n(n ) M max (n) = 3 = Θ(n ) (abstegend sortert) M avg (n) = Θ(n ) (ohne Bewes) bubble_sort st populär, aber schlecht. Glederung Vorbemerungen allgemene selecton sort (Sorteren durch Auswahl) nserton sort (Sorteren durch Enfügen) bubble sort (Blasensorterung) quc sort heap sort merge sort untere Schranen spezelle 35 / 36 /

10 Vorgehen von quc sort falls F de leere Folge st oder nur en Element hat, so blebt F unverändert, sonst dvde: wähle Pvotelement von F, tele F ohne n Telfolgen F und F mt conquer: F enthält nur Elemente F enthält nur Elemente qucsort(f); qucsort(f); danach snd F und F sortert wr önnten qucsort reursv mt loalen, zu sorterenden Feldern mplementeren es folgt ene Implementerung, de n stu sortert dazu tauschen wr de lenen Schlüssel nach vorn und de großen nach hnten de Reurson sortert dann mmer Telntervalle von [,..., n] wr wählen als Pvotelement stets das rechte Element combne: blde F durch Anenanderfügen n der Rehenfolge F,, F. 37 / 38 / wr füllen A(0) mt enem hnrechend lenen Element, um Schlefenabfragen zu verenfachen: begn A(0) = lene_zahl qucsort(a,,n) end Vorgehen zur Umsorterung Se v = A(r ) der Pvotschlüssel: en Zeger wandert vom lnen Intervallende nach rechts er stoppt, sobald er en Element mt A() v fndet en Zeger j wandert vom rechten Intervallende nach lns er stoppt, sobald er en Element mt A(j) v fndet l=4 r=9 wobe lene_zahl mn n = A() Poston Pvotelement Schlüssel j Anfangsposton j. Halt 39 / 40 /

11 Vorgehen zur Umsorterung Se v = A(r ) der Pvotschlüssel: en Zeger wandert vom lnen Intervallende nach rechts er stoppt, sobald er en Element mt A() v fndet en Zeger j wandert vom rechten Intervallende nach lns er stoppt, sobald er en Element mt A(j) v fndet de Elemente A() und A(j) werden vertauscht Poston Schlüssel l=4 r= Pvotelement j Anfangsposton j. Halt Vorgehen zur Umsorterung Se v = A(r ) der Pvotschlüssel: en Zeger wandert vom lnen Intervallende nach rechts er stoppt, sobald er en Element mt A() v fndet en Zeger j wandert vom rechten Intervallende nach lns er stoppt, sobald er en Element mt A(j) v fndet de Elemente A() und A(j) werden vertauscht danach glt: A( ) v für alle und A( ) v für alle j de Zeger wandern weter bs j glt j 4 / 4 / Se j: wenn bede ncht halten, glt für = j: v < A(j) = A() < v hält: dann st A() v, A( ) < v j hält an der Stelle und es glt A(j) v A() j hält: dann st A(j) v, A(j + ) > v hält an der Stelle j + und es glt A(j) v A() wr haben somt stets A(j) v A() und j + per Konstruton glt: A( ) v für < A( ) v für > j h somt: A(l),..., A(j) v h A(),..., A(r ) wr önnen de Elemente A() und A(r ) vertauschen und de Reurson aufrufen für de Intervalle h A(l),..., A( ) und h A( + ),..., A(r ) 43 / 44 /

12 Ablauf qucsort(a,4,9) qucsort(a,l,r) l=4 r=9 f (r > l) then do = l- j = r v = A(r) // Pvotelement repeat do = + whle (A() < v) // (*) do j = j- whle (A(j) > v) // (*) f ( >= j) goto PIVOT // Pvotposton vertausche A() und A(j) // (**) end repeat PIVOT: vertausche A() und A(r) // (**) qucsort(a,l,-) qucsort(a,+,r) end f Poston Schlüssel Pvotelement j Anfangsposton j. Halt j j. Halt Halt / 46 / Termnerung der whle-schlefen: erste Schlefe lar durch Wahl des Pvotelements ganz rechts. zwete Schlefe: qucsort(a,,n) durch Wahl von A(0) alle reursven Aufrufe der Form qucsort(a,l,r): n Poston l steht: A(0), falls l = en Pvotelement ener vorangehenden Auftelung, sonst. Das Programm st auch orret, falls Schlüssel mehrfach vorommen. Allerdngs gbt es dann unnötge Vertauschungen.. < qucsort(a,,) < < < n qucsort(a,,n-) < < < n qucsort(a,,n-) < < < n qucsort(a,,n) n n n 47 / 48 /

13 worst-case Schlüsselvergleche: aufstegend sorterte Folge!!! C max (n) = nx = = n(n + ) = Θ(n ) average-case Schlüsselvergleche: wr wollen zegen, dass qucsort m Mttel nur O(n log n) Vergleche benötgt dazu benötgen wr enen Hlfssatz über ene Reurson best-case Schlüsselvergleche: de durch de Auftelung erhaltenen Folgen F und F haben mmer ungefähr de gleche Länge dann halberen sch de zu sorterenden Intervalle n jedem Schrtt de Höhe des Reursonsbaums st Θ(log n) zur Auftelung aller Intervalle auf jedem Nveau werden Θ(n) Vergleche durchgeführt, also C mn (n) = Θ(n log n) Lemma De Reursonsglechung der Form j a für n = T (n) = a n + b n T (n ) für n P hat de Lösung T (n) = n `Πn j=+ b j a. = Dabe st we üblch das Produt über ene leere Indexmenge. 49 / 50 / T (n) = j a für n = a n + b n T (n ) für n Bewes: (Induton über n) T () = a ff T (n) = a n + b n T (n ) 0 Xn = a n + b = 0 Xn = a n = 0 = = ny j=+ n Y j=+ ny j=+ b j A a b j T (n) = b j A a A a nx `Πn j=+ b j a. = average-case Schlüsselvergleche: üblche Grundannahme: alle Schlüssel snd verscheden (obda. n {,,..., n}), alle Permutatonen snd glech wahrschenlch daraus ergbt sch: jede Zahl {,,..., n} trtt mt glecher Wahrschenlchet als Pvotelement an Poston n auf n das Pvotelement erzeugt zwe Folgen der Längen ( ) und (n ) bede snd zufällg: werden sämtlche Folgen mt n Elementen mt dem Pvotelement getelt, so erhält man sämtlche Folgen der Längen ( ) und (n ). 5 / 5 /

14 Satz De mttlere Anzahl von Verglechen und de mttlere Laufzet von Qucsort beträgt O(n log n). Bewes: Se T (n) de Laufzetfunton, d.h. für Konstanten c und d glt: 8 >< 0 für n = 0 T (n) = c für n = >: T ( ) + T (n ) + d (n ) für n n P n = wobe d (n ) der Auftelungsaufwand für ene Folge der Länge n st. Ensetzen T (0) = 0: j c für n = T (n) = P n = T ( ) + d (n ) für n n Daraus folgt: n j c für n = T (n) = P n = T ( ) + d (n ) für n (n + )T (n + ) = dn(n + ) + nx T ( ) und = Xn nt (n) = dn(n ) + T ( ) Subtraton deser beden Glechungen ergbt: Somt: T () = c =: a T (n + ) = und T (n) = a n + b n T (n ) mt a := = n n + d + n + n + T (n). ( ) d und b := +, 53 / 54 / T () = c und T (n) = a n + b n T (n ) mt a = Mt dem vorgen Lemma folgt dann: T (n) = nx `Πn j=+ b j a = = c n + c n + + nx = n (n + )d = O(n log n). (da ( ) d und b = + ( ) d nx = nx = = ln n + O()) Zusammenfassung quc sort: Schlüsselvergleche: C mn (n) = Θ(n log n) C max (n) = Θ(n ) C avg (n) = Θ(n log n) Bewegungen: M mn (n) = Θ(n) (aufstegend sorterte Folge) M mn (n) = 0, falls man überflüssge Bewegungen vermedet M max (n)? 55 / 56 /

15 M max (n) : Wr betrachten de Vertauschungen n enem Auftelungsschrtt: werden n ( ) zwe Elemente vertauscht dann st das ene lener, das andere größer als das Pvotelement also st de Anzahl der Vertauschungen be enem Auftelungsschrtt höchstens so groß we de Anzahl der Elemente n der ürzeren Telfolge wr belasten de Kosten für ene Vertauschung dem Element, das n der ürzeren Telfolge landet d.h. jedes Element wrd n enem Auftelungsschrtt mt höchstens onstanten Kosten belastet. M max (n) : Verfolgung enes Elements über den gesamten Sorterprozess: wrd deses Element mt Bewegungsosten belastet, dann reduzert sch de Länge der Telfolge, n der es sch befndet, auf höchstens de Hälfte das ann höchstens log n mal passeren, danach hat de Telfolge nur noch en Element das glt für jedes der n Elemente, also M max (n) = O(n log n) M avg (n) schent offen 57 / 58 / Dsurs: Reursve Funtonen und Stapel be jedem reursven Aufruf werden de atuellen Werte der Parameter und der loalen Varablen n enem Stac gepushed, und nach Beendgung des reursven Aufrufs weder gepopped wr haben gesehen, dass der Stapel für qucsort m worst case Θ(n) Platz benötgt des ann auf Θ(log n) gedrüct werden, wenn man stets das lenere Intervall sortert warum? (Übungsaufgabe) Abschleßende Bemerungen zu qucsort das beste Verfahren n der Praxs es gbt vele Varanten, auch solche, de den worst-case Fall ener sorterten Folge verhndern, z.b.: zufällge Wahl des Pvotelements, mttleres (Medan) von dre zufällg gewählten Elementen. man ann qucsort mt Hlfe von Stapeln ohne reursve Aufrufe mplementeren (Übungsaufgabe). 59 / 60 /

16 Glederung Vorbemerungen alle bshergen Verfahren (außer merge sort) benötgen m worst case Θ(n ) Zet wr behandeln nun mt besserem worst-case-verhalten m Folgenden sorteren wr aufstegend allgemene selecton sort (Sorteren durch Auswahl) nserton sort (Sorteren durch Enfügen) bubble sort (Blasensorterung) quc sort heap sort merge sort untere Schranen spezelle 6 / 6 / (Max)-Heap wr spechern de Schlüsselelemente F =,,..., n n enem vollständgen bnären Baum ab der Baum heßt Heap (Haufen) oder heap-geordnet, falls glt: jeder Schlüssel st mndestens so groß st we de Schlüssel sener Knder zur Ernnerung: n der sequentellen Numererung enes vollständgen Baums hat der Knoten den Vater de Schlüsselelemente snd somt heap-geordnet, wenn wr so umnumereren, dass für alle {, 3,..., n} glt:. auf jedem Pfad von der Wurzel zu enem Blatt fallen de Schlüssel monoton 63 / 64 /

17 Bespel: F = 8, 6, 7, 3, 4, 5,, Methode zum abstegenden mache aus der Engabefolge enen Heap, solange der Heap ncht leer st: gb aus, (Wert n der Wurzel) entferne aus dem Heap, mache aus den restlchen Schlüsseln enen Heap / 66 / Im Bespel: Im Bespel: Ausgabe und Entfernen von (8): Schlüssel mt höchstem Index an de Wurzel: Es bleben zwe "Telheaps" enzger Fehler m Heap / 68 /

18 Im Bespel: Verscern von nach unten durch Vertauschen mt dem jewels größeren Knd: 7 7 Methode zum aufstegenden statt der Ausgabe des jewelgen Maxmums an der Wurzel: spechere es an der Stelle des Schlüssel, der neu an de Wurzel ommt Ausgabe und Entfernen von (7), usw. 69 / 70 / Bespel: Man beachte de Analoge zu selecton sort verscere(a,, m) // Verscere A() bs höchstens nach A(m) whle (*<=m) do // hat lnes Knd j = * // j st lnes Knd von f (j < m) then do // hat rechtes Knd j+ f (A(j) < A(j+)) do j = j + end do // nun st j größtes Knd (C) end f f (A() < A(j)) then do // (C) vertausche A() und A(j)// (M) = j // verscere weter end do else = m // Heap-Bedngung erfüllt end f end whle end 7 / 7 /

19 Analyse von heap sort nach der Konstruton des ersten Heaps: Θ(n) Bewegungen n M (entferne Maxmum) en Heap mt n Elementen hat ene Höhe von log(n + ) somt benötgt das Verscern enes Knotens höchstens O( log(n + ) ) Schrtte verscere wrd n mal aufgerufen also m worst case Θ(n log n) Ausführungen von C, C, M, d.h. und C max (n) = Θ(n log n) M max (n) = Θ(n log n). Konstruton enes Heaps. Versuch für =,..., n: es se berets en Heap der Größe aufgebaut füge dem Heap en neues Blatt hnzu spechere das Element m neuen Blatt reparere durch aufwärtspumpen (analog zum verscern) benötgt m schlechtesten Fall O(n log n) Schrtte. 73 / 74 / Konstruton enes Heaps. Versuch: Idee de Telbäume unter den Blättern snd berets heap-geordnet n Elemente de Telbäume unter den Vätern von Blättern önnen n 3 Schrtten heapgeordnet werden n 4 Elemente de Telbäume unter den Gr0ßvätern von Blättern önnen n 6 Schrtten heapgeordnet werden n 8 Elemente Konstruton enes Heaps. Versuch lege de Elemente belebg n enem vollständgen Baum ab n der Rehenfolge: von unten nach oben und von rechts nach lns verscere jewels Schlüssel, deren bede Unterbäume berets de Heap-Egenschaft haben / 76 /

20 Bespel: Analyse für den Aufbau des ersten Heaps se h de Höhe des Heaps auf Tefe snd höchstens Schlüssel auf Tefe st de Anzahl der Vergleche und Bewegungen zum Verscern jewels proportonal zu h de Gesamtzahl der Vergleche und Bewegungen st damt proportonal zu höchstens hx (h ). =0 77 / 78 / es glt: hx (h ) = 0 h + (h ) + (h ) h =0 = hx h = = h hx = h es glt X =! = (n + ) (da h = log(n + ) ) = O(n). heapsort(a, n) // Baue enen Heap aus A[..n] for =n/ down to do verscere (A,,n) end do // sortere den Heap A[..n] for = n down to do vertausche A() und A() end do end verscere (A,,-) // (M) // verscere A() 79 / 80 /

21 Analyse für Heapsort C max (n) = Θ(n log n) M max (n) = Θ(n log n) emprsch: gleche Ordnungen m average-case quc sort st m Durchschntt schneller, aber der zusätzlchen Specherplatzbedarf beträgt be heap sort: O(), be quc sort: O(log n). Exurs Prortätsschlange (prorty queues) abstrate Datenstrutur bestehend aus: Objet: ene Menge S von Datensätzen mt verglechbaren Schlüssel Operatonen: Insert(S,x) fügt x zu S hnzu Maxmum(S) lefert en Element n S mt größtem Schlüssel ExtractMax(S): we Maxmum(S) plus Entfernen des geleferten Elementes aus S. 8 / 8 / Anwendung: Job Schedulng : auf ener Maschne sollen verschedene Aufträge (Jobs) hnterenander ausgeführt werden wenn en Auftrag beendet st, so folgt der mt der höchsten Prortät jederzet önnen neue Aufträge hnzu ommen Übungsaufgabe: Zegen Se, dass man Prortätschlangen mt Hlfe von Heaps mplementeren ann. Wevel Zet benötgen de dre Operatonen? Lassen sch Prortätsänderungen von Elementen aus S als zusätzlche Operatonen problemlos hnzufügen? Wenn ja, we und wevel Zet benötgen se? Glederung Vorbemerungen allgemene selecton sort (Sorteren durch Auswahl) nserton sort (Sorteren durch Enfügen) bubble sort (Blasensorterung) quc sort heap sort merge sort untere Schranen spezelle 83 / 84 /

22 merge_sort... (berets n Kaptel behandelt) merge_sort(a,p,r) f (p < r) then do Analyse für von merge_sort es glt C mn (n) = C max (n) = C avg (n) = Θ(n log n) M mn (n) = M max (n) = M avg (n) = Θ(n log n). end end f q = (p+r)/ merge_sort(a,p,q) merge_sort(a,q+,r) merge(a,p,q,r) Mergesort benötgt Θ(n) zusätzlchen Specherplatz (Lstenzeger) als Datenstrutur egnen sch auch verettete Lsten, da alle Telfolgen nur sequentell verarbetet werden es werden ene Daten bewegt, nur Zeger verändert (vortelhaft, wenn de dat-komponenten groß snd) Mergesort st daher auch als externes geegnet (wenn z.b. de Daten auf Bändern legen): 85 / 86 / man ann Varanten angeben, für de C mn (n) und M mn (n) lener snd externes Sorteren n Datensätze legen auf Bändern se de Hauptspechergröße mt n tele de Daten n n Blöce der Größe auf n der Standardvarante wrd de Engangsfolge auf enelementge Folgen herunter gebrochen dese werden reursv mttels merge zusammengemscht anstelle von enelementgen Folgen önnen monotone Telfolgen gewählt werden sortere de Blöce ntern msche de Blöce we n merge_sort Bespel: F =,, 5, 7, 3, 4, 6, 8 ann mt enem Mschvorgang sortert werden. 87 / 88 /

23 Bemerung zur Vorsorterung bswelen snd Datensätze berets vorsortert wenge der vorgestellten nutzen Vorsorterthet aus (nserton sort) qucsort hat sogar maxmale Laufzet auf ener vorsorterten Folge wr werden n enem späteren Kaptel auf das Sorteren vorsorterter Daten zuücommen. Glederung Vorbemerungen allgemene untere Schranen spezelle 89 / 90 / Annahme: alle Schlüssel snd verscheden, obda.,,..., n. wr betrachten en belebges allgemenes d.h. wr erlauben auf den Schlüsseln nur Vergleche der Form alle bshergen Verfahren benötgen m worst-case O(n log n) ann man bessere Verfahren fnden? genauer: wevele Verglechsoperatonen muss en allgemenes m worst-case durchführen? glt a a j? Auftelung n Anordnungen, de a a j erfüllen, und solche, de es ncht erfüllen a : a j > je nach Ausgang des Verglechs verzwegt das Verfahren auch de Auswahl der nächsten zu verglechenden Schlüssel ann vom Ausgang abhängen 9 / 9 /

24 Bespel: nserton sort für S, S, S 3. wr halten de ausgeführten Vergleche n enem bnären Baum fest (Entschedungsbaum) S S S 3 < S S S 3 S : S 3 < >_ S : S 3 S : S >_ S : S 3 < >_ < < S : S 3 S 3 S S S S S S S S S 3 S S 3 3 >_ >_ jeder nnere Knoten enthält en Paar (S, S j ) von Schlüsseln repräsentert enen Verglech zwschen den beden Schlüsseln hat genau zwe Söhne der lne Sohn repräsentert de Stuaton S < S j der rechte de Stuaton S S j de Blätter entsprechen Permutatonen jedes Blatt st mt ener Permutaton der Schlüssel S,..., S n marert de Permutaton n enem Blatt erfüllt alle Bedngungen, de auf dem Weg von der Wurzel zu desem Blatt auftreten. 93 / 94 / Defnton En Entschedungsbaum T löst das Sorterproblem der Größe n, wenn glt: es gbt ene Beschrftung der Blätter mt Permutatonen Π von {,..., n} für jede Engabe S,..., S n st das errechte Blatt genau dann mt Π beschrftet, wenn S Π() S Π(n). en Entschedungsbaum ann überflüssge Vergleche durchführen, er muss nur mndestens n! Blätter haben, und jede Permutaton muss als Blatt auftreten. Satz maxmale Anzahl von Verglechen = maxmale Tefe enes Blattes m Entschedungsbaum mttlere Anzahl von Verglechen = mttlere Tefe enes Blattes m Entschedungsbaum wr wssen: De maxmale und de mttlere Tefe enes Blattes n enem Bnärbaum mt Blättern beträgt mndestens log. 95 / 96 /

25 Satz Jeder Entschedungsbaum-Algorthmus benötgt m worst-case und m Mttel log n! = Ω(n log n) Vergleche, um n Elemente zu sorteren. Folgerung Heapsort und Mergesort snd asymptotsch zetoptmale Sorteralgorthmen. Bewes: der Entschedungsbaum hat mndestens n! Blätter nach obgem Satz st de maxmale und mttlere Anzahl der Vergleche log n! es glt: n! n n somt: de maxmale und mttlere Anzahl der Vergleche st von der Ordnung Ω(n log n). de untere Schrane von Ω(n log n) blebt erhalten, auch wenn de Operatonen +,,, / auf den Schlüsseln erlaubt snd, wr werden glech zegen, dass wr ene mttlere Laufzet von O(n) errechen önnen, wenn wr de Operaton zulassen. 97 / 98 / Glederung Vorbemerungen allgemene untere Schranen spezelle wr haben bsher zum Sorteren ledglch den Verglech von Schlüsseln zugelassen, wr wollen jetzt erlauben, dass de spezelle Natur der Schlüssel ausgenutzt werden ann 99 / 00 /

26 Glederung allgemene untere Schranen spezelle radx sort (Sorteren durch Fachvertelung) bucet sort Hybrdsort radx sort: Sorteren durch Fachvertelung Annahme: De Schlüssel snd m-adsche Zahlen der Länge l. Bespele: m = 0: Dezmalzahlen m = : Dualzahlen m = 6: Wörter über dem Alphabet {a, b,..., z} allgemen: m Zahlzechen, Bass m (Wurzel, radx) 0 / 0 / Bespele: = = = = Sorteren durch Fachvertelung Methode: Funtonswese ener Lochartensortermaschne = = = = 33 6 = = = / 04 /

27 Bespel: radx sort für jede Zffer n {0,..., m } exstert en Fach am Anfang st der Stapel von Karten unsortert F 9 F 8 F 7 F F 9 F 8 F 7 F Vertelen nach Poston 0 von unten nach oben: 54 F 5 5 F 5 54 Karte landet n Fach F, falls n Poston 0 Zffer steht 3 40 F F 4 40 Sammeln: Stapel aus Fach F m auf F m auf... F 0 F 3 3 F 3 38 danach Postonen,,..., l F F F F F 0 F / 06 / Korrethet von radx sort nach dem ersten Aufsammeln st der Stapel nach der Poston 0 sortert nach dem zweten Aufsammeln st der Stapel nach den Postonen 0 und sortert... nach dem (l )-ten Aufsammeln st der Stapel nach den Postonen 0 bs l sortert. Implementerung für jedes Fach n Specherplätze: verschwendet Platz statt dessen: () vor jeder Vertelungsphase zählen, we groß de Fächer werden, oder () Queues verwenden wr mplementeren Methode () 07 / 08 /

28 radxsort(a, n) for t = 0 to l- do // Feld c(0...m-) für Fachgröße Wr verwenden ene Routne Zffer m (pos, ey ): der Schlüssel ey se m-adsch dargestellt berechnet de Zffer an Poston pos: () nteger Zffer () Zffer = Zffer / m pos (3) Zffer = Zffer mod m setze c() auf 0 for = to n do j = zffer_m(t,a()) c(j) = c(j) + end do // c(j) b= Größe von Fach j c(m-) = n - c(m-) + for = to m do c(m-) = c(m-+) - c(m-) end do // c() b= Anfang von Fach 09 / for = to n do j = zffer_m(t,a()) B(c(j)) = A() c(j) = c(j) + end do opere B() nach A() end do // Vertelen: // Sammeln 0 / Analyse Laufzet T (n) = Θ(l(m + n)) Specherbedarf S(n) = Θ(m + n) für festes l und festes m st bedes lnear Natürlche Anwendung: Schlüssel mt mehreren Feldern, z.b. erfordert Tag/Monat/Jahr dre Phasen von Radxsort Nachtel: vel Specherplatz be verschedenen Schlüsseln muss l log m n sen st l = c log m n für ene Konstante c, so haben wr weder en Θ(n log n) Verfahren, das normalerwese schlechter als etwa Qucsort st / /

29 Lexographsche Ordnung se A = {a 0,..., a m } en Alphabet von m Buchstaben en Wort a... a r st ene Folge aus Buchstaben a j se ene lneare Ordnung auf A, etwa a 0 a... m wr setzen de Ordnung auf Wörter fort seen x = x... x und y = y... y l zwe Wörter über A Lexographsche Ordnung x st lexographsch lener als y (x y), falls es en mt 0 gbt, so dass x j = y j für alle j {,..., } und entweder = < l oder x y : entweder st x Anfangswort von y oder der erste Buchstabe, n dem sch x und y unterscheden, st n x lener als n y. Anton Antona ( = = 5) Anton Auto ( = <, < l, aber x + = n y + = u) radx sort lässt sch lecht auf de lexographsche Sorterung anpassen Wr besprechen jetzt en struturell noch enfaches Verfahren: <, < l und x + y +. 3 / 4 / Glederung allgemene untere Schranen Bucet sort es seen n natürlche Schlüssel,..., n se max der Maxmalwert der Schlüssel zu sorteren spezelle erzeuge max Emer (bucets) radx sort (Sorteren durch Fachvertelung) bucet sort Hybrdsort gehe de Schlüssel der Rehe nach durch wrf Schlüssel n den Emer mt Index sammel de Inhalte der Emer weder auf 5 / 6 /

30 Emer önne als verettete Lsten mplementert werden das Verfahren st effzent, wenn Schlüssel mehrfach vorommen und max len st auch wenn nur zwe verschedene Schlüsselwerte 0 und max auftreten, benötgt bucet sort max Emer Ausweg: größere Emer, de en Intervall abdecen reursve Sorterung nnerhalb jeden Emers Glederung allgemene untere Schranen spezelle radx sort (Sorteren durch Fachvertelung) bucet sort Hybrdsort 7 / 8 / Hybrdsort Annahme: De Schlüssel snd n reelle Zahlen x,..., x n (o.b.d.a. x (0, ]) gesucht: aufstegende Sorterung wr stellen en Verfahren vor, das ene Mschung aus enem spezellen und enem allgemenem darstellt. wähle ene Konstante α > 0 und erzeuge = αn leere Körbe, wrf x n den Korb x sortere de Elemente n den Körben per Heapsort und hänge de Körbe hnterenander. Beobachtung: se x < x j dann folgt x + x + x j < x j +, also x < x j somt snd de Körbe rchtg geordnet 9 / 0 /

31 Bespel: sortere: 00 Schlüssel,..., 00 Intervall [, 0.000] gesucht: aufstegende Sorterung aus natürlchen Zahlen m Satz () De Laufzet von Hybrdsort st m schlechtesten Fall O(n log n). () Snd de x unabhängg und glechvertelt, so hat Hybrdsort ene mttlere Laufzet von O(n). se max =.000 Dvson aller Schlüssel durch max ergbt x aus (0, ] se α = 0.5 dann st = αn = = 50 das Element x = 0.98 landet dann m Korb x = = 49 das Element x = 0.3 landet dann m Korb x = = 7... Bewes: () de ersten beden Schrtte benötgen O(n) se t de Anzahl der Elemente m Korb de Laufzet der zweten Phase beträgt höchstens O( P = t log t ). wegen P t = n folgt X t log t X t log n n log n und damt (). / / () jedes enzelne x j Somt: st mt Wahrschenlchet / n Korb dann st de Wahrschenlchet, dass genau h Elemente m Korb landen, glech: der Anzahl der Möglcheten, h Elemente aus n auszuwählen, mal der Wahrschenlchet, dass dese Elemente m Korb legen, und alle anderen ncht. Prob(t = h) = n h! ( )h ( )n h. Se T avg (n) de erwartete Laufzet von Hybrdsort. Dann glt: X nx T avg (n) h log h Prob(t = h) = h= Mt folgt: T avg (n) h T avg (n) h= h=! nx h log h n ( h )h ( )n h! nx h n ( h )h ( )n h.! n n! = (h(h ) + h) h (n h)!h!!! n = n(n ) + n n h h =: A(n, h) + B(n, h) nx h= A(n, h) + B(n, h) «h n h 3 / 4 /

32 A(n, h) = n(n )`n h mt P n `n h=0 h ah b n h = (a + b) n folgt: nx h A(n, h) n h h=! nx n h = n(n ) n h h h= Xn = n(n ) = = = h=0 n(n ) Xn h=0 n(n ) n h!! n h + h+ n h h n h «n n(n ) 5 / B(n, h) = n`n h entsprechend folgt: = n = n = = = = nx h= n nx h= h B(n, h) n h n h h n h nx n h+ h h= nx n h h h= n n X n h h h=0 n + n n n h n h n h n «n n n n n 0 n / nx T avg h (n) A(n, h) n h nx h + B(n, h) n h h= h= {z } {z } ` = n(n ) = n n n n(n ) n = + n n(n ) + n (wel ) n n(n ) + n (wel αn) α n = O(n). 7 /