Algorithmen I. Prof. Jörn Müller-Quade Institut für Theoretische Informatik Web:

Transkript

1 Algorithmen I Prof. Jörn Müller-Quade Institut für Theoretische Informatik Web: (Folien von Peter Sanders) KIT Institut für Theoretische Informatik 1

2 Quicksort zufälliger Pivot Function quicksort(s : Sequence of Element) : Sequence of Element if s 1 then return s pick p s uniformly at random a:= e s : e < p b:= e s : e = p c:= e s : e > p return concatenation of quicksort(a), b, and quicksort(c) KIT Institut für Theoretische Informatik 2

3 Satz: Quicksort hat erwartete Laufzeit O(n log n) Annahme: alle Elemente verschieden Warum `OBdA'? Es genügt, die 3-Wege Vergleiche (<,=,>) C(n) zu zählen. Genauer: wir bestimmen C(n) = E[C(n)] Function quicksort(s : Sequence of Element) : Sequence of Element if s 1 then return s pick p s uniformly at random a:= e s : e < p // s 1 b:= e s : e = p // 3-Wegec:= e s : e > p // Vergleiche return concatenation of quicksort(a), b, and quicksort(c) KIT Institut für Theoretische Informatik 3

4 Beweisansatz 1: Rekurrenzen Beweis: Im Buch wird bewiesen, dass mit Wahrscheinlichkeit 1/2 das Aufspaltverhältnis nicht schlechter als 1 4 : 3 4 ist. Das genügt um C(n) = O(n logn) zu zeigen. Satz: C(n) 2n lnn 1.45n logn KIT Institut für Theoretische Informatik 4

5 Satz: C(n) 2n lnn 1.45n logn Sei s = e 1,...,e n sortierte Eingabefolge. Indikatorzufallsvariable: X ij := 1 gdw. e i wird mit e j verglichen. C(n) = E [ n n i=1 j=i+1 X ij ] = n n i=1 j=i+1 E[X ij ] = n n i=1 j=i+1 P[X ij = 1]. KIT Institut für Theoretische Informatik 5

6 Lemma: P [ X ij = 1] = 2 j i+1 Sortierte Eingabefolge: s = e 1,...,e i 1,e i,e i+1,...,e j 1,e j,e j+1 }{{},...,e n j i+1 Elemente X ij = 1 e i wird mit e j verglichen e i oder e j wird Pivot bevor ein Pivot aus e i+1,...,e j 1 gewählt wird. P[X ij = 1] = 2 j i+1 KIT Institut für Theoretische Informatik 6

7 Satz: C(n) 2n lnn 1.45n logn C(n) = = n n i=1 j=i+1 n i=1 n n i+1 k=2 n i=1 k=2 n =2n k=2 2 k 1 k 2 j i k =2n(H n 1) 2n(1 + lnn 1) = 2n lnn. =:k {}}{ i j j i n 2..n 2 3..n 2..n n 2..n 2... n 1 n..n 2..2 n /0 /0 (harmonische Summe) KIT Institut für Theoretische Informatik 7

8 Exkurs: Harmonische Summe i+1 i 1 x dx 1 i i 1 i 1 x dx f Also n n 1 1 lnn = 1 x dx = i=1 i+1 i n 1 1 x dx 1 i i=1 n i=1 1 i = 1 + i 1 n i=2 i i+1 1 i 1 + n i i=2 i 1 1 n x = dx = 1 + lnn x KIT Institut für Theoretische Informatik 8

9 Quicksort: Eziente Implementierung Array-Implementierung inplace 2-Wegevergleiche KIT Institut für Theoretische Informatik 9

10 Quicksort: Eziente Implementierung Procedure qsort(a : Array of Element; l, r : N) if l r then return k:= pickpivotpos(a, l, r) m:= partition(a, l, r, k) qsort(a,l,m 1) qsort(a,m + 1,r) KIT Institut für Theoretische Informatik 10

11 Quicksort: Eziente Implementierung Function partition(a : Array of Element; l,r,k : N) p:= a[k] swap(a[k],a[r]) i:= l for j := l to r 1 do l i j r invariant p > p? p if a[j] p then swap(a[i],a[j]) i++ l i r assert p > p p swap(a[i],a[r]) l i r assert p p > p return i // pivot KIT Institut für Theoretische Informatik 11

12 Beispiel: Partitionierung, k = 1 p, i, j KIT Institut für Theoretische Informatik 12

13 Beispiel: Rekursion KIT Institut für Theoretische Informatik 13

14 Gröÿerer Basisfall Procedure qsort(a : Array of Element; l, r : N) if r l + 1 n 0 then insertionsort(a[l..r]) else k:= pickpivotpos(a, l, r) m:= partition(a, l, r, k) qsort(a,l,m 1) qsort(a,m + 1,r) KIT Institut für Theoretische Informatik 14

15 Inplace? Wirklich? Im schlechtesten Fall: O(n) für Rekursionsstapel. Potentielles Sicherheitsproblem! Im Mittel: O(log n) zusätzlicher Platz kein Problem. Als Garantie für schlechtesten Fall: halbrekursive Implementierung Rekursion auf kleinere Hälfte KIT Institut für Theoretische Informatik 15

16 Halbrekursive Implementierung Procedure qsort(a : Array of Element; l, r : N) while r l + 1 > n 0 do k:= pickpivotpos(a, l, r) m:= partition(a, l, r, k) if m < (l + r)/2 then qsort(a,l,m 1); l:= m + 1 else qsort(a,m + 1,r); r:= m 1 insertionsort(a[l..r]) KIT Institut für Theoretische Informatik 16

17 Halbrekursive Implementierung Procedure qsort(a : Array of Element; l, r : N) while r l + 1 > n 0 do k:= pickpivotpos(a, l, r) m:= partition(a, l, r, k) if m < (l + r)/2 then qsort(a,l,m 1); l:= m + 1 else qsort(a,m + 1,r); r:= m 1 insertionsort(a[l..r]) Satz: Rekursionstiefe log nn0 Beweisidee: Induktion. Teilproblemgröÿe halbiert sich (mindestens) mit jedem rekursiven Aufruf KIT Institut für Theoretische Informatik 17

18 Quadratische Komplexität bei gleichen Elementen? Variante aus dem Buch verwenden oder doch Drei-Wege-Partitionierung KIT Institut für Theoretische Informatik 18