Überblick über einige vergleichsbasierte Sortierverfahren 14 | 1

Sortierverfahren Worst-Case Laufzeit Average-Case Laufzeit In-Place

Insertion-Sort ⇥(n2 ) ⇥(n2 ) ja

Merge-Sort ⇥(n log n) ⇥(n log n) nein

Quick-Sort ⇥(n2 ) ⇥(n log n) ja

Heap-Sort ⇥(n log n) ⇥(n log n) ja

n = Anzahl zu sortierender Elemente

Untere Laufzeit-Schranke für vergleichsbasiertes Sortieren: ⌦(n log n)

Klimm et al. Computerorientierte Mathematik

 Erinnerung: Insertion Sort 14 | 2

python Julia
def insertionSort ( A ): function insertionSort ( A :: Vector { T } ) where T
n = len ( A ) n = length ( A )
for i in range (1 , n ): for i in 1: n
s = A[i] s = A[i]
k = i k = i
while k > 0 and s < A [k - 1 ]: while k > 1 && s < A [k -1]
A [ k ] = A [k - 1 ] A [ k ] = A [k -1]
k -= 1 k -= 1
A[k] = s end
A[k] = s
A = input (). split () end
insertionSort ( A ) return A
print ( A ) end

A = split ( readline ())

insertionSort ( A )
print ( A )

Klimm et al. Computerorientierte Mathematik

 Computerorientierte Mathematik I

14 Heaps und Heapsort

14.1 Datenstruktur MaxHeap

Klimm et al. Computerorientierte Mathematik

 Eigenschaften der Datenstruktur MaxHeap 14 | 4

Die Datenstruktur MaxHeap unterstützt die folgenden Operationen:

Operation Laufzeit

Maximum(H) O(1)
ExtractMax(H) O(log n)
Insert(H,x) O(log n)
ChangeKey(H,x,k) O(log n)
ExtractMax(H): liefert Zeiger x auf Element in H mit x.key maximal und löscht dieses aus H.

ChangeKey(H,x,k): setzt x.key = k

Analog gibt es eine Datenstruktur MinHeap mit Operationen Minimum(H) (statt Maximum(H)) und
ExtractMin(H) (statt ExtractMax(H)).

Klimm et al. Computerorientierte Mathematik

 Interpretation von Arrays als Binärbäume 14 | 5

Identifiziere Elemente in einem Heap immer mit ihren Schlüsseln.

Die Datenstruktur Heap besteht aus einem Array, das wir als fast vollständigen Binärbaum
interpretieren:
1 2 3 4 5 6 7 8 9 10
Parent(i) = bi/2c
16 14 10 8 7 9 3 2 4 1
Left(i) = 2i

1 Right(i) = 2i + 1
16
2 3
14 10
4 5 6 7
8 7 9 3

8 9 10
2 4 1
Klimm et al. Computerorientierte Mathematik
 MaxHeap-Eigenschaft 14 | 6

Definition 1
16
Ein Array A der Größe n und der zugehörige Binärbaum 2 3
besitzen MaxHeap-Eigenschaft, falls 14 10
A [Parent(i)] > A [i] für 1 < i 6 n.
4 5 6 7

Wir sagen dann auch, dass der zugehörige Binärbaum ein 8 7 9 3

MaxHeap ist.
8 9 10
2 4 1
Bemerkungen
In einem MaxHeap A steht das größte Element in der Wurzel A [1].
Entlang eines Weges von der Wurzel zu einem Blatt fallen die Elemente monoton.
Die Höhe des Baumes (Länge des längsten Weges von Wurzel zu einem Blatt) ist blog nc.
Ist A absteigend sortiert, so hat A die MaxHeap-Eigenschaft.
(hinreichend, aber nicht notwendig – s. o.)
Klimm et al. Computerorientierte Mathematik
 Computerorientierte Mathematik I

14 Heaps und Heapsort

14.2 Herstellen der Heap-Eigenschaft

Klimm et al. Computerorientierte Mathematik

 (Wieder-)Herstellen der MaxHeap-Eigenschaft (Teil 1) 14 | 8

Max-Heapify(A, i)
1 ` = Left(i), r = Right(i)
2 if ` 6 n and A [`] > A [i] then 1

largest ` 2
3 3
3 else 4 10
largest i 4 5 6 7

4 if r 6 n and A [r] > A [largest] then 14 7 9 16

largest r 8 9 10
5 if largest 6= i then 2 8 1
exchange A [i] with A [largest]
Max-Heapify(A, largest)

Lemma
a Ist die MaxHeap-Eigenschaft für die Binärbäume unterhalb Left(i) und Right(i) erfüllt,
so ist sie nach Max-Heapify(A, i) für den gesamten Binärbaum unterhalb von i erfüllt.
b Die Laufzeit ist linear in der Höhe des Binärbaums unterhalb von i.
Klimm et al. Computerorientierte Mathematik
 Beweis des Lemmas zu Max-Heapify 14 | 9

Lemma
a Ist die MaxHeap-Eigenschaft für die Binärbäume unterhalb Left(i) und Right(i) erfüllt,
so ist sie nach Max-Heapify(A, i) für den gesamten Binärbaum unterhalb von i erfüllt.
b Die Laufzeit ist linear in der Höhe des Binärbaums unterhalb von i.

Beweis:
a Induktion über Höhe von i in Baum: Ist i Blatt, so sind `, r > n.
Also ist nach Schritt 4 largest = i, und in Schritt 5 passiert nichts.
Ist i kein Blatt, so wird in den ersten vier Schritten ermittelt, welches der drei Elemente A [i],
A [`] und A [r] am größten ist.
(Es wird berücksichtigt, falls Left(i) oder Right(i) nicht existieren.)
Nach Swap von A [i] und A [largest] ist MaxHeap-Eigenschaft evtl. in largest verletzt;
wird durch rekursiven Aufruf repariert nach Induktion.
b Die Laufzeitanalyse ist klar.
Klimm et al. Computerorientierte Mathematik
 (Wieder-)Herstellen der MaxHeap-Eigenschaft (Teil 2) 14 | 10

Idee
Wende Max-Heapify(A, i) wiederholt auf Knoten i an, deren Teilbäume bereits die
MaxHeap-Eigenschaft erfüllen.
Iteriere dazu beispielsweise über alle Nicht-Blätter des Binärbaumes von unten nach oben.
Beachte: Knoten i ist Blatt () i > bn/2c 1
2 4 3
Build-Max-Heap(A) 1 3
1 for i = bn/2c downto 1: 4 5 6 7
Max-Heapify(A, i) 2 16 9 10
8 9 10
14 8 7

Theorem
Nach Aufruf von Build-Max-Heap(A) besitzt A die MaxHeap-Eigenschaft.
Die Laufzeit beträgt O(n).
Klimm et al. Computerorientierte Mathematik
 Build-Max-Heap: Korrektheit und Laufzeitanalyse 14 | 11

Theorem
Nach Aufruf von Build-Max-Heap(A) besitzt A die MaxHeap-Eigenschaft.
Die Laufzeit beträgt O(n).

Beweis: Korrektheit folgt aus Lemma zu Max-Heapify. Laufzeit:

Laufzeit Max-Heapify(A, i): O(h), wobei h = Höhe von i
Anzahl der Knoten der Höhe h ist höchtens dn/2h+1 e.
Gesamtlaufzeit:
0 1
blog(n)c blog(n)c
X ⌃ ⌥ X hA
n/2h+1 O(h) = O @n = O(n)
2h
h=0 h=0

Letzte Gleichung gilt, da:

1
X h 1/2
= = 2
2h (1 - 1/2)2
h=0
Klimm et al. Computerorientierte Mathematik
 Computerorientierte Mathematik I

14 Heaps und Heapsort

14.3 Heap-Sort

Klimm et al. Computerorientierte Mathematik

 Sortieren mit Heaps: Heap-Sort 14 | 13

1
Heap-Sort(A)
2 16 3
1 Build-Max-Heap(A)
14 10
2 while n > 1: 4 5 6 7
exchange A [1] with A [n] 8 7 9 3
n n-1
8 9 10
Max-Heapify(A, 1)
2 4 1

Theorem
Heap-Sort sortiert ein Array A der Länge n in Zeit ⇥(n log n) und benötigt dafür nur konstant
viel zusätzlichen Speicher (‘in-place’).

Bemerkung:
Die Laufzeit von Heap-Sort ist empirisch etwa vergleichbar mit Mergesort.

Klimm et al. Computerorientierte Mathematik

 Heap-Sort: Korrektheit und Laufzeitanalyse 14 | 14

Theorem
Heap-Sort sortiert ein Array A der Länge n in Zeit ⇥(n log n) und benötigt dafür nur konstant
viel zusätzlichen Speicher (‘in-place’).

Beweis
Korrektheit:
Algorithmus berechnet in Schritt 1 Max-Heap; Wurzel ist größtes Element.
Nach Austausch A [1] $ A [n] hat der binäre Baum auf den ersten n - 1 Knoten fast
Heap-Struktur: nur die Wurzel steht eventuell falsch.
Die Korrektheit folgt damit induktiv aus der Korrektheit von Max-Heapify.

Laufzeit:
O(n) für Build-Max-Heap in Schritt 1
dann n - 1 mal Max-Heapify mit Aufwand jeweils O(log n)
Klimm et al. Computerorientierte Mathematik
 Computerorientierte Mathematik I

14 Heaps und Heapsort

14.4 Heaps als Priority Queues

Klimm et al. Computerorientierte Mathematik

 Heaps als Prioritätswarteschlangen (Priority Queues) 14 | 16

Max-Prioritätswarteschlangen unterstützen die folgenden Operationen:

Operation Laufzeit für MaxHeaps

Maximum(H) O(1)
ExtractMax(H) O(log n)
Insert(H,x) O(log n)
IncreaseKey(H,x,k) O(log n)

Bemerkung:
MaxHeaps unterstützen auch DecreaseKey(H,x,k) in Zeit O(log n).

Es gilt:
Die auf der nächsten Folie spezifizierten Operationen arbeiten korrekt mit den oben angegebenen
Laufzeiten.

Klimm et al. Computerorientierte Mathematik

 Implementation der Operationen für MaxHeaps 14 | 17

Betrachte ein durch ein Array A gegebenen MaxHeap der Größe n > 1.
Maximum(A)
IncreaseKey(A,i,k)
1 return A [1]
1 if k < A [i] then
return “k too small”
ExtractMax(A)
2 A [i] k
1 exchange A [1] with A [n]
3 while i > 1 and A [Parent(i)] < A [i]:
2 n n-1
exchange A [i] with A [Parent(i)]
3 Max-Heapify(A, 1) i Parent(i)
4 return A [n + 1]
DecreaseKey(A,i,k)
Insert(A,k) 1 if k > A [i] then
1 n n+1 return “k too large”
2 A [n] -1 2 A [i] k
3 IncreaseKey(A,n,k) 3 Max-Heapify(A,i)
Klimm et al. Computerorientierte Mathematik
 Fibonacci-Heaps 14 | 18

Fibonacci-Heaps sind eine Weiterentwicklung von Heaps.

Die amortisierte Laufzeit einiger Operationen ist besser als bei Heaps.

MinHeaps Fibonacci-MinHeaps
Operation
(worst-case) (amortisiert)
Minimum(H) ⇥(1) ⇥(1)
ExtractMin(H) ⇥(log n) ⇥(log n)
Insert(H,x) ⇥(log n) ⇥(1)
DecreaseKey(H,x,k) O(log n) ⇥(1)

Details: Siehe Cormen et al. Kapitel 19.

Klimm et al. Computerorientierte Mathematik

 Computerorientierte Mathematik I

14 Heaps und Heapsort

14.5 Prims Algorithmus mit Heaps

Klimm et al. Computerorientierte Mathematik

 Wiederholung: Prims Algorithmus 14 | 20

8
5
7
9 5
15

6 9
8
11

Klimm et al. Computerorientierte Mathematik

 Eine Anwendung von MinHeaps: Prims Algorithmus 14 | 21

Im folgenden sei H eine Min-Prioritätswarteschlange.

Prims Algorithmus
Input: zusammenhängender Graph G = (V, E, ), Gewichte c : E ! R
Output: aufspannender Baum minimalen Gewichts
1 for v 2 V :
2 set v.key1, v.pred None, v.inTree false
3 Insert(H,v)
4 choose v0 2 V arbitrary, DecreaseKey(H,v0 ,0)
5 while not isEmpty(H):
6 v ExtractMin(H), v.inTree true
7 for e 2 (v):
8 let w 2 (e) \ {v}
9 if c(e) < w.key and not w.inTree then
10 DecreaseKey(H,w,c(e)), w.pred e
Klimm et al. Computerorientierte Mathematik
 Prims Algorithmus: Anzahl der Operationen und Laufzeit 14 | 22

Operation # Aufrufe

Insert(H,v) |V|
ExtractMin(H) |V|
DecreaseKey(H,v,c) 6 |E| + 1

Korollar
a Eine Implementation von Prims Algorithmus mit einem MinHeap H besitzt Laufzeit
O(|E| log |V|).
b Mit einem Fibonacci-MinHeap kann Laufzeit auf O(|E| + |V| log |V|) verbessert werden.

Klimm et al. Computerorientierte Mathematik