Algo rithm en und D atenstruk turen 9. V o rlesung

Transkript

1 Algo rithm en und D atenstruk turen 9. V o rlesung Martin D ietzfelb in ger 6. J u n i 2005 T : Lineares Sondieren 0: 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: November Juli Januar Februar Juni September Maerz (4) (5) (8) April (8) August Oktober Mai (12) (2) Dezember (3) (4) (6) (10) (10) (12) F G K T u E A, T U Ilm en a u A u D FG KTuEA, TU Ilmenau AuD Prop osition Bei linearem S ond ieren in einer Tabelle d er Größ e m mit S ch lüsselmenge S = {x 1,...,x n } gilt, mit α = n/m: Die erw artete (nach (UF )) Anzah l von S ch lüsselvergleich en bei erfolgloser Suche nach y / S ist 1 ( ) (1 α) 2. Die erw artete (nach (UF )) mittlere (über x 1,...,x n ) Anzah l von S ch lüsselvergleich en bei erfolgreicher Suche nach y S ist 1 ( ) α N ur von α, nicht von n, m abhängig! Lineares Sondieren Anzahl Vergleiche α erfolglos erfolgreich FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

2 Verdoppelungsstrategie bei linearem Sondieren: V erdop p le die Tabelle, sobald der Auslastungsfaktor α = n /m einen W ert von α 0 übersteigt z.b. α 0 = 0,75 oder α 0 = 0,8. E mpfehlung: Kombiniere lineares Sondieren mit einer guten universellen H ashklasse. Nicht auf die Z ufälligkeit von S vertrauen!!!! L ineares Sondieren p asst p erfekt zu C ache-architekturen und ist in der Praxis sehr schnell. Verallgemeinerung: open addressing G eschlossenes H ashing (man bleibt in T) Für jeden Schlüssel x U gibt es eine in [m]. Sondierungsfolge h(x, 0), h(x, 1), h(x, 2),... Beim Einfügen von x und Suchen nach x w erden die Zellen von T in dieser Reihenfolge untersucht bis eine leere Zelle oder der Eintrag x gefunden w ird. (Analog empty(m), in sert(x) und looku p(x) bei linearem Sondieren.) FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Günstig: ( ) h(x, 0), h(x, 1), h(x, 2),..., h(x, m 1) erreicht jede Zelle, d.h.: (h(x, 0), h(x, 1), h(x, 2),..., h(x, m 1)) ist eine Permutation von [m]. Wenn ( ) gilt und mindestens eine Zelle in T leer ist, dann endet jede erfolglose Suche in einer leeren Zelle. Bei linearem Sondieren: h(x, k) = (h(x) + k) m o d m. Andere Folgen sind möglich, zum Beispiel... Quadratisches Sondieren h: U [m] gewöhnliche Hashfunktion. h(x, 0) = h(x) h(x, 1) = (h(x) + 1) mod m h(x, 2) = (h(x) 1) mod m h(x, 3) = (h(x) + 4) mod m h(x, 4) = (h(x) 4) mod m h(x, 5) = (h(x) + 9) mod m h(x, 6) = (h(x) 9) mod m. h(x, k) = ( h(x) + 2 k ( 1) k+1) mod m. 2 FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

3 Übung: Berechne die Folgenglieder inkrementell ohne Multiplikationen.... ja sogar ohne Divisionen (... mod m ). Idee 1: n 2 = (2n 1). Man erreicht die Quadratzahlen, indem man Inkremente 1, 3, 5,... addiert. Man erreicht die negativen Quadratzahlen modulo m, indem man (modulo m) Inkremente m 1, m 3, m 5,... addiert. Idee 2: Wenn 0 a < m,0 b m, dann ist a + b mod m einer der beiden Werte a + b und (a + b) m. Lösung: ( Bei pause wird die Abarbeitung der Prozedur unterbrochen, der Zustand aufbewahrt; beim nächsten Aufruf wird die Verarbeitung an der Unterbrechungsstelle fortgeführt. ) Quadratic Probe Sequence(x) (1) h h(x); output h; pause; (2) incr 1; n incr m 1; (3) f h; g h; (4) for j from 1 to (m 1)/2 do (7) f (f + incr); ff f m; if ff 0 then f ff; (6) output f; pause; (7) g (g + n incr); gg g m; if gg 0 then g gg; (8) output g; pause; (9) incr (incr + 2); n incr (n incr 2); FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Fakt Ist m Primzahl, m = 4j + 3 für ein j N, dann ist {h(x, k) 0 k < m} = [m], d.h. ( ) gilt. (Beweis: Elementare Zahlentheorie) Beispiel: m = 19, h(x) = 0, liefert Sondierungsfolge 0, 1, 18, 4, 15, 9, 10, 16, 3, 6, 13, 17, 2, 11, 8, 7, 12, 5, 14. M itteilung: Quadratisches Sondieren verhält sich der Erfahrung nach sehr gut. (h gut verteilend, Auslastungsfaktor 0,9.) Doppel-Hashing Benutze zwei (unabhängig berechnete) Hashfunktionen und setze, für k = 0, 1, 2,...: h 1 : U [m] h 2 : U [m 1] h(x, k) := (h 1 (x) + k (1 + h 2 (x))) mod m. Übung: Berechne die Folgenglieder inkrementell ohne Multiplikationen und Divisionen (... mod m ). FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

4 Lösung: ( Bei pause wird die Abarbeitung der Prozedur unterbrochen, Zustand aufbewahrt, bis zum nächsten Aufruf; die Verarbeitung wird an der Unterbrechungsstelle fortgeführt. ) Double Hashing Sequence(x) (1) h h 1 (x); output h; pause; (2) incr 1 + h 2 (x); (3) for j from 1 to m 1 do (4) h h + incr; hh h m; if hh 0 then h hh; (5) output h; pause; Proposition Wenn m Primzahl ist, dann gilt für Doppel-Hashing: ( ) {h(x, k) 0 k < m} = [m]. Beweis: Sei z = 1 + h 2 (x). Dann: 1 z m 1. Wenn h(x, k) = h(x, l), dann ist (h 1 (x) + k z) mod m = (h 1 (x) + l z) mod m, also (l k) z 0 (mod m), d.h. m teilt (l k) z. Da m Primzahl ist und 1 z < m, teilt m die Zahl l k, also ist k = l, weil 0 k, l < m. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Kann beweisen: Wenn h 1 (x), h 2 (x), x S, rein zufällig sind, verhält sich Doppel-Hashing sehr gut, nämlich im wesentlichen wie Uniformes Sondieren. Uniformes Sondieren / Ideales Hashing Dies ist keine Methode, sondern eine W ahrscheinlichkeitsannahme: (h(x, 0), h(x, 1),..., h(x, m 1)) ist eine rein z ufällige Permutation von [m]. Effekt: x 1,..., x n seien gespeichert; y kommt neu hinzu. Ganz egal was die Hashwerte von x 1,..., x n und was h(y, 0),..., h(y, k 1) sind: h(y, k) nimmt jeden Wert i {0,..., m 1} {h(y, 0),..., h(y, k 1)} mit derselben Wahrscheinlichkeit 1/(m k) an. (Erinnerung: Es gibt m! verschiedene Permutationen von [m].) FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

5 n: Anzahl der Schlüssel in T[0.. m 1]; α = n m. T n,m := Zahl der Schlüsselvergleiche bei erfolgloser Suche. C n,m := E(T n,m). T n,m := Zahl der Schlüsselvergleiche bei erfolgreicher Suche, gemittelt über x 1,..., x n. C n,m := E(T n,m ). Satz Unter der Annahme Uniformes Hashing gilt: (i) C n,m = m+1 m+1 n = 1 1 m+1 n Dies ist < 1 1 n/ m = 1 1 α. Wenn α fest und m, dann gilt C n,m 1 1 α.. Beweis: Bei der erfolglosen Suche gibt es 2 Fälle: 1. F a ll: T[h(y, 0)] ist leer. Wahrscheinlichkeit: m n m Kosten: F a ll: T[h(y, 0)] ist nicht leer. Wahrscheinlichkeit: n m Kosten: 1 + C m 1,n 1. (Suche in m 1 Plätzen, von denen n 1 besetzt sind.) R ekursionsformel, für 0 n < m: { 1, falls n = 0 C m,n = m n m + n m (1 + C m 1,n 1), falls n 1. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD C m,0 = 1 ; C m,1 = m 1 m + 1 m + 1 (1 + 1) = m m ; C m,2 = m 2 m + 2 m (1 + m m 1 ) = m 1 = m + 1 m 1 ; C m,3 = m 3 m + 3 m (1 + m m 2 ) = m 2 = m + 1 m 2 ; und so weiter. Ergibt: C m,n = m + 1 m + 1 n. Formaler Beweis d u rch vollstän d ige In d u ktion. Satz Unter der Annahme Uniformes H ashing gilt b ei α = n/m: (i) C n,m = m+1 m+1 n = 1 1 m+1 n Dies ist < 1 1 n/ m = 1 1 α. W enn α fest und m, dann gilt C n,m 1 1 α.. (ii) Für T n,m = m ittlere (üb er S) Anzahl getesteter Tab ellenp lätze b ei erfolgreicher Suche: C n,m = E(T n,m ) < 1 α ln ( 1 1 α ). FG K T u E A, T U Ilmen au A u D FG KTuEA, TU Ilmenau AuD

6 Beweis: Suchaufwand für x i = Einfügeaufwand für x i. Mittelung über C m,0,c m,1,...,c m,n 1: C n,m = 1 n m + 1 m + 1 (i 1) 1 i n = m + 1 ( 1 n m ) m m + 1 (n 1) = m + 1 (H m+1 H m+1 n ) n mit H k = k. L eicht zu sehen (Untersumme!): d t m+1 n t = H m+1 H m+1 n m+1 ( ln(m + 1) ln(m + 1 n) = ln m+1 m+1 n ). Also: C n,m m + 1 n ( ) 1 ln 1 n m+1 < m ( ) 1 n ln 1 n. m Für α = n/m, α fest, n, ist C n,m 1 α ln( 1 1 α ). FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Uniformes Hashing Anzahl Vergleiche α erfolglos erfolgreich Löschungen? Problem: Z.B. Quadratisches Sondieren Suchfolge Dezember mit h(dezember) = 7: 7, 8, 6, 11. T : 0: 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: April (12) August (1) Oktober (1) Mai (3) November (3) Juli (6) Juni (8) Januar (8) Februar (9) September (10) Dezember (7) Maerz (12) Lösche J uli! FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

7 Löschungen? Problem: Z.B. Quadratisches Sondieren Suchfolge Dezember mit h(dezember) = 7: 7, 8, 6, 11. T : 0: 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: April (12) August (1) Oktober (1) Mai (3) November (3)!!! Juni (8) Januar (8) Februar (9) September (10) Dezember (7) Maerz (12) Lösche Juli! Dezember wird nicht mehr gefunden. FG KTuEA, TU Ilmenau AuD Ausw eg: Zelle hat Statusvariable status (voll, leer, gelösc h t). Löschen: Zelle nicht auf leer, sondern auf gelösc h t setzen. Suchen: Immer bis zur ersten leer en Zelle gehen. Zellen, die gelösc h t sind, dürfen mit einem neuen Schlüssel überschrieben werden. Üb erlauf tritt spätestens ein, wenn die letzte leer e Zelle beschrieben werden würde. Sinnvoller: Überlauf tritt ein, wenn die Anzahl der vollen und gelösc h ten Zellen zusammen eine feste Schranke bound überschreitet. Z.B. m 1 oder α 0 m, α 0 passend zum Sondierungsverfahren. FG KTuEA, TU Ilmenau AuD empty(m): Lege leeres Array T[0.. m 1] an. ( Mögliche Einträge: (x, r, voll) oder (,, leer) oder (?,?, gelöscht). ) Initialisiere alle Zellen T[i] mit (,, leer). Initialisiere load mit 0. (Zählt nicht-leere Zellen.) Initialisiere bound (maximal m 1). looku p(x): Finde erstes j in der Indexfolge h(x, 0), h(x, 1), h(x, 2),... mit T[j].status = leer oder (T[j].status = voll und T[j].key = x); Falls T[j].status = leer: return n ot fou n d ; Sonst: return T[j].data. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

8 delete(x): Finde erstes j in der Indexfolge h(x, 0), h(x, 1), h(x, 2),... mit T[j].status = leer oder (T[j].status = voll und T[j].key = x); Falls T[j].status = leer: tue nichts; ( Warnung: not found ) Sonst: T[j].status gelöscht; insert(x, r): Finde erstes j in der Indexfolge h(x, 0), h(x, 1), h(x, 2),... mit T[j].status = leer oder (T[j].status = voll und T[j].key = x); Merke dabei das erste l in dieser Folge, das T[l].status {gelöscht, leer} erfüllt; F all 1: T[j].status = voll: T[j].data r; ( Update ) F all 2: T[l].status = gelöscht: T[l] (x, r, voll); ( überschreibe gelöschtes Feld ) F all 3: T[l].status = leer: ( j = l, neue Zelle ) if load + 1 > bound then Überlaufbehandlung else load load + 1; T[j] (x, r, voll); FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Überlaufbehandlung, V erdopplung: Sinnvoll: Überlauf tritt ein, wenn der Anteil der vollen und gelöschten Zellen zusammen eine Schranke α 0 m überschreitet. (α 0 passend zum Sondierungsverfahren festlegen.) Zähle die vollen Zellen: Anzahl v. Falls v + 1 > α 1 m für (z.b.) α 1 = 0.8α 0, verdopple Tabellengröß e. Trage Schlüssel neu in die größ ere Tabelle ein. Sonst: Trage alle Schlüssel neu in die alte Tabelle T ein. Trick für neues Eintragen: (Ohne zusätzlichen Platz. N ur für Spezialisten!) 1) Für i = 0, 1,..., m 1 tue folgendes: Wenn T[i].status = voll, setze T[i].status a lt. Wenn T[i].status = gelöscht, setze T[i].status leer. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

9 2) Für i = 0, 1,..., m 1 tue folgendes: Wenn T[i].status = alt, dann setze (x, r) (T[i].key, T[i].data), setze T[i].status = leer, und füge (x, r) ein mit folgender Besonderheit: Eine mit alt markierte Zelle wird wie leer behandelt, der dort enthaltene Eintrag (x, r ) wird durch (x, r, voll) verdrängt; (x, r )wird sofort anschließend mit demselben V erfahren eingefügt. Dies setzt sich fort, bis eine Einfügung in eine mit leer markierte Zelle erfolgt. Dann fährt man mit der Abarbeitung der i-schleife fort. Sortieren G egeben: Universum U mit totaler Ordnung <. Sortierproblem, abstrakt: Siehe Vorlesung 1. G egeben: Universum U mit totaler Ordnung <. Elemente: (Sortier-)Schlüssel. Gegeben: Folge (a 1,..., a n ) in U. Aufgabe: Arrangiere so um zu (b 1,..., b n ), dass b 1 b n. O der: Berechne eine Permutation π von {1,..., n}, die (a 1,..., a n ) sortiert, d.h. mit b i = a π(i), 1 i n, gilt b 1 b n. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Sortiermethoden, schon gesehen: Straight Insertion Sort, B ubble Sort, Shell Sort (GdP1) Viele Varianten: Sortieren Einträge enthalten neben Schlüssel weitere Daten (data); Eintrag/Item: mit Sortierschlüssel (key) versehenes Objekt. Einträge sind nur Zeiger/Referenzen auf Datensätze (mit Schlüsseln) Bei Vorkommen gleicher Sortierschlüssel: Sortierverfahren heißt stabil, wenn Objekte mit identischen Schlüsseln in der Ausgabe in derselben Reihenfolge stehen wie in der Eingabe. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

10 Sortieren a 1 a 2 a 3 a n US SO RA OR RT HM LG IE IT Eingabe: Array-Sortieren Array A[1.. n] mit Einträgen a 1,..., a n U. π(2) π(5) π(8) Item: Schlüssel x "key" Inform: dat "data" π(1) Aufgabe: Permutiere die Einträge von A[1.. n] so, dass schließlich A[1] A[2] A[3]... A[n]. Alternative: Berechne eine Permutation π von {1,..., n}, die A[1.. n] sortiert. SO RT IE RA LG OR IT HM US "Stabilität" FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Array-Sortieren Bemerkung: Permutationssortieren und gewöhnliches Sortieren sind praktisch dasselbe Problem. Wenn man das eine gelöst hat, kann man das andere in zusätzlicher Zeit O(n) lösen. 1) Gegeben sei eine Permutation π von {1,..., n}, die A[1.. n] sortiert. Transportiere A[i] nach B[π(i)], i = 1,..., n. Dann kopiere B[i] nach A[i], i = 1,..., n. Array-Sortieren Bemerkung: Permutationssortieren und gewöhnliches Sortieren sind praktisch dasselbe Problem. Wenn man das eine lösen kann, kann man das andere in zusätzlicher Zeit O(n) lösen. 2) Gegeben sei ein gewöhnliches Sortierverfahren S. Eingabe: A[1.. n]. Setze B[i] (B[i],i), für 1 i n. Zweite Komponente: index. Sortiere B[1.. n] mittels S, Sortierschlüssel: erste Komponente. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

11 Beispiel: Array-Sortieren A: B: index: B, sortiert: index: π: π(b[i].index) i, für 1 i n. Verifiziere Korrektheit! Listen-Sortieren Eingabe: Liste L mit Einträgen a 1,..., a n U. Aufgabe: Permutiere die Listenelemente in L so, dass schließlich die Einträge in L aufsteigend sortiert sind. α: β: γ: δ: γ: β: δ: α: Nur Zeiger ( ) ändern sich. Vorteil: Kein Datentransport. Kosten: Platz für Zeiger.... FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Maß zahlen für Sortieralgorithmen: In Abhängigkeit von n fragen wir nach: 1. Laufzeit (in O-Notation); wenn dieser nur O(1), also von n unabhängig, ist: Algorithmus arbeitet in situ. 2. Anzahl der Vergleiche A[i] < A[j] bzw. A[i] A[j] ( wesentliche V ergleiche ); 3. Anzahl der Datenverschiebungen oder Kopiervorgänge (wichtig bei sehr umfangreichen Objekten); 4. der neb en A (und pi) benötigte Speicherplatz; FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

12 Mergesort - Sortieren durch Mischen (engl. merge = vermengen, reißverschlussartig zusammenfügen) Algorithmenparadigma oder -schema: divide-and-conquer (D -A-C ) ( teile und herrsche ) Vorgehen eines D-A-C-Algorithmus A für Berechnungsproblem P auf Instanz x I : 0. Trivialitätstest: Wenn P für x einfach direkt zu lösen ist, tue dies. Sonst: 1. Teile: Zerteile x in (zwei oder mehr) Stücke x 1, x 2,..., x b. Wesentlich für Korrektheit/Terminierung: Jedes der Stücke ist kleiner als x. 2. R ekursion: Löse P für x 1, x 2,..., x b, durch rekursive Verwendung von A. 3. Kombiniere: Baue aus den Teillösungen für die Stücke x 1, x 2,..., x b eine Lösung für x auf. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Mergesort ist konkreter D-A-C-Algorithmus zum Sortieren eines Arrays A[1.. n]: 0. Trivialitätstest: Wenn n 1, ist nichts zu tun. 1. Teile: Zerlege A in zwei gleichgroße Teilarrays A 1 und A Rekursion: Sortiere A 1 und A 2 durch rekursive Aufrufe von Mergesort. 3. Kombiniere: Konstruiere aus den sortierten Teilarrays aus 2. ein sortiertes Array, das alle Einträge enthält. Gegeben sei eine Prozedur merge(a, m, b), 1 a m < b n d ie folgen d es tu t: V ora u ssetzu n g: A[a..m] u n d A[m + 1..b] sin d sortiert. Resu lta t: A[a..b] ist sortiert. A n sa tz: Qu a sip ara lleler D u rch la u f d u rch d ie T eilarrays. D eta ils: Siehe V o rlesu ng G dp 1. A u fw a n d : b a S ch lü sselvergleich e, Zeit Θ (b a + 1). Technisch günstiger: Mergesort sortiert ein Teilarray A[a.. b]. FG KTuEA, TU Ilmenau AuD F G K T u E A, T U Ilm en a u A u D

13 Algorithm us m ergesort(a, b) (1) if b a > 1 then (2) m (b a) div 2; (3) m ergesort(a, m); (4) m ergesort(m + 1, b); (5) m erge(a, m, b). Terminierung, Korrektheit: Induktion üb er k = b a + 1: Klar falls a = b. Falls a < b: Teilarrays hab en L ängen (b a + 1)/2 und (b a + 1)/2 b eides < (b a + 1). N ach I.V. liefern die rekursiven Aufrufe in (3) und (4) das korrekte Resultat. N ach Annahme üb er m erge sortiert dann Zeile (5) korrekt. Zeitanalyse: 1) Die Kosten (Rechenzeit) sind proportional zur Anzahl der durchgeführten Vergleiche. 2) W ir fi nden eine obere Schranke C MS (k) für die Anzahl der Vergleiche, die mergesort(a, b) ausführt, auf k = b a + 1 Schlüsseln. R ek ursionsungleichung: C MS (1) = 0; C MS (k) k 1 +C MS ( k/2 ) + C MS ( k/2 ), }{{} m erge für k 2. Resultierende Schranken: FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD k C MS (k) Diff.: log k Kann zeigen: C MS (k) 1 i k log i. Exakte B erechnung der Summe ist möglich. Liefert: C MS (k) log k k 2 lo g k + 1. E ntw icklungsmethode : Lösung für den Fall k = 2l. C MS (k) = C MS (2 l ) 2 l + 2 C MS (2 l 1 ) 2 l l C MS (2 l 2 ) 3 2 l C MS (2 l 3 )... j 2 l + 2 j C MS (2 l j )... l 2 l + 2 l C MS (2 l l ) = k log k. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

14 Alternative: Direkte Analyse, Induktionsbeweis. T MS (k) seien die Kosten eines Aufrufs mergesort(a, b), auf k = b a + 1 Schlüsseln, im schlechtesten Fall. Es gibt Konstante c > 0 und d > 0 mit T MS (1) c; T MS (k) d k + T MS ( k/2 ) + T MS ( k/2 ), für k 2. Trick: Lösung mit P arametern A, B raten; der Induktionsbeweis liefert die richtigen P arameter. Behauptung: T MS (k) A k + Bk log k, für alle k 1. Beweis: Induktion über k. Interessant: Die genauen Werte A und B werden erst durch die Rechnung ermittelt. k = 1: T MS (1) c A k, falls A c. k 2: FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD T MS (k) d k + T MS ( k/2 ) + T MS ( k/2 ) I.V. d k + A k/2 + B k/2 log k/2 + A k/2 + B k/2 log k/2 d k + Ak + Bk log k/2 d k + Ak + Bk(log k ) Analog zeigt man: T MS (k) A k+b k log k, für gewisse Konstanten A, B > 0. denn: k 3 log(k + 1) log k Also: T MS (k) (d + A 0.4B)k + Bk log k. Wenn wir A = c und B = d/0.4 wählen, funktioniert der Induktionsbeweis. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

15 Satz Die Anwendung des Mergesort-Algorithmus, d. h. der Aufruf mergesort(1, n), auf einem Array von n Objekten benötigt höchstens n log n Vergleiche und hat Kosten (Laufzeit) O(n log n). M ergesort ist stabil (wenn merge entsprechend eingestellt wird). M ergesort benötigt zusätzlichen Speicherplatz, ist also nicht in situ, (n/2 Arrayeinträge, wenn man weiter keine Vorkehrungen trifft). Variante 1: (Standardmäß ig angewandt) Ziel: Überproportional hohen Zeitaufwand für rekursive Aufrufe bei kleinen Teilarrays vermeiden. Strategie: In mergesort kleine Teilarrays (b a, 1 konstant) durch (z. B.) Straight-Insertion- Sort sortieren. Das optimale auf einer konkreten Maschine kann nur ein Experiment liefern. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Variante 2: Sortieren von (linearen) Listen. Wenn die Liste L nur ein Element enthält, ist nichts zu tun. Andernfalls wird die Liste in 2 Teillisten L 1, L 2 der halben Länge zerteilt. (Durchlaufe L, hänge die Einträge abwechselnd an L 1 und L 2 an. Kosten: Θ(Länge von L).) Auf L 1 und L 2 wird der Algorithmus rekursiv angewendet. Dann werden die beiden nun sortierten Listen gemischt. (Vgl. Übung zu dünn besetzten Matrizen.) Laufzeitanalyse: Identisch zum Obigen. Variante 3: Iteratives Mergesort, b ottom-up Idee: Arbeite in Runden i = 1, 2, 3,..., log n. Vor Runde i: Teilarrays A[(l 1)2 i l2 i ] sind aufsteigend sortiert. (Eventuell ist das am weitesten rechts stehende Teilarray unvollständig.) In Runde i führe merge((l 2)2 i + 1, (l 1)2 i, l2 i ) aus, für l = 2, 4,..., 2 n/2 i+1. (Mögliche Sonderrolle für unvollständige Teilarrays ganz rechts.) FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

16 Beisp iel: Runde Trick, spart Kopierarbeit: Benutze 2 Arrays, die in jeder Runde ihre Rolle wechseln. 1 A: Zeitverhalten von iterativem Mergesort: wie bei rekursivem Mergesort. 2 C: Bei dieser Variante bietet sich noch eine alternative, einfache Zeitanalyse an: 3 A: J ede Runde kostet offenbar Zeit Θ(n), und es gibt log n Runden: also ist die Gesamtzeit 4 C: Θ(n log n ) = Θ(n log n). A: FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Variante 4: Mehrweg-Mergesort Besonders in Kombination mit dem iterativen Verfahren interessant ist die Möglichkeit, in einer merge-runde nicht nur ein Array, sondern 3, 4, oder mehr Teilarrays zusammenzumischen. Beispiel: A: Bei Cache-Architekturen oder Sortieren von Daten auf H intergrundspeichern (Platten) kann diese Variante Laufzeitvorteile bringen, da die Anzahl der Cache- bzw. Seitenfehler (cache m isses bzw. page faults) verringert wird. Früher: Sortieren von Daten auf Bändern. Algorithmus der Wahl: Mergesort. 4 way merge: wähle kleinstes Element aus 4 (Rest )Arrays. C: Die nächsten gewählten Elemente: "9" aus 2. Teilarray, 10, 11, etc. "9" aus 1.Teilarray, FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD