Algorithmen und Datenstrukturen 7. Vorlesung

Behandelte Sortieralgorithmen
Algorithmen und Datenstrukturen
7. Vorlesung
• insertion-sort(A[1..n]) mit worst-case und average-case
Laufzeit O(n2)
Karl-Heinz Niggl
• merge-sort(A, p, r) mit worst-case Laufzeit O(n · log n),
n := r − p + 1 die Anzahl der zu sortierenden Elemente
16. Mai 2006
• heap-sort(A[1..n]) mit worst-case Laufzeit O(n · log n),
basierend auf der Datenstruktur Heap
Heute:
• Datenstruktur Priority Queue (Vorrangswarteschlange)
• quicksort(A[1..n]) mit Laufzeit O(n2) im worst-case, aber
O(n · log n) im average-case
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
1
Erinnerung an die Datenstruktur Heap – 1
Erinnerung an die Datenstruktur Heap – 2
Ein Max-Heap ist ein Array A[1..len(A)] mit Einträgen aus
einer totalen Ordnung (U, ≤) und Attribut heap-size(A) =: n,
so daß für j = 2, . . . , n gilt:
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 ′)
A[parent(j)] ≥ A[j]
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.
oder explizit ausgedrückt:
1 ≤ left(i) ≤ n =⇒ A[i] ≥ A[left(i)]
1 ≤ right(i) ≤ n =⇒ A[i] ≥ A[right(i)]
Gesehen: Jeder n-elementige Max-Heap A entspricht genau
einem max-heapgeordneten, linksvollständigen Binärbaum TA
der Tiefe (Höhe) ⌊log n⌋.
Dabei:
• parent(i) := ⌊i/2⌋
• left(i) := 2i und right(i) := 2i + 1
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
2
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
3
Erinnerung an die Datenstruktur Heap – 3
Erinnerung an heap-sort – 1
Bsp. Max-Heap als Binärbaum und als Array
Zentral in max-heapsort ist die Prozedur max-heapify(A, i).
Eingabe: Ein Array A und ein Index i, so daß die zugehörigen
(binären) Teilbäume mit Wurzel left(i) bzw. right(i) maxheapgeordnet sind, aber die Max-Heap-Eigenschaft A[i] ≥
A[left(i)], A[right(i)] eventuell verletzt ist.
1
16
2
14
4
8
8
9
10
2
4
1
1
2
3
4
3
5
6
7
9
10
7
3
Ausgabe: Array A, so daß der zugehörige Teilbaum mit Wurzel
i max-heapgeordnet ist.
5
6
7
8
9 10
Idee: Vertausche rekursiv A[i] mit Maximum von A[left(i)]
und A[right(i)], bis Max-Heap-Eigenschaft erfüllt ist.
16 14 10 8 7 9 3 2 4 1
=⇒ worst-case Laufzeit O(log n)
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
4
FG KTuEA, TU Ilmenau
Erinnerung an heap-sort – 2
Insgesamt ergibt dies:
Wissen: Die Elemente mit Indizes ⌊n/2⌋+1, ⌊n/2⌋+2, . . . , 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.
2:
3:
4:
2:
3:
4:
6:
procedure max-heapsort(A)
build-max-heap(A)
for i ← len(A) downto 2 do
Vertausche A[1] mit A[i]
heap-size(A) ← heap-size(A) − 1
max-heapify(A, 1)
Laufzeit: O(n·log n)
Denn: build-max-heap(A) benötigt Zeit O(n) und jeder der
n − 1 Aufrufe von max-heapify(A, 1) benötigt Zeit O(log n).
Laufzeit: O(n)
AuD – 16.5.2006
1:
5:
procedure build-max-heap(A)
heap-size(A) ← len(A)
for i ← ⌊len(A)/2⌋ downto 1 do
max-heapify(A, i)
FG KTuEA, TU Ilmenau
5
Erinnerung an heap-sort – 3
Weiterer Baustein: Prozedur build-max-heap(A)
1:
AuD – 16.5.2006
6
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
7
Priority Queues – 1
Priority Queues – 2
Def. Eine Max-Priority Queue (und analog für Min-Priority
Queue) ist eine Datenstruktur zur Verwaltung einer (dynamischen) Menge S, wobei jedem Element x ein Schlüssel key(x)
aus (U, ≤) zugeordnet ist (Schlüssel =
b 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).
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
8
Anwendungen:
1) 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.
Aktuell ausführbare Prozesse befinden sich in einer 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 – 16.5.2006
9
Priority Queues – 3
Priority Queues – 4
2) Discrete Event Simulation“
”
System von Aktionen soll auf dem Rechner simuliert werden.
Jeder Aktion A ist ein Zeitpunkt tA ∈ [0, ∞) zugeordnet.
Vereinfachungen: 1) Die zugrundeliegende Schlüsselmenge
ist N. 2) Wir identifizieren die eigentlichen Datenelemente mit
ihren Schlüsseln.
Die Ausführung eines A kann neue Aktionen A′ erzeugen oder
ausführbar machen, mit neuen Zeitpunkten tA′ > tA.
Ein Schritt: Wähle diejenige noch nicht ausgeführte Aktion
mit dem frühesten Ausführungszeitpunkt und führe sie aus.
3) Behandeln (o.E.) nur Datenstruktur Max-Priority Queue.
Diese kann mittels Datenstruktur Heap effizient implementiert
werden:
Die Prozedur heap-maximum(A) implementiert die Operation maximum in konstanter Zeit Θ(1).
1:
3) Innerhalb von Algorithmen (Beispiele später).
2:
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
10
procedure heap-maximum(A)
return A[1]
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
11
Priority Queues – 5
Priority Queues – 6
Die Prozedur heap-extract-max(A) implementiert die
Operation extract-max in Zeit O(log n).
Die Prozedur heap-increase-key(A, i, key) implementiert
die Operation heap-increase-key in Zeit O(log n).
1:
2:
3:
4:
5:
6:
7:
8:
procedure heap-extract-max(A)
if heap-size[A] < 1 then
error heap underflow“
”
max ← A[1]
⊲ max buffern
A[1] ← A[heap-size[A]] ⊲ A[1] geeignet überschreiben
heap-size[A] ← heap-size[A]]−1
max-heapify(A, 1)
⊲ Heap wiederherstellen
return max
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
12
1:
2:
3:
4:
5:
6:
7:
procedure heap-increase-key(A, i, key)
if key < A[i] then
error key ist kleiner als akt. Schlüssel“
”
A[i] ← key
⊲ Schlüssel aktualisieren
while (i > 1 und A[parent(i)] < A[i]) do
Vertausche A[i] mit A[parent(i)]
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
Priority Queues – 7
AuD – 16.5.2006
13
Priority Queues – 8
Bsp. heap-increase-key(A, 9, 15) mit TA:
Bsp. heap-increase-key(A, 9, 15) fortgesetzt
16
16
14
10
8
2
i
7
4
9
14
3
10
15
1
2
i
7
8
16
14
2 i 15
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
i
10
7
3
1
16
8
9
9
3
15
10
14
1
2
14
FG KTuEA, TU Ilmenau
7
8
AuD – 16.5.2006
9
3
1
15
Priority Queues – 9
Quicksort – 1
Die Prozedur max-heap-insert(A, key) implementiert die
Operation insert in Zeit O(log n).
quicksort(A[p..r]) ist ein Divide-and-Conquer Algorithmus.
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.
1:
2:
3:
4:
procedure max-heap-insert(A, key)
heap-size[A] ← heap-size[A]+1
A[heap-size[A]] ← −∞
heap-increase-key(A, heap-size[A], key)
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
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 + 1], . . . , A[r]} seiner Elemente.
16
FG KTuEA, TU Ilmenau
Quicksort – 2
Divide: Teile (i.a. mit Umarrangieren) A[p..r] in zwei Teilarrays A[p..q−1] und A[q+1..r] auf, so daß gilt:
A[p..q−1] ≤ A[q] ≤ A[q+1..r]
Die Berechnung von q ist Bestandteil dieses Schrittes; A[q]
heißt Pivotelement mit Pivotindex q.
Conquer: Sortiere nun (in-place) rekursiv mittels
quicksort die Teilarrays A[p..q−1] und A[q+1..r].
Combine: Entfällt, da der resultierende Array A[p..r] bereits
sortiert ist.
AuD – 16.5.2006
17
Quicksort – 3
quicksort(A[p..r]) (Array über (U, ≤)) arbeitet wie folgt:
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
18
Die Prozedur quicksort lautet damit wie folgt:
1: procedure quicksort(A,p,r)
2:
if p < r then
q ← partition(A, p, r)
3:
4:
quicksort(A, p, q−1)
5:
quicksort(A, q+1, r)
Aus der Korrektheit von partition(A, p, r) folgt dann die
Korrektheit von quicksort(A, p, r).
Der Aufruf quicksort(A, 1, len(A)) sortiert einen Input-Array
A[1..len(A)].
Frage: Wie lautet partition(A, p, r)?
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
19
Quicksort – 4
Quicksort – 5
Die Prozedur partition(A, p, r) nach N. Lomuto (ursprüngl.
Fassung: C. Hoare): Ein in-place Algorithmus zur Berechnung
des Pivotelementes
1: procedure partition(A,p,r)
x ← A[r]
⊲ das Pivotelement!
2:
i ← p−1
⊲ grüner Bereich
3:
4:
for j ← p to r−1 do
5:
if A[j] ≤ x then
6:
i ← i+1
7:
Vertausche A[i] mit A[j]
8:
9:
Bsp.
i
i
p, i
j
i
2 8 7 1 3 5 6 4
p, i
i
i
j
r
j
i
AuD – 16.5.2006
r
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
21
A[j] ≤ x Dann wird A[j] mit A[i+1] vertauscht. Nach I.V.
bzw. Fall-Annahme gilt dann:
r
A[p..i+1] = A[p..i] :: A[j] ≤ x
A[i+2..j] = A[i+2..j−1] :: A[i+1] > x
r
2 1 3 4 7 5 6 8
FG KTuEA, TU Ilmenau
j
Beweis. j = p Klar, da ∅ ≤ x < ∅. j → j + 1 Betrachte
die zwei Fälle in Runde j:
r
2 1 3 8 7 5 6 4
p
r
Vor Ausführung von Runde j (Schleifenrumpf (5-7) mit
Laufindex j) gilt: A[p..i] ≤ x = A[r] < A[i+1..j−1]
2 1 3 8 7 5 6 4
p
j
2 8 7 1 3 5 6 4
Korrektheit(partition(A, p, r)). Zeige Schleifen-Invariante:
r
2 1 3 8 7 5 6 4
p
r
Quicksort – 7
2 1 7 8 3 5 6 4
p
j
2 8 7 1 3 5 6 4
20
i
r
2 8 7 1 3 5 6 4
Quicksort – 6
p
p, j
p, i
AuD – 16.5.2006
Bsp. fortgesetzt
r
2 8 7 1 3 5 6 4
Vertausche A[i+1] mit x
return i+1
FG KTuEA, TU Ilmenau
p, j
Fertig, da i := i+1 in Runde j gesetzt wird.
22
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
23
Quicksort – 8
Quicksort – 9
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:
Laufzeitanalyse: partition(A, p, r) benötigt Zeit Θ(n), wobei n := r − p + 1.
A[i+1..j] = A[i+1..j−1] :: A[j] > x
Korrektheit: Nach Runde r − 1, d.h. vor Ausführung von
Runde j = r, gilt aufgrund der Schleifen-Invariante:
A[p..i] ≤ x = A[r] < A[i+1..r−1]
Nach Vertauschen von A[i+1] mit x = A[r] gilt wie gewünscht:
Die worst-case Laufzeit T (n) von quicksort hängt stark
davon ab, wie balanciert oder unbalanciert die von partition
erzeugten Aufteilungen ausfallen.
Worst-case Aufteilung: In jedem rek. Aufruf von partition
bzgl. Problemgröße n entstehen Teilarrays der Größe n − 1
und 0.
Wegen T (0) = Θ(1) erhalten wir die Rekursion:
T (n) = T (n − 1) + Θ(n)
A[p..i] :: x ≤ x < A[i+2..r−1] :: A[i+1]
Hierfür gilt (Übungsaufgabe!): T (n) = Θ(n2)
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
24
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
25
Quicksort – 10
Quicksort – 11
Best-case Aufteilung: In jedem rek. Aufruf von partition
bzgl. Problemgröße n entstehen Teilarrays der Größe ⌊n/2⌋
und ⌈n/2⌉ − 1.
Aufteilung mit konstanter Proportionalität: Jeder rek. Aufruf von partition bzgl. Problemgröße n erzeugt Teilarrays
mit konstanter Proportionalität, z.B. eine 9-zu-1-Aufteilung
(sehr unbalanciert!)
In diesem Fall erhalten wir die Rekursionsungleichung:
In diesem Fall erhalten wir die Rekursionsungleichung:
T (n) ≤ 2·T (n/2) + Θ(n)
Hierfür ergibt das Master-Theorem eine ungleich viel bessere
asymptotische Lösung der Rekursion:
T (n) ≤ T (9n/10) + T (n/10) + c·n
Die Rekursionsbaum-Methode ergibt hierfür ebenfalls:
T (n) = O(n·log n)
T (n) = O(n·log n)
Fazit: Bei der best-case Aufteilung arbeitet quicksort so
schnell wie merge-sort – mit wesentlich kleinerer Konstante!
Fazit: Selbst bei Aufteilung mit konstanter Proportionalität
arbeitet quicksort so schnell wie merge-sort.
FG KTuEA, TU Ilmenau
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
26
AuD – 16.5.2006
27
Quicksort – 12
Quicksort – 13
Rekursionbaum für konstante 9-zu-1-Aufteilung:
n
9
10 n
log 109 n
9
100 n
1
100 n
T (n) ≤ T (n′) + T (n′′) + c·n mit n′ + n′′ = n − 1
cn
1
10 n
log10 n
Worst-Case Laufzeit T (n) von quicksort: Wissen nur
cn
für n ≥ 1 und c > 0 geeignet.
81
100 n
cn
Beh. T (n) ≤ d·n2 für ein d > 0 geeignet und n ≥ 1
81
729
1000 n 1000 n
cn
Beweis. Wertverlaufsinduktion. Sei n ≥ 1 beliebig.
9
100 n
1
n = 1 Dann gilt T (1) ≤ 2·T (0) + c ≤ d, für d geeignet.
≤ cn
1
n > 1 Dann gilt nach I.V. für n′, n′′ mit n′ + n′′ = n − 1:
≤ cn
T (n) ≤ d·(n′)2 + d·(n′′)2 + c·n
≤ d·(n − 1)2 + c·n (Binomische Formel)
≤ d·n2 für 2·T (0) + c ≤ d
O(n log n)
Bem. Das gleiche Argument ergibt sich für beliebige Aufteilungen konstanter Proportionalität!
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
28
FG KTuEA, TU Ilmenau
Quicksort – 14
AuD – 16.5.2006
29
Quicksort – 15
Average-Case Laufzeit T (n) von quicksort(A, p, r), wobei
n := r − p + 1.
Gleichverteilungsannahme: Alle Permutationen der n Einträge eines Input-Arrays A[p..r] sind gleichwahrscheinlich.
1:
2:
3:
4:
Einfachere Analyse: Randomisierung von quicksort: Anstelle stets A[r] als Pivotelement zu wählen, wählen wir zufällig
ein Pivotelement aus A[p..r].
2:
Effekt: Die erwartete Aufteilung ist gut balanciert!
4:
1:
3:
5:
procedure randomized-partition(A,p,r)
i ← random(p, r)
Vertausche A[r] mit A[i]
partition(A, p, r)
procedure randomized-quicksort(A,p,r)
if p < r then
q ← randomized-partition(A, p, r)
randomized-quicksort(A, p, q−1)
randomized-quicksort(A, q+1, r)
Im folgenden sei random(a, b) ein Zufallsgenerator, der
zufällig eine Zahl m ∈ [a, b] erzeugt, d.h. jede dieser Zahlen
ist gleichwahrscheinlich.
Für erwartete Laufzeit von randomized-quicksort: Einschub Wahrscheinlichkeitstheorie
FG KTuEA, TU Ilmenau
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
30
AuD – 16.5.2006
31
Wahrscheinlichkeit: Grundbegriffe – 1
Wahrscheinlichkeit: Grundbegriffe – 2
Wahrscheinlichkeitstheorie ist ein wesentliches Werkzeug bei
der Laufzeitanalyse im average-case oder bei der Analyse von
randomisierten Algorithmen.
Def. Eine Ereignis ist eine Teilmenge A eines Stichprobenraums S.
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 2
über H (head: Kopf) und T (tail: Zahl).
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.
=⇒ S = {HH, HT, TH, TT}
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
32
Wahrscheinlichkeit: Grundbegriffe – 3
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
33
Wahrscheinlichkeit: Grundbegriffe – 4
Folg (W-Raum).
Def. Eine Wahrscheinlichkeitsverteilung auf einem Stichprobenraum S ist eine Abbildung Pr{·} : Ereignisse(S) → R,
die die folgenden Axiome erfüllt:
Sei (Pr{·}, S) ein W-Raum und A, B Ereignisse von S. Dann
gilt:
(P1) Pr{A} ≥ 0 für alle Ereignisse von S
1. Pr{∅} = 0
(P2) Pr{S} = 1
2. A ⊆ B =⇒ Pr{A} ≤ Pr{B}
(P3) Für paarweise disjunkte Ereignisse A1, . . . , An gilt:
n
P
Pr{Ai}
Pr{A1 ∪ . . . ∪ An} =
3. Pr{A} = 1 − Pr{A}, wobei A := S \A
i=1
Ein solches Paar (Pr{·}, S) heißt Wahrscheinlichkeitsraum,
kurz W-Raum.
4. Pr{A ∪ B} = Pr{A} + Pr{B} − Pr{A ∩ B} (Siebformel)
P
Pr{s}
5. Pr{A} =
s∈A
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
34
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
35
Wahrscheinlichkeit: Grundbegriffe – 5
P2
Wahrscheinlichkeit: Grundbegriffe – 6
P3, P2
Beweis. Zu 1). 1 = Pr{S} = Pr{S ⊎ ∅} = 1 + Pr{∅}
Def. Ist S endlich und sind alle s ∈ S gleichwahrscheinlich,
d.h. Pr{s} = 1/|S|, so spricht man von Gleichverteilung.
Zu 2). Gelte A ⊆ B. Dann gilt B = A ⊎ B \A und somit:
P1
P3
Pr{B} = Pr{A} + Pr{B \A} ≥ Pr{A}
Bsp. Experiment, eine faire Münze n-mal zu werfen. Dann
erhalten wir eine Gleichverteilung auf S := {H, T}n vermöge
Pr{s} = 1/2n für alle s ∈ S.
P3
P2
Zu 3). 1 = Pr{S} = Pr{A ⊎ S \A} = Pr{A} + Pr{S \A}
Zu 4). Es gilt A = (A ∩ B) ⊎ A\B und somit:
Das Ereignis A := {k-mal Kopf und (n − k)-mal Zahl} hat
damit Wahrscheinlichkeit:
Folg 5) P
Pr{A} =
Pr{s} = |A| · 21n = nk · 21n
P3
Pr{A} = 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}
s∈A
Denn: A = {s ∈ S | #Kopf(s) = k}
Zu 5). Folgt direkt aus P3.
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
36
Wahrscheinlichkeit: Grundbegriffe – 7
• 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
AuD – 16.5.2006
37
Wahrscheinlichkeit: Grundbegriffe – 8
Def. Sei (Pr{·}, S) ein W-Raum.
−1
FG KTuEA, TU Ilmenau
(x)
Analog seien X ≥ x, X > x, und X ≤ x, X < x definiert.
Def. Sei (Pr{·}, S) ein W-Raum und X eine Zufallsvariable
auf S. Der Erwartungswert von X ist definiert durch:
P
E[X] :=
x · Pr{X = x}
x∈R
Intuition: E[X] gibt die durchschnittliche Verteilung der
Werte von X relativ zu Pr{·} an.
P
P
P
X(s) · Pr{s}
x·(
Bem. E[X] =
Pr{s}) =
x∈R
s∈X −1(x)
Bei Gleichverteilung gilt also: E[X] =
s∈S
1
|S|
·
P
X(s)
Bsp. Experiment, zwei faire Würfel zu werfen. Wir erhalten
eine Gleichverteilung auf S := {1, 2, 3, 4, 5, 6}2 mit Pr{s} =
1/36 für s ∈ S. Für die Zufallsvariable auf S, X((z, z ′)) :=
max{z, z ′} gilt dann: Pr{X = 3} = 5/36
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
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
38
AuD – 16.5.2006
s∈S
39
Wahrscheinlichkeit: Grundbegriffe – 9
Wahrscheinlichkeit: Grundbegriffe – 10
Bsp. Betrachte das Experiment, zwei faire Münzen zu werfen.
Dann erhalten wir eine Gleichverteilung auf
S := {HH, HT, TH, TT}
vermöge Pr{s} = 1/4 für s ∈ S. Für die Zufallsvariable X,
Lemma (Einfache Eigenschaften).
Sei (Pr{·}, S) ein W-Raum, seien X, Y Zufallsvariablen auf S
und α, β ∈ R Konstanten, sowie g : R → R. Dann gilt:
1. E[α·X + β ·Y ] = α·E[X] + β ·E[Y ]
P
g(x)·Pr{X = x}
2. E[g ◦ X] =
X(s) := 3·#Kopf(s) −2·#Zahl(s)
für s ∈ S, ergibt sich dann der folgende Erwartungswert:
(Linearität)
x∈R
3. Für X(S) ⊆ N gilt: E[X] =
E[X] = 3·2·Pr{HH} + Pr{HT} + Pr{TH} −2·2·Pr{TT}
= 6/4 + 2/4 −4/4
=1
∞
P
Pr{X ≥ i}
i=1
Beweis. 1) ergibt sich einfach aus der üblichen Definition:
(α·X + β ·Y )(s) = α·X(s) + β ·Y (s)
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
40
Wahrscheinlichkeit: Grundbegriffe – 11
P
Zu 2). E[g ◦ X] = y∈R
P
= y∈R
P
= y∈R
P
= y∈R
P
= x∈R
41
Zusatz (Einfache Eigenschaften).
Wenn X, Y unabhängig sind, d.h. für alle x, y ∈ R gilt
y · Pr{g ◦ X = y}
y · Pr{{s ∈ S | g(X(s)) = y}}
U
y · Pr{
X = x}
x∈g −1(y)
P
y·
Pr{X = x}
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:
PP
x·y·Pr{X = x und Y = y}
E[X ·Y ] =
x y
P
P
x·y·Pr{X = x} · Pr{Y = y}
=
!
x y
P
P
y·Pr{Y = y}
x·Pr{X = x} ·
=
x∈g −1(y)
g(x) · Pr{X = x}
x
da 1 · (a1−a2) + 2 · (a2 − a3) . . . = a1 + a2 + a3 + . . .
AuD – 16.5.2006
AuD – 16.5.2006
Wahrscheinlichkeit: Grundbegriffe – 12
P∞
Zu 3). E[X] = i=1 i · Pr{X = i} da X(S) ⊆ N
P∞
= i=1 i · (Pr{X ≥ i} − Pr{X ≥ i + 1})
P∞
= i=1 Pr{X ≥ i}
FG KTuEA, TU Ilmenau
FG KTuEA, TU Ilmenau
y
= E[X]·E[Y ]
42
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
43
Wahrscheinlichkeit: Grundbegriffe – 13
Wahrscheinlichkeit: Grundbegriffe – 14
Konzept Indikator-Zufallsvariable: Erleichtert Berechnung des
Erwartungswertes einer Zufallsvariable.
Bsp. Erwartete Anzahl von Kopf“ nach n-maligem Werfen
”
einer fairen Münze. Erinnerung: Gleichverteilung auf S :=
{H, T}n vermöge Pr{s} = 1/2n für s ∈ S.
Def. Sei (Pr{·}, S) ein W-Raum und A ⊆ S. Die IndikatorZufallsvariable I{A} bzgl. A (auch XA) ist definiert durch
1 falls A eintrifft
I{A} :=
0 sonst,
d.h. IA(s) := 1, falls s ∈ A, und IA(s) := 0, falls s ∈
/ A.
Folg (Indikator-Zufallsvariable). E[X{A}] = Pr{A}
P
Denn: E[XA] =
x · Pr{XA = x} = Pr{XA = 1} = Pr{A}.
x∈R
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
Betrachte Zufallsvariable X(s) := #Kopf(s) für s ∈ S, sowie
für i = 1, . . . , n die Indikator-Zufallsvariable Xi bzgl. Ereignis:
i-ter Wurf liefert Kopf“,
”
Folg
=⇒ E[Xi] = Pr{ i-ter Wurf liefert Kopf“} = 1/2
”
X = X1 + . . . + Xn
n
n
P
Lin. P
=⇒ E[X] =
E[Xi] =
1/2 = n/2
i=1
44
FG KTuEA, TU Ilmenau
i=1
AuD – 16.5.2006
45
Quicksort fortgesetzt – 16
Quicksort fortgesetzt – 17
Erwartete Zeit T (n) von randomized-quicksort(A, p, r),
wobei n := r − p + 1. Beobachtung:
Seien z1, z2, . . . , zn die Elemente des Eingabe-Arrays A[p..r]
in aufsteigend sortierter Reihenfolge. Ferner sei
1) Es gibt maximal n Aufrufe von partition innerhalb einer
Rechnung von quicksort bei Eingabegröße n.
Zij := {zi, zi+1, . . . , zj }.
2) Ein Aufruf von partition benötigt Zeit O(1) 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).
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
46
Frage: Wann vergleicht der Algorithmus zi mit zj ?
Definiere die Indikator-Zufallsvariable (gemessen über die gesamte Rechnung von quicksort)
Xij := I{zi wird mit zj verglichen}.
Jedes Paar zi, zj wird höchstens einmal miteinander verglichen!
n
n−1
P P
Xij
=⇒ X =
i=1 j=i+1
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
47
Quicksort fortgesetzt – 18
Quicksort fortgesetzt – 19
Linearität des Erwartungswertes und Folg. ergibt damit:
#
"
n
n−1
P P
Xij
E[X] = E
=⇒
i=1 j=i+1
n−1
P
=
n
P
i=1 j=i+1
n
n−1
P P
=
E[Xij ]
Pr{zi
= Pr{zi
= Pr{zi
Pr{zj
2
= j−i+1
=⇒ E[X] =
Pr{zi wird mit zj verglichen}
i=1 j=i+1
Nun gilt für i < j: zi und zj werden verglichen ⇐⇒ das erste
aus Zij gewählte Pivotelement ist zi oder zj .
=
Wegen Randomisierung ist jedes aus Zij erstmals gewählte
1
Pivotelement gleichwahrscheinlich: j−i+1
=
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
48
Quicksort fortgesetzt – 20
Die Aussage
n
P
k=1
1
1
≤
=
1
k
+ 12 + 31 + . . . + n1
1
20
+ ( 211 + 221−1 ) + . . . +
P 1
P
i≤⌊log n⌋ j<2i
≤
P
P
i≤⌊log n⌋ j<2i
≤
≤ (log n) + 1 = O(log n) erhält man so:
P
2i+j
1
2⌊log n⌋
1
+ . . . + 2⌊log n⌋+1
−1
1
2i
1
i≤⌊log n⌋
≤ (log n) + 1
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
50
n−1
P
wird mit zj verglichen}
oder zj ist erstes Pivotelement in Zij }
ist erstes Pivotelement in Zij } +
ist erstes Pivotelement in Zij }
n
P
2
j−i+1
i=1 j=i+1
n−1
n−1
n
P 2
P n−i
P P
2
<
k+1
k
i=1 k=1
i=1 k=1
n−1
P
O(log n)
(Harmonische Reihe)
i=1
= O(n·log n)
FG KTuEA, TU Ilmenau
AuD – 16.5.2006
49