Algorithmen und Datenstrukturen 7. Vorlesung

Transkript

1 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 FG KTuEA, TU Ilmenau AuD 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 FG KTuEA, TU Ilmenau AuD

2 Erinnerung an die Datenstruktur Heap 3 Bsp. Max-Heap als Binärbaum und als Array 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 FG KTuEA, TU Ilmenau AuD 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 FG KTuEA, TU Ilmenau AuD

3 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 FG KTuEA, TU Ilmenau AuD 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 FG KTuEA, TU Ilmenau AuD

4 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 FG KTuEA, TU Ilmenau AuD Priority Queues 7 Bsp. heap-increase-key(a,9,5) mit T A : Priority Queues 8 Bsp. heap-increase-key(a,9,5) fortgesetzt i 4 i i i 5 8 FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

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 FG KTuEA, TU Ilmenau AuD 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 FG KTuEA, TU Ilmenau AuD

6 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 i p, j r p, i j r p, i j r p, i j r FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Quicksort 6 Quicksort 7 Bsp. fortgesetzt p i j r p i p i j r p i p i 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 FG KTuEA, TU Ilmenau AuD

7 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 FG KTuEA, TU Ilmenau AuD 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 FG KTuEA, TU Ilmenau AuD

8 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 n 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 FG KTuEA, TU Ilmenau AuD 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 FG KTuEA, TU Ilmenau AuD

9 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 FG KTuEA, TU Ilmenau AuD 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 FG KTuEA, TU Ilmenau AuD

10 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 FG KTuEA, TU Ilmenau AuD 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 FG KTuEA, TU Ilmenau AuD

11 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 FG KTuEA, TU Ilmenau AuD 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 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 FG KTuEA, TU Ilmenau AuD

12 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 FG KTuEA, TU Ilmenau AuD 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 FG KTuEA, TU Ilmenau AuD

13 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 FG KTuEA, TU Ilmenau AuD Die Aussage n Quicksort fortgesetzt 0 k k= (log n) + = O(log n) erhält man so: 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

14