Algorithmen mit Datenstrukturen, Heaps, Heap-Sort

8. A & D - Heapsort
Werden sehen, wie wir durch geschicktes Organsieren
von Daten effiziente Algorithmen entwerfen können.
Genauer werden wir immer wieder benötigte
Operationen durch Datenstrukturen unterstützen.
Werden im Laufe des Semesters viel mehr über
Datenstrukturen und ihren Zusammenhang mit
effizienten Algorithmen lernen.
Beispiel Sortieren: Warum nicht Array sortieren,
indem wir immer wieder Minimum berechnen?
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
1
Min-Sort
Eingabe: Array A
Ausgabe: Zahlen in A in aufsteigender Reihenfolge sortiert.
Min - Sort ( A )
1. for i = 1 to length ( A )
2.
do m ← Min-Search( A[i,K ,length ( A )])
3.
A[i ] ↔ A[m ]
Aber: Algorithmus Min-Sort hat Laufzeit Θ(n 2 ).
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
2
Heaps
Definition 8.1: Ein Heap über einem Array A ist das Array
A zusammen mit einem Parameter heap-size[A]
und drei Funktionen
Parent, Left, Right : {1,K ,heap-size[A]} → {1,K ,length[A]}
.
Dabei gilt:
1.
2.
3.
4.
1 ≤ heap - size[A] ≤ length[A]
Parent (i ) = i / 2 für alle 1 ≤ i ≤ heap − size[A]
Left (i ) = 2i für alle 1 ≤ i ≤ heap − size[A]
Right (i ) = 2i + 1 für alle 1 ≤ i ≤ heap − size[A].
Arrayelemente A[1],…, A[heap-size[A]] heissen
Heapelemente.
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
3
Heaps (2)
Die Funktionen Parent, Left, Right versehen ein Array
mit einer binären Baumstruktur.
Nehmen dabei an, dass der Baum fast vollständig
ist, d.h. der Baum ist bis auf die letzte Ebene auf
jeder Ebene vollständig besetzt. Die letzte Ebene
ist von links nach rechts besetzt.
Parent liefert Elternknoten, Left und Right liefern
linkes und rechtes Kind eines Knotens.
Liegt dabei ein Funktionswert außerhalb des Intervalls
[1,K , heap − size[A]], so bedeutet dies, dass der Knoten
kein Eltern oder kein linkes bzw. rechtes Kind besitzt.
Es gibt nur einen Knoten ohne Eltern, dies ist die Wurzel
A[1].
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
4
Arrays und Bäume
16 14 10 8 7 9 3 2 4 1
1
16
2
14
4
8
8
2
SS 2006
3
10
5
7
6
9
7
3
9 10
4
1
Datenstrukturen und Algorithmen 8. A & D -Heapsort
5
Heaps
Definition 8.2: Ein Heap heisst
1. max-Heap, wenn für alle 2 ≤ i ≤ heap − size[A]
gilt
A[Parent(i )] ≥ A[i ].
2. min-Heap, wenn für alle 2 ≤ i ≤ heap − size[A]
gilt
A[Parent(i )] ≤ A[i ].
Die Eigenschaften in 1. und 2. werden max-Heapbzw. min-Heap-Eigenschaft genannt.
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
6
Max-Heaps
16
4
10
Kein max-Heap!
14
2
7
8
9
3
1
16
14
10
max-Heap!
8
2
SS 2006
7
4
9
3
1
Datenstrukturen und Algorithmen 8. A & D -Heapsort
7
Höhe von Knoten und Heaps
Definition 8.3:
1. In einem binären Baum ist die Höhe h eines Knoten
v des Baums die Länge des längsten abwärts
gerichteten Pfades von v zu einem Blatt des
Baums.
Dabei ist ein Pfad abwärtsgerichtet, wenn jede
Kante von einem Knoten w zu einem Kind von w
führt.
2. Die Höhe eines binären Baums ist die maximale
Höhe eines Knoten des Baums.
3. Die Höhe eines Heaps ist die Höhe des durch den
Heap gegebenen Baums.
Satz 8.4: Ein Heap mit n Elemente hat Höhe log(n ) .
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
8
Höhe eines Heaps
16 14 10 8 7 9 3 2 4 1
Höhe 3
16
Höhe 2
14
8
2
SS 2006
10
7
4
9
1
Datenstrukturen und Algorithmen 8. A & D -Heapsort
Höhe 1
3
Höhe 0
9
Algorithmen auf Heaps
Max-Heapify wird benutzt, um die Max-Heap Eigenschaft
aufrecht zu erhalten.
Build-Max-Heap konstruiert aus einem unstrukturierten
Array einen max-Heap.
Heapsort sortiert mit Hilfe von Heaps.
Mit Heaps können Prioritätswarteschlangen realisiert
werden.
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
10
Max-Heapify
Max - Heapify ( A,i )
1. l ← Left (i )
2. r ← Right (i )
3. if l ≤ heap − size[A] und A[l ] > A[i ]
4. then largest ← l
5. else largest ← i
6. if r ≤ heap − size[A] und A[r ] > A[largest ]
7. then largest ← r
8. if largest ≠ i
9. then A[i ] ↔ A[largest ]
10.
Max - Heapify ( A,largest )
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
11
Illustration von Max-Heapify(A,2) (1)
16
4
14
2
10
7
8
9
3
1
16
14
4
2
SS 2006
10
7
8
9
3
1
Datenstrukturen und Algorithmen 8. A & D -Heapsort
12
Illustration von Max-Heapify(A,2) (2)
16
14
4
2
10
7
8
9
3
1
16
14
8
2
SS 2006
10
7
4
9
3
1
Datenstrukturen und Algorithmen 8. A & D -Heapsort
13
Max-Heapify – Korrektheit
Lemma 8.5: Sei A ein Heap und 1 ≤ i ≤ length[A].
Die Teilbäume mit Wurzel Left(i) und Right(i) erfüllen
die max-Heap-Eigenschaft. Dann erfüllt nach
Durchlauf von max-Heapify(A,i) der Teilbaum mit
Wurzel i die max-Heap-Eigenschaft.
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
14
Max-Heapify – Analyse
Lemma 8.6:
1. Ist h die Höhe des Teilbaums mit Wurzel
i im Heap A, so hat Max-Heapify(A,i) Laufzeit
Θ(h ).
2. Ist n die Größe des Teilbaums mit Wurzel
i im Heap A, so hat Max-Heapify(A,i) Laufzeit
Θ(log(n )).
Lemma 8.7: In einem Heap der Größe n haben sowohl
der linke als auch der rechte Teilbaum der Wurzel
höchstens Größe 2/3n.
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
15
Maximal unbalancierte Teilbäume
Höhe h
Höhe h-2
Höhe h-1
jeweils vollständig
Gesamtgröß e des Baums :
2h − 1 + 2h-1 − 1 + 1 = 3 ⋅ 2h-1 − 1
Größe linker Teilbaum :
2h − 1
Größe linker Teilbaum
2
≤
Größer Gesamtbaum
3
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
16
Aufbau eines Heaps
Eingabe: (unstrukturiertes) Array A
Ausgabe: max-Heap über A
Build - Max - Heap( A )
1. heap − size[A] ← length[A]
2. for i ← length[A] / 2 downto 1
3.
do Max - Heapify ( A,i )
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
17
Illustration von Build-Max-Heap (1)
4 1 3 2 16 9 10 14 8 7
1
4
2
1
4
2
8
14
SS 2006
3
3
5
16
6
9
7
10
9 10
8
7
Datenstrukturen und Algorithmen 8. A & D -Heapsort
18
Illustration von Build-Max-Heap (2)
1
4
2
3
1
3
4
5
6
7
2
16
9
10
8
14
9 10
8
7
1
4
8
14
SS 2006
2
3
1
3
4
5
6
7
2
16
9
10
9 10
8
7
Datenstrukturen und Algorithmen 8. A & D -Heapsort
19
Illustration von Build-Max-Heap (3)
1
4
2
3
1
3
4
5
6
7
14
16
9
10
8
2
9 10
8
7
1
4
8
2
SS 2006
2
3
1
10
4
5
6
7
14
16
9
3
9 10
8
7
Datenstrukturen und Algorithmen 8. A & D -Heapsort
20
Illustration von Build-Max-Heap (4)
1
4
2
3
16
10
4
5
6
7
14
7
9
3
8
2
9 10
8
1
1
16
8
2
SS 2006
2
3
14
10
4
5
6
7
8
7
9
3
9 10
4
1
Datenstrukturen und Algorithmen 8. A & D -Heapsort
21
Invariante für Build-Max-Heap
Invariante: Vor Durchlauf der for-Schleife in den Zeilen 2
und 3 für Index i sind die Knoten i+1, …, n Wurzeln von
max-Heaps.
Initialisierung: Zu Beginn gilt i = n / 2. Knoten i > n / 2
sind Blätter und damit Wurzeln von max-Heaps.
Erhaltung: Max-Heapify(A,i) stellt max-Heap-Eigenschaft
bei Knoten i her und erhält max-Heap-Eigenschaft bei
Knoten j>i.
Terminierung: Knoten 1 ist Wurzel eines max-Heaps.
Damit ist Algorithmus korrekt.
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
22
Analyse für Build-Max-Heap (1)
1.
Ein n-elementiger Heap hat Höhe log(n ) und
 n 
besitzt höchstens  h +1  Knoten der Höhe h.
2 
2.
Es existiert eine Konstante c, so dass Max-Heapify
bei Knoten der Höhe h Laufzeit höchstens ch
besitzt.
3.
Laufzeit von Build-Max-Heap ist dann höchstens
log( n )
∑
h =0
SS 2006
log( n )
n
h


.
h
 2h +1 ch ≤ 2cn ∑
h =0 2
Datenstrukturen und Algorithmen 8. A & D -Heapsort
23
Analyse für Build-Max-Heap (2)
4. Es gilt
∞
h
= 2.
∑
h
h =0 2
5. Damit ist
log ( n )
∑
h =0
∞
log ( n )
h
h
 n 
ch
≤
2
cn
≤
2
cn
= 4cn .
∑
∑
h
h
 2h +1 
h =0 2
h =0 2
Satz 8.8: Die Laufzeit von Build-Max-Heap ist O(n).
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
24
Heapsort
Eingabe: Array A
Ausgabe: Zahlen in A in aufsteigender Reihenfolge sortiert.
Heapsort ( A )
1. Build - Max - Heap( A )
2. for i ← length[A] downto 2
3.
do A[1] ↔ A[i ]
4.
heap-size[A] ← heap-size[A] − 1
5.
Max - Heapify ( A,1)
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
25
Illustration von Heapsort
1
16
1
1
33
10
2
14
4
8
6
9
5
7
7
3
9 10
4
1
8
2
1
14
4
4
8
2
SS 2006
16
6
9
5
7
6
9
7
3
9 10
4 16
16 14 10 8 7 9 3 2 4 1
33
10
5
7
9
1
4
8
8
2
2
8
3
3
10
2
14
7
3
14 8 10 4 7 9 3 2 1 16
Datenstrukturen und Algorithmen 8. A & D -Heapsort
26
Laufzeit von Heapsort
Satz 8.9: Heapsort besitzt Laufzeit O(nlog(n )).
Beweisskizze:
1. Aufruf von Build-Max-Heap: O(n ).
2. for-Schleife in Zeilen 2-5 (n-1)-mal durchlaufen.
3. Pro Durchlauf Laufzeit O (log(n )) (Max-Heapify).
SS 2006
Datenstrukturen und Algorithmen 8. A & D -Heapsort
27