Algorithmen. Markus Lohrey. Wintersemester 2016/2017. Universität Siegen. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

Transkript

1 Algorithmen Markus Lohrey Universität Siegen Wintersemester 2016/2017 Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

2 Überblick, Literatur Überblick: 1 Grundlegendes 2 Divide & Conquer 3 Sortieren 4 Greedyalgorithmen 5 Dynamische Programmierung 6 Graphalgorithmen Literatur: Cormen, Leiserson Rivest, Stein. Introduction to Algorithms (3. Auflage); MIT Press 2009 Schöning, Algorithmik. Spektrum Akademischer Verlag 2001 Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

3 Landau Symbole Grundlegendes Seien f,g : N N Funktionen. Es gilt g O(f), falls c > 0 n 0 n n 0 : g(n) c f(n). Also: g wächst nicht schneller als f. Es gilt g o(f), falls c > 0 n 0 n n 0 : g(n) c f(n). Also: g wächst echt langsamer als f. g Ω(f) f O(g) Also: g wächst mindestens so schnell wie f. g ω(f) f o(g) Also: g wächst echt schneller als f. g Θ(f) (f O(g) g O(f)) Dies heißt, g und f wachsen asymptotisch gleichschnell. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

4 Grundlegendes Jensen s Ungleichung Sei f : D R eine Funktion, wobei D R ein Intervall ist. f ist konvex, falls für alle x,y D und all 0 λ 1 gilt: f(λx +(1 λ)y) λf(x)+(1 λ)f(y). f ist konkav, falls für alle x,y D und all 0 λ 1 gilt: f(λx +(1 λ)y) λf(x)+(1 λ)f(y). Jensens Ungleichung Ist f konkav, so gilt für alle x 1,...,x n D und alle λ 1,...,λ n 0 mit λ 1 + +λ n = 1: ( n ) n f λ i x i λ i f(x i ). i=1 Ist f konvex, so gilt für alle x 1,...,x n D und alle λ 1,...,λ n 0 mit λ 1 + +λ n = 1: ( n ) n f λ i x i λ i f(x i ). i=1 Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306 i=1 i=1

5 Komplexitätsmaße Grundlegendes Wir beschreiben die Laufzeit eines Algorithmus A als eine Funktion in Abhängigkeit von der Eingabelänge n. Standard: Komplexität im ungünstigsten Fall (worst case). Maximale Laufzeit über alle Eingaben der Länge n: wobei X n = {x x = n}. t A,worst (n) = max{t A (x) x X n }, Kritik: Unrealistisch, da Worst-Case Eingaben in der Praxis häufig nicht auftreten. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

6 Komplexitätsmaße Grundlegendes Alternative: Komplexität im Mittel (average case). Benötigt eine Wahrscheinlichkeitsverteilung auf der Menge X n. Standard: Gleichverteilung, d.h. Prob(x) = 1 X n. Mittlerer Zeitbedarf: t A,Mittel (n) = x X n Prob(x) t A (x) = 1 X n x X n t A (x) Problem: Häufig schwer zu analysieren. Beispiel: Quicksort (bei Gleichverteilung) Beim Quicksort-Algorithmus ist die Anzahl der Vergleiche im ungünstigsten Fall t Q (n) Θ(n 2 ). Mittlerer Anzahl der Vergleiche: t Q,Mittel (n) = 1.38nlogn Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

7 Grundlegendes Maschinenmodelle: Turingmaschine Die Turingmaschine (TM) ist ein mathematisch leicht exakt beschreibbares Berechnungsmodell. Aber: Der zeitraubende Speicherzugriff (Bandzugriff) in der Realität nicht gegeben. Arbeitet ein Algorithmus auf einer TM schnell, so ist er schnell! Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

8 Grundlegendes Maschinenmodelle: Registermaschine (RAM) x 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8 x 9... Eingabe READ ONLY RAM IC Programm Speicher 0 = Akku 1 = 1.Reg 2 = 2.Reg 3 = 3.Reg 4 = 4.Reg... y 1 y 2 y 3 y 4 y 5 y 6 y 7 y 8 y 9... Ausgabe WRITE ONLY Annahme: Elementare Registeroperationen (z.b. arithmetische Operationen +,,, DIV, Vergleiche, bitweises UND bzw. ODER) können in einem Rechenschritt durchgeführt werden. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

9 Überblick Divide & Conquer Lösen von Rekursionsgleichungen Mergesort Schnelle Multiplikation ganzer Zahlen Matrixmultiplikation nach Strassen Schnelle Fourier Transformation Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

10 Divide & Conquer Divide & Conquer: Grundidee Als erstes zentrales Entwurfsprinzip für Algorithmen wollen wir Divide & Conquer kennenlernen: Grundidee: Zerlege die Eingabe in mehrere (meistens ungefähr gleich große) Teile Löse das Problem auf jedem Teil der Eingabe separat (Rekursion!) Füge die Teillösungen zu einer Gesamtlösung zusammen. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

11 Divide & Conquer Rekursionsgleichungen Divide & Conquer führt auf natürliche Weise zu Rekursionsgleichungen. Annahmen: Eingabe der Länge n wird in a viele Teile der Größe n/b zerlegt. Zerlegen sowie Zusammenfügen der Teillösungen benötigt Zeit g(n). Für eine Eingabe der Länge 1 beträgt die Rechenzeit g(1). Dies führt für die Rechenzeit zu folgender Rekursionsgleichung: t(1) = g(1) t(n) = a t(n/b)+g(n) Technisches Problem: Was, wenn n nicht durch b teilbar ist? Lösung 1: Ersetze n/b durch n/b. Lösung 2: Wir setzen voraus, dass n = b k für ein k 0. Falls dies nicht erfüllt ist: Strecke die Eingabe (Für jede Zahl n existiert ein k 0 mit n b k < bn). Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

12 Divide & Conquer Lösen einfacher Rekursionsgleichungen Theorem 1 Seien a,b N und b > 1, g : N N und es gelte die Rekursionsgleichung: t(1) = g(1) t(n) = a t(n/b)+g(n) Dann gilt für n = b k (d.h. für k = log b (n)): t(n) = k a i g i=0 ( n b i ). Beweis: Induktion über k. k = 0 : Es gilt n = b 0 = 1 und t(1) = g(1). Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

13 Divide & Conquer Lösen einfacher Rekursionsgleichungen k > 0 : Nach Induktion gilt Also: t(n) = a t = a = = ( k 1 ( n k 1 t = a b) i g ( n b) +g(n) a i g i=0 k a i g i=1 k a i g i=0 i=0 ( n b i+1 ) ) +g(n) ( n ) ( n ) b i +a 0 g b 0 ( n b i ). ( n b i+1 ). Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

14 Mastertheorem I Divide & Conquer Theorem 2 (Mastertheorem I) Seien a,b,c,d N, mit b > 1 und es gelte die Rekursionsgleichung: t(1) = d t(n) = a t(n/b)+d n c Dann gilt für alle n der Form b k mit k 0: Θ(n c ) falls a < b c t(n) Θ(n c logn) falls a = b c Θ(nlogb) loga falls a > b c Bemerkung: loga logb = log ba. Falls a > b c, so ist log b a > c. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

15 Divide & Conquer Beweis Mastertheorem I Sei g(n) = dn c. Damit gilt nach Theorem 1 mit k = log b n: 1. Fall: a < b c t(n) d n c i=0 t(n) = d n c k ( a ) i. b c i=0 ( a ) i b c = d n c 1 1 a O(n c ). b c Außerdem gilt t(n) Ω(n c ). Hieraus folgt t(n) Θ(n c ). 2. Fall: a = b c t(n) = (k +1) d n c Θ(n c logn). Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

16 Divide & Conquer Beweis Mastertheorem I 3. Fall a > b c t(n) = d n c ( Θ ( = Θ = Θ = Θ = Θ n c k ( a ) i b c = d n c ( a b ) k+1 1 c a b 1 c ( a ) ) log b(n) b c ) i=0 n c a log b (n) b c log b (n) (a log (n)) b (b log b (a) log b (n)) (n log b (a)) Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

17 Divide & Conquer Strecken der Eingabe macht nichts Strecken der Eingabe auf b-potenz Länge ändert nichts an der Aussage des Mastertheorems I. Formal: Angenommen die Funktion t erfüllt die Rekursionsgleichung t(1) = d t(n) = a t(n/b)+d n c für b-potenzen n. Definiere die Funktion s : N N durch s(n) = t(m), wobei m die kleinste b-potenz größer-gleich n ist ( n m bn). Dann gilt nach dem Mastertheorem I Θ(m c ) = Θ(n c ) falls a < b c s(n) = t(m) Θ(m c logm) = Θ(n c logn) falls a = b c Θ(mlogb) loga = Θ(nlogb) loga falls a > b c Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

18 Mastertheorem II Divide & Conquer Theorem 3 (Mastertheorem II) Sei r > 0, r i=0 α i < 1 und für eine Konstante c sei ( r ) t(n) t( α i n ) +c n i=0 Dann gilt t(n) O(n). Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

19 Divide & Conquer Beweis Mastertheorem II Wähle ein ε > 0 und ein n 0 > 0 so, dass r r α i n ( α i ) n+(r +1) (1 ε)n i=0 i=0 für alle n n 0. Wähle ein γ so, dass c γε und t(n) γn für alle n < n 0. Für den Induktionsschritt (n n 0 ) gilt: ( r ) t(n) t( α i n ) +cn i=0 ( r ) γ α i n + cn (mit Induktion) i=0 (γ(1 ε)+c)n γn Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

20 Mergesort Divide & Conquer Mergesort Wir wollen eine Array A der Länge n sortieren, wobei n = 2 k für ein k 0. Algorithmus mergesort procedure mergesort(l, r) var m : integer; begin if (l < r) then m := (r +l) div 2; mergesort(l,m); mergesort(m +1,r); merge(l,m,r); endif endprocedure Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

21 Mergesort Divide & Conquer Mergesort Algorithmus merge procedure merge(l,m,r) var i,j,k : integer; begin i = l; j := m+1; for k := 1 to r l +1 do if i = m+1 or (i m and j r and A[j] A[i]) then B[k] := A[j]; j := j +1 else B[k] := A[i]; i := i +1 endif endfor for k := 0 to r l do A[l +k] := B[k +1] endfor endprocedure Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

22 Mergesort Divide & Conquer Mergesort Beachte: merge(l,m,r) arbeitet in Zeit O(r l +1). Laufzeit: t ms (n) = 2 t ms (n/2)+d n für Konstante d. Mastertheorem I: t ms (n) Θ(nlogn). Wir werden noch sehen, dass O(n log n) asymptotisch optimal für vergleichsbasierte Sortieralgorithmen ist. Nachteil von Mergesort: kein In-Place-Sortieralgorithmus Ein Sortieralgorithmus arbeitet In-Place, falls zu jedem Zeitpunkt nur eine konstante Zahl von Elementen des Eingabearrays A außerhalb von A gespeichert wird. Wir werden noch In-Place-Sortieralgorithmen mit einer Laufzeit von O(n log n) kennenlernen. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

23 Divide & Conquer Multiplikation natürlicher Zahlen Multiplikation natürlicher Zahlen Wir wollen zwei natürliche n-bit Zahlen multiplizieren, wobei n = 2 k für ein k 0. Schulmethode: Θ(n 2 ) Bit-Operationen. Anderer Ansatz: r = A B s = C D Dabei sind A (C) die ersten und B (D) die letzten n/2 Bits von r (s), d.h. r = A2 n/2 +B; s = C 2 n/2 +D r s = AC 2 n +(AD +BC)2 n/2 +B D Mastertheorem I: t mult (n) = 4 t mult (n/2)+θ(n) Θ(n 2 ) Nichts gewonnen! Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

24 Divide & Conquer Multiplikation natürlicher Zahlen Schnelle Multiplikation nach A. Karatsuba, 1960 Berechne stattdessen besser rekursiv AC, (A B)(D C) und BD. Damit: rs = AC 2 n +(A B)(D C)2 n/2 +(B D +AC)2 n/2 +B D Gesamtaufwand nach dem Mastertheorem I: t mult (n) = 3 t mult (n/2)+θ(n) Θ(n log3 log2) = Θ(n ). Wir haben also durch den Divide & Conquer Ansatz den Exponenten des naiven Ansatzes von 2 auf heruntergesetzt. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

25 Divide & Conquer Multiplikation natürlicher Zahlen Wie schnell kann man Multiplizieren? 1971 konnten Arnold Schönhage and Volker Strassen einen Algorithmus konstruieren, der zwei n-bit Zahlen in Zeit O(n logn loglogn) auf einer Mehrband-Turingmaschine multipliziert. Der Schönhage-Strassen Algorithmus basiert auf der schnellen Fouriertransformation (kommt noch) in geeigneten Restklassenringen. In der Praxis ist der Schönhage-Strassen Algorithmus erst für Zahlen mit ca Dezimalstellen schneller als der Karatsuba Algorithmus, denoch findet er Anwendung in der Praxis. Erst 2007 konnte der Schönhage-Strassen Algorithmus von Martin Fürer geschlagen werden. Sein Algorithmus hat eine Laufzeit von O(n logn 2 log n ). Hierbei ist log n die Zahl k, so dass log 2 k-mal angewendet auf n eine Zahl 1 ergibt. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

26 Divide & Conquer Matrixmultiplikation Matrixmultiplikation mittels naiven Divide & Conquer Seien A = (a i,j ) 1 i,j n und B = (b i,j ) 1 i,j n zwei (n n)-matrizen. Für die Produktmatrix AB = (c i,j ) 1 i,j n = C gilt c i,j = Θ(n 3 ) skalare Multiplikationen. n a i,k b k,j Divide & Conquer: A, B werden in 4 etwa gleichgroße Untermatrizen unterteilt, wobei sich das Produkt AB = C wie folgt darstellen lässt: ( ) ) A11 A 12 = A 21 A 22 k=1 ) ( B11 B 21 B 12 B 22 ( C11 C 21 C 12 C 22 Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

27 Divide & Conquer Matrixmultiplikation Matrixmultiplikation naiver Divide-and-Conquer ( A11 A 21 A 12 A 22 ) ( B11 B 21 B 12 B 22 Dabei ergeben sich folgende Beziehungen: Also: C 11 = A 11 B 11 +A 12 B 21 C 12 = A 11 B 12 +A 12 B 22 C 21 = A 21 B 11 +A 22 B 21 C 22 = A 21 B 12 +A 22 B 22 t(n) = 8 t(n/2)+θ(n 2 ) Θ(n 3 ) Erneut keine Verbesserung. ) = ( C11 C 21 C 12 C 22 ) Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

28 Divide & Conquer Matrixmultiplikation Matrixmultiplikation nach Volker Strassen (1969) Berechne das Produkt von 2 2 Matrizen mit 7 Multiplikationen: M 1 := (A 12 A 22 )(B 21 +B 22 ) C 11 = M 1 +M 2 M 4 +M 6 M 2 := (A 11 +A 22 )(B 11 +B 22 ) C 12 = M 4 +M 5 M 3 := (A 11 A 21 )(B 11 +B 12 ) C 21 = M 6 +M 7 M 4 := (A 11 +A 12 )B 22 M 5 := A 11 (B 12 B 22 ) M 6 := A 22 (B 21 B 11 ) C 22 = M 2 M 3 +M 5 M 7 M 7 := (A 21 +A 22 )B 11 Laufzeit: t(n) = 7 t(n/2)+θ(n 2 ). Mastertheorem I (a = 7, b = 2, c = 2): t(n) Θ(n log 2 7 ) = Θ(n 2,81... ) Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

29 Divide & Conquer Die Geschichte nach Strassen Matrixmultiplikation Strassens Resultat wurde über die Jahre stetig verbessert: Strassen 1969: n 2,81... Pan 1979: n 2, Bini, Capovani, Romani, Lotti 1979: n 2,78... Schönhage 1981: n 2, Romani 1982: n 2, Coppersmith, Winograd 1981: n Strassen 1986: n 2, Coppersmith, Winograd 1987: n Stothers 2010: n 2, Williams 2014: n 2, Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

30 Divide & Conquer Konvolution von Polynomen Schnelle Fourier Transformation Betrachte zwei Polynome (mit Koeffizienten etwa aus C): f(x) = a 0 +a 1 x+a 2 x 2 + a n x n, g(x) = b 0 +b 1 x+b 2 x 2 + b m x m repräsentiert durch ihre Koeffizientenfolgen f = (a 0,...,a n,a n+1,...,a N 1 ), g = (b 0,...,b m,b m+1,...,b N 1 ) wobei N = n+m+1, a n+1 = = a N 1 = b b+1 = = b N 1 = 0. Wir wollen das Produktpolynom (fg)(x) = a 0 b 0 +(a 1 b 0 +a 0 b 1 )x + +(a 0 b N 1 + +a N 1 b 0 )x N 1 berechnen, welches durch die Koeffizientenfolge fg = (a 0 b 0,a 1 b 0 +a 0 b 1,...,a 0 b N 1 + +a N 1 b 0 ), (die Konvolution der Folgen f und g) repräsentiert wird. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

31 Divide & Conquer Punktrepräsentation von Polynomen Schnelle Fourier Transformation Naive Berechnung von fg: O(N 2 ) skalare Operationen FFT (nach James Cooley und John Tukey, 1965) reduziert die Zeit auf O(Nlog(N)) Grundidee: Punktrepräsentation von Polynomen Ein Polynom f vom Grad N 1 kann eindeutig durch die Folge der Werte (f(ζ 0 ),f(ζ 1 ),...,f(ζ N 1 )) repräsentiert werden, wobei ζ 0,...,ζ N 1 N verschiedene Werte aus dem Grundbereich (z.b. komplexe Zahlen), sind. Offensichtlich gilt (fg)(ζ) = f(ζ)g(ζ) Die Punktrepräsentation der Konvolution von f und g kann in Zeit O(N) aus den Punktrepräsentationen von f und g berechnet werden. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

32 Grundprinzip der FFT Divide & Conquer Schnelle Fourier Transformation Grundprinzip der schnellen Fourier Transformation (FFT): Koeffizientenrepr. von f und g Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

33 Grundprinzip der FFT Divide & Conquer Schnelle Fourier Transformation Grundprinzip der schnellen Fourier Transformation (FFT): Koeffizientenrepr. von f und g Auswertung Punktrepr. f und g Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

34 Grundprinzip der FFT Divide & Conquer Schnelle Fourier Transformation Grundprinzip der schnellen Fourier Transformation (FFT): Koeffizientenrepr. von f und g Auswertung Punktrepr. f und g punktweises Punktrepr. fg Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

35 Grundprinzip der FFT Divide & Conquer Schnelle Fourier Transformation Grundprinzip der schnellen Fourier Transformation (FFT): Koeffizientenrepr. von f und g Koeffizientenrepr. von fg Auswertung Interpolation Punktrepr. f und g punktweises Punktrepr. fg Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

36 Einheitswurzeln Divide & Conquer Schnelle Fourier Transformation Der entscheidende Punkt ist die Auswahl der Punkte ζ 0,ζ 1,...,ζ N 1. Annahme: Die Koeffizienten der Polynome stammen aus einem Körper F, so dass gilt: N hat ein multiplikatives Inverses in F, d.h. die Charakteristik von F teilt nicht N. Das Polynom X N 1 hat N verschiedene Nullstellen die N-ten Einheitswurzeln welche sich als ω i (0 i < N) für eine Nullstelle ω schreiben lassen. Für F = C sind die N-ten Einheitswurzeln etwa von der Form ω j (0 j < N), wobei ω = e 2πi N. Die Nullstelle ω wird auch als primitive N-te Einheitswurzel bezeichnet. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

37 Einheitswurzeln Divide & Conquer Schnelle Fourier Transformation Einige nützliche Fakten aus der Algebra: Sei ω eine primitive N-te Einheitswurzel. Für alle i,j Z gilt: ω i = ω j g.d.w. i j mod N. Für i Z ist ω i eine primitive N-te Einheitswurzel g.d.w. ggt(i,n) = 1 (wobei ggt(i,n) der größte gemeinsame Teiler von i und N ist). Insbesondere ist ω 1 = ω N 1 eine primitive N-te Einheitswurzel. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

38 Divide & Conquer Schnelle Fourier Transformation Schnelle Fourier Transformation (FFT) Fixiere eine primitive N-te Einheitswurzel ω. Wir wählen die Punkte ζ i = ω i (0 i N 1) für die Auswertung von f und g. Auswertung von f = a 0 +a 1 x + a N 1 x N 1 an den Punkten ω 0 = 1,ω 1,...,ω N 1 läuft auf eine Matrixmultiplikation hinaus: ω 1 ω 2 ω N 1 1 ω 2 ω 4 ω 2(N 1) ω N 1 ω 2(N 1) ω (N 1)2 a 0 a 1 a 2. a N 1 = f(1) f(ω) f(ω 2 ). f(ω N 1 ) Die durch die Matrix F N (ω) = (ω ij ) 0 i,j<n realisierte lineare Abbildung wird als diskrete Fourier Transformation bezeichnet. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

39 Inverse FFT Divide & Conquer Schnelle Fourier Transformation Lemma 4 (F ( N (ω)) ) 1 = 1 N F N(ω 1 ), d.h. das Inverse der Matrix (ω ij ) 0 i,j<n ist ω ij N (beachte: 0 i,j<n ω 1 ist eine primitive N-te Einheitswurzel). Beweis: Da x N 1 = (x 1) N 1 j=0 xj gilt, ist jedes ω i für 0 < i < N eine Nullstelle von N 1 j=0 xj. Daher gilt für alle 0 i < N: N 1 j=0 ω i j = { 0 falls i > 0 N falls i = 0 Wir erhalten für alle 0 i,j < N: N 1 k=0 ω ik ω kj = N 1 k=0 ω k(i j) = { 0 falls i j N falls i = j Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

40 Divide & Conquer FFT mittels Divide & Conquer Schnelle Fourier Transformation Wir müssen nun noch die diskrete Fouriertransformation f F N (ω)f (wobei f = (a 0,a 1,...,a N 1 ) T ) in Zeit O(Nlog(N)) berechnen. Dann kann die inverse diskrete Fouriertransformation (= Interpolation) h (F N (ω)) 1 h = 1 N F N(ω 1 )h in der gleichen Zeitschranke berechnet werden. Die Schulmethode für die Multiplikation einer Matrix mit einem Vektor benötigt Zeit O(N 2 ): kein Gewinn gegenüber der Schulmethode für Polynommultiplikation. Wir berechnen F N (ω)f = (ω ij ) 0 i,j<n f mittel Divide & Conquer. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

41 FFT mittels Divide & Conquer Divide & Conquer Schnelle Fourier Transformation Angenommen N ist gerade. Für f(x) = a 0 +a 1 x + +a N 1 x N 1 sei f 0 (x) = a 0 +a 2 x 2 +a 4 x 4 + +a N 2 x N 2 f 0 (x) = a 0 +a 2 x +a 4 x 2 + +a N 2 x N 2 2 f 1 (x) = a 1 +a 3 x 2 +a 5 x 4 + +a N 1 x N 2 f 1 (x) = a 1 +a 3 x +a 5 x 2 + +a N 1 x N 2 2 Also: f(x) = f 0 (x)+xf 1 (x), f 0 (x) = f 0 (x 2 ) und f 1 (x) = f 1 (x 2 ). Die Polynome f 0 (x) und f 1 (x) haben Grad N 2 2. Sei 0 i < N. Da ω 2 eine primitive N 2-Einheitswurzel ist, gilt: (F N (ω)f 0 ) i = f 0 (ω i ) = f 0 (ω 2i ) = f 0 (ω 2i modn ) = f 0 (ω 2(i mod N 2 ) ) = f 0 ((ω 2 ) i mod N 2) = (FN 2 (ω 2 ) f 0 ) i mod N, 2 Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

42 Divide & Conquer FFT mittels Divide & Conquer Schnelle Fourier Transformation Wir erhalten F N (ω)f 0 = und analog F N (ω)f 1 = ( FN 2 FN 2 ( FN 2 FN 2 ) (ω 2 ) f 0 (ω 2 ) f 0 ) (ω 2 ) f 1 (ω 2. ) f 1 Mit f(x) = f 0 (x)+xf 1 (x) folgt F N (ω)f = F N (ω)f 0 +(F N (ω)x F N (ω)f 1 ), wobei F N (ω)x = (1,ω,ω 2,...,ω N 1 ) T und die punktweise Multiplikation von Vektoren bezeichnet. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

43 Divide & Conquer FFT mittels Divide & Conquer Schnelle Fourier Transformation Wir haben somit die Berechnung von F N (ω)f reduziert auf: Die Berechnung von FN(ω 2 ) f 0 und FN(ω 2 ) f (2 FFTs der Dimension N/2) O(N) viele weitere arithmetische Operationen. Wir erhalten somit die Rekursionsgleichung für eine Konstante d. Mastertheorem I (a = b = 2,c = 1): T fft (N) = 2T fft (N/2) +dn T fft (N) θ(nlogn). Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

44 Divide & Conquer Schnelle Fourier Transformation Schnelle Fourier Transformation (FFT) Grundprinzip der FFT: Koeffizientenrepr. von f und g Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

45 Divide & Conquer Schnelle Fourier Transformation Schnelle Fourier Transformation (FFT) Grundprinzip der FFT: Koeffizientenrepr. von f und g O(Nlog(N)) F N (ω) Auswertung Punktrepr. f und g Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

46 Divide & Conquer Schnelle Fourier Transformation Schnelle Fourier Transformation (FFT) Grundprinzip der FFT: Koeffizientenrepr. von f und g O(Nlog(N)) F N (ω) Auswertung Punktrepr. f und g punktweises O(N) Punktrepr. fg Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

47 Divide & Conquer Schnelle Fourier Transformation Schnelle Fourier Transformation (FFT) Grundprinzip der FFT: Koeffizientenrepr. von f und g F N (ω) O(Nlog(N)) Auswertung Punktrepr. f und g punktweises O(N) Koeffizientenrepr. von fg Interpolation 1 N F N(ω 1 ) Punktrepr. fg O(Nlog(N)) Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

48 Überblick Sortieren Untere Schranke für vergleichsbasierte Sortieralgorithmen Quicksort Heapsort Sortieren in linearer Zeit Medianberechnung Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

49 Sortieren Vergleichsbasierte Sortieralgorithmen Untere Schranke für vergleichsbasierte Sortieralgorithmen Ein Sortieralgorithmus ist vergleichsbasiert falls die Elemente des Arrays einen Datentypen bilden, dessen einzige Operation der Vergleich zweier Elemente ist. Wir gehen für die folgende Betrachtung davon aus, dass das Input-Array A[1,...,n] folgende Eigenschaften hat: A[i] {1,...,n} für alle 1 i n. A[i] A[j] für i j In anderen Worten: Die Eingabe ist eine Permutation der Liste [1,2,...,n]. Der Sortieralgorithmus soll diese Liste sortieren. Andere Sichtweise: Der Sortieralgorithmus soll die Permutation [i 1,i 2,...,i n ] ausgeben, so dass A[i k ] = k für alle 1 k n gilt. Beispiel: Bei Eingabe [2,3,1] soll [3,1,2] ausgegeben werden. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

50 Sortieren Untere Schranke für den Worst-Case Untere Schranke für vergleichsbasierte Sortieralgorithmen Theorem 5 Für jeden vergleichsbasierten Sortieralgorithmus und jedes n existiert ein Array der Länge n, auf dem der Algorithmus mindestens viele Vergleiche macht. nlog 2 (n) log 2 (e)n nlog 2 (n) 1,443n Beweis: Wir führen den Algorithmus in Gedanken auf einem Array A[1,...,n] aus, ohne dabei die konkreten Werte A[i] zu kennen. Dies ergibt einen Entscheidungsbaum, der wie folgt konstruiert ist. Angenommen, der Algorithmus vergleicht als erstes A[i] und A[j]. Wir beschriften die Wurzel des Entscheidungsbaums mit i : j. Der linke (rechte) Teilbaum ergibt sich, indem wir den Algorithmus unter der Annahme A[i] < A[j] (A[i] > A[j]) weiter laufen lassen. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

51 Sortieren Untere Schranke für den Worst-Case Untere Schranke für vergleichsbasierte Sortieralgorithmen Dies ergibt einen Binärbaum mit n! vielen Blättern, denn jede Eingabepermutation muss zu einem anderen Blatt führen. Beispiel: Hier ist ein Entscheidungsbaum für das Sortieren eines Arrays der Länge 3. 2 : 3 1 : 2 1 : 3 1,2,3 1 : 3 1,3,2 1 : 2 2,1,3 2,3,1 3,1,2 3,2,1 Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

52 Sortieren Untere Schranke für den Worst-Case Untere Schranke für vergleichsbasierte Sortieralgorithmen Beachte: Die Tiefe (= max. Anzahl der Kanten von der Wurzel zu einem Blatt) des Entscheidunbsbaums ist die maximale Anzahl von Vergleichen des Algorithmus auf einem Array der Länge n. Ein Binärbaum mit N vielen Blättern hat Tiefe mindestens log 2 (N). Stirlings Formel (wir benötigen nur n! > 2πn(n/e) n ) impliziert log 2 (n!) nlog 2 (n) log 2 (e)n +Ω(logn) nlog 2 (n) 1,443n. Also gibt es eine Eingabepermutation, für die der Algorithmus mindestens nlog 2 (n) 1,443n viele Vergleiche macht. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

53 Sortieren Untere Schranke für den Average-Case Untere Schranke für vergleichsbasierte Sortieralgorithmen Ein vergleichsbasierter Sortieralgorithmus macht sogar auf fast allen Permutationen mindestens nlog 2 (n) 2,443n viele Vergleiche. Theorem 6 Für jeden vergleichsbasierten Sortieralgorithmus gilt: Der Anteil aller Permutationen, auf denen der Algorithmus mindestens log 2 (n!) n nlog 2 (n) 2,443n viele Vergleiche macht, ist mindestens 1 2 n+1. Für den Beweis benötigen wir ein einfaches Lemma: Lemma 7 Sei A {0,1} mit A = N, und sei 1 n < log 2 (N). Dann haben mindestens (1 2 n+1 )N viele Wörter in A Länge log 2 (N) n. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

54 Sortieren Untere Schranke für den Average-Case Untere Schranke für vergleichsbasierte Sortieralgorithmen Betrachte nun wieder den Entscheidungsbaum; er hat n! Blätter, und jedes Blatt entspricht einer Permutation der Zahlen {1,...,n}. Jede der n! vielen Permutationen kann daher durch ein Wort über dem Alphabet {0, 1} repräsentiert werden: 0 bedeutet: Gehe im Entscheidungsbaum zum linken Kind. 1 bedeutet: Gehe im Entscheidunbsbaum zum rechten Kind. Lemma 7 Der Entscheidungsbaum hat mindestens (1 2 n+1 )n! viele Wurzel-Blatt Pfade der Länge log 2 (n!) n nlog 2 (n) 2,443n. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

55 Sortieren Untere Schranke für den Average-Case Untere Schranke für vergleichsbasierte Sortieralgorithmen Korollar Jeder vergleichsbasierte Sortieralgorithmus benötigt im Durchschnitt mindestens nlog 2 (n) 2,443n viele Vergleiche zum Sortieren eines Arrays der Länge n (für n groß genug). Beweis: Wegen Theorem 6 werden im Durchschnitt mindestens (1 2 n+1 ) (log 2 (n!) n)+2 n+1 = log 2 (n!) n log 2(n!) n 1 2 n 1 nlog 2 (n) 2,443n +Ω(log 2 n) log 2(n!) n 1 2 n 1 viele Vergleiche gemacht. nlog 2 (n) 2,443n Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

56 Quicksort Sortieren Quicksort Der Quicksort-Algorithmus (Tony Hoare, 1962): Wähle ein Array-Element A[i] (das Pivotelement). Partitionieren: Sortiere das Array so um, so dass links (bzw. rechts) vom Pivoelement alle Elemente stehen die kleiner gleich (bzw. größer) als das Pivoelement sind (benötigt n 1 Vergleiche). Wende den Algorithmus rekursiv auf die Subarrays links und rechts vom Pivoelement an. Kritisch: die Wahl des Pivotelements. Laufzeit ist optimal, falls das Pivotelement gleich dem mittleren Element des Feldes (Median) ist. In der Praxis bewährt: die Median-aus-Drei-Methode. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

57 Partitionieren Sortieren Quicksort Zunächst geben wir die Prozedur zum Partitionieren eines Subarrays A[l,...,r] bzgl. eines Pivotelements P = A[p] an, wobei l < r und l p r gelte. Ergebnis dieser Prozedur ist ein Index m {l,...,r}, der folgende Eigenschaften erfüllt: A[m] = P A[k] P für alle l k m 1 A[k] > P für alle m+1 k r Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

58 Partitionieren Sortieren Quicksort Algorithmus Partitionieren function partitioniere(a[l...r] : array of integer, p : integer) : integer begin swap(p,r); P := A[r]; i := l 1; for j := l to r 1 do if A[j] P then i := i +1; swap(i,j) endif endfor swap(i +1,r) return i +1 endfunction Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

59 Partitionieren Sortieren Quicksort Folgende Invarianten gelten vor jeder Iteration der for-schleife: A[r] = P Für alle l k i gilt A[k] P Für alle i +1 k j 1 gilt A[k] > P Somit gilt vor der return-anweisung: A[k] P für alle l k i +1 A[k] > P für alle i +2 k r A[i +1] = P Beachte: partitioniere(a[l...r]) macht r l viele Vergleiche. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

60 Quicksort Sortieren Quicksort Algorithmus Quicksort procedure quicksort(a[l...r] : array of integer) begin if l < r then p := Index des Medians von A[l], A[(l+r) div 2], A[r]; m := partitioniere(a[l...r], p); quicksort(a[l...m 1]); quicksort(a[m +1...r]); endif endprocedure Worst-Case Laufzeit: O(n 2 ). Tritt ein, wenn nach jedem Aufruf von partitioniere(a[l...r], p) eines der beiden Teilarrays (A[l...m 1] oder A[m+1...r]) leer ist. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

61 Sortieren Quicksort: Durschnittsanalyse Quicksort Durchschnittsanalyse unter der Annahme einer zufälliger Auswahl des Pivotelements. Alternativ: Eingabearray ist zufällig angeordnet. Es sei Q(n) die mittlere Anzahl der Schlüsselvergleiche bei einem Eingabearray der Länge n. Theorem 8 Es gilt Q(n) = 2(n+1)H(n) 4n, wobei die n-te harmonische Zahl ist. H(n) := n k=1 1 k Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

62 Sortieren Quicksort: Durschnittsanalyse Quicksort Beweis: Für n = 1 gilt offensichtlich Q(1) = 0 = Für n 2 gilt: Q(n) = (n 1)+ 1 n Dabei ist: = (n 1)+ 2 n n [Q(i 1)+Q(n i)] i=1 n Q(i 1) i=1 (n 1) = Zahl der Vergleiche beim Partitionieren Q(i 1)+Q(n i) = mittlere Zahl der Vergleiche für das rekursive Sortieren der beiden Teilhälften. Der Faktor 1/n ergibt sich, da alle Positionen für das Pivotelement gleich wahrscheinlich sind. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

63 Sortieren Quicksort: Durschnittsanalyse Damit gilt: Also: nq(n) = n(n 1)+2 Quicksort n Q(i 1) i=1 nq(n) (n 1)Q(n 1) = n(n 1)+2 Wir erhalten: n Q(i 1) i=1 n 1 (n 1)(n 2) 2 Q(i 1) i=1 = n(n 1) (n 2)(n 1)+2Q(n 1) = 2(n 1)+2Q(n 1) nq(n) = 2(n 1)+2Q(n 1)+(n 1)Q(n 1) = 2(n 1)+(n+1)Q(n 1) Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

64 Sortieren Quicksort: Durschnittsanalyse Quicksort Indem wir durch n(n+1) teilen, erhalten wir Hieraus folgt mit Induktion nach n: Q(n) 2(n 1) = n+1 n(n+1) + Q(n 1) n Q(n) n+1 = = 2 n k=1 2(k 1) k(k +1) n k=1 ( n = 2 k=1 (k 1) k(k +1) k n k(k +1) k=1 1 ) k(k +1) Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

65 Sortieren Quicksort: Durschnittsanalyse Quicksort Q(n) n+1 = 2 = 2 = 2 [ n k=1 [ n k=1 ] 1 n k +1 1 k(k +1) k=1 ] 2 n k +1 1 k k=1 [ ( ) 1 2 n+1 +H(n) 1 = 2H(n)+ 4 n+1 4. ] H(n) Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

66 Sortieren Quicksort: Durschnittsanalyse Quicksort Schließlich erhält man für Q(n): Q(n) = 2(n+1)H(n)+4 4(n+1) = 2(n+1)H(n) 4n. Es ist H(n) lnn 0, = Eulersche Konstante. Also: Q(n) 2(n+1)(0,58+lnn) 4n 2nlnn 2,8n 1,38nlogn 2,8n. Theoretische Grenze: log(n!) nlogn 1,44n; Quicksort ist im Mittel um 38% schlechter. Die Durchschnittsanalyse der Median-aus-Drei Methode liefert 1,18nlogn 2,2n. Dies ist im Mittel nur noch um 18% schlechter. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

67 Heaps Sortieren Heapsort Definition 9 Ein (Max-)Heap ist ein Feld a[1...n] mit den Eigenschaften: a[i] a[2i] für alle i 1 mit 2i n a[i] a[2i +1] für alle i 1 mit 2i +1 n Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

68 Heaps Sortieren Heapsort Beispiel: Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

69 Einsinkprozess Sortieren Heapsort Als erstes wollen wir die Einträge eines Arrays a[1,...,n] so permutieren, dass danach die Heap-Bedingung erfüllt ist. Angenommen, das Subarray a[i +1,...,n] erfüllt bereits die Heap-Bedingung. Um die Heap-Bedingung auch für i zu erzwingen, lassen wir a[i] einsinken: y i x 2i 2i +1 Mit 2 Vergleichen können wir max{x,y,z} bestimmen. z Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

70 Einsinkprozess Sortieren Heapsort Als erstes wollen wir die Einträge eines Arrays a[1,...,n] so permutieren, dass danach die Heap-Bedingung erfüllt ist. Angenommen, das Subarray a[i +1,...,n] erfüllt bereits die Heap-Bedingung. Um die Heap-Bedingung auch für i zu erzwingen, lassen wir a[i] einsinken: y i x 2i 2i +1 Mit 2 Vergleichen können wir max{x,y,z} bestimmen. Ist x das Max., so stoppt der Einsinkprozess. z Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

71 Einsinkprozess Sortieren Heapsort Als erstes wollen wir die Einträge eines Arrays a[1,...,n] so permutieren, dass danach die Heap-Bedingung erfüllt ist. Angenommen, das Subarray a[i +1,...,n] erfüllt bereits die Heap-Bedingung. Um die Heap-Bedingung auch für i zu erzwingen, lassen wir a[i] einsinken: y i x 2i 2i +1 Mit 2 Vergleichen können wir max{x,y,z} bestimmen. Ist y das Max., so vertauschen wir x und y und machen bei 2i weiter. x i y z 2i 2i +1 Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306 z

72 Einsinkprozess Sortieren Heapsort Als erstes wollen wir die Einträge eines Arrays a[1,...,n] so permutieren, dass danach die Heap-Bedingung erfüllt ist. Angenommen, das Subarray a[i +1,...,n] erfüllt bereits die Heap-Bedingung. Um die Heap-Bedingung auch für i zu erzwingen, lassen wir a[i] einsinken: y i x 2i 2i +1 Mit 2 Vergleichen können wir max{x,y,z} bestimmen. Ist z das Max., so vertauschen wir x und z und machen bei 2i +1 weiter. y i z z 2i 2i +1 Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306 x

73 Reheap Sortieren Heapsort Algorithmus Reheap procedure reheap(i,n: integer) ( i ist die Wurzel ) var m: integer; begin if i n/2 then m := max{a[i],a[2i],a[2i +1]}; ( 2 Vergleiche! ) if (m a[i]) (m = a[2i]) then swap(i,2i); ( vertausche x,y ) reheap(2i, n) elsif (m a[i]) (m = a[2i +1]) then swap(i,2i +1); ( vertausche x,z ) reheap(2i +1,n) endif endif endprocedure Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

74 Heap-Aufbau Sortieren Heapsort Algorithmus Build Heap procedure build-heap(n: integer) begin for i := n 2 downto 1 do reheap(i, n) endfor endprocedure Invariante: Vor dem Aufruf von reheap(i, n) erfüllt das Subarray a[i +1,...,n] die Heap-Bedingung. Für i = n 2 ist dies trivialerweise richtig. Angenommen die Invariante gilt für i. Die Heap-Bedingung ist daher nur für i eventuell verletzt. Nach dem Einsinken von a[i] gilt dann die Heap-Bedingung auch für i. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

75 Sortieren Zeitanalyse für Heap-Aufbau Heapsort Theorem 10 Built-heap läuft in Zeit O(n). Beweis: Einsinken von a[i] kostet 2 (Höhe des Teilbaums unter a[i]) viele Vergleiche. Wir führen die Analyse für n = 2 k 1 durch. Dann haben wir eine vollen Binärbaum der Tiefe k 1 vorliegen. Es gibt dann 2 0 Bäume der Höhe k 1, 2 1 Bäume der Höhe k 2,. 2 i Bäume der Höhe k 1 i,. 2 k 1 Bäume der Höhe 0. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

76 Sortieren Zeitanalyse für Heap-Aufbau Heapsort Daher sind zum Heapaufbau maximal k 1 2 i=0 viele Vergleiche nötig. k 1 2 i (k 1 i) = 2 Behauptung: j 0 j 2 j = 2 i=0 i=0 2 k 1 i i k 1 = 2 k i 2 i (n+1) i 2 i i 0 Beweise der Behauptung: Für z < 1 gilt: j 0 z j = 1 1 z. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

77 Sortieren Zeitanalyse für Heap-Aufbau Heapsort Ableiten ergibt j z j 1 = j 0 und damit j z j = j 0 1 (1 z) 2, z (1 z) 2. Einsetzen von z = 1/2 ergibt j 2 j = 2 j 0 Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

78 Sortieren Heapsort Standard Heapsort (W. J. Williams, 1964) Algorithmus Heapsort procedure heapsort(n: integer) begin build-heap(n) for i := n downto 2 do swap(1,i); reheap(1,i 1) endfor endprocedure Theorem 11 Standard Heapsort sortiert ein Array mit n Elementen und erfordert 2nlog 2 n+o(n) Vergleiche. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

79 Standard Heapsort Sortieren Heapsort Beweis: Korrektheit: Nach build-heap(n) ist a[1] das maximale Element des Arrays. Dieses wird mittels swap(1, n) an seine korrekte Position (n) transportiert. Nach Induktion wird während der restlichen Laufzeit das Subarray a[1,...,n 1] sortiert. Laufzeit: Der Heap-Aufbau erfordert O(n) und der Abbau durch Einsinken 2nlog 2 n Vergleiche. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

80 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

81 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

82 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

83 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

84 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

85 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

86 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

87 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

88 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

89 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

90 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

91 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

92 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

93 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

94 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

95 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

96 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

97 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

98 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

99 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

100 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

101 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

102 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

103 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

104 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

105 Sortieren Beispiel für Standard Heapsort Heapsort Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

106 Bottom-Up-Heapsort Sortieren Heapsort Bemerkung: Eine Analyse der Durchschnittskomplexität von Heapsort ergibt einen mittlerer Aufwand von 2nlog 2 n Vergleichen (kommt noch). Damit ist Standard-Heapsort zu Quicksort nicht konkurrenzfähig. Bottom-Up-Heapsort benötigt wesentlich weniger Vergleiche. Nach dem Vertauschen swap(1, i) wird zuerst der potentielle Einsinkpfad des Elementes a[i] bestimmt. Es wird der Weg verfolgt, der immer zum größeren der beiden Nachfolger führt (Kosten: nur logn statt 2log 2 n Vergleiche). Da erwartungsgemäß a[i] tief einsinken wird, bietet sich anschließend eine bottom-up Bestimmung der tatsächlichen Position auf dem Einsinkpfad an. Hoffnung: Die bottom-up Bestimmung erfordert insgesamt nur O(n) Vergleiche. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

107 Der Einsinkpfad Sortieren Heapsort x 0 x > 1 y 1 y < 2 x 2 y < 3 x 3. x k 1 x k > y k Das Einsinken wird auf dem Pfad [x 0,x 1,x 2,...,x k 1,x k ] geschehen, welcher mittels log 2 n Vergleiche bestimmt werden kann. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

108 Sortieren Heapsort Einsortieren auf dem Einsinkpfad Wir bestimmen jetzt vom Blatt des Einsinkpfades aus (also bottom-up) die tatsächliche Position p auf dem Einsinkpfad. Ist diese Position p gefunden, so werden die Elemente x 0,...,x p zyklisch vertauscht (x 0 geht an die Stelle von x p, und x 1,...,x p rutschen hoch). Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

109 Sortieren Heapsort Einsortieren auf dem Einsinkpfad Wir bestimmen jetzt vom Blatt des Einsinkpfades aus (also bottom-up) die tatsächliche Position p auf dem Einsinkpfad. Ist diese Position p gefunden, so werden die Elemente x 0,...,x p zyklisch vertauscht (x 0 geht an die Stelle von x p, und x 1,...,x p rutschen hoch) Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

110 Sortieren Heapsort Einsortieren auf dem Einsinkpfad Wir bestimmen jetzt vom Blatt des Einsinkpfades aus (also bottom-up) die tatsächliche Position p auf dem Einsinkpfad. Ist diese Position p gefunden, so werden die Elemente x 0,...,x p zyklisch vertauscht (x 0 geht an die Stelle von x p, und x 1,...,x p rutschen hoch) > 3? Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

111 Sortieren Heapsort Einsortieren auf dem Einsinkpfad Wir bestimmen jetzt vom Blatt des Einsinkpfades aus (also bottom-up) die tatsächliche Position p auf dem Einsinkpfad. Ist diese Position p gefunden, so werden die Elemente x 0,...,x p zyklisch vertauscht (x 0 geht an die Stelle von x p, und x 1,...,x p rutschen hoch) > 3? Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

112 Sortieren Heapsort Einsortieren auf dem Einsinkpfad Wir bestimmen jetzt vom Blatt des Einsinkpfades aus (also bottom-up) die tatsächliche Position p auf dem Einsinkpfad. Ist diese Position p gefunden, so werden die Elemente x 0,...,x p zyklisch vertauscht (x 0 geht an die Stelle von x p, und x 1,...,x p rutschen hoch) Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

113 Sortieren Average Analyse von Heapsort Heapsort Unser Ziel ist der Beweis des folgenden Satzes: Theorem 12 Standard-Heapsort macht auf einem Anteil von mindestens 1 2 (n 1) vieler Eingabepermutationen mindestens 2nlog 2 (n) O(n) viele Vergleiche. Bottomup-Heapsort macht auf einem Anteil von mindestens 1 2 (n 1) vieler Eingabepermutationen höchstens nlog 2 (n)+o(n) viele Vergleiche. Beweis: Durch ein informationstheoretisches Argument. Ein Sortieralgorithmus produziert aus einer Permutation von [1,...,n] die sortierte Liste [1,...,n]. Wir können daher die Eingabepermutation dadurch spezifizieren, indem wir zusätzliche Information in Form eines {0, 1}-Strings angeben, welche es erlaubt, den Algorithmus von der Ausgabe [1,...,n] rückwärts laufen zu lassen. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

114 Sortieren Average Analyse von Heapsort Heapsort Im Fall von Standard-Heapsort: Wir merken uns die Einsinkpfade, d.h. jedes mal, wenn wir ein Element mit dem linken (bzw. rechten) Kind vertauschen, schreiben wir eine 0 bzw. 1 auf. Dadurch wird Heapsort reversibel. Aber: Wir müssen aufeinanderfolgende Einsinkpfade (= {0, 1}-Strings) voneinander trennen. 1. Alternative: Wir kodieren ein Wort w = a 1 a 2 a t 1 a t {0,1} durch Beachte: c 1 (w) = 2 w. c 1 (w) = a 1 0a 2 0 a t 1 0a t Alternative: Wir kodieren ein Wort w = a 1 a 2 a t 1 a t {0,1} duch c 2 (w) = c 1 (Binärdarstellung von t)a 1 a t Dann gilt c 2 (w) = w +2log 2 ( w ). Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

115 Sortieren Average Analyse von Heapsort Heapsort Beachte: c 2 (ε) = 01, da 0 = Binärdarstellung der Zahl 0. Wir kodieren den Einsinkpfad w = a 1 a 2 a t {0,1} durch c 2(w) = c 1 (Binärdarstellung von log 2 (n) t)a 1 a t. Beachte: t log 2 (n), denn jeder Einsinkpfad hat Länge höchstens log 2 n. Unser Argument, welches gezeigt hat, dass der Heapaufbau nur O(n) viele Vergleiche benötigt, zeigt: In Phase 1 wird ein {0, 1}-String der Länge O(n) erzeugt. Wir analysieren nun die Länge des in Phase 2 erzeugten {0, 1}-Strings. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

116 Sortieren Average Analyse von Heapsort Heapsort Seien t 1,...,t n die Längen der Einsinkpfade während Phase 2. Also wird in Phase 2 ein {0,1}-String der Länge n n n (t i +2log 2 (log 2 (n) t i )) = t i + 2 log 2 (log 2 (n) t i )) i=1 generiert. Definiere den Mittelwert i=1 n i=1 t = t i. n Die Funktion f mit f(x) = log 2 (log 2 (n) x) ist konkav auf ihrem Definitionsbereich (,log 2 (n)). Dann folgt aus Jensens Ungleichung (Folie 4): n 1 log 2 (log 2 (n) t) n log 2(log 2 (n) t i )). i=1 Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306 i=1

117 Sortieren Average Analyse von Heapsort Also gilt: n t i + 2 i=1 Heapsort n log 2 (log 2 (n) t i )) n t +2nlog 2 (log 2 (n) t). i=1 Insgesamt erhalten wir: Die Eingabepermutation σ von [1,...,n] kann durch einen {0, 1}-String der Länge I(σ) cn+n t +2nlog 2 (log 2 (n) t) kodiert werden, wobei c eine Konstante (für Phase 1) ist. Lemma 7 impliziert, dass für mindestens (1 2 n+1 )n! viele Eingabepermutationen gilt: cn+n t +2nlog 2 (log 2 (n) t) I(σ) log 2 (n!) n nlog 2 (n) 2,443n Umgeformt mit d = 2,443+c: t log 2 (n) 2log 2 (log 2 (n) t) d. (1) Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

118 Sortieren Average Analyse von Heapsort Heapsort Wegen t 0 folgt: t log 2 (n) 2log 2 (log 2 (n)) d. (2) Aus (1) und (2) folgt die bessere Abschätzung t log 2 (n) 2log 2 (2log 2 (log 2 (n))+d) d. (3) Diese Abschätzung können wir wieder in (1) einsetzen,... Allgemein erhalten wir für alle i 1: t log 2 (n) α i d, wobei α 1 = 2log 2 (log 2 (n)) und α i+1 = 2log 2 (α i +d). (Beweis durch Induktion über i 1) Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

119 Sortieren Average Analyse von Heapsort Heapsort Nun gilt für alle x max{10,d}: 2log 2 (x +d) 2log 2 (2x) = 2log 2 (x)+2 0,9 x. Solange also α i max{10,d} gilt, haben wir α i+1 0,9 α i. Daher existiert eine Konstante α mit t log 2 (n) α d. (4) Also gilt für mindestens (1 2 n+1 )n! viele Eingabepermutationen n t i nlog 2 n O(n). i=1 Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

120 Sortieren Average Analyse von Heapsort Heapsort Die Aussage von Theorem 12 für Standard-Heapsort folgt nun einfach : In Phase 2 macht Standard-Heapsort 2 n i=1 t i viele Vergleiche. Also macht Standard-Heapsort für mindestens (1 2 n+1 )n! viele Eingabepermutationen mindestens 2nlog 2 n O(n) viele Vergleiche. Nun zu Bottomup-Heapsort: Dieser macht in Phase 2 höchstens n n nlog 2 (n)+ (log 2 (n) t i ) = 2nlog 2 (n) viele Vergleiche. i=1 Also macht Bottomup-Heapsort für mindestens (1 2 n+1 )n! viele Eingabepermutationen höchstens n O(n)+2nlog 2 (n) t i nlog 2 (n)+o(n) viele Vergleiche. i=1 Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306 i=1 t i

121 Sortieren Heapsort Variante nach Svante Carlsson, 1986 Es kann gezeigt werden, dass Bottom-up Heapsort im schlechtesten Fall höchstens 1.5n log n + O(n) viele Vergleiche macht. Wenn man nach Carlsson auf dem Einsinkpfad eine binäre Suche anwendet, so kommt man auf einen worst-case Aufwand von höchstens nlogn+o(nloglogn). Eine binäre Suche ist aber in der Praxis zu aufwendig und außerdem steigt man in den Pfad i.a. zu hoch ein. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306

122 Counting-Sort Sortieren Sortieren in linearer Zeit Zur Erinnerung: Die Ω(n log n)-schranke gilt nur für vergleichsbasierte Sortieralgorithmen. Wenn wir gewisse Annahmen über die Arrayeinträge machen, können wir in Zeit O(n) sortieren. Annahme: Die Arrayelemente A[1],...A[n] sind Zahlen aus dem Bereich [0,k]. Counting-Sort (siehe nächste Folie) sortiert unter dieser Annahme in Zeit O(k +n). Gilt also k O(n), so sortiert Counting-Sort in Linearzeit. Markus Lohrey (Universität Siegen) Algorithmen WS 2016/ / 306