Average Analyse von QuickSort - ALGORITHM ENGINEERING
Werbung
Überblick
Kap. 3: Sortieren (3)
• Quick-Sort
• Analyse von Quick-Sort
• Quick-Sort Varianten
Professor Dr. Petra Mutzel
Lehrstuhl für Algorithm Engineering, LS11
Fakultät für Informatik, TU Dortmund
6. VO
DAP2
SS 2009
Petra Mutzel
• Heap-Sort
30. April 2009
DAP2 SS09
1
Petra Mutzel
DAP2 SS09
Termine für Übungstests
Motivation
• 1. Übungstest:
• Di 19. Mai, in der Vorlesung im
AudiMax, Beginn: ab 12:15 Uhr, ab 12
Uhr anwesend sein wegen Sitzordnung
„Warum soll ich hier bleiben?“
Wir lernen Quick-Sort
„Was ist daran denn besonders?“
• 2. Übungstest:
• Di 16. Juni, in der VO im AudiMax,
Beginn: ab 12:15 Uhr, ab 12 Uhr
anwesend sein wegen Sitzordnung
Petra Mutzel
DAP2 SS09
Quick-Sort gehört zu den „Top 10“
wichtigsten Algorithmen
3
Analyse von QuickSort: Average
DAP2 SS09
4
• Teilt man sämtliche Folgen mit n Elementen mit dem
Pivotelement (an der letzten Stelle), so erhält man
sämtliche Folgen der Länge k-1 und n-k.
– alle Schlüssel sind verschieden
– o.B.d.A. A[i]∈{1,2,…n}
– alle
Permutationen
sind
gleich
wahrscheinlich
Rekursionsgleichung der Laufzeitfunktionen:
• Jede Zahl k∈{1,2,…,n} tritt mit gleicher
Wahrscheinlichkeit 1/n an Position n auf
• Pivotelement k erzeugt zwei Folgen der Längen k-1
und n-k
• Diese Folgen sind wieder zufällig:
gilt
DAP2 SS09
Petra Mutzel
Analyse von QuickSort: Average
• Grundannahmen
Petra Mutzel
2
wobei die Summe über alle n möglichen Aufteilungen
läuft und bn der Aufteilungsaufwand für eine Folge
der Länge n ist.
5
Petra Mutzel
DAP2 SS09
6
1
Analyse von QuickSort: Average
Beweis von Average-Case
Einsetzen von T(0)=0:
• Wir zeigen: T(n)=O(n log n)
• T(n)=Ω(n log n) ähnlich (o.Bw.)
Lösung der Rekursionsgleichung:
T(n)=Θ(n log n)
Wir zeigen durch vollständige Induktion:
es existieren c,n0>0, so dass für alle n≥n0:
T(n) ≤ cn log n
Wir wählen: n0=2.
Induktionsanfang: n=2: T(2)=T(1)+bn=a+2b
somit ist T(2)≤c2 log 2 g.d.w. c≥(a+2b)/2=a/2+b
Petra Mutzel
DAP2 SS09
7
Beweis von Average-Case ff
Petra Mutzel
DAP2 SS09
8
Eigenschaften von QuickSort
Induktionsschluss: Sei nun n≥3, Beh. gilt für alle
kleineren Werte:
• Anzahl der Schlüsselvergleiche:
Cbest(n)=Cavg(n)=Θ(n log n); Cworst(n)=Θ(n2)
• Eigenschaften:
– in situ?
Θ(n) zusätzlichen Speicher
– adaptiv?
– stabil?
Diese Ungleichung gilt, falls c≥4b
Wähle insgesamt c=max {a/2+b,4b}
Quicksort - Varianten
• sehr gut in der Praxis
• es existieren viele Varianten
Randomisierter Quick-Sort
Ziel: Laufzeit unabhängig von der „Qualität“ der
Eingabefolge (vorsortiert, etc…)
• Randomisierter Quicksort
Idee: Wähle Pivotelement zufällig aus!
• Quicksort mit log(n) Speicher
Petra Mutzel
Einfachste Umsetzung: „Neues“ Partitionieren:
(1) z := Zufallszahl zwischen l und r
(2) vertausche A[z] mit A[r]
(3) normales Partitionieren
DAP2 SS09
11
Petra Mutzel
DAP2 SS09
12
2
Randomisierter Quick-Sort
Quick-Sort mit log(n) Speicher
Randomisierte Algorithmen: Es lassen sich
keine Best-Case und Worst-Case Beispiele
mehr konstruieren!
Aber: Natürlich kann der Worst-Case noch
eintreten!
Bisher: O(n) Speicher
l ... p-1 p
p+1................ r
Idee: Lange Teile sofort bearbeiten
D.h.: Rekursiver Aufruf nur für kleinere Teile.
diese Teile sind ≤ Hälfte der betrachteten Länge
Tiefe der rekursiven Aufrufe: O(log n) Man berechnet eine Erwartete Laufzeit
= Erwartungswert der Laufzeit ≈
durchschnittliche Laufzeit Average-Case
E[ T(n) ] = O(n log n)
Petra Mutzel
DAP2 SS09
13
Petra Mutzel
l ... p-1 p
Idee: Lange Teile sofort bearbeiten
bisher
Zwischenschritt
(1) procedure QS(ref A,l,r)
(2) while l < r do {
(3) p := Partition(A,l,r)
(4) QuickSort(A,l,p-1)
(5) l := p+1
(6) }
Petra Mutzel
DAP2 SS09
14
Quick-Sort mit log(n) Speicher
Quick-Sort mit log(n) Speicher
(1) procedure QS(ref A,l,r)
(2) if l < r then {
(3) p := Partition(A,l,r)
(4) QuickSort(A,l,p-1)
(5) QuickSort(A,p+1,r)
(6) }
DAP2 SS09
15
Was bisher geschah…
Zwischenschritt
(1) procedure QS(ref A,l,r)
(2) while l < r do {
(3)
p := Partition(A,l,r)
(4)
QuickSort(A,l,p-1)
(5)
l := p+1
(6) }
p+1................ r
(1) procedure QS(ref A,l,r)
(2) while l < r do {
(3)
p := Partition(A,l,r)
(4)
if p-l < r-p then {
(5)
QuickSort(A,l,p-1)
(6)
l := p+1
(7) } else {
(8)
QuickSort(A,p+1,r)
(9)
r := p-1
(10) } } Petra Mutzel
DAP2 SS09
16
Übersicht
Insertion-Sort: O(n2)
einfach
2
Selection-Sort: Θ(n )
Merge-Sort: O(n log n)
nicht in-situ
Quick-Sort: praxis schnell
O(n2)
Heap-Sort
Einführung in Datenstruktur Heap
Analyse von Heap-Sort
Jetzt:
Heap-Sort:
O(n log n) , in-situ
Auf Basis von Selection-Sort!
Petra Mutzel
DAP2 SS09
17
Petra Mutzel
DAP2 SS09
18
3
Selection-Sort…
Heap (=Haufen)
GUT
In jedem Schritt wird ein Schlüssel an seine
richtige Position gesetzt
Heap: eine neue Datenstruktur!
Speicherung…
SCHLECHT
…weiterhin als Array (in-situ!)
Suchen des richtigen Schlüssels: Θ(n)
Interpretation…
IDEE
Den unsortierten Teil „vorsortieren”
Schnelles Finden des nächsten Schlüssels
Petra Mutzel
…als binärer Baum,
an dessen Wurzel immer das größte
Element stehen soll
DAP2 SS09
19
Petra Mutzel
Definition Heap
12345678
F=<8,6,7,3,4,5,2,1>
Ähnlich sind Min-Heaps definiert. Dort gilt:
Falls 2i≤n, so gilt ki≤k2i und falls 2i+1≤n so gilt ki≤k2i+1.
Petra Mutzel
DAP2 SS09
F=<8,6,7,3,4,5,2,1>
1
Heap-Eigenschaft:
Falls 2i≤n, so gilt ki≥k2i und
falls 2i+1≤n so gilt ki≥k2i+1.
Heap–Eigenschaft:
Schlüssel der
Elternknoten ist größer
gleich denen seiner
Kinder
21
Heap: Interpretation
2
6
3
3
8
5
4
7
6
5
7
2
1
Petra Mutzel
S
8
4
Binärer Baum
1
20
Heap: Interpretation
Eine Folge H=<k1,k2,…,kn> von Schlüsseln ist ein
(Max-) Heap, wenn für jede Position i die folgende
Heap-Eigenschaft erfüllt ist:
Falls 2i≤n, so gilt ki≥k2i und falls 2i+1≤n so gilt ki≥k2i+1.
Beispiel:
DAP2 SS09
DAP2 SS09
22
Wurzel
Ebene 1
1
S
Interpretation als Binärer Baum
2
O
3
Ebene 2
R
Knoten
2
O
3
Elter / Vater
R
Kind
= Einträge im Baum
4
T
5
I
6
N
7
G
Ebene 3 4 T
Kanten
verbinden Knoten
1
Speicherung als Array
2
3
4
S O R T
5
6
7
I N G
5
I
6
N
7
G
Blätter = Knoten ohne Kinder
Binärer Baum: maximal 2 Kinder pro Knoten
4
Tiefe/Höhe des Baums
Ebene 1
2
Ebene 2
1
2
4
Ebene 3 4 T
15
8
Ebene 4
2k-1
2k-1
Ebene k
7
S
1
O
5
3
I
6
R
N
7
G
Heap-Eigenschaft
Heap–Eigenschaft:
Schlüssel der
Elternknoten ist größer
gleich denen seiner
Kinder
1
2
Ebene 1
Tiefe/Höhe eines
1 S Baums =
Anzahl der Ebenen - 1
2
Ebene 2
Gegebene
Höhe h: 3 R
2 O
nmax = 2h+1-1
nmin = 2h
4
Maximale Höhe bei n
Ebene 3 4Elementen?
6 N
T 5 I
15
8
Ebene 4
2k-1
2k-1
Ebene k
7
7 G
n = 2h hmax = log2 n
Höhe des Heaps: O(log n)
Elemente im unsortierten Array so verschieben,
dass die Heap-Eigenschaft erfüllt ist
(CreateHeap)
S
O
3
R
Größtes Element im Heap finden ist einfach
Wurzel = erstes Element im Array
∀ Indizes i:
4
T
5
I
6
N
7
G
Wurzel aus Heap entfernen
Heap-Eigenschaften wiederherstellen
(Sifting)
nicht erfüllt!
falls diese Indizes
existieren
1
2
3
4
S O R T
5
6
7
I N G
Petra Mutzel
CreateHeap
DAP2 SS09
29
CreateHeap
Beobachtung
Die Heapbedingung ist
an den Blättern erfüllt.
1
2
Algorithmus
Betrachte Knoten über den
Blättern repariere
Teilheap
Bearbeite Baum von unten
nach oben Teilbäume
sind immer Heaps
1
Idee von Heap-Sort
Array A[1…n]
A[i] ≥ A[2i] und
A[i] ≥ A[2i+1]
3
# Knoten PRO Ebene
1
# Knoten BIS Ebene
3
# Knoten PRO Ebene
# Knoten BIS Ebene
1
Tiefe/Höhe des Baums
procedure CREATEHEAP () {
for i := n/2 … 1 {
SIFTDOWN (i, n)
} }
S
O
3
R
1
S
i
2 O
procedure SIFTDOWN (i, m) {
while Knoten i hat Kinder ≤ m
{
j := Kind ≤ m mit größerem
Wert
5 I
6
4 T
if A[i] < A[j] then {
vertausche A[i] und A[j]
1
2
3
4
i := j
S
O
R
T
} else return
} }
3
R
4
T
1
5
I
2
3
6
4
S O R T
Petra Mutzel
N
5
7
6
G
7
I N G
DAP2 SS09
30
N
7
2i
5
G
2i+1
6
7
I N G
5
CreateHeap
CreateHeap
procedure CREATEHEAP () {
for i := n/2 … 1 {
SIFTDOWN (i, n)
} }
1
Heap-Erstellung beendet
i
procedure CREATEHEAP () {
for i := n/2 … 1 {
SIFTDOWN (i, n)
} }
S
i
2 O
procedure SIFTDOWN (i, m) {
3 R
while Knoten i hat Kinder ≤ m
{
j := Kind ≤ m mit größerem
Wert
5 I
6 N
7 G
4 T
if A[i] < A[j] then {
2i
2i+1
vertausche A[i] und A[j]
1
2
3
4
5
6
7
i := j
S O R T I N G
} else return
} }
1
S
j
2 T
procedure SIFTDOWN (i, m) {
3 R
while Knoten i hat Kinder ≤ m
{
j := Kind ≤ m mit größerem
Wert
5 I
6 N
7 G
4 O
if A[i] < A[j] then {
vertausche A[i] und A[j]
1
2
3
4
5
6
7
i := j
S T R O I N G
} else return
} }
HeapSort
HeapSort
procedure HEAPSORT () {
CREATEHEAP ()
for k := n … 2 {
vertausche A[1] und A[k]
SIFTDOWN (1, k-1)
} }
1
2
4
S
3
O
5
I
1
2
3
procedure HEAPSORT () {
CREATEHEAP ()
for k := n … 2 {
vertausche A[1] und A[k]
SIFTDOWN (1, k-1)
} }
G
T
6
4
R
N
5
7
6
k
G
T
1
4
7
G
T S R O I N G
T
Petra Mutzel
DAP2 SS09
2
O
G
S
G
O
5
I
1
2
3
G
S
3
6
4
R
N
5
7
6
k
T
7
G
S O
G
S R G
O I N T
34
HeapSort
Petra Mutzel
DAP2 SS09
35
HeapSort
procedure HEAPSORT () {
CREATEHEAP ()
for k := n … 2 {
vertausche A[1] und A[k]
SIFTDOWN (1, k-1)
} }
1
4
2
O
G
5
I
1
2
3
procedure HEAPSORT () {
CREATEHEAP ()
for k := n … 2 {
vertausche A[1] und A[k]
SIFTDOWN (1, k-1)
} }
N
R
S
3
6
4
R
N
k
N
S
5
7
6
T
4
7
N
R
S O N
R G I N
S T
Petra Mutzel
DAP2 SS09
1
2
O
I
G
5
k
RI
1
2
3
O
R
I
3
6
4
N
S
5
7
6
T
7
O
R
I O
I N G R
I S T
36
Petra Mutzel
DAP2 SS09
37
6
HeapSort
HeapSort
procedure HEAPSORT () {
CREATEHEAP ()
for k := n … 2 {
vertausche A[1] und A[k]
SIFTDOWN (1, k-1)
} }
1
2
4
I
3
k
O
G
5
R
1
2
3
procedure HEAPSORT () {
CREATEHEAP ()
for k := n … 2 {
vertausche A[1] und A[k]
SIFTDOWN (1, k-1)
} }
O
G
N
6
4
G
N
S
5
7
6
T
4
7
O
G
N I G
N O
G R S T
Petra Mutzel
DAP2 SS09
1
2
G
I
O
5
R
1
2
3
G
N
I
3
6
4
k
G
N
S
5
7
6
T
7
G
N
I G
I G
N O R S T
38
Petra Mutzel
DAP2 SS09
39
HeapSort
procedure HEAPSORT () {
CREATEHEAP ()
for k := n … 2 {
vertausche A[1] und A[k]
SIFTDOWN (1, k-1)
} }
1
4
2
k
G
I
O
5
R
1
2
3
G
I
3
6
4
N
S
5
7
6
T
7
G
I G
I N O R S T
Petra Mutzel
DAP2 SS09
40
7
