Algorithmen und Datenstrukturen 7. Vorlesung

Algorithmen und Datenstrukturen 7. Vorlesung Karl-Heinz Niggl 6. Mai 006 Behandelte Sortieralgorithmen insertion-sort(a[..n]) mit worst-case und average-case Laufzeit O(n ) merge-sort(a,p,r) mit worst-case Laufzeit O(n log n), n := r p + die Anzahl der zu sortierenden Elemente heap-sort(a[..n]) mit worst-case Laufzeit O(n log n), basierend auf der Datenstruktur Heap Heute: Datenstruktur Priority Queue (Vorrangswarteschlange) quicksort(a[..n]) mit Laufzeit O(n ) im worst-case, aber O(n log n) im average-case FG KTuEA, TU Ilmenau AuD 6.5.006 FG KTuEA, TU Ilmenau AuD 6.5.006 Erinnerung an die Datenstruktur Heap Ein Max-Heap ist ein Array A[..len(A)] mit Einträgen aus einer totalen Ordnung (U, ) und Attribut heap-size(a) =: n, so daß für j =,...,n gilt: oder explizit ausgedrückt: A[parent(j)] A[j] left(i) n = A[i] A[left(i)] right(i) n = A[i] A[right(i)] Dabei: parent(i) := i/ left(i) := i und right(i) := i + Erinnerung an die Datenstruktur Heap Ein Binärbaum T mit Knotenbeschriftungen l(v) aus (U, ) heißt max-heapgeordnet, falls für je zwei Knoten v,v gilt: v ist Vater von v = l(v) l(v ) Ein Binärbaum T der Tiefe d heißt linksvollständig, falls alle Schichten i d vollständig aufgefüllt sind, bis auf eventuell Schicht d; diese ist von links her aufgefüllt. Gesehen: Jeder n-elementige Max-Heap A entspricht genau einem max-heapgeordneten, linksvollständigen Binärbaum T A der Tiefe (Höhe) log n. FG KTuEA, TU Ilmenau AuD 6.5.006 FG KTuEA, TU Ilmenau AuD 6.5.006 3

Erinnerung an die Datenstruktur Heap 3 Bsp. Max-Heap als Binärbaum und als Array 8 4 5 6 7 9 4 4 8 7 0 6 3 0 9 3 3 4 5 6 7 8 9 0 6 4 0 8 7 9 3 4 Erinnerung an heap-sort Zentralinmax-heapsort ist die Prozedurmax-heapify(A,i). Eingabe: Ein Array A und ein Index i, so daß die zugehörigen (binären) Teilbäume mit Wurzelleft(i) bzw. right(i) maxheapgeordnet sind, aber die Max-Heap-Eigenschaft A[i] A[left(i)],A[right(i)] eventuell verletzt ist. Ausgabe: ArrayA, so daß der zugehörige Teilbaum mit Wurzel i max-heapgeordnet ist. Idee: Vertausche rekursiv A[i] mit Maximum von A[left(i)] und A[right(i)], bis Max-Heap-Eigenschaft erfüllt ist. = worst-case Laufzeit O(log n) FG KTuEA, TU Ilmenau AuD 6.5.006 4 FG KTuEA, TU Ilmenau AuD 6.5.006 5 Erinnerung an heap-sort Weiterer Baustein: Prozedur build-max-heap(a) Wissen: Die Elemente mit Indizes n/ +, n/ +,...,n sind genau die Blätter des gesuchten n-elementigen Heaps A. Diese bilden die Basis für build-max-heap. Die restlichen Elemente werden mittels max-heapify in A einsortiert. : procedure build-max-heap(a) : heap-size(a) len(a) 3: for i len(a)/ downto do 4: max-heapify(a,i) Laufzeit: O(n) Insgesamt ergibt dies: Erinnerung an heap-sort 3 : procedure max-heapsort(a) : build-max-heap(a) 3: for i len(a) downto do 4: Vertausche A[] mit A[i] 5: heap-size(a) heap-size(a) 6: max-heapify(a,) Laufzeit: O(n log n) Denn: build-max-heap(a) benötigt ZeitO(n) undjederder n Aufrufevonmax-heapify(A,) benötigt Zeit O(log n). FG KTuEA, TU Ilmenau AuD 6.5.006 6 FG KTuEA, TU Ilmenau AuD 6.5.006 7

Priority Queues Def. Eine Max-Priority Queue (undanalogfürmin-priority Queue) ist eine Datenstruktur zur Verwaltung einer (dynamischen) Menge S, wobeijedem Element x einschlüsselkey(x) aus (U, ) zugeordnet ist (Schlüssel = Priorität), die folgende Operationen unterstützt: insert(s, x) fügt das Element x in S ein. maximum(s) liefert das Element mit größtem Schlüssel. extract-max(s) liefert und entfernt das Element von S mit größtem Schlüssel. increase-key(s, x, k) aktualisiert den Schlüssel von Element x mit k, falls k > key(x). Anwendungen: Priority Queues ) Prozessverwaltung in Multitask-Systemen Jeder Prozess hat einen Namen (eine ID ) und eine Priorität (Zahl in N). Üblich: kleinere Zahlen bedeuten höhere Prioritäten. Aktuellausführbare Prozesse befindensichineiner Queue. Bei Freiwerden eines Prozessors (z.b. durch Unterbrechen eines Prozesses) wird einer der Prozesse mit höchster Priorität aus der Queue entnommen und weitergeführt. FG KTuEA, TU Ilmenau AuD 6.5.006 8 FG KTuEA, TU Ilmenau AuD 6.5.006 9 Priority Queues 3 ) Discrete Event Simulation System von Aktionen soll auf dem Rechner simuliert werden. Jeder Aktion A ist ein Zeitpunkt t A [0, ) zugeordnet. Die Ausführung eines A kann neue Aktionen A erzeugen oder ausführbar machen, mit neuen Zeitpunkten t A > t A. Ein Schritt: Wähle diejenige noch nicht ausgeführte Aktion mit dem frühesten Ausführungszeitpunkt und führe sie aus. 3) Innerhalb von Algorithmen (Beispiele später). Priority Queues 4 Vereinfachungen: ) Die zugrundeliegende Schlüsselmenge ist N. ) Wiridentifizierendie eigentlichendatenelemente mit ihren Schlüsseln. 3) Behandeln (o.e.) nur Datenstruktur Max-Priority Queue. Diese kannmittels DatenstrukturHeapeffizient implementiert werden: Die Prozedurheap-maximum(A) implementiert die Operation maximum in konstanter Zeit Θ(). : procedure heap-maximum(a) : return A[] FG KTuEA, TU Ilmenau AuD 6.5.006 0 FG KTuEA, TU Ilmenau AuD 6.5.006

Priority Queues 5 Die Prozedur heap-extract-max(a) implementiert die Operation extract-max in Zeit O(log n). : procedure heap-extract-max(a) : if heap-size[a] < then 3: error heap underflow 4: max A[] max buffern 5: A[] A[heap-size[A]] A[] geeignet überschreiben 6: heap-size[a] heap-size[a]] 7: max-heapify(a,) Heap wiederherstellen 8: return max Priority Queues 6 Die Prozedur heap-increase-key(a,i,key) implementiert die Operation heap-increase-key in Zeit O(log n). : procedure heap-increase-key(a,i,key) : if key < A[i] then 3: error key ist kleiner als akt. Schlüssel 4: A[i] key Schlüssel aktualisieren 5: while (i > und A[parent(i)] < A[i]) do 6: Vertausche A[i] mit A[parent(i)] 7: i parent(i) Idee: (für While-Schleife) Durchlaufe den Pfad von Knoten i in Richtung Wurzel, bis Platz für key gefunden ist. FG KTuEA, TU Ilmenau AuD 6.5.006 FG KTuEA, TU Ilmenau AuD 6.5.006 3 Priority Queues 7 Bsp. heap-increase-key(a,9,5) mit T A : Priority Queues 8 Bsp. heap-increase-key(a,9,5) fortgesetzt 6 6 4 0 4 0 8 7 9 3 5 7 9 3 i 4 i 8 4 6 0 i 5 6 0 8 7 9 3 4 7 9 3 i 5 8 FG KTuEA, TU Ilmenau AuD 6.5.006 4 FG KTuEA, TU Ilmenau AuD 6.5.006 5

Priority Queues 9 Die Prozedur max-heap-insert(a,key) implementiert die Operation insert in Zeit O(log n). Idee: Erzeuge zunächst ein neues Heap-Element mit kleinstem Schlüssel ( ). Dazu wird heap-size[a] um eins vergrößert. Mittels heap-increase-key wird damit key richtig eingefügt. : procedure max-heap-insert(a,key) : heap-size[a] heap-size[a]+ 3: A[heap-size[A]] 4: heap-increase-key(a,heap-size[a],key) Quicksort quicksort(a[p..r]) ist ein Divide-and-Conquer Algorithmus. Im folgenden sei (U, ) eine total geordnete Menge. Def. Für eine Teilmenge T U und x U schreiben wir T x (sprich x ist obere Schranke von T) für die Aussage: t T : t x Analog seien T < x und x T (u. Schranke), x < T definiert. Folg (Leere Menge). Es gilt x < x für jedes x U. Ferner identifizieren wir einen Array-Abschnitt A[p..r] mit der Menge {A[p],A[p +],...,A[r]} seiner Elemente. FG KTuEA, TU Ilmenau AuD 6.5.006 6 FG KTuEA, TU Ilmenau AuD 6.5.006 7 Quicksort quicksort(a[p..r]) (Array über (U, )) arbeitet wie folgt: Divide: Teile (i.a. mit Umarrangieren) A[p..r] in zwei Teilarrays A[p..q ] und A[q+..r] auf, so daß gilt: A[p..q ] A[q] A[q+..r] Die Berechnung von q ist Bestandteil dieses Schrittes; A[q] heißtpivotelement mit Pivotindex q. Conquer: Sortiere nun (in-place) rekursiv mittels quicksort die Teilarrays A[p..q ] und A[q+..r]. Combine: Entfällt, da der resultierende ArrayA[p..r] bereits sortiert ist. Quicksort 3 Die Prozedur quicksort lautet damit wie folgt: : procedure quicksort(a,p,r) : if p < r then 3: q partition(a,p,r) 4: quicksort(a,p,q ) 5: quicksort(a,q+,r) Aus der Korrektheit von partition(a,p,r) folgt dann die Korrektheit von quicksort(a,p,r). DerAufrufquicksort(A,,len(A)) sortiert eineninput-array A[..len(A)]. Frage: Wie lautet partition(a,p,r)? FG KTuEA, TU Ilmenau AuD 6.5.006 8 FG KTuEA, TU Ilmenau AuD 6.5.006 9

Quicksort 4 Die Prozedur partition(a,p,r) nach N. Lomuto (ursprüngl. Fassung: C. Hoare): Ein in-place Algorithmus zur Berechnung des Pivotelementes : procedure partition(a,p,r) : x A[r] das Pivotelement! 3: i p grüner Bereich 4: for j p to r do 5: if A[j] x then 6: i i+ 7: Vertausche A[i] mit A[j] 8: Vertausche A[i+] mit x 9: return i+ Bsp. Quicksort 5 i p, j r 8 7 3 5 6 4 i p, j r 8 7 3 5 6 4 p, i j r 8 7 3 5 6 4 p, i j r 8 7 3 5 6 4 p, i j r 8 7 3 5 6 4 FG KTuEA, TU Ilmenau AuD 6.5.006 0 FG KTuEA, TU Ilmenau AuD 6.5.006 Quicksort 6 Quicksort 7 Bsp. fortgesetzt p i j r 7 8 3 5 6 4 p i 3 8 7 5 6 4 p i j r 3 8 7 5 6 4 p i 3 8 7 5 6 4 p i 3 4 7 5 6 8 j r r r Korrektheit(partition(A,p,r)). Zeige Schleifen-Invariante: Vor Ausführung von Runde j (Schleifenrumpf (5-7) mit Laufindex j) gilt: A[p..i] x=a[r] <A[i+..j ] Beweis. j = p Klar, da x <. j j + Betrachte die zwei Fälle in Runde j: A[j] x Dann wirda[j] mit A[i+] vertauscht. Nach I.V. bzw. Fall-Annahme gilt dann: A[p..i+] = A[p..i]::A[j] x A[i+..j] = A[i+..j ]::A[i+] > x Fertig, da i := i+ in Runde j gesetzt wird. FG KTuEA, TU Ilmenau AuD 6.5.006 FG KTuEA, TU Ilmenau AuD 6.5.006 3

Quicksort 8 A[j] > x Dann bleibt i unverändert, also gilt A[p..i] x nach I.V., und nach I.V. bzw. Fall-Annahme gilt: A[i+..j] = A[i+..j ]::A[j] > x Korrektheit: Nach Runde r, d.h. vor Ausführung von Runde j =r, gilt aufgrund der Schleifen-Invariante: A[p..i] x=a[r] <A[i+..r ] NachVertauschenvonA[i+] mit x=a[r] giltwie gewünscht: A[p..i]::x x <A[i+..r ]::A[i+] Quicksort 9 Laufzeitanalyse: partition(a,p,r) benötigt Zeit Θ(n), wobei n := r p +. Die worst-case Laufzeit T(n) von quicksort hängt stark davon ab, wie balanciert oderunbalanciertdie vonpartition erzeugten Aufteilungen ausfallen. Worst-case Aufteilung: Injedem rek. Aufrufvonpartition bzgl. Problemgröße n entstehen Teilarrays der Größe n und 0. Wegen T(0) = Θ() erhalten wir die Rekursion: T(n) = T(n ) + Θ(n) Hierfür gilt (Übungsaufgabe!): T(n) = Θ(n ) FG KTuEA, TU Ilmenau AuD 6.5.006 4 FG KTuEA, TU Ilmenau AuD 6.5.006 5 Quicksort 0 Best-case Aufteilung: In jedem rek. Aufruf von partition bzgl. Problemgröße n entstehen Teilarrays der Größe n/ und n/. In diesem Fall erhalten wir die Rekursionsungleichung: T(n) T(n/) + Θ(n) Hierfürergibtdas Master-Theorem eine ungleichviel bessere asymptotische Lösung der Rekursion: T(n) = O(n log n) Fazit: Bei der best-case Aufteilung arbeitet quicksort so schnellwie merge-sort mit wesentlichkleinererkonstante! Quicksort Aufteilungmit konstanter Proportionalität: Jeder rek. Aufruf von partition bzgl. Problemgröße n erzeugt Teilarrays mit konstanter Proportionalität, z.b. eine 9-zu--Aufteilung (sehr unbalanciert!) In diesem Fall erhalten wir die Rekursionsungleichung: T(n) T(9n/0) + T(n/0) + c n Die Rekursionsbaum-Methode ergibt hierfür ebenfalls: T(n) = O(n log n) Fazit: Selbst bei Aufteilung mit konstanter Proportionalität arbeitet quicksort so schnell wie merge-sort. FG KTuEA, TU Ilmenau AuD 6.5.006 6 FG KTuEA, TU Ilmenau AuD 6.5.006 7

Quicksort Rekursionbaum für konstante 9-zu--Aufteilung: log0 9 n log 0 n 0 n n 9 0 n 00 n 9 00 n 9 00 n 8 00 n 8 000 n 79 000 n cn cn cn cn cn cn O(n logn) Bem. Das gleiche Argument ergibt sich für beliebige Aufteilungen konstanter Proportionalität! Quicksort 3 Worst-Case Laufzeit T(n) von quicksort: Wissen nur T(n) T(n ) + T(n ) + c n mit n + n = n für n und c > 0 geeignet. Beh. T(n) d n für ein d > 0 geeignet und n Beweis. Wertverlaufsinduktion. Sei n beliebig. n = Dann gilt T() T(0) + c d, für d geeignet. n > Dann gilt nach I.V. für n,n mit n + n = n : T(n) d (n ) + d (n ) + c n d (n ) + c n (Binomische Formel) d n für T(0) + c d FG KTuEA, TU Ilmenau AuD 6.5.006 8 FG KTuEA, TU Ilmenau AuD 6.5.006 9 Quicksort 4 Average-CaseLaufzeit T(n) von quicksort(a,p,r), wobei n := r p +. Gleichverteilungsannahme: Alle Permutationen der n Einträge eines Input-Arrays A[p..r] sind gleichwahrscheinlich. Einfachere Analyse: Randomisierung von quicksort: Anstelle stets A[r] als Pivotelementzuwählen, wählenwirzufällig ein Pivotelement aus A[p..r]. Effekt: Die erwartete Aufteilung ist gut balanciert! Im folgenden sei random(a,b) ein Zufallsgenerator, der zufällig eine Zahl m [a,b] erzeugt, d.h. jede dieser Zahlen ist gleichwahrscheinlich. Quicksort 5 : procedure randomized-partition(a,p,r) : i random(p, r) 3: Vertausche A[r] mit A[i] 4: partition(a,p,r) : procedure randomized-quicksort(a,p,r) : if p < r then 3: q randomized-partition(a,p,r) 4: randomized-quicksort(a,p,q ) 5: randomized-quicksort(a,q+,r) Für erwartete Laufzeit von randomized-quicksort: Einschub Wahrscheinlichkeitstheorie FG KTuEA, TU Ilmenau AuD 6.5.006 30 FG KTuEA, TU Ilmenau AuD 6.5.006 3

Wahrscheinlichkeit: Grundbegriffe Wahrscheinlichkeitstheorie ist ein wesentliches Werkzeug bei der Laufzeitanalyse im average-case oder bei der Analyse von randomisierten Algorithmen. Def. Ein Stichprobenraum ist eine endliche (i.a. abzählbar unendliche) Menge S von Elementarereignissen. Intuition: Ein Elementarereignis ist ein möglicher Ausgang eines Zufallsexperiments. Bsp. Für das Experiment, zwei Münzen zu werfen, gibt es vier mögliche Ausgänge, dargestellt als Strings der Länge über H (head: Kopf) und T (tail: Zahl). = S = {HH,HT,TH,TT} Wahrscheinlichkeit: Grundbegriffe Def. Eine Ereignis ist eine Teilmenge A eines Stichprobenraums S. Bsp. Das Ereignis, beim Werfen zweier Münzen Kopf und Zahl zu erhalten, ist die Menge A = {HT,TH}. Das Ereignis S heißt sicher und heißt Nullereignis. Elementarereignisse s S werden oft mit dem Ereignis {s} identifiziert. Def. Zwei Ereignisse A,B heißen disjunkt, falls A B = gilt. FG KTuEA, TU Ilmenau AuD 6.5.006 3 FG KTuEA, TU Ilmenau AuD 6.5.006 33 Wahrscheinlichkeit: Grundbegriffe 3 Def. Eine Wahrscheinlichkeitsverteilung auf einem Stichprobenraum S ist eine Abbildung Pr{ }: Ereignisse(S) R, die die folgenden Axiome erfüllt: (P) Pr{A} 0 für alle Ereignisse von S (P) Pr{S} = (P3) Für paarweise disjunkte Ereignisse A,...,A n gilt: Pr{A... A n } = n Pr{A i } Ein solches Paar (Pr{ },S) heißtwahrscheinlichkeitsraum, kurz W-Raum. i= Wahrscheinlichkeit: Grundbegriffe 4 Folg (W-Raum). Sei (Pr{ },S) ein W-Raum und A,B Ereignisse von S. Dann gilt:. Pr{ } = 0. A B = Pr{A} Pr{B} 3. Pr{A} = Pr{A}, wobei A := S\A 4. Pr{A B} = Pr{A} + Pr{B} Pr{A B} (Siebformel) 5. Pr{A} = Pr{s} s A FG KTuEA, TU Ilmenau AuD 6.5.006 34 FG KTuEA, TU Ilmenau AuD 6.5.006 35

Wahrscheinlichkeit: Grundbegriffe 5 Beweis. Zu ). P P3, P = Pr{S} = Pr{S } = + Pr{ } Zu ). Gelte A B. Dann gilt B = A B\A und somit: Pr{B} P3 = Pr{A} + Pr{B\A} P Pr{A} Zu 3). P = Pr{S} = Pr{A S\A} P3 = Pr{A} + Pr{S\A} Zu 4). Es gilt A = (A B) A\B und somit: Pr{A} P3 = Pr{A B} + Pr{A\B} ( ) = Pr{A B} = Pr{B A\B} P3 = Pr{B} + Pr{A\B} ( ) = Pr{B} + Pr{A} Pr{A B} Zu 5). Folgt direkt aus P3. Wahrscheinlichkeit: Grundbegriffe 6 Def. Ist S endlich und sind alle s S gleichwahrscheinlich, d.h. Pr{s} = / S, so spricht man von Gleichverteilung. Bsp. Experiment, eine faire Münze n-mal zu werfen. Dann erhalten wir eine Gleichverteilung auf S := {H,T} n vermöge Pr{s} = / n für alle s S. Das Ereignis A := {k-mal Kopf und (n k)-mal Zahl} hat damit Wahrscheinlichkeit: Pr{A} Folg 5) = s A Denn: A = {s S #Kopf(s) = k} Pr{s} = A n = ( ) n k n FG KTuEA, TU Ilmenau AuD 6.5.006 36 FG KTuEA, TU Ilmenau AuD 6.5.006 37 Wahrscheinlichkeit: Grundbegriffe 7 Def. Sei (Pr{ },S) ein W-Raum. Eine Zufallsvariable auf S ist eine Abbildung X : S R. Ist X eine Zufallsvariable auf S und x R, so bezeichne X = x das Ereignis: {s S X(s) = x} = X (x) Analog seien X x, X > x, und X x, X < x definiert. Bsp. Experiment, zwei faire Würfel zu werfen. Wir erhalten eine Gleichverteilung auf S := {,,3,4,5,6} mit Pr{s} = /36 für s S. Für die Zufallsvariable auf S, X((z,z )) := max{z,z } gilt dann: Pr{X = 3} = 5/36 Wahrscheinlichkeit: Grundbegriffe 8 Def. Sei (Pr{ },S) ein W-Raum und X eine Zufallsvariable auf S. Der Erwartungswert von X ist definiert durch: E[X] := x R x Pr{X = x} Intuition: E[X] gibt die durchschnittliche Verteilung der Werte von X relativ zu Pr{ } an. Bem. E[X] = x ( Pr{s}) = X(s) Pr{s} x R s X (x) s S Bei Gleichverteilung gilt also: E[X] = S s S X(s) Vorsicht: Ist S abzählbar unendlich, so ist E[X] i.a. nicht definiert, jedoch dann, falls die Reihe absolut konvergiert. FG KTuEA, TU Ilmenau AuD 6.5.006 38 FG KTuEA, TU Ilmenau AuD 6.5.006 39

Wahrscheinlichkeit: Grundbegriffe 9 Bsp. Betrachte das Experiment, zweifaire Münzenzuwerfen. Dann erhalten wir eine Gleichverteilung auf S := {HH,HT,TH,TT} vermöge Pr{s}=/4 für s S. Für die Zufallsvariable X, X(s) := 3 #Kopf(s) #Zahl(s) für s S, ergibt sich dann der folgende Erwartungswert: E[X] = 3 Pr{HH} + Pr{HT} + Pr{TH} Pr{TT} = 6/4 + /4 4/4 = Wahrscheinlichkeit: Grundbegriffe 0 Lemma (Einfache Eigenschaften). Sei (Pr{ },S) einw-raum, seien X, Y ZufallsvariablenaufS und α, β R Konstanten, sowie g: R R. Dann gilt:. E[α X + β Y ] = α E[X] + β E[Y ] (Linearität). E[g X] = x R g(x) Pr{X = x} 3. Für X(S) N gilt: E[X] = Pr{X i} i= Beweis. ) ergibt sich einfach aus der üblichen Definition: (α X + β Y )(s) = α X(s) + β Y (s) FG KTuEA, TU Ilmenau AuD 6.5.006 40 FG KTuEA, TU Ilmenau AuD 6.5.006 4 Wahrscheinlichkeit: Grundbegriffe Zu ). E[g X] = y R y Pr{g X = y} = y R y Pr{{s S g(x(s)) = y}} = y R y Pr{ X = x} x g (y) = y R y Pr{X = x} Zu 3). = x R E[X] = i= = i= = i= x g (y) g(x) Pr{X = x} i Pr{X = i} da X(S) N i (Pr{X i} Pr{X i + }) Pr{X i} da (a a ) + (a a 3 )... = a + a + a 3 +... Wahrscheinlichkeit: Grundbegriffe Zusatz (Einfache Eigenschaften). Wenn X, Y unabhängig sind, d.h. für alle x,y R gilt Pr{X =x und Y =y} = Pr{X =x} Pr{Y =y}, dann gilt E[X Y ] = E[X] E[Y ]. Beweis. Nach Definition und Unabhängigkeit erhält man: E[X Y ] = x y Pr{X =x und Y =y} x y = x y Pr{X =x} Pr{Y =y} ( x y ) ( ) = x Pr{X =x} y Pr{Y =y} x = E[X] E[Y ] y FG KTuEA, TU Ilmenau AuD 6.5.006 4 FG KTuEA, TU Ilmenau AuD 6.5.006 43

Wahrscheinlichkeit: Grundbegriffe 3 Konzept Indikator-Zufallsvariable: Erleichtert Berechnungdes Erwartungswertes einer Zufallsvariable. Def. Sei (Pr{ },S) ein W-Raum und A S. Die Indikator- Zufallsvariable I{A} bzgl. A (auch X A ) ist definiert durch { falls A eintrifft I{A}:= 0 sonst, d.h. I A (s) :=, falls s A, und I A (s) := 0, falls s / A. Folg (Indikator-Zufallsvariable). E[X{A}] = Pr{A} Denn: E[X A ]= x R x Pr{X A =x}=pr{x A =}=Pr{A}. Wahrscheinlichkeit: Grundbegriffe 4 Bsp. Erwartete Anzahl von Kopf nach n-maligem Werfen einer fairen Münze. Erinnerung: Gleichverteilung auf S := {H,T} n vermöge Pr{s} = / n für s S. Betrachte Zufallsvariable X(s) := #Kopf(s) für s S, sowie für i =,...,n die Indikator-Zufallsvariable X i bzgl. Ereignis: i-ter Wurf liefert Kopf, = E[X i ] Folg = Pr{ i-ter Wurf liefert Kopf } = / X = X +... + X n = E[X] Lin. = n E[X i ] = n / = n/ i= i= FG KTuEA, TU Ilmenau AuD 6.5.006 44 FG KTuEA, TU Ilmenau AuD 6.5.006 45 Quicksort fortgesetzt 6 Erwartete Zeit T(n) von randomized-quicksort(a,p,r), wobei n := r p +. Beobachtung: ) Es gibt maximal n Aufrufe von partition innerhalb einer Rechnung von quicksort bei Eingabegröße n. ) Ein Aufruf von partition benötigt Zeit O() plus eine Zeit, die proportional zur Anzahl der in der FOR-Schleife durchgeführten Schlüsselvergleiche (Zeile 4) ist. Lemma (Ansatz für Zufallsvariable). Sei X die Anzahl der von partition durchgeführten Schlüsselvergleiche in Zeile 4 innerhalb einer Rechnung von quicksort auf Eingaben der Größe n. Dann gilt T(n) = O(n + X). Quicksort fortgesetzt 7 Seien z,z,...,z n die Elemente des Eingabe-Arrays A[p..r] in aufsteigend sortierter Reihenfolge. Ferner sei Z ij := {z i,z i+,...,z j }. Frage: Wann vergleicht der Algorithmus z i mit z j? Definiere die Indikator-Zufallsvariable (gemessen über die gesamte Rechnung von quicksort) X ij := I{z i wird mit z j verglichen}. Jedes Paar z i,z j wird höchstens einmal miteinander verglichen! = X = n n X ij i= j=i+ FG KTuEA, TU Ilmenau AuD 6.5.006 46 FG KTuEA, TU Ilmenau AuD 6.5.006 47

Quicksort fortgesetzt 8 Linearität des Erwartungswertes und Folg. ergibt damit: [ ] n n E[X] = E X ij = n i= j=i+ n i= j=i+ = n n i= j=i+ E[X ij ] Pr{z i wird mit z j verglichen} Nun gilt für i<j: z i und z j werden verglichen das erste aus Z ij gewählte Pivotelement ist z i oder z j. Wegen Randomisierung ist jedes aus Z ij erstmals gewählte Pivotelement gleichwahrscheinlich: j i+ Quicksort fortgesetzt 9 = Pr{z i wird mit z j verglichen} = Pr{z i oder z j ist erstes Pivotelement in Z ij } = Pr{z i ist erstes Pivotelement in Z ij } + Pr{z j ist erstes Pivotelement in Z ij } = j i+ = E[X] = n n j i+ i= j=i+ = n n i k+ < n n k i= k= i= k= = n O(log n) i= = O(n log n) (Harmonische Reihe) FG KTuEA, TU Ilmenau AuD 6.5.006 48 FG KTuEA, TU Ilmenau AuD 6.5.006 49 Die Aussage n Quicksort fortgesetzt 0 k k= (log n) + = O(log n) erhält man so: + + 3 +... + n ( + ( + 0 ) +... + +... + log n = i log n i log n i log n j< i i +j j< i i (log n) + log n + ) FG KTuEA, TU Ilmenau AuD 6.5.006 50