Algorithmen und Datenstrukturen

SS15
Algorithmen und Datenstrukturen
6. Kapitel
Sortieralgorithmen
Martin Dietzfelbinger
Mai 2015
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
6.1 Erinnerung, Grundbegriffe
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
1
6.1 Erinnerung, Grundbegriffe
a1
a2
a3
an
10
1
4
5
1
9
4
1
8
US
SO
RA
OR
RT
HM
LG
IE
IT
Item:
Schlüssel
Daten:
1
1
1
4
4
5
8
9
10
SO
RT
IE
RA
LG
OR
IT
HM
US
x
"key"
dat
"data"
"Stabilität"
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
1
Sortierproblem, abstrakt: Siehe Kapitel 1.
Input: Array A[1..n],
Einträge sind Objekte mit Schlüssel- und Datenteil:
A[i].key und A[i].data.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
2
Sortierproblem, abstrakt: Siehe Kapitel 1.
Input: Array A[1..n],
Einträge sind Objekte mit Schlüssel- und Datenteil:
A[i].key und A[i].data.
Achtung: In Bildern unterdrücken wir oft den Datenteil. Das Objekt wird
also einfach als Schlüssel dargestellt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
2
Sortierproblem, abstrakt: Siehe Kapitel 1.
Input: Array A[1..n],
Einträge sind Objekte mit Schlüssel- und Datenteil:
A[i].key und A[i].data.
Achtung: In Bildern unterdrücken wir oft den Datenteil. Das Objekt wird
also einfach als Schlüssel dargestellt.
Schon gesehen: Sortieralgorithmus Straight Insertion Sort.
Bei Vorkommen gleicher Sortierschlüssel: Sortierverfahren
heißt stabil, wenn Objekte mit identischen Schlüsseln in der
Ausgabe in derselben Reihenfolge stehen wie in der Eingabe.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
2
Maßzahlen für Sortieralgorithmen:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
3
Maßzahlen für Sortieralgorithmen:
In Abhängigkeit von n fragen wir nach:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
3
Maßzahlen für Sortieralgorithmen:
In Abhängigkeit von n fragen wir nach:
1. Laufzeit (in O-Notation);
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
3
Maßzahlen für Sortieralgorithmen:
In Abhängigkeit von n fragen wir nach:
1. Laufzeit (in O-Notation);
2. Anzahl der Vergleiche ( wesentliche Vergleiche“)
”
A[i].key < A[j].key“
”
FG KTuEA, TU Ilmenau
bzw. A[i].key ≤ A[j].key“;
”
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
3
Maßzahlen für Sortieralgorithmen:
In Abhängigkeit von n fragen wir nach:
1. Laufzeit (in O-Notation);
2. Anzahl der Vergleiche ( wesentliche Vergleiche“)
”
A[i].key < A[j].key“
”
bzw. A[i].key ≤ A[j].key“;
”
3. Anzahl der Datenverschiebungen oder Kopiervorgänge
(wichtig bei sehr umfangreichen Objekten);
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
3
Maßzahlen für Sortieralgorithmen:
In Abhängigkeit von n fragen wir nach:
1. Laufzeit (in O-Notation);
2. Anzahl der Vergleiche ( wesentliche Vergleiche“)
”
A[i].key < A[j].key“
”
bzw. A[i].key ≤ A[j].key“;
”
3. Anzahl der Datenverschiebungen oder Kopiervorgänge
(wichtig bei sehr umfangreichen Objekten);
4. der neben dem Array A[1..n] (bzw. der zu sortierenden
Liste) benötigte Speicherplatz;
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
3
Maßzahlen für Sortieralgorithmen:
In Abhängigkeit von n fragen wir nach:
1. Laufzeit (in O-Notation);
2. Anzahl der Vergleiche ( wesentliche Vergleiche“)
”
A[i].key < A[j].key“
”
bzw. A[i].key ≤ A[j].key“;
”
3. Anzahl der Datenverschiebungen oder Kopiervorgänge
(wichtig bei sehr umfangreichen Objekten);
4. der neben dem Array A[1..n] (bzw. der zu sortierenden
Liste) benötigte Speicherplatz;
wenn dieser nur O(1), also von n unabhängig, ist:
Algorithmus arbeitet in situ“ oder in-place“.
”
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
3
Straight Insertion Sort:
1
2 n(n
n2
2
− 1) ≈
Vergleiche
Schlechtester Fall:
(kann auch vorkommen); Zeit Θ(n2).
Bester Fall: n − 1 Vergleiche, Zeit Θ(n).
Durchschnittlicher Fall, alle Eingabereihenfolgen gleich
wahrscheinlich: Zeit Θ(n2).
Stabil, in situ.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
4
6.2 Mergesort
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
5
6.2 Mergesort
(engl. merge = vermengen, reißverschlussartig zusammenfügen)
Algorithmenparadigma oder -schema:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
5
6.2 Mergesort
(engl. merge = vermengen, reißverschlussartig zusammenfügen)
Algorithmenparadigma oder -schema:
Divide-and-Conquer“ (D-a-C)
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
5
6.2 Mergesort
(engl. merge = vermengen, reißverschlussartig zusammenfügen)
Algorithmenparadigma oder -schema:
Divide-and-Conquer“ (D-a-C)
”
( teile und herrsche“)
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
5
MergeSort ist
Sortierproblem.
FG KTuEA, TU Ilmenau
konkreter
D-a-C-Algorithmus
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
für
das
6
MergeSort ist
Sortierproblem.
konkreter
D-a-C-Algorithmus
für
das
Lege eine Trivialitätsschranke n0 ≥ 1 fest.
(Einfachster Fall: n0 = 1, für n = 1 ist nichts zu tun.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
6
MergeSort ist
Sortierproblem.
konkreter
D-a-C-Algorithmus
für
das
Lege eine Trivialitätsschranke n0 ≥ 1 fest.
(Einfachster Fall: n0 = 1, für n = 1 ist nichts zu tun.)
Falls 2 ≤ n ≤ n0:
Sortiere mit einem naiven Algorithmus (z. B. Straight Insertion Sort).
Sonst:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
6
MergeSort ist
Sortierproblem.
konkreter
D-a-C-Algorithmus
für
das
Lege eine Trivialitätsschranke n0 ≥ 1 fest.
(Einfachster Fall: n0 = 1, für n = 1 ist nichts zu tun.)
Falls 2 ≤ n ≤ n0:
Sortiere mit einem naiven Algorithmus (z. B. Straight Insertion Sort).
Sonst:
Teilen: Setze m := dn/2e.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
6
MergeSort ist
Sortierproblem.
konkreter
D-a-C-Algorithmus
für
das
Lege eine Trivialitätsschranke n0 ≥ 1 fest.
(Einfachster Fall: n0 = 1, für n = 1 ist nichts zu tun.)
Falls 2 ≤ n ≤ n0:
Sortiere mit einem naiven Algorithmus (z. B. Straight Insertion Sort).
Sonst:
Teilen: Setze m := dn/2e.
Rekursion für Teilprobleme:
Sortiere a1, . . . , am rekursiv, Ergebnis a01, . . . , a0m;
sortiere am+1, . . . , an rekursiv, Ergebnis a0m+1, . . . , a0n.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
6
MergeSort ist
Sortierproblem.
konkreter
D-a-C-Algorithmus
für
das
Lege eine Trivialitätsschranke n0 ≥ 1 fest.
(Einfachster Fall: n0 = 1, für n = 1 ist nichts zu tun.)
Falls 2 ≤ n ≤ n0:
Sortiere mit einem naiven Algorithmus (z. B. Straight Insertion Sort).
Sonst:
Teilen: Setze m := dn/2e.
Rekursion für Teilprobleme:
Sortiere a1, . . . , am rekursiv, Ergebnis a01, . . . , a0m;
sortiere am+1, . . . , an rekursiv, Ergebnis a0m+1, . . . , a0n.
Kombinieren:
Mische“ die Folgen a01, . . . , a0m und a0m+1, . . . , a0n zu einer
”
sortierten Folge zusammen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
6
Prozedur r MergeSort(a, b):
A:
a
5
b
m
7
2
3
6
3
1
a
2
FG KTuEA, TU Ilmenau
2
b
m
3
5
6
3
Rekur−
sion
Rekur−
sion
A:
5
7
1
2
3
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
3
5
7
Prozedur r MergeSort(a, b):
A:
a
5
b
m
7
2
3
6
3
1
a
2
2
b
m
3
5
6
3
Rekur−
sion
Rekur−
sion
A:
5
7
1
2
3
3
5
Aufteilen von A[a . . . b] in A[a . . . m] und A[m + 1 . . . b].
Rekursives Sortieren der beiden Segmente.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
7
Prozedur r MergeSort(a, b):
A:
a
5
b
m
7
2
3
6
3
1
a
2
2
b
m
3
5
6
3
Rekur−
sion
Rekur−
sion
A:
5
7
1
2
3
3
5
Aufteilen von A[a . . . b] in A[a . . . m] und A[m + 1 . . . b].
Rekursives Sortieren der beiden Segmente.
Dann: Merge(a, m, b).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
7
Datenstruktur: 2 Arrays A[1..n] (Ein-/Ausgabe), B[1..n] (Hilfsarray)
Prozedur r MergeSort(a, b)
// für 1 ≤ a < b ≤ n, sortiert A[a..b]
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
8
Datenstruktur: 2 Arrays A[1..n] (Ein-/Ausgabe), B[1..n] (Hilfsarray)
Prozedur r MergeSort(a, b)
// für 1 ≤ a < b ≤ n, sortiert A[a..b]
(1)
if b − a ≤ n0
(2)
then StraightInsertionSort(a, b)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
8
Datenstruktur: 2 Arrays A[1..n] (Ein-/Ausgabe), B[1..n] (Hilfsarray)
Prozedur r MergeSort(a, b)
// für 1 ≤ a < b ≤ n, sortiert A[a..b]
(1)
if b − a ≤ n0
(2)
then StraightInsertionSort(a, b)
(3)
else
(4)
m ← b(a + b)/2c;
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
8
Datenstruktur: 2 Arrays A[1..n] (Ein-/Ausgabe), B[1..n] (Hilfsarray)
Prozedur r MergeSort(a, b)
// für 1 ≤ a < b ≤ n, sortiert A[a..b]
(1)
if b − a ≤ n0
(2)
then StraightInsertionSort(a, b)
(3)
else
(4)
m ← b(a + b)/2c;
(5)
if a < m then r MergeSort(a, m);
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
8
Datenstruktur: 2 Arrays A[1..n] (Ein-/Ausgabe), B[1..n] (Hilfsarray)
Prozedur r MergeSort(a, b)
// für 1 ≤ a < b ≤ n, sortiert A[a..b]
(1)
if b − a ≤ n0
(2)
then StraightInsertionSort(a, b)
(3)
else
(4)
m ← b(a + b)/2c;
(5)
if a < m then r MergeSort(a, m);
(6)
if m + 1 < b then r MergeSort(m + 1, b);
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
8
Datenstruktur: 2 Arrays A[1..n] (Ein-/Ausgabe), B[1..n] (Hilfsarray)
Prozedur r MergeSort(a, b)
// für 1 ≤ a < b ≤ n, sortiert A[a..b]
(1)
if b − a ≤ n0
(2)
then StraightInsertionSort(a, b)
(3)
else
(4)
m ← b(a + b)/2c;
(5)
if a < m then r MergeSort(a, m);
(6)
if m + 1 < b then r MergeSort(m + 1, b);
(7)
Merge(a, m, b) // benutzt Hilfsarray B[1..n]
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
8
Datenstruktur: 2 Arrays A[1..n] (Ein-/Ausgabe), B[1..n] (Hilfsarray)
Prozedur r MergeSort(a, b)
// für 1 ≤ a < b ≤ n, sortiert A[a..b]
(1)
if b − a ≤ n0
(2)
then StraightInsertionSort(a, b)
(3)
else
(4)
m ← b(a + b)/2c;
(5)
if a < m then r MergeSort(a, m);
(6)
if m + 1 < b then r MergeSort(m + 1, b);
(7)
Merge(a, m, b) // benutzt Hilfsarray B[1..n]
Prozedur MergeSort(A[1..n])
// sortiert A[1..n]
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
8
Datenstruktur: 2 Arrays A[1..n] (Ein-/Ausgabe), B[1..n] (Hilfsarray)
Prozedur r MergeSort(a, b)
// für 1 ≤ a < b ≤ n, sortiert A[a..b]
(1)
if b − a ≤ n0
(2)
then StraightInsertionSort(a, b)
(3)
else
(4)
m ← b(a + b)/2c;
(5)
if a < m then r MergeSort(a, m);
(6)
if m + 1 < b then r MergeSort(m + 1, b);
(7)
Merge(a, m, b) // benutzt Hilfsarray B[1..n]
Prozedur MergeSort(A[1..n])
// sortiert A[1..n]
(1)
if n ≤ n0
(2)
then StraightInsertionSort(1, n)
(3)
else r MergeSort(1, n).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
8
Benötigt: Prozedur Merge(a, m, b), 1 ≤ a ≤ m < b ≤ n
die folgendes tut:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
9
Benötigt: Prozedur Merge(a, m, b), 1 ≤ a ≤ m < b ≤ n
die folgendes tut:
Voraussetzung: A[a . . m] und A[m + 1 . . b] sind sortiert.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
9
Benötigt: Prozedur Merge(a, m, b), 1 ≤ a ≤ m < b ≤ n
die folgendes tut:
Voraussetzung: A[a . . m] und A[m + 1 . . b] sind sortiert.
Resultat: A[a . . b] ist sortiert.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
9
Benötigt: Prozedur Merge(a, m, b), 1 ≤ a ≤ m < b ≤ n
die folgendes tut:
Voraussetzung: A[a . . m] und A[m + 1 . . b] sind sortiert.
Resultat: A[a . . b] ist sortiert.
Ansatz: Quasiparalleler Durchlauf durch die Teilarrays:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
9
Benötigt: Prozedur Merge(a, m, b), 1 ≤ a ≤ m < b ≤ n
die folgendes tut:
Voraussetzung: A[a . . m] und A[m + 1 . . b] sind sortiert.
Resultat: A[a . . b] ist sortiert.
Ansatz: Quasiparalleler Durchlauf durch die Teilarrays:
Reißverschlussverfahren“.
”
Benutze Hilfsarray B[a . . b] für das Ergebnis.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
9
a
b
m
2
3
5
6
7
1
2
3
3
5
1
2
2
3
3
3
5
5
6
7
a
FG KTuEA, TU Ilmenau
m
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
b
10
a
b
m
2
3
5
6
7
1
2
3
3
5
1
2
2
3
3
3
5
5
6
7
a
m
b
Mischen von A[a . . . m] und A[m + 1 . . . b].
Rote Pfeile: i–k-Paare in Zeile (6).
Grüne Pfeile: j–k-Paare in Zeile (7).
Blaue Pfeile: i–k-Paare in Zeile (8), Kopieren.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
10
Prozedur Merge(a, m, b)
// für 1 ≤ a ≤ m < b ≤ n, sortiert A[a..b],
// nimmt an, dass A[a..m] und A[m + 1..b] sortiert sind.
(1)
i ← a;
// Index in A[a..m]
(2)
j ← m + 1; // Index in A[m + 1..b]
(3)
k ← a;
// Index in B[a..b]
(4)
while i ≤ m and j ≤ b do
(5)
if A[i] ≤ A[j]
(6)
then B[k] ← A[i]; i++; k++
(7)
else B[k] ← A[j]; j++; k++
// verbleibendes Schlussstück kopieren:
(8)
while i ≤ m do B[k] ← A[i]; i++; k++;
(9)
while j ≤ b do B[k] ← A[j]; j++; k++;
// B[a..b] nach A[a..b] kopieren:
(10) for k from a to b do A[k] ← B[k].
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
11
Eigenschaften von Prozedur Merge(a, m, b):
• korrekt;
• höchstens b − a Schlüsselvergleiche
(bei jedem Vergleich ein Transport, am Ende mindestens ein Eintrag übrig);
• Zeitbedarf Θ(b − a);
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
12
Eigenschaften von Prozedur Merge(a, m, b):
• korrekt;
• höchstens b − a Schlüsselvergleiche
(bei jedem Vergleich ein Transport, am Ende mindestens ein Eintrag übrig);
• Zeitbedarf Θ(b − a);
• Merge ist stabil
(Vergleichsmodus Zeile (5) bevorzugt linkes Teilarray).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
12
Eigenschaften von Prozedur Merge(a, m, b):
• korrekt;
• höchstens b − a Schlüsselvergleiche
(bei jedem Vergleich ein Transport, am Ende mindestens ein Eintrag übrig);
• Zeitbedarf Θ(b − a);
• Merge ist stabil
(Vergleichsmodus Zeile (5) bevorzugt linkes Teilarray).
Satz 6.2.1
MergeSort(A[1..n]) sortiert A[1..n] stabil.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
12
Eigenschaften von Prozedur Merge(a, m, b):
• korrekt;
• höchstens b − a Schlüsselvergleiche
(bei jedem Vergleich ein Transport, am Ende mindestens ein Eintrag übrig);
• Zeitbedarf Θ(b − a);
• Merge ist stabil
(Vergleichsmodus Zeile (5) bevorzugt linkes Teilarray).
Satz 6.2.1
MergeSort(A[1..n]) sortiert A[1..n] stabil.
Beweis: Durch Induktion über rekursive Aufrufe von
r MergeSort(a, b) zeigt man, dass diese Prozedur das betreffende Teilarray stabil sortiert.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
12
Zeitanalyse von Mergesort über Rekurrenzgleichungen“:
”
Wir zählen nur Vergleiche.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
13
Zeitanalyse von Mergesort über Rekurrenzgleichungen“:
”
Wir zählen nur Vergleiche.
C(n) = Anzahl der Vergleiche beim Sortieren von n Eingaben,
schlechtester Fall.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
13
Zeitanalyse von Mergesort über Rekurrenzgleichungen“:
”
Wir zählen nur Vergleiche.
C(n) = Anzahl der Vergleiche beim Sortieren von n Eingaben,
schlechtester Fall.
C(1) = 0, C(2) = 1, C(3) = 3.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
13
Zeitanalyse von Mergesort über Rekurrenzgleichungen“:
”
Wir zählen nur Vergleiche.
C(n) = Anzahl der Vergleiche beim Sortieren von n Eingaben,
schlechtester Fall.
C(1) = 0, C(2) = 1, C(3) = 3.
C(n) = C(dn/2e) + C(bn/2c) + n − 1.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
13
Zeitanalyse von Mergesort über Rekurrenzgleichungen“:
”
Wir zählen nur Vergleiche.
C(n) = Anzahl der Vergleiche beim Sortieren von n Eingaben,
schlechtester Fall.
C(1) = 0, C(2) = 1, C(3) = 3.
C(n) = C(dn/2e) + C(bn/2c) + n − 1.
Ausrechnen von Hand liefert:
n
C(n)
1
0
2
1
FG KTuEA, TU Ilmenau
3
3
4
5
5
8
6
11
7
14
8
17
9
21
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
10
25
11
29
12
33
13
37
14
41
13
...
...
Zunächst: Zweierpotenzen n = 2k , k ≥ 0.
n
C(n)
FG KTuEA, TU Ilmenau
1
0
2
1
4
5
8
17
16
49
32
129
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
64
321
...
...
14
Zunächst: Zweierpotenzen n = 2k , k ≥ 0.
n
C(n)
1
0
2
1
4
5
8
17
16
49
32
129
64
321
...
...
Geratene Beobachtung: k ≥ 0 ⇒ C(2k ) = (k − 1) · 2k + 1.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
14
Zunächst: Zweierpotenzen n = 2k , k ≥ 0.
n
C(n)
1
0
2
1
4
5
8
17
16
49
32
129
64
321
...
...
Geratene Beobachtung: k ≥ 0 ⇒ C(2k ) = (k − 1) · 2k + 1.
(Kann durch Induktion über k bewiesen werden.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
14
Zunächst: Zweierpotenzen n = 2k , k ≥ 0.
n
C(n)
1
0
2
1
4
5
8
17
16
49
32
129
64
321
...
...
Geratene Beobachtung: k ≥ 0 ⇒ C(2k ) = (k − 1) · 2k + 1.
(Kann durch Induktion über k bewiesen werden.)
n
C(n)
1
0
2
1
FG KTuEA, TU Ilmenau
3
3
4
5
5
8
6
11
7
14
8
17
9
21
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
10
25
11
29
12
33
13
37
14
41
14
...
...
Zunächst: Zweierpotenzen n = 2k , k ≥ 0.
n
C(n)
1
0
2
1
4
5
8
17
16
49
32
129
64
321
...
...
Geratene Beobachtung: k ≥ 0 ⇒ C(2k ) = (k − 1) · 2k + 1.
(Kann durch Induktion über k bewiesen werden.)
n
C(n)
1
0
2
1
3
3
4
5
5
8
6
11
7
14
8
17
9
21
10
25
11
29
12
33
13
37
14
41
Zwischen 2k−1 und 2k jeweils Zuwachs um k.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
14
...
...
Zunächst: Zweierpotenzen n = 2k , k ≥ 0.
n
C(n)
1
0
2
1
4
5
8
17
16
49
32
129
64
321
...
...
Geratene Beobachtung: k ≥ 0 ⇒ C(2k ) = (k − 1) · 2k + 1.
(Kann durch Induktion über k bewiesen werden.)
n
C(n)
1
0
2
1
3
3
4
5
5
8
6
11
7
14
8
17
9
21
10
25
11
29
12
33
13
37
14
41
Zwischen 2k−1 und 2k jeweils Zuwachs um k.
Damit Vermutung: Für 2k−1 < n ≤ 2k , d. h. k = dlog ne:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
14
...
...
Zunächst: Zweierpotenzen n = 2k , k ≥ 0.
n
C(n)
1
0
2
1
4
5
8
17
16
49
32
129
64
321
...
...
Geratene Beobachtung: k ≥ 0 ⇒ C(2k ) = (k − 1) · 2k + 1.
(Kann durch Induktion über k bewiesen werden.)
n
C(n)
1
0
2
1
3
3
4
5
5
8
6
11
7
14
8
17
9
21
10
25
11
29
12
33
13
37
14
41
Zwischen 2k−1 und 2k jeweils Zuwachs um k.
Damit Vermutung: Für 2k−1 < n ≤ 2k , d. h. k = dlog ne:
C(n) = (k − 2)2k−1 + 1 +
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
14
...
...
Zunächst: Zweierpotenzen n = 2k , k ≥ 0.
n
C(n)
1
0
2
1
4
5
8
17
16
49
32
129
64
321
...
...
Geratene Beobachtung: k ≥ 0 ⇒ C(2k ) = (k − 1) · 2k + 1.
(Kann durch Induktion über k bewiesen werden.)
n
C(n)
1
0
2
1
3
3
4
5
5
8
6
11
7
14
8
17
9
21
10
25
11
29
12
33
13
37
14
41
Zwischen 2k−1 und 2k jeweils Zuwachs um k.
Damit Vermutung: Für 2k−1 < n ≤ 2k , d. h. k = dlog ne:
C(n) = (k − 2)2k−1 + 1 + (n − 2k−1)k
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
14
...
...
Zunächst: Zweierpotenzen n = 2k , k ≥ 0.
n
C(n)
1
0
2
1
4
5
8
17
16
49
32
129
64
321
...
...
Geratene Beobachtung: k ≥ 0 ⇒ C(2k ) = (k − 1) · 2k + 1.
(Kann durch Induktion über k bewiesen werden.)
n
C(n)
1
0
2
1
3
3
4
5
5
8
6
11
7
14
8
17
9
21
10
25
11
29
12
33
13
37
14
41
Zwischen 2k−1 und 2k jeweils Zuwachs um k.
Damit Vermutung: Für 2k−1 < n ≤ 2k , d. h. k = dlog ne:
C(n) = (k − 2)2k−1 + 1 + (n − 2k−1)k = nk − 2k + 1.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
14
...
...
Satz 6.2.2
C(n) = ndlog ne − 2dlog ne + 1, für n ≥ 1.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
15
Satz 6.2.2
C(n) = ndlog ne − 2dlog ne + 1, für n ≥ 1.
Beweis: Induktion über n, unter Benutzung der Behauptung“
”
k
für n = 2 .
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
15
Satz 6.2.2
C(n) = ndlog ne − 2dlog ne + 1, für n ≥ 1.
Beweis: Induktion über n, unter Benutzung der Behauptung“
”
k
für n = 2 .
Details (für Interessierte): Druckfolien.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
15
Satz 6.2.2
C(n) = ndlog ne − 2dlog ne + 1, für n ≥ 1.
Beweis: Induktion über n, unter Benutzung der Behauptung“
”
k
für n = 2 .
Details (für Interessierte): Druckfolien.
Korollar 6.2.3
C(n) ≤ n log n, für n ≥ 1.
Korollar 6.2.4
Die Rechenzeit von Mergesort ist Θ(n log n).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
15
Variante 1: (Sollte man immer anwenden)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
16
Variante 1: (Sollte man immer anwenden)
Ziel: Überproportional hohen Zeitaufwand für die vielen
rekursiven Aufrufe bei kleinen Teilarrays vermeiden.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
16
Variante 1: (Sollte man immer anwenden)
Ziel: Überproportional hohen Zeitaufwand für die vielen
rekursiven Aufrufe bei kleinen Teilarrays vermeiden.
Strategie: In r MergeSort kleine Teilarrays (b − a ≤ n0)
durch (z. B.) StraightInsertionSort sortieren.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
16
Variante 1: (Sollte man immer anwenden)
Ziel: Überproportional hohen Zeitaufwand für die vielen
rekursiven Aufrufe bei kleinen Teilarrays vermeiden.
Strategie: In r MergeSort kleine Teilarrays (b − a ≤ n0)
durch (z. B.) StraightInsertionSort sortieren.
Das optimale n0 auf einer konkreten Maschine kann ein
Experiment liefern.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
16
Variante 2: Mergesort für lineare Listen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
17
Variante 2: Mergesort für lineare Listen.
Wenn die Liste L nur ein Element enthält, ist nichts zu tun.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
17
Variante 2: Mergesort für lineare Listen.
Wenn die Liste L nur ein Element enthält, ist nichts zu tun.
Andernfalls wird L in 2 Teillisten L1, L2 der halben Länge
zerteilt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
17
Variante 2: Mergesort für lineare Listen.
Wenn die Liste L nur ein Element enthält, ist nichts zu tun.
Andernfalls wird L in 2 Teillisten L1, L2 der halben Länge
zerteilt.
(Durchlaufe L, hänge die Einträge abwechselnd an L1 und L2
an. Kosten: Θ(Länge von L).)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
17
Variante 2: Mergesort für lineare Listen.
Wenn die Liste L nur ein Element enthält, ist nichts zu tun.
Andernfalls wird L in 2 Teillisten L1, L2 der halben Länge
zerteilt.
(Durchlaufe L, hänge die Einträge abwechselnd an L1 und L2
an. Kosten: Θ(Länge von L).)
Auf L1 und L2 wird der Algorithmus rekursiv angewendet.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
17
Variante 2: Mergesort für lineare Listen.
Wenn die Liste L nur ein Element enthält, ist nichts zu tun.
Andernfalls wird L in 2 Teillisten L1, L2 der halben Länge
zerteilt.
(Durchlaufe L, hänge die Einträge abwechselnd an L1 und L2
an. Kosten: Θ(Länge von L).)
Auf L1 und L2 wird der Algorithmus rekursiv angewendet.
Dann werden die beiden nun sortierten Listen gemischt“.
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
17
Variante 2: Mergesort für lineare Listen.
Wenn die Liste L nur ein Element enthält, ist nichts zu tun.
Andernfalls wird L in 2 Teillisten L1, L2 der halben Länge
zerteilt.
(Durchlaufe L, hänge die Einträge abwechselnd an L1 und L2
an. Kosten: Θ(Länge von L).)
Auf L1 und L2 wird der Algorithmus rekursiv angewendet.
Dann werden die beiden nun sortierten Listen gemischt“.
”
Analyse der Vergleiche: Identisch zum Obigen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
17
Variante 2: Mergesort für lineare Listen.
Wenn die Liste L nur ein Element enthält, ist nichts zu tun.
Andernfalls wird L in 2 Teillisten L1, L2 der halben Länge
zerteilt.
(Durchlaufe L, hänge die Einträge abwechselnd an L1 und L2
an. Kosten: Θ(Länge von L).)
Auf L1 und L2 wird der Algorithmus rekursiv angewendet.
Dann werden die beiden nun sortierten Listen gemischt“.
”
Analyse der Vergleiche: Identisch zum Obigen.
Laufzeit: Proportional zur Anzahl der Vergleiche, also auch
Θ(n log n).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
17
Variante 2: Mergesort für lineare Listen.
Wenn die Liste L nur ein Element enthält, ist nichts zu tun.
Andernfalls wird L in 2 Teillisten L1, L2 der halben Länge
zerteilt.
(Durchlaufe L, hänge die Einträge abwechselnd an L1 und L2
an. Kosten: Θ(Länge von L).)
Auf L1 und L2 wird der Algorithmus rekursiv angewendet.
Dann werden die beiden nun sortierten Listen gemischt“.
”
Analyse der Vergleiche: Identisch zum Obigen.
Laufzeit: Proportional zur Anzahl der Vergleiche, also auch
Θ(n log n).
Kein zusätzlicher Platz (aber Zeiger für die Liste).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
17
Variante 3: Iteratives Mergesort, bottom-up“
”
Beispiel:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
18
Variante 3: Iteratives Mergesort, bottom-up“
”
Idee: Arbeite in Runden i = 1, 2, 3, . . . , dlog ne.
Beispiel:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
18
Runde
A:
7
2
9
6
3
1
6 10
2 17 12
6
2
7
4
C:
2
7
6
9
1
3
6 10
2 17 6
12
2
7
4
A:
2
6
7
9
1
3
6 10
2
6
12 17
2
4
7
C:
1
2
3
6
6
7
9 10
2
2
4
6
7
12 17
A:
1
2
2
2
3
4
6
6
7
7
9
10 12 17
1
2
3
4
FG KTuEA, TU Ilmenau
6
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
19
Variante 3: Iteratives Mergesort, bottom-up“
”
Vor Runde i:
Teilarrays A[(l − 1) · 2i + 1 . . . l · 2i] sind aufsteigend sortiert.
(Eventuell ist das am weitesten rechts stehende Teilarray unvollständig.)
In Runde i führe merge((l − 2) · 2i + 1, (l − 1)2i, l · 2i) aus,
für l = 2, 4, 6, . . . , 2bn/2i+1c,
mit Hilfe eines zweiten Arrays B.
(Mögliche Sonderrolle für unvollständige Teilarrays ganz
rechts.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
20
Trick, spart Kopierarbeit:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
21
Trick, spart Kopierarbeit:
Benutze 2 Arrays, die in jeder Runde ihre Rolle wechseln.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
21
Trick, spart Kopierarbeit:
Benutze 2 Arrays, die in jeder Runde ihre Rolle wechseln.
Zeitverhalten von iterativem Mergesort:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
21
Trick, spart Kopierarbeit:
Benutze 2 Arrays, die in jeder Runde ihre Rolle wechseln.
Zeitverhalten von iterativem Mergesort:
wie bei rekursivem Mergesort.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
21
Trick, spart Kopierarbeit:
Benutze 2 Arrays, die in jeder Runde ihre Rolle wechseln.
Zeitverhalten von iterativem Mergesort:
wie bei rekursivem Mergesort.
Alternative, einfache Zeitanalyse für diese Variante:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
21
Trick, spart Kopierarbeit:
Benutze 2 Arrays, die in jeder Runde ihre Rolle wechseln.
Zeitverhalten von iterativem Mergesort:
wie bei rekursivem Mergesort.
Alternative, einfache Zeitanalyse für diese Variante:
Jede Runde kostet offenbar < n Vergleiche und Zeit Θ(n),
und es gibt dlog ne Runden: also ist die die Zahl der Vergleiche
< ndlog ne und die Gesamtzeit
Θ(ndlog ne) = Θ(n log n).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
21
Variante 4: Mehrweg-Mergesort
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
22
Variante 4: Mehrweg-Mergesort
Besonders in Kombination mit dem iterativen Verfahren interessant ist die Möglichkeit, in einer merge-Runde nicht nur ein
Array, sondern 3, 4, oder mehr Teilarrays zusammenzumischen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
22
Variante 4: Mehrweg-Mergesort
Besonders in Kombination mit dem iterativen Verfahren interessant ist die Möglichkeit, in einer merge-Runde nicht nur ein
Array, sondern 3, 4, oder mehr Teilarrays zusammenzumischen.
Beispiel:
A:
1 7 9 13 2 5 7 9
3 6 6 10
2 4 11 12
4−way merge: wähle kleinstes Element
aus 4 (Rest−)Arrays.
C:
1 2 2 3 4 5 6 6 7 7
Die nächsten gewählten Elemente: "9" aus 1.Teilarray,
"9" aus 2. Teilarray, 10, 11, etc.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
22
Benötigt: Auswahl des kleinsten aus k“. Dafür: Heap (später).
”
Beim Sortieren von Daten auf Hintergrundspeichern (Platten)
bringt diese Variante gebenüber dem Mischen von zwei Teilfolgen Laufzeitvorteile, da die Anzahl der Seitenfehler (page
faults) verringert wird.
Für Sortieren von großen Datenmengen auf Hintergrundspeichern: Mergesort-artige Verfahren benutzen!
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
23
Benötigt: Auswahl des kleinsten aus k“. Dafür: Heap (später).
”
Beim Sortieren von Daten auf Hintergrundspeichern (Platten)
bringt diese Variante gebenüber dem Mischen von zwei Teilfolgen Laufzeitvorteile, da die Anzahl der Seitenfehler (page
faults) verringert wird.
Für Sortieren von großen Datenmengen auf Hintergrundspeichern: Mergesort-artige Verfahren benutzen!
Ein ähnlicher Effekt tritt auch beim Sortieren im Hauptspeicher
ein: Die Zahl der Cachefehler (cache misses) sinkt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
23
6.3 Quicksort
Schnelles Sortieren im Durchschnitt
(C. A. R. Hoare, 1960)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
24
6.3 Quicksort
Schnelles Sortieren im Durchschnitt
(C. A. R. Hoare, 1960)
Folgt ebenfalls dem
Divide-and-Conquer-Ansatz
Zentrale Teilaufgabe:
Sortiere (Teil-)Array A[a..b], wo 1 ≤ a ≤ b ≤ n.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
24
6.3 Quicksort
Schnelles Sortieren im Durchschnitt
(C. A. R. Hoare, 1960)
Folgt ebenfalls dem
Divide-and-Conquer-Ansatz
Zentrale Teilaufgabe:
Sortiere (Teil-)Array A[a..b], wo 1 ≤ a ≤ b ≤ n.
Zu erledigen von einer (rekursiven) Prozedur r qsort(a, b).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
24
Kernstück: Partitionieren und rekursiv sortieren.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
25
Kernstück: Partitionieren und rekursiv sortieren.
Quicksort−Schema:
Teilaufgabe: Sortiere A[a...b]
x
4
a
23
17
9
1
5
8
b
16
Partitioniere!
5
1
FG KTuEA, TU Ilmenau
4
8
1
9
p
23
16
17
9
>9
Sortiere
rekursiv
Sortiere
rekursiv
4
5
8
9
16
17
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
23
25
Ansatz für r qsort(a, b), Korrektheit:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
26
Ansatz für r qsort(a, b), Korrektheit:
0) Trivialitätstest: Wenn a ≥ b, ist nichts zu tun.
(Oder: Wenn b − a < n0: StraightInsertionSort(a, b).)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
26
Ansatz für r qsort(a, b), Korrektheit:
0) Trivialitätstest: Wenn a ≥ b, ist nichts zu tun.
(Oder: Wenn b − a < n0: StraightInsertionSort(a, b).)
1. Teile: (Hier partitioniere“)
”
Wähle x ∈ {A[a].key,...,A[b].key}.
Arrangiere die Einträge von A[a..b] so um, dass
A[a].key, . . . ,A[p − 1].key ≤ A[p].key = x < A[p + 1].key, . . . ,A[b].key
für ein p mit a ≤ p ≤ b.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
26
Ansatz für r qsort(a, b), Korrektheit:
0) Trivialitätstest: Wenn a ≥ b, ist nichts zu tun.
(Oder: Wenn b − a < n0: StraightInsertionSort(a, b).)
1. Teile: (Hier partitioniere“)
”
Wähle x ∈ {A[a].key,...,A[b].key}.
Arrangiere die Einträge von A[a..b] so um, dass
A[a].key, . . . ,A[p − 1].key ≤ A[p].key = x < A[p + 1].key, . . . ,A[b].key
für ein p mit a ≤ p ≤ b.
2. Teilprobleme rekursiv lösen:
r qsort(a, p − 1) (links), r qsort(p + 1, b) (rechts).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
26
Ansatz für r qsort(a, b), Korrektheit:
0) Trivialitätstest: Wenn a ≥ b, ist nichts zu tun.
(Oder: Wenn b − a < n0: StraightInsertionSort(a, b).)
1. Teile: (Hier partitioniere“)
”
Wähle x ∈ {A[a].key,...,A[b].key}.
Arrangiere die Einträge von A[a..b] so um, dass
A[a].key, . . . ,A[p − 1].key ≤ A[p].key = x < A[p + 1].key, . . . ,A[b].key
für ein p mit a ≤ p ≤ b.
2. Teilprobleme rekursiv lösen:
r qsort(a, p − 1) (links), r qsort(p + 1, b) (rechts).
Nach I.V. gilt nun: A[a..p − 1], A[p + 1..b] sortiert.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
26
Ansatz für r qsort(a, b), Korrektheit:
0) Trivialitätstest: Wenn a ≥ b, ist nichts zu tun.
(Oder: Wenn b − a < n0: StraightInsertionSort(a, b).)
1. Teile: (Hier partitioniere“)
”
Wähle x ∈ {A[a].key,...,A[b].key}.
Arrangiere die Einträge von A[a..b] so um, dass
A[a].key, . . . ,A[p − 1].key ≤ A[p].key = x < A[p + 1].key, . . . ,A[b].key
für ein p mit a ≤ p ≤ b.
2. Teilprobleme rekursiv lösen:
r qsort(a, p − 1) (links), r qsort(p + 1, b) (rechts).
Nach I.V. gilt nun: A[a..p − 1], A[p + 1..b] sortiert.
3. Kombiniere: Es ist nichts zu tun: A[a..b] ist sortiert.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
26
Kernstück: Partitionieren.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
27
Kernstück: Partitionieren.
Woher nehmen wir das Pivotelement“ x?
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
27
Kernstück: Partitionieren.
Woher nehmen wir das Pivotelement“ x?
”
Beispiele: x := A[a].key (erstes Element des Teilarrays)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
27
Kernstück: Partitionieren.
Woher nehmen wir das Pivotelement“ x?
”
Beispiele: x := A[a].key (erstes Element des Teilarrays)
x := A[b].key (letztes Element des Teilarrays)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
27
Kernstück: Partitionieren.
Woher nehmen wir das Pivotelement“ x?
”
Beispiele: x := A[a].key (erstes Element des Teilarrays)
x := A[b].key (letztes Element des Teilarrays)
x := A[b(a + b)/2c].key (Mitte des Teilarrays)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
27
Kernstück: Partitionieren.
Woher nehmen wir das Pivotelement“ x?
”
Beispiele: x := A[a].key (erstes Element des Teilarrays)
x := A[b].key (letztes Element des Teilarrays)
x := A[b(a + b)/2c].key (Mitte des Teilarrays)
Clever Quicksort“: x ist der Median von A[a].key,
”
A[b].key, A[b(a + b)/2c].key
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
27
Kernstück: Partitionieren.
Woher nehmen wir das Pivotelement“ x?
”
Beispiele: x := A[a].key (erstes Element des Teilarrays)
x := A[b].key (letztes Element des Teilarrays)
x := A[b(a + b)/2c].key (Mitte des Teilarrays)
Clever Quicksort“: x ist der Median von A[a].key,
”
A[b].key, A[b(a + b)/2c].key
Randomisiertes Quicksort“
”
Wähle einen der b − a + 1 Einträge in A[a..b] zufällig.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
27
Kernstück: Partitionieren.
Woher nehmen wir das Pivotelement“ x?
”
Beispiele: x := A[a].key (erstes Element des Teilarrays)
x := A[b].key (letztes Element des Teilarrays)
x := A[b(a + b)/2c].key (Mitte des Teilarrays)
Clever Quicksort“: x ist der Median von A[a].key,
”
A[b].key, A[b(a + b)/2c].key
Randomisiertes Quicksort“
”
Wähle einen der b − a + 1 Einträge in A[a..b] zufällig.
Allgemein: Wähle ein s mit a ≤ s ≤ b,
vertausche A[a] mit A[s].
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
27
Kernstück: Partitionieren.
Woher nehmen wir das Pivotelement“ x?
”
Beispiele: x := A[a].key (erstes Element des Teilarrays)
x := A[b].key (letztes Element des Teilarrays)
x := A[b(a + b)/2c].key (Mitte des Teilarrays)
Clever Quicksort“: x ist der Median von A[a].key,
”
A[b].key, A[b(a + b)/2c].key
Randomisiertes Quicksort“
”
Wähle einen der b − a + 1 Einträge in A[a..b] zufällig.
Allgemein: Wähle ein s mit a ≤ s ≤ b,
vertausche A[a] mit A[s].
Dann: Pivotelement x := A[a].key.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
27
Kernstück: Partitionieren. Pivotelelement: x = A[a].key
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
28
Kernstück: Partitionieren. Pivotelelement: x = A[a].key
Klar: b−a Vergleiche genügen, um Schlüssel ≤ x nach links“
”
und Schlüssel > x nach rechts“ zu schaffen, und den Eintrag
”
mit dem Pivotelement an die Stelle zwischen den Bereichen
zu schreiben.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
28
Kernstück: Partitionieren. Pivotelelement: x = A[a].key
Klar: b−a Vergleiche genügen, um Schlüssel ≤ x nach links“
”
und Schlüssel > x nach rechts“ zu schaffen, und den Eintrag
”
mit dem Pivotelement an die Stelle zwischen den Bereichen
zu schreiben.
Eine sehr geschickte Methode wurde schon von C. A. R.
Hoare angegeben:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
28
Kernstück: Partitionieren. Pivotelelement: x = A[a].key
Klar: b−a Vergleiche genügen, um Schlüssel ≤ x nach links“
”
und Schlüssel > x nach rechts“ zu schaffen, und den Eintrag
”
mit dem Pivotelement an die Stelle zwischen den Bereichen
zu schreiben.
Eine sehr geschickte Methode wurde schon von C. A. R.
Hoare angegeben: kein zusätzlicher Platz, keine unnötige
Datenbewegung.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
28
Kernstück: Partitionieren. Pivotelelement: x = A[a].key
Klar: b−a Vergleiche genügen, um Schlüssel ≤ x nach links“
”
und Schlüssel > x nach rechts“ zu schaffen, und den Eintrag
”
mit dem Pivotelement an die Stelle zwischen den Bereichen
zu schreiben.
Eine sehr geschickte Methode wurde schon von C. A. R.
Hoare angegeben: kein zusätzlicher Platz, keine unnötige
Datenbewegung.
Hier: Variante des in der AuP-Vorlesung angegebenen Verfahrens.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
28
a+1
i
0000
1111
00
11
0000
00
11
x
>x
x 1111
0000
1111
00
11
FG KTuEA, TU Ilmenau
?
j 1111
b
0000
000
111
0000
000
111
x 1111
>x
0000
1111
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
000
111
29
a+1
i
0000
1111
00
11
0000
00
11
x
>x
x 1111
0000
1111
00
11
?
j 1111
b
0000
000
111
0000
000
111
x 1111
>x
0000
1111
000
111
Ignoriere A[a].
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
29
a+1
i
0000
1111
00
11
0000
00
11
x
>x
x 1111
0000
1111
00
11
?
j 1111
b
0000
000
111
0000
000
111
x 1111
>x
0000
1111
000
111
Ignoriere A[a].
Lasse ab a + 1 einen Zeiger“ (Index) i nach rechts wandern,
”
bis ein Schlüssel > x erreicht wird.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
29
a+1
i
0000
1111
00
11
0000
00
11
x
>x
x 1111
0000
1111
00
11
?
j 1111
b
0000
000
111
0000
000
111
x 1111
>x
0000
1111
000
111
Ignoriere A[a].
Lasse ab a + 1 einen Zeiger“ (Index) i nach rechts wandern,
”
bis ein Schlüssel > x erreicht wird.
Lasse ab b einen Zeiger“ j (Index) nach links wandern, bis
”
ein Schlüssel ≤ x erreicht wird.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
29
a+1
i
0000
1111
00
11
0000
00
11
x
>x
x 1111
0000
1111
00
11
?
j 1111
b
0000
000
111
0000
000
111
x 1111
>x
0000
1111
000
111
Ignoriere A[a].
Lasse ab a + 1 einen Zeiger“ (Index) i nach rechts wandern,
”
bis ein Schlüssel > x erreicht wird.
Lasse ab b einen Zeiger“ j (Index) nach links wandern, bis
”
ein Schlüssel ≤ x erreicht wird.
Falls i < j: Vertausche A[i] und A[j].
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
29
a+1
i
0000
1111
00
11
0000
00
11
x
>x
x 1111
0000
1111
00
11
j 1111
b
0000
000
111
0000
000
111
x 1111
>x
0000
1111
000
111
?
Ignoriere A[a].
Lasse ab a + 1 einen Zeiger“ (Index) i nach rechts wandern,
”
bis ein Schlüssel > x erreicht wird.
Lasse ab b einen Zeiger“ j (Index) nach links wandern, bis
”
ein Schlüssel ≤ x erreicht wird.
Falls i < j: Vertausche A[i] und A[j].
a
11111
00000
00
11
00000
11111
00
11
x
x
00000
11111
00
11
i
x
j
?
b
1111
0000
000
111
0000
000
111
>x 1111
>x
0000
1111
000
111
REST
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
29
a+1
i
0000
1111
00
11
0000
00
11
x
>x
x 1111
0000
1111
00
11
j 1111
b
0000
000
111
0000
000
111
x 1111
>x
0000
1111
000
111
?
Ignoriere A[a].
Lasse ab a + 1 einen Zeiger“ (Index) i nach rechts wandern,
”
bis ein Schlüssel > x erreicht wird.
Lasse ab b einen Zeiger“ j (Index) nach links wandern, bis
”
ein Schlüssel ≤ x erreicht wird.
Falls i < j: Vertausche A[i] und A[j].
a
11111
00000
00
11
00000
11111
00
11
x
x
00000
11111
00
11
i
x
j
?
b
1111
0000
000
111
0000
000
111
>x 1111
>x
0000
1111
000
111
REST
Erhöhe i um 1, erniedrige j um 1. Wiederhole.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
29
. . . bis sich i und j treffen“ und überkreuzen“.
”
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
30
. . . bis sich i und j treffen“ und überkreuzen“.
”
”
a
x
a
z
x
j i
z
x
j i
x
b
>x
b
>x
p=j
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
30
. . . bis sich i und j treffen“ und überkreuzen“.
”
”
a
x
a
z
x
j i
z
x
j i
x
b
>x
b
>x
p=j
Vertausche A[a] mit A[j].
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
30
. . . bis sich i und j treffen“ und überkreuzen“.
”
”
a
x
a
z
x
j i
z
x
j i
x
b
>x
b
>x
p=j
Vertausche A[a] mit A[j].
Position p des Pivotelements jetzt: A[j].
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
30
. . . bis sich i und j treffen“ und überkreuzen“.
”
”
a
x
a
z
x
j i
z
x
j i
x
b
>x
b
>x
p=j
Vertausche A[a] mit A[j].
Position p des Pivotelements jetzt: A[j].
Sorgfalt bei der Implementierung der Idee nötig. Randfälle und Abschluss
korrekt behandeln! Nach einigem Tüfteln ergibt sich:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
30
Prozedur partition(a, b, p)
// Partitionierungsprozedur in r qsort(a, b)
// Voraussetzung: a < b; Pivotelement: A[a]
(1)
x ← A[a].key;
(2)
i ← a + 1; j ← b;
(3)
while (i ≤ j) do
// noch nicht fertig; Hauptschleife
(4)
while (i ≤ j) and (A[i].key ≤ x) do i++;
(5)
while (j > i) and (A[j].key > x) do j--;
(6)
if (i = j) then j--;
// Wissen: A[i].key > x
(7)
if (i < j) then
(8)
vertausche A[i] und A[j];
(9)
i++; j--;
(10)
if (a < j) then vertausche A[a] und A[j];
(11)
p ← j; // Rückgabewert
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
31
Beispiel für partition:
2
5
20 7 16 18 30
a
x =20
// 7 16 18 30
i
x =20
// 7 16 18 30
i
x =20
// 7 16 18 9
x =20
// 7
FG KTuEA, TU Ilmenau
16 18 9
12 25
8
9 35 31
b
Vorbereitung
12 25
8
9
j
12 25
8
9
j
12 25
i
8
j
30
12 25
i
8
j
30
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Vertauschen
32
x =20
// 7
x =20
// 7
x =20
// 7
16 18 9
16 18 9
16 18 9
12 25
i
8
j
12
8
j
25 30
i
8
25 30
12
30
Vertauschen
fertig!
Aufräumen
8
7
16 18 9
12
20 25 30
p
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
33
Lemma 6.3.1
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
34
Lemma 6.3.1 Ein Aufruf partition(a, b, p)
bewirkt folgendes, wenn 1 ≤ a < b ≤ n gilt:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
34
Lemma 6.3.1 Ein Aufruf partition(a, b, p)
bewirkt folgendes, wenn 1 ≤ a < b ≤ n gilt:
Sei x = A[a].key (vor Aufruf), p der Inhalt von p (nach Aufruf).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
34
Lemma 6.3.1 Ein Aufruf partition(a, b, p)
bewirkt folgendes, wenn 1 ≤ a < b ≤ n gilt:
Sei x = A[a].key (vor Aufruf), p der Inhalt von p (nach Aufruf).
(a) A[a . . b] wird so umarrangiert, dass x = A[p].key und
A[a].key,. . . ,A[p−1].key ≤ x < A[p+1].key,. . . ,A[b].key.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
34
Lemma 6.3.1 Ein Aufruf partition(a, b, p)
bewirkt folgendes, wenn 1 ≤ a < b ≤ n gilt:
Sei x = A[a].key (vor Aufruf), p der Inhalt von p (nach Aufruf).
(a) A[a . . b] wird so umarrangiert, dass x = A[p].key und
A[a].key,. . . ,A[p−1].key ≤ x < A[p+1].key,. . . ,A[b].key.
(b) An welche Stelle A[j], a ≤ j ≤ b, gelangt, hängt nur von
der Menge {i ∈ [a + 1, b] | A[i].key > x} ab,
nicht von den konkreten Schlüsselwerten.
(Beweis: (a) Nicht prüfungsrelevant, siehe Druckfolien. (b) Alle Entscheidungen werden nur aufgrund von Vergleichen mit x getroffen.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
34
Lemma 6.3.1 Ein Aufruf partition(a, b, p)
bewirkt folgendes, wenn 1 ≤ a < b ≤ n gilt:
Sei x = A[a].key (vor Aufruf), p der Inhalt von p (nach Aufruf).
(a) A[a . . b] wird so umarrangiert, dass x = A[p].key und
A[a].key,. . . ,A[p−1].key ≤ x < A[p+1].key,. . . ,A[b].key.
(b) An welche Stelle A[j], a ≤ j ≤ b, gelangt, hängt nur von
der Menge {i ∈ [a + 1, b] | A[i].key > x} ab,
nicht von den konkreten Schlüsselwerten.
(Beweis: (a) Nicht prüfungsrelevant, siehe Druckfolien. (b) Alle Entscheidungen werden nur aufgrund von Vergleichen mit x getroffen.)
Lemma 6.3.2 Bei partition(a, b, p) gilt:
(a) Die Anzahl der Schlüsselvergleiche ist exakt b − a;
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
34
Lemma 6.3.1 Ein Aufruf partition(a, b, p)
bewirkt folgendes, wenn 1 ≤ a < b ≤ n gilt:
Sei x = A[a].key (vor Aufruf), p der Inhalt von p (nach Aufruf).
(a) A[a . . b] wird so umarrangiert, dass x = A[p].key und
A[a].key,. . . ,A[p−1].key ≤ x < A[p+1].key,. . . ,A[b].key.
(b) An welche Stelle A[j], a ≤ j ≤ b, gelangt, hängt nur von
der Menge {i ∈ [a + 1, b] | A[i].key > x} ab,
nicht von den konkreten Schlüsselwerten.
(Beweis: (a) Nicht prüfungsrelevant, siehe Druckfolien. (b) Alle Entscheidungen werden nur aufgrund von Vergleichen mit x getroffen.)
Lemma 6.3.2 Bei partition(a, b, p) gilt:
(a) Die Anzahl der Schlüsselvergleiche ist exakt b − a;
(b) der (Zeit-)Aufwand ist Θ(b − a).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
34
Prozedur r qsort(a, b)
// Rekursive Prozedur im Quicksort-Algorithmus, 1 ≤ a < b ≤ n
(1)
s ← ein Element von {a, . . . , b};
// Es gibt verschiedene Methoden/Arten, s zu wählen!
(2)
if (a < s) then vertausche A[a] und A[s];
(3)
partition(a, b, p); // p: Ausgabeparameter
(4)
if a < p − 1 then r qsort(a, p − 1);
(5)
if p + 1 < b then r qsort(p + 1, b).
Effiziente Variation zu den Abbruchkriterien in Zeilen (4), (5):
Teilarrays der Länge ≤ n0 mit StraightInsertionSort(a, b)
sortieren, für ein passendes n0.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
35
Lemma 6.3.3
Ein Aufruf von r qsort(a, b) sortiert A[a . . b].
(Beweis schon gesehen.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
36
Lemma 6.3.3
Ein Aufruf von r qsort(a, b) sortiert A[a . . b].
(Beweis schon gesehen.)
Um A[1 . . n] zu sortieren:
Prozedur quicksort(A[1..n])
(1) if n > 1 then r qsort(1, n).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
36
Die Laufzeit von r qsort(a, b)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
37
Die Laufzeit von r qsort(a, b), wobei n = b − a + 1.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
37
Die Laufzeit von r qsort(a, b), wobei n = b − a + 1.
Der Aufwand für einen Aufruf ist O(1)
plus der Aufwand für partition(a, b, p)
plus der Aufwand für die rekursiven Aufrufe.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
37
Die Laufzeit von r qsort(a, b), wobei n = b − a + 1.
Der Aufwand für einen Aufruf ist O(1)
plus der Aufwand für partition(a, b, p)
plus der Aufwand für die rekursiven Aufrufe.
Der Aufwand für partition(a, b, p) ist proportional zu b − a,
und das ist genau die Anzahl der Schlüsselvergleiche, die
partition(a, b, p) durchführt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
37
Die Laufzeit von r qsort(a, b), wobei n = b − a + 1.
Der Aufwand für einen Aufruf ist O(1)
plus der Aufwand für partition(a, b, p)
plus der Aufwand für die rekursiven Aufrufe.
Der Aufwand für partition(a, b, p) ist proportional zu b − a,
und das ist genau die Anzahl der Schlüsselvergleiche, die
partition(a, b, p) durchführt.
In jedem Aufruf ist ein anderer Arrayeintrag Pivotelement.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
37
Die Laufzeit von r qsort(a, b), wobei n = b − a + 1.
Der Aufwand für einen Aufruf ist O(1)
plus der Aufwand für partition(a, b, p)
plus der Aufwand für die rekursiven Aufrufe.
Der Aufwand für partition(a, b, p) ist proportional zu b − a,
und das ist genau die Anzahl der Schlüsselvergleiche, die
partition(a, b, p) durchführt.
In jedem Aufruf ist ein anderer Arrayeintrag Pivotelement.
Gesamtaufwand für r qsort(a, b), wobei n = b − a + 1:
O(n) plus O(Gesamtanzahl
aller{zSchlüsselvergleiche}).
|
=:V
V ist eine Größe, die von der Anordnung der Eingabe abhängt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
37
Schlechtester Fall: ( worst case“)
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
38
Schlechtester Fall: ( worst case“)
”
Wenn zwei Schlüssel verglichen werden, ist einer davon (x)
das Pivotelement, der andere wandert in eines der beiden
Teilarrays.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
38
Schlechtester Fall: ( worst case“)
”
Wenn zwei Schlüssel verglichen werden, ist einer davon (x)
das Pivotelement, der andere wandert in eines der beiden
Teilarrays.
Konsequenz: Es werden niemals dieselben Schlüssel später
nochmals verglichen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
38
Schlechtester Fall: ( worst case“)
”
Wenn zwei Schlüssel verglichen werden, ist einer davon (x)
das Pivotelement, der andere wandert in eines der beiden
Teilarrays.
Konsequenz: Es werden niemals dieselben Schlüssel später
nochmals verglichen.
1
n
Also: V ≤ 2 = 2 n(n − 1).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
38
Schlechtester Fall: ( worst case“)
”
Wenn zwei Schlüssel verglichen werden, ist einer davon (x)
das Pivotelement, der andere wandert in eines der beiden
Teilarrays.
Konsequenz: Es werden niemals dieselben Schlüssel später
nochmals verglichen.
1
n
Also: V ≤ 2 = 2 n(n − 1).
Dieser Wert kommt vor, wenn die Eingabe schon sortiert ist
und man in Prozedur r qsort(a, b) immer A[a] als Pivotelement wählt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
38
Schlechtester Fall: ( worst case“)
”
Wenn zwei Schlüssel verglichen werden, ist einer davon (x)
das Pivotelement, der andere wandert in eines der beiden
Teilarrays.
Konsequenz: Es werden niemals dieselben Schlüssel später
nochmals verglichen.
1
n
Also: V ≤ 2 = 2 n(n − 1).
Dieser Wert kommt vor, wenn die Eingabe schon sortiert ist
und man in Prozedur r qsort(a, b) immer A[a] als Pivotelement wählt.
(Dann ist das linke Teilarray leer, das rechte enthält b − a Elemente.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
38
Schlechtester Fall: ( worst case“)
”
Wenn zwei Schlüssel verglichen werden, ist einer davon (x)
das Pivotelement, der andere wandert in eines der beiden
Teilarrays.
Konsequenz: Es werden niemals dieselben Schlüssel später
nochmals verglichen.
1
n
Also: V ≤ 2 = 2 n(n − 1).
Dieser Wert kommt vor, wenn die Eingabe schon sortiert ist
und man in Prozedur r qsort(a, b) immer A[a] als Pivotelement wählt.
(Dann ist das linke Teilarray leer, das rechte enthält b − a Elemente.
n
Rekursionstiefe n, und V = (n − 1) + (n − 2) + · · · + 3 + 2 + 1 = 2 .)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
38
Schlechtester Fall: ( worst case“)
”
Wenn zwei Schlüssel verglichen werden, ist einer davon (x)
das Pivotelement, der andere wandert in eines der beiden
Teilarrays.
Konsequenz: Es werden niemals dieselben Schlüssel später
nochmals verglichen.
1
n
Also: V ≤ 2 = 2 n(n − 1).
Dieser Wert kommt vor, wenn die Eingabe schon sortiert ist
und man in Prozedur r qsort(a, b) immer A[a] als Pivotelement wählt.
(Dann ist das linke Teilarray leer, das rechte enthält b − a Elemente.
n
Rekursionstiefe n, und V = (n − 1) + (n − 2) + · · · + 3 + 2 + 1 = 2 .)
Achtung: Ähnlicher Effekt, wenn Array fast“ sortiert.
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
38
Durchschnittlicher/erwarteter Fall?
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
39
Durchschnittlicher/erwarteter Fall?
Wahrscheinlichkeitsannahme:
Die Eingabeschlüssel sind verschieden. – O.B.d.A.:
Eingabeschlüssel sind n verschiedene Zahlen x1 < . . . < xn.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
39
Durchschnittlicher/erwarteter Fall?
Wahrscheinlichkeitsannahme:
Die Eingabeschlüssel sind verschieden. – O.B.d.A.:
Eingabeschlüssel sind n verschiedene Zahlen x1 < . . . < xn.
Jede Anordnung der Eingabeschlüssel hat dieselbe Wahrscheinlichkeit. (Es gibt n! solche Anordnungen.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
39
Durchschnittlicher/erwarteter Fall?
Wahrscheinlichkeitsannahme:
Die Eingabeschlüssel sind verschieden. – O.B.d.A.:
Eingabeschlüssel sind n verschiedene Zahlen x1 < . . . < xn.
Jede Anordnung der Eingabeschlüssel hat dieselbe Wahrscheinlichkeit. (Es gibt n! solche Anordnungen.)
Als Pivotelement wählen wir den Eintrag an einer festen Stelle,
z. B. A[a].
Unter dieser Wahrscheinlichkeitsannahme wird V zu einer
Zufallsgröße.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
39
Durchschnittlicher/erwarteter Fall?
Wahrscheinlichkeitsannahme:
Die Eingabeschlüssel sind verschieden. – O.B.d.A.:
Eingabeschlüssel sind n verschiedene Zahlen x1 < . . . < xn.
Jede Anordnung der Eingabeschlüssel hat dieselbe Wahrscheinlichkeit. (Es gibt n! solche Anordnungen.)
Als Pivotelement wählen wir den Eintrag an einer festen Stelle,
z. B. A[a].
Unter dieser Wahrscheinlichkeitsannahme wird V zu einer
Zufallsgröße.
Wir untersuchen den Erwartungswert/Mittelwert von V .
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
39
Durchschnittlicher/erwarteter Fall?
Wahrscheinlichkeitsannahme:
Die Eingabeschlüssel sind verschieden. – O.B.d.A.:
Eingabeschlüssel sind n verschiedene Zahlen x1 < . . . < xn.
Jede Anordnung der Eingabeschlüssel hat dieselbe Wahrscheinlichkeit. (Es gibt n! solche Anordnungen.)
Als Pivotelement wählen wir den Eintrag an einer festen Stelle,
z. B. A[a].
Unter dieser Wahrscheinlichkeitsannahme wird V zu einer
Zufallsgröße.
Wir untersuchen den Erwartungswert/Mittelwert von V .
(Vorsicht! Die folgende Überlegung gilt nicht für Clever-Quicksort“ und
”
nicht, wenn die Schlüssel nicht alle verschieden sind.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
39
Cn := die erwartete Anzahl der Vergleiche beim Sortieren
eines Teilarrays mit n Einträgen mit r qsort
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
40
Cn := die erwartete Anzahl der Vergleiche beim Sortieren
eines Teilarrays mit n Einträgen mit r qsort
C0 = 0,
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
40
Cn := die erwartete Anzahl der Vergleiche beim Sortieren
eines Teilarrays mit n Einträgen mit r qsort
C0 = 0,
C1 =
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
40
Cn := die erwartete Anzahl der Vergleiche beim Sortieren
eines Teilarrays mit n Einträgen mit r qsort
C0 = 0,
C1 = 0,
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
40
Cn := die erwartete Anzahl der Vergleiche beim Sortieren
eines Teilarrays mit n Einträgen mit r qsort
C0 = 0,
C1 = 0,
FG KTuEA, TU Ilmenau
C2 =
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
40
Cn := die erwartete Anzahl der Vergleiche beim Sortieren
eines Teilarrays mit n Einträgen mit r qsort
C0 = 0,
C1 = 0,
FG KTuEA, TU Ilmenau
C2 = 1,
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
40
Cn := die erwartete Anzahl der Vergleiche beim Sortieren
eines Teilarrays mit n Einträgen mit r qsort
C0 = 0,
C1 = 0,
C2 = 1,
C3: Wenn man beim ersten r qsort(a, b)-Aufruf mit b = a + 2
das mittlere Element x2 als Pivot hat, gibt es 2 Vergleiche
insgesamt.
Wahrscheinlichkeit hierfür: 13 .
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
40
Cn := die erwartete Anzahl der Vergleiche beim Sortieren
eines Teilarrays mit n Einträgen mit r qsort
C0 = 0,
C1 = 0,
C2 = 1,
C3: Wenn man beim ersten r qsort(a, b)-Aufruf mit b = a + 2
das mittlere Element x2 als Pivot hat, gibt es 2 Vergleiche
insgesamt.
Wahrscheinlichkeit hierfür: 13 .
Wenn man x1 oder x3 als Pivot hat, hat man zunächst 2
Vergleiche, und einer der rekursiven Aufrufe führt zu einem
dritten.
Insgesamt: 3 Vergleiche. Wahrscheinlichkeit hierfür: 23 .
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
40
Cn := die erwartete Anzahl der Vergleiche beim Sortieren
eines Teilarrays mit n Einträgen mit r qsort
C0 = 0,
C1 = 0,
C2 = 1,
C3: Wenn man beim ersten r qsort(a, b)-Aufruf mit b = a + 2
das mittlere Element x2 als Pivot hat, gibt es 2 Vergleiche
insgesamt.
Wahrscheinlichkeit hierfür: 13 .
Wenn man x1 oder x3 als Pivot hat, hat man zunächst 2
Vergleiche, und einer der rekursiven Aufrufe führt zu einem
dritten.
Insgesamt: 3 Vergleiche. Wahrscheinlichkeit hierfür: 23 .
Mittlere Vergleichsanzahl:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
40
Cn := die erwartete Anzahl der Vergleiche beim Sortieren
eines Teilarrays mit n Einträgen mit r qsort
C0 = 0,
C1 = 0,
C2 = 1,
C3: Wenn man beim ersten r qsort(a, b)-Aufruf mit b = a + 2
das mittlere Element x2 als Pivot hat, gibt es 2 Vergleiche
insgesamt.
Wahrscheinlichkeit hierfür: 13 .
Wenn man x1 oder x3 als Pivot hat, hat man zunächst 2
Vergleiche, und einer der rekursiven Aufrufe führt zu einem
dritten.
Insgesamt: 3 Vergleiche. Wahrscheinlichkeit hierfür: 23 .
Mittlere Vergleichsanzahl: C3 = 31 · 2
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
40
Cn := die erwartete Anzahl der Vergleiche beim Sortieren
eines Teilarrays mit n Einträgen mit r qsort
C0 = 0,
C1 = 0,
C2 = 1,
C3: Wenn man beim ersten r qsort(a, b)-Aufruf mit b = a + 2
das mittlere Element x2 als Pivot hat, gibt es 2 Vergleiche
insgesamt.
Wahrscheinlichkeit hierfür: 13 .
Wenn man x1 oder x3 als Pivot hat, hat man zunächst 2
Vergleiche, und einer der rekursiven Aufrufe führt zu einem
dritten.
Insgesamt: 3 Vergleiche. Wahrscheinlichkeit hierfür: 23 .
Mittlere Vergleichsanzahl: C3 = 31 · 2 + 32 · 3
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
40
Cn := die erwartete Anzahl der Vergleiche beim Sortieren
eines Teilarrays mit n Einträgen mit r qsort
C0 = 0,
C1 = 0,
C2 = 1,
C3: Wenn man beim ersten r qsort(a, b)-Aufruf mit b = a + 2
das mittlere Element x2 als Pivot hat, gibt es 2 Vergleiche
insgesamt.
Wahrscheinlichkeit hierfür: 13 .
Wenn man x1 oder x3 als Pivot hat, hat man zunächst 2
Vergleiche, und einer der rekursiven Aufrufe führt zu einem
dritten.
Insgesamt: 3 Vergleiche. Wahrscheinlichkeit hierfür: 23 .
Mittlere Vergleichsanzahl: C3 = 31 · 2 + 32 · 3 = 83 .
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
40
Cn: Wenn man beim ersten r qsort(a, b)-Aufruf
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
41
Cn: Wenn man beim ersten r qsort(a, b)-Aufruf
das i-t kleinste Element xi als Pivotelement hat,
dann erzeugt dieser Aufruf selbst zunächst genau n − 1
Vergleiche,
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
41
Cn: Wenn man beim ersten r qsort(a, b)-Aufruf
das i-t kleinste Element xi als Pivotelement hat,
dann erzeugt dieser Aufruf selbst zunächst genau n − 1
Vergleiche,
und es entstehen die rekursiven Aufrufe
r qsort(a, a + i − 2) (wenn i ≥ 3)
r qsort(a + i, b) (wenn i ≤ n − 2)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
41
Cn: Wenn man beim ersten r qsort(a, b)-Aufruf
das i-t kleinste Element xi als Pivotelement hat,
dann erzeugt dieser Aufruf selbst zunächst genau n − 1
Vergleiche,
und es entstehen die rekursiven Aufrufe
r qsort(a, a + i − 2) (wenn i ≥ 3)
r qsort(a + i, b) (wenn i ≤ n − 2)
Diese kosten im Durchschnitt Ci−1 und Cn−i Vergleiche.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
41
Cn: Wenn man beim ersten r qsort(a, b)-Aufruf
das i-t kleinste Element xi als Pivotelement hat,
dann erzeugt dieser Aufruf selbst zunächst genau n − 1
Vergleiche,
und es entstehen die rekursiven Aufrufe
r qsort(a, a + i − 2) (wenn i ≥ 3)
r qsort(a + i, b) (wenn i ≤ n − 2)
Diese kosten im Durchschnitt Ci−1 und Cn−i Vergleiche.
(Beachte: Da anfangs die Schlüssel zufällig angeordnet waren, und bei
partition die Schlüssel nur mit dem Pivotelement verglichen werden, ist
nachher die Anordnung in der beiden Teilarrays ebenfalls zufällig.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
41
Falls also xi Pivotelement ist:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
42
Falls also xi Pivotelement ist:
Durchschnittliche Kosten sind (n − 1) + Ci−1 + Cn−i.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
42
Falls also xi Pivotelement ist:
Durchschnittliche Kosten sind (n − 1) + Ci−1 + Cn−i.
Die Wahrscheinlichkeit, dass xi Pivotelement ist, ist gleich
1/n, weil
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
42
Falls also xi Pivotelement ist:
Durchschnittliche Kosten sind (n − 1) + Ci−1 + Cn−i.
Die Wahrscheinlichkeit, dass xi Pivotelement ist, ist gleich
1/n, weil
nach der W-Annahme jede Anordnung der Einträge x1, . . . , xn
in A[a . . b] gleichwahrscheinlich ist (Lemma 6.3.1(b)).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
42
Falls also xi Pivotelement ist:
Durchschnittliche Kosten sind (n − 1) + Ci−1 + Cn−i.
Die Wahrscheinlichkeit, dass xi Pivotelement ist, ist gleich
1/n, weil
nach der W-Annahme jede Anordnung der Einträge x1, . . . , xn
in A[a . . b] gleichwahrscheinlich ist (Lemma 6.3.1(b)).
Also:
Cn
FG KTuEA, TU Ilmenau
n
X
1
·
((n − 1) + Ci−1 + Cn−i)
=
n i=1
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
42
Falls also xi Pivotelement ist:
Durchschnittliche Kosten sind (n − 1) + Ci−1 + Cn−i.
Die Wahrscheinlichkeit, dass xi Pivotelement ist, ist gleich
1/n, weil
nach der W-Annahme jede Anordnung der Einträge x1, . . . , xn
in A[a . . b] gleichwahrscheinlich ist (Lemma 6.3.1(b)).
Also:
Cn
n
X
1
·
((n − 1) + Ci−1 + Cn−i)
=
n i=1
n
1 X
= (n − 1) + ·
(Ci−1 + Cn−i).
n i=1
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
42
Abschnitt 4.2 in Kap. 4, Folien 32–37 :
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
43
Abschnitt 4.2 in Kap. 4, Folien 32–37 :
Rekursionsformel für die mittlere totale Weglänge A(n) in
zufällig erzeugten binären Suchbäumen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
43
Abschnitt 4.2 in Kap. 4, Folien 32–37 :
Rekursionsformel für die mittlere totale Weglänge A(n) in
zufällig erzeugten binären Suchbäumen.
A(0) = A(1) = 0, A(2) = 1,
Pn
1
A(n) = (n − 1) + n · i=1(A(i − 1) + A(n − i)).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
43
Abschnitt 4.2 in Kap. 4, Folien 32–37 :
Rekursionsformel für die mittlere totale Weglänge A(n) in
zufällig erzeugten binären Suchbäumen.
A(0) = A(1) = 0, A(2) = 1,
Pn
1
A(n) = (n − 1) + n · i=1(A(i − 1) + A(n − i)).
Das ist genau die gleiche Rekursion wie die für Cn!
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
43
Abschnitt 4.2 in Kap. 4, Folien 32–37 :
Rekursionsformel für die mittlere totale Weglänge A(n) in
zufällig erzeugten binären Suchbäumen.
A(0) = A(1) = 0, A(2) = 1,
Pn
1
A(n) = (n − 1) + n · i=1(A(i − 1) + A(n − i)).
Das ist genau die gleiche Rekursion wie die für Cn!
Bemerkung: Dies ist kein Zufall, sondern es besteht eine enge Verbindung der beiden Verfahren Quicksort und Erzeugen von Suchbäumen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
43
Abschnitt 4.2 in Kap. 4, Folien 32–37 :
Rekursionsformel für die mittlere totale Weglänge A(n) in
zufällig erzeugten binären Suchbäumen.
A(0) = A(1) = 0, A(2) = 1,
Pn
1
A(n) = (n − 1) + n · i=1(A(i − 1) + A(n − i)).
Das ist genau die gleiche Rekursion wie die für Cn!
Bemerkung: Dies ist kein Zufall, sondern es besteht eine enge Verbindung der beiden Verfahren Quicksort und Erzeugen von Suchbäumen.
Also sind auch die Lösungen identisch.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
43
Satz 6.3.4
Die erwartete Vergleichsanzahl bei der Anwendung von Quicksort auf ein Array mit n verschiedenen Einträgen, die zufällig
angeordnet sind, ist
2(n + 1)Hn − 4n ≈ (2 ln 2)n log n − 2,846 . . . n.
Dabei ist 2 ln 2 ≈ 1,386 (die Quicksort-Konstante“).
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
44
Bemerkung:
Dieselbe Aussage gilt für die randomisierte Version, bei der
das Pivotelement zufällig gewählt wird,
und zwar für jedes beliebige feste Eingabearray A[1 . . n].
Randomisierung
Quicksort.
FG KTuEA, TU Ilmenau
verhindert
worst-case-Eingaben
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
bei
45
Bemerkung:
Dieselbe Aussage gilt für die randomisierte Version, bei der
das Pivotelement zufällig gewählt wird,
und zwar für jedes beliebige feste Eingabearray A[1 . . n].
Randomisierung
Quicksort.
verhindert
worst-case-Eingaben
bei
Bemerkung:
Eine O(n log n)-Laufzeit stellt sich bei (randomisiertem)
Quicksort sogar mit hoher Wahrscheinlichkeit ein.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
45
Bemerkung:
Dieselbe Aussage gilt für die randomisierte Version, bei der
das Pivotelement zufällig gewählt wird,
und zwar für jedes beliebige feste Eingabearray A[1 . . n].
Randomisierung
Quicksort.
verhindert
worst-case-Eingaben
bei
Bemerkung:
Eine O(n log n)-Laufzeit stellt sich bei (randomisiertem)
Quicksort sogar mit hoher Wahrscheinlichkeit ein.
( Zuverlässigkeitsaussage“.)
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
45
Bemerkungen:
• Quicksort ist in der Praxis sehr schnell.
(Partition-Prozedur ist auch Cache-freundlich.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
46
Bemerkungen:
• Quicksort ist in der Praxis sehr schnell.
(Partition-Prozedur ist auch Cache-freundlich.)
• Vermeide rekursive Aufrufe für allzu kleine Teilarrays:
besser direkt mit StraightInsertionSort sortieren.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
46
Bemerkungen:
• Quicksort ist in der Praxis sehr schnell.
(Partition-Prozedur ist auch Cache-freundlich.)
• Vermeide rekursive Aufrufe für allzu kleine Teilarrays:
besser direkt mit StraightInsertionSort sortieren.
• Warnung 1: Wenn A[1 . . n] teilweise sortiert ist, und man das Pivotelement naiv wählt, erhält man schlechte Laufzeiten. (Bis zu Ω(n2).)
Abhilfe: Clever Quicksort oder Randomisiertes Quicksort.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
46
Bemerkungen:
• Quicksort ist in der Praxis sehr schnell.
(Partition-Prozedur ist auch Cache-freundlich.)
• Vermeide rekursive Aufrufe für allzu kleine Teilarrays:
besser direkt mit StraightInsertionSort sortieren.
• Warnung 1: Wenn A[1 . . n] teilweise sortiert ist, und man das Pivotelement naiv wählt, erhält man schlechte Laufzeiten. (Bis zu Ω(n2).)
Abhilfe: Clever Quicksort oder Randomisiertes Quicksort.
• Warnung 2: Wenn A[1 . . n] (viele) identische Schlüssel enthält, ist das
beschriebene Verfahren nicht günstig.
Einfache Abhilfe: Ersetze Schlüssel A[i].key durch das Paar
(A[i].key,i), und sortiere lexikographisch mit randomisiertem
Quicksort.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
46
Bemerkungen:
• Quicksort ist nicht stabil.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
47
Bemerkungen:
• Quicksort ist nicht stabil.
• Platz (für den Rekursionsstack) kann im schlechtesten Fall bis zu O(n)
groß werden.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
47
Bemerkungen:
• Quicksort ist nicht stabil.
• Platz (für den Rekursionsstack) kann im schlechtesten Fall bis zu O(n)
groß werden.
Ausweg: Formuliere r qsort um, so dass Rekursion nur für das kleinere
der beiden Teilarray angewendet wird.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
47
Bemerkungen:
• Quicksort ist nicht stabil.
• Platz (für den Rekursionsstack) kann im schlechtesten Fall bis zu O(n)
groß werden.
Ausweg: Formuliere r qsort um, so dass Rekursion nur für das kleinere
der beiden Teilarray angewendet wird.
Das größere wird in einer Iteration weiterbehandelt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
47
Bemerkungen:
• Quicksort ist nicht stabil.
• Platz (für den Rekursionsstack) kann im schlechtesten Fall bis zu O(n)
groß werden.
Ausweg: Formuliere r qsort um, so dass Rekursion nur für das kleinere
der beiden Teilarray angewendet wird.
Das größere wird in einer Iteration weiterbehandelt.
Effekt: Deutlich weniger Prozeduraufrufe.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
47
Bemerkungen:
• Quicksort ist nicht stabil.
• Platz (für den Rekursionsstack) kann im schlechtesten Fall bis zu O(n)
groß werden.
Ausweg: Formuliere r qsort um, so dass Rekursion nur für das kleinere
der beiden Teilarray angewendet wird.
Das größere wird in einer Iteration weiterbehandelt.
Effekt: Deutlich weniger Prozeduraufrufe.
Rekursionsstack hat höchstens Tiefe log n – fast in situ“.
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
47
Prozedur hr qsort(a, b)
FG KTuEA, TU Ilmenau
// Halb-rekursive Variante
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
48
Prozedur hr qsort(a, b) // Halb-rekursive Variante
(1)
a ← a; b ← b;
(2)
while a < b do
(3)
s ← ein (z.B. zufälliges) Element von {a, . . . , b};
(4)
vertausche A[a] und A[s];
(5)
partition(a, b, p);
(6)
if p − a < b − p then
(7)
if a < p − 1 then hr qsort(a, p − 1);
(8)
a ← p + 1;
// while-Schleife bearbeitet rechtes Teilarray weiter
(9)
else // p − a ≥ b − p
(10)
if p + 1 < b then hr qsort(p + 1, b);
(11)
b ← p − 1;
// while-Schleife bearbeitet linkes Teilarray weiter
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
48
6.4 Heapsort
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
49
6.4 Heapsort
Heap-Ordnung in Binärbäumen:
Beispiel:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
49
6.4 Heapsort
Heap-Ordnung in Binärbäumen:
Beispiel:
3
min:
10
4
5
12
FG KTuEA, TU Ilmenau
10
3
5
12
12
12
12
3
12
17
max:
17
3
4
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
49
6.4 Heapsort
Heap-Ordnung in Binärbäumen:
Beispiel:
3
min:
10
4
5
12
10
3
5
12
12
12
12
3
12
17
max:
17
3
4
Hier nur interne Knoten relevant.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
49
6.4 Heapsort
Heap-Ordnung in Binärbäumen:
Beispiel:
3
min:
10
4
5
12
10
3
5
12
12
12
12
3
12
17
max:
17
3
4
Hier nur interne Knoten relevant.
Blätter: Knoten ohne (interne) Kinder.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
49
Definition 6.4.1
Ein Binärbaum T mit Knotenbeschriftungen m(v) aus (U, <)
heißt min-heapgeordnet (kurz oft: heapgeordnet),
wenn für alle Knoten v und w gilt:
v Vorgänger von w ⇒ m(v) ≤ m(w).
B
E
F
G
N
FG KTuEA, TU Ilmenau
E
P
H
F
N
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
50
B
E
F
G
N
E
P
H
F
N
Beachte: T heapgeordnet ⇒ in Knoten v steht der minimale
Eintrag des Teilbaums Tv mit Wurzel v.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
51
B
E
F
G
N
E
P
H
F
N
Beachte: T heapgeordnet ⇒ in Knoten v steht der minimale
Eintrag des Teilbaums Tv mit Wurzel v.
(T heißt max-heapgeordnet, wenn für jeden Knoten v gilt:
v Vorgänger von w ⇒ m(v) ≥ m(w).)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
51
Ein linksvollständiger“ Binärbaum:
”
Alle Levels j = 0, 1, . . . voll (jeweils 2j Knoten) bis auf das
tiefste.
Das tiefste Level l hat von links her gesehen eine ununterbrochene Folge von Knoten.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
52
Nummerierung von Knoten in unendlichem, vollständigen
Binärbaum
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
53
Nummerierung von Knoten in unendlichem, vollständigen
Binärbaum gemäß Leveldurchlauf-Anordnung:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
53
Nummerierung von Knoten in unendlichem, vollständigen
Binärbaum gemäß Leveldurchlauf-Anordnung:
1
1
0
2
0
1
1
0
1
1
0
0
11
10
9
7
6
0
1
1
0
5
8
0
3
4
0
1
0
1
12
0
1
14
13
1
0
1
0
1
0
15
0
1
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0
32
FG KTuEA, TU Ilmenau
1
1
46 47
63
0
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
53
Nummerierung von Knoten in unendlichem, vollständigen
Binärbaum gemäß Breitendurchlauf-Anordnung:
Beispiel:
(101110)2 = 46
1
1
0
2
0
1
1
0
1
1
0
0
11
10
9
7
6
0
1
1
0
5
8
0
3
4
0
1
0
1
12
0
1
14
13
1
0
1
0
1
0
15
0
1
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0
32
FG KTuEA, TU Ilmenau
1
1
46 47
63
0
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
53
Ist s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von der
Wurzel zu Knoten i auf Level l, so ist 1s1 · · · sl die Binärdarstellung von i.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
54
Ist s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von der
Wurzel zu Knoten i auf Level l, so ist 1s1 · · · sl die Binärdarstellung von i.
Knoten 1 ist die Wurzel;
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
54
Ist s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von der
Wurzel zu Knoten i auf Level l, so ist 1s1 · · · sl die Binärdarstellung von i.
Knoten 1 ist die Wurzel;
Knoten 2i ist linkes Kind von i;
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
54
Ist s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von der
Wurzel zu Knoten i auf Level l, so ist 1s1 · · · sl die Binärdarstellung von i.
Knoten 1 ist die Wurzel;
Knoten 2i ist linkes Kind von i;
Knoten 2i + 1 ist rechtes Kind von i;
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
54
Ist s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von der
Wurzel zu Knoten i auf Level l, so ist 1s1 · · · sl die Binärdarstellung von i.
Knoten
Knoten
Knoten
Knoten
1 ist die Wurzel;
2i ist linkes Kind von i;
2i + 1 ist rechtes Kind von i;
i ≥ 2 hat Vorgänger bi/2c.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
54
Ist s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von der
Wurzel zu Knoten i auf Level l, so ist 1s1 · · · sl die Binärdarstellung von i.
Knoten
Knoten
Knoten
Knoten
1 ist die Wurzel;
2i ist linkes Kind von i;
2i + 1 ist rechtes Kind von i;
i ≥ 2 hat Vorgänger bi/2c.
Damit: Array-Darstellung für linksvollständige Binärbaume:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
54
Ist s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von der
Wurzel zu Knoten i auf Level l, so ist 1s1 · · · sl die Binärdarstellung von i.
Knoten
Knoten
Knoten
Knoten
1 ist die Wurzel;
2i ist linkes Kind von i;
2i + 1 ist rechtes Kind von i;
i ≥ 2 hat Vorgänger bi/2c.
Damit: Array-Darstellung für linksvollständige Binärbaume:
Speichere Einträge in Knoten i ∈ {1, . . . , n} in Arrayposition
A[i].
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
54
Ist s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von der
Wurzel zu Knoten i auf Level l, so ist 1s1 · · · sl die Binärdarstellung von i.
Knoten
Knoten
Knoten
Knoten
1 ist die Wurzel;
2i ist linkes Kind von i;
2i + 1 ist rechtes Kind von i;
i ≥ 2 hat Vorgänger bi/2c.
Damit: Array-Darstellung für linksvollständige Binärbaume:
Speichere Einträge in Knoten i ∈ {1, . . . , n} in Arrayposition
A[i].
Spart den Platz für die Zeiger!
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
54
Kombiniere Heapbedingung, Array-Darstellung, Daten:
Definition 6.4.2
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
55
Kombiniere Heapbedingung, Array-Darstellung, Daten:
Definition 6.4.2 Sei (U, <) Totalordnung.
Ein (Teil-)Array A[1 . . k] mit Einträgen aus U × D
heißt ein Min-Heap (oder Heap),
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
55
Kombiniere Heapbedingung, Array-Darstellung, Daten:
Definition 6.4.2 Sei (U, <) Totalordnung.
Ein (Teil-)Array A[1 . . k] mit Einträgen aus U × D
heißt ein Min-Heap (oder Heap), wenn der entsprechende
linksvollständige Binärbaum mit k Knoten
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
55
Kombiniere Heapbedingung, Array-Darstellung, Daten:
Definition 6.4.2 Sei (U, <) Totalordnung.
Ein (Teil-)Array A[1 . . k] mit Einträgen aus U × D
heißt ein Min-Heap (oder Heap), wenn der entsprechende
linksvollständige Binärbaum mit k Knoten
(Knoten i mit A[i].key ∈ U und A[i].data ∈ D beschriftet)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
55
Kombiniere Heapbedingung, Array-Darstellung, Daten:
Definition 6.4.2 Sei (U, <) Totalordnung.
Ein (Teil-)Array A[1 . . k] mit Einträgen aus U × D
heißt ein Min-Heap (oder Heap), wenn der entsprechende
linksvollständige Binärbaum mit k Knoten
(Knoten i mit A[i].key ∈ U und A[i].data ∈ D beschriftet)
bezüglich der key-Komponenten (min-)heapgeordnet ist,
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
55
Kombiniere Heapbedingung, Array-Darstellung, Daten:
Definition 6.4.2 Sei (U, <) Totalordnung.
Ein (Teil-)Array A[1 . . k] mit Einträgen aus U × D
heißt ein Min-Heap (oder Heap), wenn der entsprechende
linksvollständige Binärbaum mit k Knoten
(Knoten i mit A[i].key ∈ U und A[i].data ∈ D beschriftet)
bezüglich der key-Komponenten (min-)heapgeordnet ist,
d. h., wenn für 1 < i ≤ k gilt: A[bi/2c].key ≤ A[i].key.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
55
Kombiniere Heapbedingung, Array-Darstellung, Daten:
Definition 6.4.2 Sei (U, <) Totalordnung.
Ein (Teil-)Array A[1 . . k] mit Einträgen aus U × D
heißt ein Min-Heap (oder Heap), wenn der entsprechende
linksvollständige Binärbaum mit k Knoten
(Knoten i mit A[i].key ∈ U und A[i].data ∈ D beschriftet)
bezüglich der key-Komponenten (min-)heapgeordnet ist,
d. h., wenn für 1 < i ≤ k gilt: A[bi/2c].key ≤ A[i].key.
Die zweite Definition erwähnt den (gedachten) Binärbaum nicht mehr
explizit.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
55
Kombiniere Heapbedingung, Array-Darstellung, Daten:
Definition 6.4.2 Sei (U, <) Totalordnung.
Ein (Teil-)Array A[1 . . k] mit Einträgen aus U × D
heißt ein Min-Heap (oder Heap), wenn der entsprechende
linksvollständige Binärbaum mit k Knoten
(Knoten i mit A[i].key ∈ U und A[i].data ∈ D beschriftet)
bezüglich der key-Komponenten (min-)heapgeordnet ist,
d. h., wenn für 1 < i ≤ k gilt: A[bi/2c].key ≤ A[i].key.
Die zweite Definition erwähnt den (gedachten) Binärbaum nicht mehr
explizit.
(Analog: Max-Heap (benutze Maxheap-Ordnung).)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
55
Beispiel: U = {A, B, C, . . . , Z} mit der Standardordnung.
Daten weggelassen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
56
Beispiel: U = {A, B, C, . . . , Z} mit der Standardordnung.
Daten weggelassen.
Ein Min-Heap und der zugeordnete Baum (k = 10):
1
2
3
4
5
6
7
8
9
10
B
E
F
G
E
H
F
H
I
G
11
12
* *
1
B
2
3
E
F
4
5
E
G
8
6
7
H
F
9 10
H
FG KTuEA, TU Ilmenau
I
G
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
56
Aufgabe: Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
G
E
F
G
E
H
F
H
I
* * *
1
G
2
3
E
F
5
4
E
G
8
6
7
H
F
9
H
I
Beobachte: Wenn man den Wurzelschlüssel G z. B. durch C
ersetzt, entsteht ein Heap.
Definition: Höchstens A[j] ist zu groß :⇔
es gibt einen Schlüssel x ≤ A[j].key, so dass ein Heap
entsteht, wenn man A[j].key durch x ersetzt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
56
Aufgabe: Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
C
E
F
G
E
H
F
H
I
* * *
1
C
2
3
F
E
4
5
E
G
8
6
7
H
F
9
H
I
Beobachte: Wenn man den Wurzelschlüssel G z. B. durch C
ersetzt, entsteht ein Heap.
Definition: Höchstens A[j] ist zu groß :⇔
es gibt einen Schlüssel x ≤ A[j].key, so dass ein Heap
entsteht, wenn man A[j].key durch x ersetzt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
56
Aufgabe: Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
G
E
F
G
E
H
F
H
I
* * *
1
G
2
3
E
F
5
4
E
G
8
6
7
H
F
9
H
I
Beobachte: Wenn man den Wurzelschlüssel G z. B. durch C
ersetzt, entsteht ein Heap.
Definition: Höchstens A[j] ist zu groß :⇔
es gibt einen Schlüssel x ≤ A[j].key, so dass ein Heap
entsteht, wenn man A[j].key durch x ersetzt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
57
Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
G
E
F
G
E
H
F
H
I
* * *
1
G
2
3
E
5
4
E
G
8
F
?
6
7
H
F
9
H
I
Höchstens A[1] ist zu groß: 1 ist aktueller Knoten“.
”
Vergleich der beiden Kinder des aktuellen Knotens.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
58
Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
G
E
F
G
E
H
F
H
I
* * *
1
G
2
3
E
5
4
E
G
8
F
<
6
7
H
F
9
H
I
Höchstens A[1] ist zu groß: 1 ist aktueller Knoten“.
”
Vergleich der beiden Kinder des aktuellen Knotens.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
58
Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
G
E
F
G
E
H
F
H
I
* * *
1
G
?
2
3
E
5
4
E
G
8
F
<
6
7
H
F
9
H
I
Vergleich des kleineren“ Kinds mit dem aktuellen Knoten.
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
58
Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
G
E
F
G
E
H
F
H
I
* * *
1
G
<
2
3
E
5
4
E
G
8
F
<
6
7
H
F
9
H
I
Vergleich des kleineren“ Kinds mit dem aktuellen Knoten.
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
58
Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
E
G
F
G
E
H
F
H
I
* * *
1
E
2
3
F
G
4
5
E
G
8
6
7
H
F
9
H
I
Falls kleiner:
Vertauschen des kleineren“ Kinds mit dem aktuellen Knoten.
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
58
Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
E
G
F
G
E
H
F
H
I
* * *
1
E
2
3
F
G
4
5
E
G
8
6
7
H
F
9
H
I
Falls kleiner:
Vertauschen des kleineren“ Kinds mit dem aktuellen Knoten.
”
Nun: Höchstens A[2] ist zu groß.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
58
Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
E
G
F
G
E
H
F
H
I
* * *
1
E
2
3
F
G
4
5
E
G
8
6
7
H
F
9
H
I
Falls kleiner:
Vertauschen des kleineren“ Kinds mit dem aktuellen Knoten.
”
Nun: Höchstens A[2] ist zu groß. (Ersetze G durch E!)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
58
Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
E
G
F
G
E
H
F
H
I
* * *
1
E
2
3
G
F
>
4
5
G
>
8
E
6
7
H
F
9
H
I
Vergleich des kleineren“ Kinds mit dem aktuellen Knoten.
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
58
Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
E
E
F
G
G
H
F
H
I
* * *
1
E
2
3
F
E
5
4
G
G
8
6
7
H
F
9
H
I
Vertauschen des kleineren“ Kinds mit dem aktuellen Knoten.
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
58
Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
E
E
F
G
G
H
F
H
I
* * *
1
E
2
3
F
E
5
4
G
G
8
6
7
H
F
9
H
I
Vertauschen des kleineren“ Kinds mit dem aktuellen Knoten.
”
Höchstens A[5] ist zu groß.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
58
Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
E
E
F
G
G
H
F
H
I
* * *
1
E
2
3
F
E
5
4
G
G
8
6
7
H
F
9
H
I
Vertauschen des kleineren“ Kinds mit dem aktuellen Knoten.
”
Höchstens A[5] ist zu groß.
Aber Knoten 5 hat keine Kinder.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
58
Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
E
E
F
G
G
H
F
H
I
* * *
1
E
2
3
F
E
5
4
G
G
8
6
7
H
F
9
H
I
Kein Fehler mehr: Reparatur beendet.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
58
Heaps reparieren
11
12
1
2
3
4
5
6
7
8
9
10
E
E
F
G
G
H
F
H
I
* * *
1
E
2
3
F
E
5
4
G
G
8
6
7
H
F
9
H
I
Kein Fehler mehr: Reparatur beendet.
Andere Möglichkeit für Ende: Eintrag im aktuellen Knoten ist
nicht größer als der im kleineren Kind“.
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
58
bubbleDown(1, k) // Heap-Reparatur in A[1 . . k]
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
59
bubbleDown(1, k) // Heap-Reparatur in A[1 . . k]
// Vorbedingung: Höchstens A[1] ist zu groß
(1)
j ← 1; done ← (2 ∗ j > k);
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
59
bubbleDown(1, k) // Heap-Reparatur in A[1 . . k]
// Vorbedingung: Höchstens A[1] ist zu groß
(1)
j ← 1; done ← (2 ∗ j > k);
(2)
while not done do
// (∗) höchstens A[j] ist zu groß, A[j] hat Kind A[2 ∗ j] im Baum
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
59
bubbleDown(1, k) // Heap-Reparatur in A[1 . . k]
// Vorbedingung: Höchstens A[1] ist zu groß
(1)
j ← 1; done ← (2 ∗ j > k);
(2)
while not done do
// (∗) höchstens A[j] ist zu groß, A[j] hat Kind A[2 ∗ j] im Baum
(3)
m ← 2 ∗ j;
(4)
if m + 1 ≤ k and A[m+1].key < A[m].key
(5)
then m ← m + 1; // A[m] ist einziges oder kleineres“ Kind
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
59
bubbleDown(1, k) // Heap-Reparatur in A[1 . . k]
// Vorbedingung: Höchstens A[1] ist zu groß
(1)
j ← 1; done ← (2 ∗ j > k);
(2)
while not done do
// (∗) höchstens A[j] ist zu groß, A[j] hat Kind A[2 ∗ j] im Baum
(3)
m ← 2 ∗ j;
(4)
if m + 1 ≤ k and A[m+1].key < A[m].key
(5)
then m ← m + 1; // A[m] ist einziges oder kleineres“ Kind
”
(6)
if A[m].key < A[j].key
(7)
then vertausche A[j] mit A[m]; j ← m; done ← (2 ∗ j > k);
(8)
// wenn done = false, dann gilt wieder (∗)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
59
bubbleDown(1, k) // Heap-Reparatur in A[1 . . k]
// Vorbedingung: Höchstens A[1] ist zu groß
(1)
j ← 1; done ← (2 ∗ j > k);
(2)
while not done do
// (∗) höchstens A[j] ist zu groß, A[j] hat Kind A[2 ∗ j] im Baum
(3)
m ← 2 ∗ j;
(4)
if m + 1 ≤ k and A[m+1].key < A[m].key
(5)
then m ← m + 1; // A[m] ist einziges oder kleineres“ Kind
”
(6)
if A[m].key < A[j].key
(7)
then vertausche A[j] mit A[m]; j ← m; done ← (2 ∗ j > k);
(8)
// wenn done = false, dann gilt wieder (∗)
(9)
else done ← true. // fertig, kein Fehler mehr.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
59
Korrektheit:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
60
Korrektheit:
Wir behaupten: Wenn höchstens A[1] zu groß ist und bubbleDown(1, k)
durchgeführt wird, dann entsteht ein Heap.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
60
Korrektheit:
Wir behaupten: Wenn höchstens A[1] zu groß ist und bubbleDown(1, k)
durchgeführt wird, dann entsteht ein Heap.
Dazu zeigen wir folgende Behauptung durch Induktion über die
Schleifendurchläufe:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
60
Korrektheit:
Wir behaupten: Wenn höchstens A[1] zu groß ist und bubbleDown(1, k)
durchgeführt wird, dann entsteht ein Heap.
Dazu zeigen wir folgende Behauptung durch Induktion über die
Schleifendurchläufe:
(IBj )
Zu Beginn des Durchlaufs, in dem j die Zahl j enthält, ist
höchstens A[j] zu groß.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
60
Korrektheit:
Wir behaupten: Wenn höchstens A[1] zu groß ist und bubbleDown(1, k)
durchgeführt wird, dann entsteht ein Heap.
Dazu zeigen wir folgende Behauptung durch Induktion über die
Schleifendurchläufe:
(IBj )
Zu Beginn des Durchlaufs, in dem j die Zahl j enthält, ist
höchstens A[j] zu groß.
Wir formulieren den Beweis in der Baum-Sprechweise.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
60
Korrektheit:
Wir behaupten: Wenn höchstens A[1] zu groß ist und bubbleDown(1, k)
durchgeführt wird, dann entsteht ein Heap.
Dazu zeigen wir folgende Behauptung durch Induktion über die
Schleifendurchläufe:
(IBj )
Zu Beginn des Durchlaufs, in dem j die Zahl j enthält, ist
höchstens A[j] zu groß.
Wir formulieren den Beweis in der Baum-Sprechweise.
Der Ind.-Anfang (j = 1) gilt nach Voraussetzung.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
60
Betrachte Schleifendurchlauf für Knoten j.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
61
Betrachte Schleifendurchlauf für Knoten j.
1. Fall: In Zeile (7) wird A[j] mit A[2j] vertauscht.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
61
Betrachte Schleifendurchlauf für Knoten j.
1. Fall: In Zeile (7) wird A[j] mit A[2j] vertauscht.
Es seien u, v, w die Schlüssel in A[j], A[2j] bzw. A[2j + 1] vor der
Vertauschung. Nach (IBj ) können wir ein x ≤ u wählen, so dass
(∗)
FG KTuEA, TU Ilmenau
ein Heap entsteht, wenn man u durch x ersetzt.
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
61
Betrachte Schleifendurchlauf für Knoten j.
1. Fall: In Zeile (7) wird A[j] mit A[2j] vertauscht.
Es seien u, v, w die Schlüssel in A[j], A[2j] bzw. A[2j + 1] vor der
Vertauschung. Nach (IBj ) können wir ein x ≤ u wählen, so dass
(∗)
ein Heap entsteht, wenn man u durch x ersetzt.
Wissen nach Algorithmus: v ≤ w und v < u.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
61
Betrachte Schleifendurchlauf für Knoten j.
1. Fall: In Zeile (7) wird A[j] mit A[2j] vertauscht.
Es seien u, v, w die Schlüssel in A[j], A[2j] bzw. A[2j + 1] vor der
Vertauschung. Nach (IBj ) können wir ein x ≤ u wählen, so dass
(∗)
ein Heap entsteht, wenn man u durch x ersetzt.
Wissen nach Algorithmus: v ≤ w und v < u.
Nach der Vertauschung steht u in A[2j] und v in A[j].
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
61
Betrachte Schleifendurchlauf für Knoten j.
1. Fall: In Zeile (7) wird A[j] mit A[2j] vertauscht.
Es seien u, v, w die Schlüssel in A[j], A[2j] bzw. A[2j + 1] vor der
Vertauschung. Nach (IBj ) können wir ein x ≤ u wählen, so dass
(∗)
ein Heap entsteht, wenn man u durch x ersetzt.
Wissen nach Algorithmus: v ≤ w und v < u.
Nach der Vertauschung steht u in A[2j] und v in A[j]. Wir behaupten,
dass ein Heap entsteht, wenn wir A[2j].key durch v ersetzen.
(Weil v < u, liefert das (IB2j ).)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
61
z
x u
2j
FG KTuEA, TU Ilmenau
v
j
w
2j+1
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
62
z
z
x u
2j
FG KTuEA, TU Ilmenau
v
j
j/2
v
w
2j+1
2j
u v
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
j
w
2j+1
62
z
z
x u
2j
v
j
j/2
v
w
2j+1
2j
u v
j
w
2j+1
Dazu müssen wir wegen (∗) nur die Beziehung der Schlüssel in Knoten
j und 2j untereinander und zu Kindern und Vorgängern betrachten (rote
Kanten).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
62
z
z
x u
2j
v
j
j/2
v
w
2j+1
2j
u v
j
w
2j+1
Dazu müssen wir wegen (∗) nur die Beziehung der Schlüssel in Knoten
j und 2j untereinander und zu Kindern und Vorgängern betrachten (rote
Kanten). Knoten j und 2j haben den gleichen Eintrag v.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
62
z
z
x u
2j
v
j
j/2
v
w
2j+1
2j
u v
j
w
2j+1
Dazu müssen wir wegen (∗) nur die Beziehung der Schlüssel in Knoten
j und 2j untereinander und zu Kindern und Vorgängern betrachten (rote
Kanten). Knoten j und 2j haben den gleichen Eintrag v.
(1) Falls j > 1, gilt für den Schlüssel z im Vaterknoten bj/2c von j:
z ≤ x ≤ v (nach (∗)).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
62
z
z
x u
2j
v
j
j/2
v
w
2j+1
2j
u v
j
w
2j+1
Dazu müssen wir wegen (∗) nur die Beziehung der Schlüssel in Knoten
j und 2j untereinander und zu Kindern und Vorgängern betrachten (rote
Kanten). Knoten j und 2j haben den gleichen Eintrag v.
(1) Falls j > 1, gilt für den Schlüssel z im Vaterknoten bj/2c von j:
z ≤ x ≤ v (nach (∗)).
(2) v ≤ Schlüssel in Kindknoten von 2j (nach (∗));
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
62
z
z
x u
2j
v
j
j/2
v
w
2j+1
2j
u v
j
w
2j+1
Dazu müssen wir wegen (∗) nur die Beziehung der Schlüssel in Knoten
j und 2j untereinander und zu Kindern und Vorgängern betrachten (rote
Kanten). Knoten j und 2j haben den gleichen Eintrag v.
(1) Falls j > 1, gilt für den Schlüssel z im Vaterknoten bj/2c von j:
z ≤ x ≤ v (nach (∗)).
(2) v ≤ Schlüssel in Kindknoten von 2j (nach (∗));
(3) v ≤ w (wurde verglichen).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
62
2. Fall: In Zeile (7) wird A[j] mit A[2j + 1] vertauscht: analog.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
63
2. Fall: In Zeile (7) wird A[j] mit A[2j + 1] vertauscht: analog.
Nach einer Reihe von Schleifendurchläufen endet die Schleife mit j in
j, weil Knoten j keine Kinder hat oder die Schlüssel in den Kindern
≥ u = A[j].key sind.
Nach der Behauptung von eben gilt (IBj ).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
63
2. Fall: In Zeile (7) wird A[j] mit A[2j + 1] vertauscht: analog.
Nach einer Reihe von Schleifendurchläufen endet die Schleife mit j in
j, weil Knoten j keine Kinder hat oder die Schlüssel in den Kindern
≥ u = A[j].key sind.
Nach der Behauptung von eben gilt (IBj ).
Sei x ≤ u so gewählt, dass ein Heap entsteht, wenn man u durch x
ersetzt. Dann ist aber auch A[1 . . k] ohne diese Ersetzung ein Heap, weil
die Schlüssel in den Kindern von Knoten j nicht kleiner als u sind und im
Fall j > 1 der Schlüssel im Vaterknoten bj/2c nicht größer als x, also erst
recht nicht größer als u ist.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
63
Kosten: Der Inhalt j der Variablen j ist anfangs 1 und verdoppelt sich
in jeder Runde (mindestens); ein Schleifendurchlauf findet nur statt, wenn
2j ≤ k ist.
Daher: Wenn es s Durchläufe durch die while-Schleife gibt, muss 2s ≤ n
sein, d. h. s ≤ log k.
Kosten: O(log k), bei nicht mehr als 2 log k Vergleichen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
64
Kosten: Der Inhalt j der Variablen j ist anfangs 1 und verdoppelt sich
in jeder Runde (mindestens); ein Schleifendurchlauf findet nur statt, wenn
2j ≤ k ist.
Daher: Wenn es s Durchläufe durch die while-Schleife gibt, muss 2s ≤ n
sein, d. h. s ≤ log k.
Kosten: O(log k), bei nicht mehr als 2 log k Vergleichen.
Wir haben damit gezeigt:
Lemma 6.4.3
Wenn anfangs höchstens A[1] zu groß ist, stellt bubbleDown(1, k) die Heapeigenschaft her. Die Prozedur führt
maximal 2 log k Vergleiche durch und hat Laufzeit O(log k).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
64
Die Idee von Heapsort für ein Array A[1..n] ist nun folgende:
1. (Heapaufbau) Arrangiere A[1..n] so um, dass ein Heap
entsteht.
2. (Auswahlphase) Für k von n abwärts bis 2:
Entnimm kleinsten Eintrag A[1] aus dem Heap A[1..k].
Stelle mit den in A[2..k] verbliebenen Einträgen in A[1..k −1]
wieder einen Heap her.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
65
Die Idee von Heapsort für ein Array A[1..n] ist nun folgende:
1. (Heapaufbau) Arrangiere A[1..n] so um, dass ein Heap
entsteht.
2. (Auswahlphase) Für k von n abwärts bis 2:
Entnimm kleinsten Eintrag A[1] aus dem Heap A[1..k].
Stelle mit den in A[2..k] verbliebenen Einträgen in A[1..k −1]
wieder einen Heap her.
(In A[k] ist dann Platz für den entnommenen Eintrag.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
65
Die Idee von Heapsort für ein Array A[1..n] ist nun folgende:
1. (Heapaufbau) Arrangiere A[1..n] so um, dass ein Heap
entsteht.
2. (Auswahlphase) Für k von n abwärts bis 2:
Entnimm kleinsten Eintrag A[1] aus dem Heap A[1..k].
Stelle mit den in A[2..k] verbliebenen Einträgen in A[1..k −1]
wieder einen Heap her.
(In A[k] ist dann Platz für den entnommenen Eintrag.)
Dadurch werden die Arrayeinträge in steigender Reihenfolge
entnommen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
65
Die Idee von Heapsort für ein Array A[1..n] ist nun folgende:
1. (Heapaufbau) Arrangiere A[1..n] so um, dass ein Heap
entsteht.
2. (Auswahlphase) Für k von n abwärts bis 2:
Entnimm kleinsten Eintrag A[1] aus dem Heap A[1..k].
Stelle mit den in A[2..k] verbliebenen Einträgen in A[1..k −1]
wieder einen Heap her.
(In A[k] ist dann Platz für den entnommenen Eintrag.)
Dadurch werden die Arrayeinträge in steigender Reihenfolge
entnommen.
Wenn wir den in Runde k entnommenen Eintrag in A[k]
speichern, ist am Ende das Array A[1..n] fallend sortiert.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
65
Auswahlphase als Programm:
Prozedur HeapSelect(1, n)
(1) for k from n downto 3 do
// in A[1] steht das Minimum von A[1..k]
(2)
vertausche A[1] mit A[k];
// in A[1..k − 1] ist höchstens A[1] zu groß
(3)
bubbleDown(1, k − 1); // Heapreparatur
// A[1..2] ist Heap, also A[1] ≤ A[2]
(4) vertausche A[1] mit A[2].
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
C
E
F
G
E
H
F
H
I
* * *
1
C
2
3
F
E
4
5
E
G
8
6
7
H
F
9
H
I
Ein Heap: A[1..9].
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
I
E
F
G
E
H
F
H
C
* * *
1
I
2
3
F
E
5
4
G
E
6
7
H
F
8
H
Minimum nach A[9], altes A[9] in die Wurzel.
In A[1..8] höchstens A[1] zu groß.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
E
E
F
G
I
H
F
H
C
* * *
1
I
2
3
F
E
5
4
G
E
6
7
H
F
8
H
Von bubbleDown verfolgter Weg.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
E
E
F
G
I
H
F
H
C
* * *
1
E
2
3
F
E
4
5
G
I
6
7
H
F
8
H
Nach bubbleDown.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
E
E
F
G
I
H
F
H
C
* * *
1
E
2
3
F
E
4
5
G
I
6
7
H
F
8
H
A[1..8] ist Heap.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
H
E
F
G
I
H
F
E
C
* * *
1
H
2
3
F
E
5
4
G
I
6
7
H
F
Minimum nach A[8], altes A[8] in die Wurzel.
In A[1..7] höchstens A[1] zu groß.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
H
E
F
G
I
H
F
E
C
* * *
1
H
2
3
F
E
5
4
G
I
6
7
H
F
Von bubbleDown verfolgter Weg.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
E
G
F
H
I
H
F
E
C
* * *
1
E
2
3
F
G
5
4
H
I
6
7
H
F
Nach bubbleDown.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
E
G
F
H
I
H
F
E
C
* * *
1
E
2
3
F
G
5
4
H
I
6
7
H
F
A[1..7] ist Heap.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
F
G
F
H
I
H
E
E
C
* * *
1
F
2
3
G
F
4
5
H
I
6
H
Minimum nach A[7], altes A[7] in die Wurzel.
In A[1..6] höchstens A[1] zu groß.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
F
G
F
H
I
H
E
E
C
* * *
1
F
2
3
G
F
4
5
H
I
6
H
Von bubbleDown verfolgter Weg.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
F
G
F
H
I
H
E
E
C
* * *
1
F
2
3
G
F
4
5
H
I
6
H
A[1..6] ist Heap.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
H
G
F
H
I
F
E
E
C
* * *
1
H
2
3
G
F
4
5
H
I
Minimum nach A[6], altes A[6] in die Wurzel.
In A[1..5] höchstens A[1] zu groß.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
H
G
F
H
I
F
E
E
C
* * *
1
H
2
3
F
G
4
5
H
I
Von bubbleDown verfolgter Weg.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
F
G
H
H
I
F
E
E
C
* * *
1
F
2
3
H
G
4
5
H
I
Nach bubbleDown.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
F
G
H
H
I
F
E
E
C
* * *
1
F
2
3
G
H
4
5
H
I
A[1..5] ist Heap.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
I
G
H
H
F
F
E
E
C
* * *
1
I
2
3
G
H
4
H
Minimum nach A[5], altes A[5] in die Wurzel.
In A[1..4] höchstens A[1] zu groß.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
I
G
H
H
F
F
E
E
C
* * *
1
I
2
3
G
H
4
H
Von bubbleDown verfolgter Weg.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
G
H
H
I
F
F
E
E
C
* * *
1
G
2
3
H
H
4
I
Nach bubbleDown.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
G
H
H
I
F
F
E
E
C
* * *
1
G
2
3
H
H
4
I
A[1..4] ist Heap.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
I
H
H
G
F
F
E
E
C
* * *
1
I
2
3
H
H
Minimum nach A[4], altes A[4] in die Wurzel.
In A[1..3] höchstens A[1] zu groß.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
I
H
H
G
F
F
E
E
C
* * *
1
I
2
3
H
H
Von bubbleDown verfolgter Weg.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
H
I
H
G
F
F
E
E
C
* * *
1
H
2
3
I
H
Nach bubbleDown.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
H
I
H
G
F
F
E
E
C
* * *
1
H
2
3
I
H
A[1..3] ist Heap.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
H
I
H
G
F
F
E
E
C
* * *
1
H
2
I
Minimum nach A[3], altes A[3] in die Wurzel.
In A[1..2] höchstens A[1] zu groß.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
H
I
H
G
F
F
E
E
C
* * *
1
H
2
I
Von bubbleDown verfolgter Weg.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
H
I
H
G
F
F
E
E
C
* * *
1
H
2
I
A[1..2] ist Heap.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Auswahlphase
11
12
1
2
3
4
5
6
7
8
9
10
I
H
H
G
F
F
E
E
C
* * *
Vertauschen von A[1] und A[2] vollendet fallende Sortierung.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
66
Satz 6.4.4
Die Prozedur HeapSelect(1, n) führt höchstens 2n log n Vergleiche durch und hat Rechenzeit O(n log n).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
67
Satz 6.4.4
Die Prozedur HeapSelect(1, n) führt höchstens 2n log n Vergleiche durch und hat Rechenzeit O(n log n).
Beweis:
Anzahl Vergleiche: höchstens
FG KTuEA, TU Ilmenau
P
2≤k≤n 2 log k
< 2n log n.
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
67
Satz 6.4.4
Die Prozedur HeapSelect(1, n) führt höchstens 2n log n Vergleiche durch und hat Rechenzeit O(n log n).
Beweis:
P
Anzahl Vergleiche: höchstens 2≤k≤n 2 log k < 2n log n.
P
Kosten:
2≤k≤n (O(1) + O(log k))
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
67
Satz 6.4.4
Die Prozedur HeapSelect(1, n) führt höchstens 2n log n Vergleiche durch und hat Rechenzeit O(n log n).
Beweis:
P
Anzahl Vergleiche: höchstens 2≤k≤n 2 log k < 2n log n.
P
Kosten:
2≤k≤n (O(1) + O(log k)) = O(n) + O(n log n) = O(n log n).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
67
. . . und wie verwandelt man A[1 . . n] in einen Heap?
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
68
. . . und wie verwandelt man A[1 . . n] in einen Heap?
Beispiel: Teil eines linksvollständigen Binärbaums, der einem
Teilheap“ A[3 . . 10] entspricht:
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
68
. . . und wie verwandelt man A[1 . . n] in einen Heap?
Beispiel: Teil eines linksvollständigen Binärbaums, der einem
Teilheap“ A[3 . . 10] entspricht:
”
Teilheap
D P A B R MN K L T E F G
D
A
P
R
B
K
FG KTuEA, TU Ilmenau
L
T
N
M
E
F
G
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
68
Definition 6.4.5
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
69
Definition 6.4.5
Das Teilarray A[` . . k] von A[1 . . n]
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
69
Definition 6.4.5
Das Teilarray A[` . . k] von A[1 . . n] (1 ≤ ` ≤ k ≤ n)
heißt ein Teilheap, falls innerhalb“ des Teilarrays die
”
Heapeigenschaft gilt, d. h.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
69
Definition 6.4.5
Das Teilarray A[` . . k] von A[1 . . n] (1 ≤ ` ≤ k ≤ n)
heißt ein Teilheap, falls innerhalb“ des Teilarrays die
”
Heapeigenschaft gilt, d. h. wenn für alle i mit 2` ≤ i ≤ k
gilt:
HE(bi/2c, i) :⇔ A[bi/2c] ≤ A[i].
Klar: Ein Teilheap ist die disjunkte Vereinigung von
heapgeordneten Bäumen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
69
Idee: Wenn A[` + 1 . . k] ein Teilheap ist, dann ist in dem
Teilbaum T`,k mit Wurzel ` und Knoten in {`, . . . , k} die
Heapbedingung höchstens in ` verletzt, d. h. höchstens der
Schlüssel in Knoten ` ist zu groß.
Wir können mit einer Variante von bubbleDown in diesem
Teilbaum die Heapbedingung herstellen.
Prozedur bubbleDown(`, k) // Heapreparatur in T`,k
(1)
j ← `; done ← (2 ∗ j > k);
(2)
while not done do
(3) . . .
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
70
Lemma 6.4.6
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
71
Lemma 6.4.6
Wenn A[` + 1..k] Teilheap ist, dann ist nach Ausführung
von bubbleDown(`, k) das Teilarray A[`..k] Teilheap. Die
Anzahl der Vergleiche ist nicht größer als 2 log(k/`), die
Laufzeit O(log(k/`)).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
71
Lemma 6.4.6
Wenn A[` + 1..k] Teilheap ist, dann ist nach Ausführung
von bubbleDown(`, k) das Teilarray A[`..k] Teilheap. Die
Anzahl der Vergleiche ist nicht größer als 2 log(k/`), die
Laufzeit O(log(k/`)).
Beweis: Korrektheit wie bei Lemma 6.4.3.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
71
Lemma 6.4.6
Wenn A[` + 1..k] Teilheap ist, dann ist nach Ausführung
von bubbleDown(`, k) das Teilarray A[`..k] Teilheap. Die
Anzahl der Vergleiche ist nicht größer als 2 log(k/`), die
Laufzeit O(log(k/`)).
Beweis: Korrektheit wie bei Lemma 6.4.3.
Anzahl Schlüsselvergleiche ähnlich wie bei Lemma 6.4.3:
Wenn es in bubbleDown(`, k) s Schleifendurchläufe gibt,
muss 2s · ` ≤ k sein, d. h. s ≤ log(k/`). Also gibt es maximal
2 log(k/`) Vergleiche bei einem Zeitaufwand von O(log(k/`)).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
71
Prozedur makeHeap(1, n)
// Transformiert Array A[1 . . n] in einen Heap
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
72
Prozedur makeHeap(1, n)
// Transformiert Array A[1 . . n] in einen Heap
(1) for l from bn/2c downto 1 do
(2)
// stelle in A[l..n] Heapbedingung her!
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
72
Prozedur makeHeap(1, n)
// Transformiert Array A[1 . . n] in einen Heap
(1) for l from bn/2c downto 1 do
(2)
// stelle in A[l..n] Heapbedingung her!
(3)
bubbleDown(l, n);
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
72
Prozedur makeHeap(1, n)
// Transformiert Array A[1 . . n] in einen Heap
(1) for l from bn/2c downto 1 do
(2)
// stelle in A[l..n] Heapbedingung her!
(3)
bubbleDown(l, n);
Lemma 6.4.7
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
72
Prozedur makeHeap(1, n)
// Transformiert Array A[1 . . n] in einen Heap
(1) for l from bn/2c downto 1 do
(2)
// stelle in A[l..n] Heapbedingung her!
(3)
bubbleDown(l, n);
Lemma 6.4.7
Ein Aufruf makeHeap(1, n) wandelt A[1..n] in einen Heap
um. Die Anzahl der Vergleiche ist nicht größer als 2n; die
Rechenzeit ist O(n).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
72
Prozedur makeHeap(1, n)
// Transformiert Array A[1 . . n] in einen Heap
(1) for l from bn/2c downto 1 do
(2)
// stelle in A[l..n] Heapbedingung her!
(3)
bubbleDown(l, n);
Lemma 6.4.7
Ein Aufruf makeHeap(1, n) wandelt A[1..n] in einen Heap
um. Die Anzahl der Vergleiche ist nicht größer als 2n; die
Rechenzeit ist O(n).
Beweis der Korrektheit:
Mit Induktion über ` = bn/2c, bn/2c − 1, . . . , 2, 1 zeige:
Nach Durchlauf mit ` in l ist A[` . . n] Teilheap.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
72
Kosten: Anzahl der Vergleiche:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
73
Kosten: Anzahl der Vergleiche:
X
2·
blog(n/`)c
1≤`≤n/2
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
73
Kosten: Anzahl der Vergleiche:
X
2·
blog(n/`)c
1≤`≤n/2
= 2·
X
1≤`≤n/2
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
73
Kosten: Anzahl der Vergleiche:
X
2·
blog(n/`)c
1≤`≤n/2
= 2·
X
X
1
1≤`≤n/2 j : `·2j ≤n
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
73
Kosten: Anzahl der Vergleiche:
X
2·
blog(n/`)c
1≤`≤n/2
= 2·
X
X
1
1≤`≤n/2 j : `·2j ≤n
= 2·
X
1≤j≤log n
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
73
Kosten: Anzahl der Vergleiche:
X
2·
blog(n/`)c
1≤`≤n/2
= 2·
X
X
1
1≤`≤n/2 j : `·2j ≤n
= 2·
X
X
1
1≤j≤log n 1≤`≤n/2j
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
73
Kosten: Anzahl der Vergleiche:
X
2·
blog(n/`)c
1≤`≤n/2
= 2·
X
X
1
1≤`≤n/2 j : `·2j ≤n
= 2·
X
X
1
1≤j≤log n 1≤`≤n/2j
≤ 2·
X
1≤j≤log n
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
73
Kosten: Anzahl der Vergleiche:
X
2·
blog(n/`)c
1≤`≤n/2
= 2·
X
X
1
1≤`≤n/2 j : `·2j ≤n
= 2·
X
X
1
1≤j≤log n 1≤`≤n/2j
≤ 2·
X
1≤j≤log n
FG KTuEA, TU Ilmenau
n
2j
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
73
Kosten: Anzahl der Vergleiche:
X
2·
blog(n/`)c
1≤`≤n/2
= 2·
X
X
1
1≤`≤n/2 j : `·2j ≤n
= 2·
X
X
1
1≤j≤log n 1≤`≤n/2j
≤ 2·
X
1≤j≤log n
FG KTuEA, TU Ilmenau
n
< 2n ·
j
2
X
1≤j≤log n
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
73
Kosten: Anzahl der Vergleiche:
X
2·
blog(n/`)c
1≤`≤n/2
= 2·
X
X
1
1≤`≤n/2 j : `·2j ≤n
= 2·
X
X
1
1≤j≤log n 1≤`≤n/2j
≤ 2·
X
1≤j≤log n
FG KTuEA, TU Ilmenau
n
< 2n ·
j
2
X
1≤j≤log n
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
1
2j
73
Kosten: Anzahl der Vergleiche:
X
2·
blog(n/`)c
1≤`≤n/2
= 2·
X
X
1
1≤`≤n/2 j : `·2j ≤n
= 2·
X
X
1
1≤j≤log n 1≤`≤n/2j
≤ 2·
X
1≤j≤log n
n
< 2n ·
j
2
(Geometrische Reihe:
FG KTuEA, TU Ilmenau
X
1≤j≤log n
1
2j
−j
2
= 1.)
j≥1
P
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
73
Kosten: Anzahl der Vergleiche:
X
2·
blog(n/`)c
1≤`≤n/2
X
= 2·
X
1
1≤`≤n/2 j : `·2j ≤n
X
= 2·
X
1
1≤j≤log n 1≤`≤n/2j
X
≤ 2·
1≤j≤log n
n
< 2n ·
j
2
(Geometrische Reihe:
X
1≤j≤log n
1
2j
−j
2
= 1.)
j≥1
P
< 2n.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
73
Algorithmus HeapSort(A[1 . . n])
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
74
Algorithmus HeapSort(A[1 . . n])
(1) makeHeap(1, n);
(2) HeapSelect(1, n);
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
74
Algorithmus HeapSort(A[1 . . n])
(1) makeHeap(1, n);
(2) HeapSelect(1, n);
Satz 6.4.8
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
74
Algorithmus HeapSort(A[1 . . n])
(1) makeHeap(1, n);
(2) HeapSelect(1, n);
Satz 6.4.8
Algorithmus HeapSort sortiert das Array A[1 . . n] in fallende
Reihenfolge.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
74
Algorithmus HeapSort(A[1 . . n])
(1) makeHeap(1, n);
(2) HeapSelect(1, n);
Satz 6.4.8
Algorithmus HeapSort sortiert das Array A[1 . . n] in fallende
Reihenfolge. Die gesamte Laufzeit ist O(n log n), die Gesamtzahl der Vergleiche ist kleiner als 2n(log n + 1), für genügend
große n.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
74
Algorithmus HeapSort(A[1 . . n])
(1) makeHeap(1, n);
(2) HeapSelect(1, n);
Satz 6.4.8
Algorithmus HeapSort sortiert das Array A[1 . . n] in fallende
Reihenfolge. Die gesamte Laufzeit ist O(n log n), die Gesamtzahl der Vergleiche ist kleiner als 2n(log n + 1), für genügend
große n. HeapSort arbeitet in situ (ist aber nicht stabil).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
74
Algorithmus HeapSort(A[1 . . n])
(1) makeHeap(1, n);
(2) HeapSelect(1, n);
Satz 6.4.8
Algorithmus HeapSort sortiert das Array A[1 . . n] in fallende
Reihenfolge. Die gesamte Laufzeit ist O(n log n), die Gesamtzahl der Vergleiche ist kleiner als 2n(log n + 1), für genügend
große n. HeapSort arbeitet in situ (ist aber nicht stabil).
Beweis: Korrektheit
Teilprozeduren.
FG KTuEA, TU Ilmenau
und
Zeitbedarf
folgt
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
aus
der
Analyse
der
74
Algorithmus HeapSort(A[1 . . n])
(1) makeHeap(1, n);
(2) HeapSelect(1, n);
Satz 6.4.8
Algorithmus HeapSort sortiert das Array A[1 . . n] in fallende
Reihenfolge. Die gesamte Laufzeit ist O(n log n), die Gesamtzahl der Vergleiche ist kleiner als 2n(log n + 1), für genügend
große n. HeapSort arbeitet in situ (ist aber nicht stabil).
Beweis: Korrektheit und Zeitbedarf folgt aus der Analyse der
Teilprozeduren. Die Gesamtzahl der Vergleiche ist nach der Analyse von
HeapSelect und Lemma 6.4.7 höchstens:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
74
Algorithmus HeapSort(A[1 . . n])
(1) makeHeap(1, n);
(2) HeapSelect(1, n);
Satz 6.4.8
Algorithmus HeapSort sortiert das Array A[1 . . n] in fallende
Reihenfolge. Die gesamte Laufzeit ist O(n log n), die Gesamtzahl der Vergleiche ist kleiner als 2n(log n + 1), für genügend
große n. HeapSort arbeitet in situ (ist aber nicht stabil).
Beweis: Korrektheit und Zeitbedarf folgt aus der Analyse der
Teilprozeduren. Die Gesamtzahl der Vergleiche ist nach der Analyse von
HeapSelect und Lemma 6.4.7 höchstens:
P
P
2n + 2≤k≤n 2 log k ≤ 2n + 2 · 2≤k≤n log k
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
74
Algorithmus HeapSort(A[1 . . n])
(1) makeHeap(1, n);
(2) HeapSelect(1, n);
Satz 6.4.8
Algorithmus HeapSort sortiert das Array A[1 . . n] in fallende
Reihenfolge. Die gesamte Laufzeit ist O(n log n), die Gesamtzahl der Vergleiche ist kleiner als 2n(log n + 1), für genügend
große n. HeapSort arbeitet in situ (ist aber nicht stabil).
Beweis: Korrektheit und Zeitbedarf folgt aus der Analyse der
Teilprozeduren. Die Gesamtzahl der Vergleiche ist nach der Analyse von
HeapSelect und Lemma 6.4.7 höchstens:
P
P
2n + 2≤k≤n 2 log k ≤ 2n + 2 · 2≤k≤n log k ≤ 2n + 2n log n.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
74
Algorithmus HeapSort(A[1 . . n])
(1) makeHeap(1, n);
(2) HeapSelect(1, n);
Satz 6.4.8
Algorithmus HeapSort sortiert das Array A[1 . . n] in fallende
Reihenfolge. Die gesamte Laufzeit ist O(n log n), die Gesamtzahl der Vergleiche ist kleiner als 2n(log n + 1), für genügend
große n. HeapSort arbeitet in situ (ist aber nicht stabil).
Beweis: Korrektheit und Zeitbedarf folgt aus der Analyse der
Teilprozeduren. Die Gesamtzahl der Vergleiche ist nach der Analyse von
HeapSelect und Lemma 6.4.7 höchstens:
P
P
2n + 2≤k≤n 2 log k ≤ 2n + 2 · 2≤k≤n log k ≤ 2n + 2n log n.
Bemerkung: Man kann sogar zeigen: < 2n log n Vergleiche.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
74
Bemerkung 1: Wenn Sortierung in aufsteigende Reihenfolge
gewünscht wird, ersetze in allen Prozeduren und Programmen
Schlüsselvergleiche A[i] ≤ A[j]“ durch A[i] ≥ A[j]“ und
”
”
umgekehrt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
75
Bemerkung 1: Wenn Sortierung in aufsteigende Reihenfolge
gewünscht wird, ersetze in allen Prozeduren und Programmen
Schlüsselvergleiche A[i] ≤ A[j]“ durch A[i] ≥ A[j]“ und
”
”
umgekehrt.
Die in A[1 . . n] entstehende Struktur heißt ein Max-Heap
– in der Wurzel des Binärbaumes steht immer das Maximum.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
75
Bemerkung 1: Wenn Sortierung in aufsteigende Reihenfolge
gewünscht wird, ersetze in allen Prozeduren und Programmen
Schlüsselvergleiche A[i] ≤ A[j]“ durch A[i] ≥ A[j]“ und
”
”
umgekehrt.
Die in A[1 . . n] entstehende Struktur heißt ein Max-Heap
– in der Wurzel des Binärbaumes steht immer das Maximum.
Bemerkung 2: Die mittlere Anzahl von Vergleichen,
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
75
Bemerkung 1: Wenn Sortierung in aufsteigende Reihenfolge
gewünscht wird, ersetze in allen Prozeduren und Programmen
Schlüsselvergleiche A[i] ≤ A[j]“ durch A[i] ≥ A[j]“ und
”
”
umgekehrt.
Die in A[1 . . n] entstehende Struktur heißt ein Max-Heap
– in der Wurzel des Binärbaumes steht immer das Maximum.
Bemerkung 2: Die mittlere Anzahl von Vergleichen, unter
der Annahme, dass jede Anordnung der Eingabeobjekte in
A[1 . . n] dieselbe Wahrscheinlichkeit 1/n! hat,
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
75
Bemerkung 1: Wenn Sortierung in aufsteigende Reihenfolge
gewünscht wird, ersetze in allen Prozeduren und Programmen
Schlüsselvergleiche A[i] ≤ A[j]“ durch A[i] ≥ A[j]“ und
”
”
umgekehrt.
Die in A[1 . . n] entstehende Struktur heißt ein Max-Heap
– in der Wurzel des Binärbaumes steht immer das Maximum.
Bemerkung 2: Die mittlere Anzahl von Vergleichen, unter
der Annahme, dass jede Anordnung der Eingabeobjekte in
A[1 . . n] dieselbe Wahrscheinlichkeit 1/n! hat,
ist 2n log n − O(n).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
75
Bemerkung 1: Wenn Sortierung in aufsteigende Reihenfolge
gewünscht wird, ersetze in allen Prozeduren und Programmen
Schlüsselvergleiche A[i] ≤ A[j]“ durch A[i] ≥ A[j]“ und
”
”
umgekehrt.
Die in A[1 . . n] entstehende Struktur heißt ein Max-Heap
– in der Wurzel des Binärbaumes steht immer das Maximum.
Bemerkung 2: Die mittlere Anzahl von Vergleichen, unter
der Annahme, dass jede Anordnung der Eingabeobjekte in
A[1 . . n] dieselbe Wahrscheinlichkeit 1/n! hat,
ist 2n log n − O(n).
Bemerkung 3: Variante Bottom-Up-Heapsort“ hat n log n + O(n)
”
Vergleiche im mittleren Fall.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
75
Bemerkung 1: Wenn Sortierung in aufsteigende Reihenfolge
gewünscht wird, ersetze in allen Prozeduren und Programmen
Schlüsselvergleiche A[i] ≤ A[j]“ durch A[i] ≥ A[j]“ und
”
”
umgekehrt.
Die in A[1 . . n] entstehende Struktur heißt ein Max-Heap
– in der Wurzel des Binärbaumes steht immer das Maximum.
Bemerkung 2: Die mittlere Anzahl von Vergleichen, unter
der Annahme, dass jede Anordnung der Eingabeobjekte in
A[1 . . n] dieselbe Wahrscheinlichkeit 1/n! hat,
ist 2n log n − O(n).
Bemerkung 3: Variante Bottom-Up-Heapsort“ hat n log n + O(n)
”
Vergleiche im mittleren Fall. – Idee: Bei bubbleDown laufe gesamten
Weg der kleineren Kinder“ bis zum Blatt, ziehe die kleineren Kinder“
”
”
um eine Ebene nach oben und füge dann das kritische Element aus der
Wurzel von unten nach oben an die richtige Stelle ein.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
75
Bemerkung 4: Bei Variante 4-Way-Heapsort“ hat jeder Kno”
ten i ≥ 1 vier Kinder, nämlich 4i − 2, 4i − 1, 4i, 4i + 1
(soweit ≤ n).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
76
Bemerkung 4: Bei Variante 4-Way-Heapsort“ hat jeder Kno”
ten i ≥ 1 vier Kinder, nämlich 4i − 2, 4i − 1, 4i, 4i + 1
(soweit ≤ n).
Die Heapbedingung wird verallgemeinert:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
76
Bemerkung 4: Bei Variante 4-Way-Heapsort“ hat jeder Kno”
ten i ≥ 1 vier Kinder, nämlich 4i − 2, 4i − 1, 4i, 4i + 1
(soweit ≤ n).
Die Heapbedingung wird verallgemeinert:
A[i] ≤ A[4i − 2], A[4i − 1], A[4i], A[4i + 1],
für i ≥ 1, soweit die Indizes ≤ n sind.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
76
Bemerkung 4: Bei Variante 4-Way-Heapsort“ hat jeder Kno”
ten i ≥ 1 vier Kinder, nämlich 4i − 2, 4i − 1, 4i, 4i + 1
(soweit ≤ n).
Die Heapbedingung wird verallgemeinert:
A[i] ≤ A[4i − 2], A[4i − 1], A[4i], A[4i + 1],
für i ≥ 1, soweit die Indizes ≤ n sind.
Bei bubbleDown:
Vertauschen mit dem kleinsten Kind-Eintrag, wenn nötig.
(Insgesamt 4 Vergleiche pro Ebene.).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
76
Bemerkung 4: Bei Variante 4-Way-Heapsort“ hat jeder Kno”
ten i ≥ 1 vier Kinder, nämlich 4i − 2, 4i − 1, 4i, 4i + 1
(soweit ≤ n).
Die Heapbedingung wird verallgemeinert:
A[i] ≤ A[4i − 2], A[4i − 1], A[4i], A[4i + 1],
für i ≥ 1, soweit die Indizes ≤ n sind.
Bei bubbleDown:
Vertauschen mit dem kleinsten Kind-Eintrag, wenn nötig.
(Insgesamt 4 Vergleiche pro Ebene.).
Vorteil: Baum hat nur Tiefe log4 n = 12 log n.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
76
Bemerkung 4: Bei Variante 4-Way-Heapsort“ hat jeder Kno”
ten i ≥ 1 vier Kinder, nämlich 4i − 2, 4i − 1, 4i, 4i + 1
(soweit ≤ n).
Die Heapbedingung wird verallgemeinert:
A[i] ≤ A[4i − 2], A[4i − 1], A[4i], A[4i + 1],
für i ≥ 1, soweit die Indizes ≤ n sind.
Bei bubbleDown:
Vertauschen mit dem kleinsten Kind-Eintrag, wenn nötig.
(Insgesamt 4 Vergleiche pro Ebene.).
Vorteil: Baum hat nur Tiefe log4 n = 12 log n.
Bei Bubble-Down Zugriff nur auf 12 log n Bereiche im Array:
halb so viele Cache-Fehler, daher schneller.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
76
6.5 Datenstruktur: Prioritätswarteschlange
oder
Vorrangwarteschlangen
Idee: (Daten mit) Schlüssel aus sortiertem Universum (U, <)
werden eingefügt und entnommen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
77
6.5 Datenstruktur: Prioritätswarteschlange
oder
Vorrangwarteschlangen
Idee: (Daten mit) Schlüssel aus sortiertem Universum (U, <)
werden eingefügt und entnommen.
Beim Entnehmen wird immer ein Eintrag mit minimalem
Schlüssel gewählt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
77
6.5 Datenstruktur: Prioritätswarteschlange
oder
Vorrangwarteschlangen
Idee: (Daten mit) Schlüssel aus sortiertem Universum (U, <)
werden eingefügt und entnommen.
Beim Entnehmen wird immer ein Eintrag mit minimalem
Schlüssel gewählt.
Schlüssel =
b Prioritäten“
”
– je kleiner der Schlüssel, desto höher die Priorität –
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
77
6.5 Datenstruktur: Prioritätswarteschlange
oder
Vorrangwarteschlangen
Idee: (Daten mit) Schlüssel aus sortiertem Universum (U, <)
werden eingefügt und entnommen.
Beim Entnehmen wird immer ein Eintrag mit minimalem
Schlüssel gewählt.
Schlüssel =
b Prioritäten“
”
– je kleiner der Schlüssel, desto höher die Priorität –
Wähle stets einen Eintrag mit höchster Priorität.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
77
6.5 Datenstruktur: Prioritätswarteschlange
oder
Vorrangwarteschlangen
Idee: (Daten mit) Schlüssel aus sortiertem Universum (U, <)
werden eingefügt und entnommen.
Beim Entnehmen wird immer ein Eintrag mit minimalem
Schlüssel gewählt.
Schlüssel =
b Prioritäten“
”
– je kleiner der Schlüssel, desto höher die Priorität –
Wähle stets einen Eintrag mit höchster Priorität.
Mit Heaps effizient zu realisieren!
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
77
Anwendungen:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
78
Anwendungen:
1) Prozessverwaltung in Multitask-System
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
78
Anwendungen:
1) Prozessverwaltung in Multitask-System
Jeder Prozess hat einen Namen (eine ID“) und eine Priorität
”
(Zahl in N).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
78
Anwendungen:
1) Prozessverwaltung in Multitask-System
Jeder Prozess hat einen Namen (eine ID“) und eine Priorität
”
(Zahl in N).
(Üblich: kleinere Zahlen bedeuten höhere Prioritäten.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
78
Anwendungen:
1) Prozessverwaltung in Multitask-System
Jeder Prozess hat einen Namen (eine ID“) und eine Priorität
”
(Zahl in N).
(Üblich: kleinere Zahlen bedeuten höhere Prioritäten.)
Aktuell rechenbereite Prozesse befinden sich in der Prozesswarteschlange. Bei Freiwerden eines Prozessors (z. B. durch
Unterbrechen eines Prozesses) wird einer der Prozesse mit
höchster Priorität aus der Warteschlange entnommen und
weiter ausgeführt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
78
Anwendungen:
2) Discrete Event Simulation“
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
79
Anwendungen:
2) Discrete Event Simulation“
”
System von Aktionen soll auf dem Rechner simuliert werden.
Jeder ausführbaren Aktion A ist ein Zeitpunkt tA ∈ [0, ∞)
zugeordnet.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
79
Anwendungen:
2) Discrete Event Simulation“
”
System von Aktionen soll auf dem Rechner simuliert werden.
Jeder ausführbaren Aktion A ist ein Zeitpunkt tA ∈ [0, ∞)
zugeordnet.
Die Ausführung einer Aktion A kann neue Aktionen A0 erzeugen oder ausführbar machen, mit neuen Zeitpunkten tA0 > tA.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
79
Anwendungen:
2) Discrete Event Simulation“
”
System von Aktionen soll auf dem Rechner simuliert werden.
Jeder ausführbaren Aktion A ist ein Zeitpunkt tA ∈ [0, ∞)
zugeordnet.
Die Ausführung einer Aktion A kann neue Aktionen A0 erzeugen oder ausführbar machen, mit neuen Zeitpunkten tA0 > tA.
Ein Schritt: Wähle diejenige noch nicht ausgeführte Aktion
mit dem frühesten Ausführungszeitpunkt und führe sie aus.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
79
Anwendungen:
2) Discrete Event Simulation“
”
System von Aktionen soll auf dem Rechner simuliert werden.
Jeder ausführbaren Aktion A ist ein Zeitpunkt tA ∈ [0, ∞)
zugeordnet.
Die Ausführung einer Aktion A kann neue Aktionen A0 erzeugen oder ausführbar machen, mit neuen Zeitpunkten tA0 > tA.
Ein Schritt: Wähle diejenige noch nicht ausgeführte Aktion
mit dem frühesten Ausführungszeitpunkt und führe sie aus.
3) (Noch etwas erweitert:) Innerhalb von Algorithmen
(Huffman-Codes, Dijkstra, Jarnı́k/Prim: später).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
79
Bei Prioritätswarteschlangen zu berücksichtigen:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
80
Bei Prioritätswarteschlangen zu berücksichtigen:
Einträge sind nicht blanke“ Schlüssel, sondern
”
mit Prioritäten versehene Datensätze.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
80
Bei Prioritätswarteschlangen zu berücksichtigen:
Einträge sind nicht blanke“ Schlüssel, sondern
”
mit Prioritäten versehene Datensätze.
Mehrere Objekte mit derselben Priorität sind möglich.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
80
Bei Prioritätswarteschlangen zu berücksichtigen:
Einträge sind nicht blanke“ Schlüssel, sondern
”
mit Prioritäten versehene Datensätze.
Mehrere Objekte mit derselben Priorität sind möglich.
Sogar: Mehrere identische Objekte sind möglich,
die man nicht identifizieren darf.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
80
Bei Prioritätswarteschlangen zu berücksichtigen:
Einträge sind nicht blanke“ Schlüssel, sondern
”
mit Prioritäten versehene Datensätze.
Mehrere Objekte mit derselben Priorität sind möglich.
Sogar: Mehrere identische Objekte sind möglich,
die man nicht identifizieren darf.
Beim Entnehmen: Alle Exemplare des kleinsten Schlüssels
gleichberechtigt, einer gewinnt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
80
Beispiel: Datensatz: (n, L), n ∈ N,
L ∈ {A, . . . , Z}, Schlüssel ist der Buchstabe L.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
81
Beispiel: Datensatz: (n, L), n ∈ N,
L ∈ {A, . . . , Z}, Schlüssel ist der Buchstabe L.
Operation
empty
FG KTuEA, TU Ilmenau
innerer Zustand
∅
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
81
Beispiel: Datensatz: (n, L), n ∈ N,
L ∈ {A, . . . , Z}, Schlüssel ist der Buchstabe L.
Operation
empty
isempty
FG KTuEA, TU Ilmenau
innerer Zustand
∅
∅
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
true
81
Beispiel: Datensatz: (n, L), n ∈ N,
L ∈ {A, . . . , Z}, Schlüssel ist der Buchstabe L.
Operation
empty
isempty
insert(1, D)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
∅
{(1, D)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
true
–
81
Beispiel: Datensatz: (n, L), n ∈ N,
L ∈ {A, . . . , Z}, Schlüssel ist der Buchstabe L.
Operation
empty
isempty
insert(1, D)
insert(2, B)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
∅
{(1, D)}
{(1, D), (2, B)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
true
–
–
81
Beispiel: Datensatz: (n, L), n ∈ N,
L ∈ {A, . . . , Z}, Schlüssel ist der Buchstabe L.
Operation
empty
isempty
insert(1, D)
insert(2, B)
insert(3, D)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
∅
{(1, D)}
{(1, D), (2, B)}
{(1, D), (2, B), (3, D)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
true
–
–
–
81
Beispiel: Datensatz: (n, L), n ∈ N,
L ∈ {A, . . . , Z}, Schlüssel ist der Buchstabe L.
Operation
empty
isempty
insert(1, D)
insert(2, B)
insert(3, D)
insert(4, E)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
∅
{(1, D)}
{(1, D), (2, B)}
{(1, D), (2, B), (3, D)}
{(1, D), (2, B), (3, D), (4, E)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
true
–
–
–
–
81
Beispiel: Datensatz: (n, L), n ∈ N,
L ∈ {A, . . . , Z}, Schlüssel ist der Buchstabe L.
Operation
empty
isempty
insert(1, D)
insert(2, B)
insert(3, D)
insert(4, E)
insert(5, G)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
∅
{(1, D)}
{(1, D), (2, B)}
{(1, D), (2, B), (3, D)}
{(1, D), (2, B), (3, D), (4, E)}
{(1, D), (2, B), (3, D), (4, E), (5, G)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
true
–
–
–
–
–
81
Beispiel: Datensatz: (n, L), n ∈ N,
L ∈ {A, . . . , Z}, Schlüssel ist der Buchstabe L.
Operation
empty
isempty
insert(1, D)
insert(2, B)
insert(3, D)
insert(4, E)
insert(5, G)
extractMin
FG KTuEA, TU Ilmenau
innerer Zustand
∅
∅
{(1, D)}
{(1, D), (2, B)}
{(1, D), (2, B), (3, D)}
{(1, D), (2, B), (3, D), (4, E)}
{(1, D), (2, B), (3, D), (4, E), (5, G)}
{(1, D), (3, D), (4, E), (5, G)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
true
–
–
–
–
–
(2, B)
81
Beispiel: Datensatz: (n, L), n ∈ N,
L ∈ {A, . . . , Z}, Schlüssel ist der Buchstabe L.
Operation
empty
isempty
insert(1, D)
insert(2, B)
insert(3, D)
insert(4, E)
insert(5, G)
extractMin
extractMin
FG KTuEA, TU Ilmenau
innerer Zustand
∅
∅
{(1, D)}
{(1, D), (2, B)}
{(1, D), (2, B), (3, D)}
{(1, D), (2, B), (3, D), (4, E)}
{(1, D), (2, B), (3, D), (4, E), (5, G)}
{(1, D), (3, D), (4, E), (5, G)}
{(1, D), (4, E), (5, G)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
true
–
–
–
–
–
(2, B)
(3, D)
81
Beispiel: Datensatz: (n, L), n ∈ N,
L ∈ {A, . . . , Z}, Schlüssel ist der Buchstabe L.
Operation
empty
isempty
insert(1, D)
insert(2, B)
insert(3, D)
insert(4, E)
insert(5, G)
extractMin
extractMin
insert(4, E)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
∅
{(1, D)}
{(1, D), (2, B)}
{(1, D), (2, B), (3, D)}
{(1, D), (2, B), (3, D), (4, E)}
{(1, D), (2, B), (3, D), (4, E), (5, G)}
{(1, D), (3, D), (4, E), (5, G)}
{(1, D), (4, E), (5, G)}
{(1, D), (4, E), (5, G), (4, E)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
true
–
–
–
–
–
(2, B)
(3, D)
–
81
Beispiel: Datensatz: (n, L), n ∈ N,
L ∈ {A, . . . , Z}, Schlüssel ist der Buchstabe L.
Operation
empty
isempty
insert(1, D)
insert(2, B)
insert(3, D)
insert(4, E)
insert(5, G)
extractMin
extractMin
insert(4, E)
insert(2, D)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
∅
{(1, D)}
{(1, D), (2, B)}
{(1, D), (2, B), (3, D)}
{(1, D), (2, B), (3, D), (4, E)}
{(1, D), (2, B), (3, D), (4, E), (5, G)}
{(1, D), (3, D), (4, E), (5, G)}
{(1, D), (4, E), (5, G)}
{(1, D), (4, E), (5, G), (4, E)}
{(1, D), (4, E), (5, G), (4, E), (2, D)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
true
–
–
–
–
–
(2, B)
(3, D)
–
–
81
Beispiel: Datensatz: (n, L), n ∈ N,
L ∈ {A, . . . , Z}, Schlüssel ist der Buchstabe L.
Operation
empty
isempty
insert(1, D)
insert(2, B)
insert(3, D)
insert(4, E)
insert(5, G)
extractMin
extractMin
insert(4, E)
insert(2, D)
extractMin
FG KTuEA, TU Ilmenau
innerer Zustand
∅
∅
{(1, D)}
{(1, D), (2, B)}
{(1, D), (2, B), (3, D)}
{(1, D), (2, B), (3, D), (4, E)}
{(1, D), (2, B), (3, D), (4, E), (5, G)}
{(1, D), (3, D), (4, E), (5, G)}
{(1, D), (4, E), (5, G)}
{(1, D), (4, E), (5, G), (4, E)}
{(1, D), (4, E), (5, G), (4, E), (2, D)}
{(1, D), (4, E), (5, G), (4, E)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
true
–
–
–
–
–
(2, B)
(3, D)
–
–
(2, D)
81
Beispiel: Datensatz: (n, L), n ∈ N,
L ∈ {A, . . . , Z}, Schlüssel ist der Buchstabe L.
Operation
empty
isempty
insert(1, D)
insert(2, B)
insert(3, D)
insert(4, E)
insert(5, G)
extractMin
extractMin
insert(4, E)
insert(2, D)
extractMin
isempty
FG KTuEA, TU Ilmenau
innerer Zustand
∅
∅
{(1, D)}
{(1, D), (2, B)}
{(1, D), (2, B), (3, D)}
{(1, D), (2, B), (3, D), (4, E)}
{(1, D), (2, B), (3, D), (4, E), (5, G)}
{(1, D), (3, D), (4, E), (5, G)}
{(1, D), (4, E), (5, G)}
{(1, D), (4, E), (5, G), (4, E)}
{(1, D), (4, E), (5, G), (4, E), (2, D)}
{(1, D), (4, E), (5, G), (4, E)}
{(1, D), (4, E), (5, G), (4, E)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
true
–
–
–
–
–
(2, B)
(3, D)
–
–
(2, D)
false
81
Datentyp: SimplePriorityQueue
(Einfache Prioritätswarteschlange)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
82
Datentyp: SimplePriorityQueue
(Einfache Prioritätswarteschlange)
Signatur:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
82
Datentyp: SimplePriorityQueue
(Einfache Prioritätswarteschlange)
Signatur:
Sorten:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
82
Datentyp: SimplePriorityQueue
(Einfache Prioritätswarteschlange)
Signatur:
Sorten:
Keys
Data
PrioQ // Priority Queues“
”
Boolean
Operatoren:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
82
Datentyp: SimplePriorityQueue
(Einfache Prioritätswarteschlange)
Signatur:
Sorten:
Keys
Data
PrioQ // Priority Queues“
”
Boolean
Operatoren:
empty : → PrioQ
isempty : PrioQ → Boolean
insert : Keys × Data × PrioQ → PrioQ
extractMin: PrioQ → Keys × Data × PrioQ
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
82
Mathematisches Modell:
Sorten:
Keys
: (U, <) // totalgeordnetes Universum“
”
∗
Multimenge: Elemente dürfen mehrfach vorkommen, wie z. B. in
{1, 1, 4, 5, 5, 5, 9}.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
83
Mathematisches Modell:
Sorten:
Keys
Data
: (U, <) // totalgeordnetes Universum“
”
: D // Menge von Datensätzen“
”
∗
Multimenge: Elemente dürfen mehrfach vorkommen, wie z. B. in
{1, 1, 4, 5, 5, 5, 9}.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
83
Mathematisches Modell:
Sorten:
Keys
: (U, <) // totalgeordnetes Universum“
”
Data
: D // Menge von Datensätzen“
”
Boolean : {false, true}
∗
Multimenge: Elemente dürfen mehrfach vorkommen, wie z. B. in
{1, 1, 4, 5, 5, 5, 9}.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
83
Mathematisches Modell:
Sorten:
Keys
Data
Boolean
PrioQ
:
:
:
:
(U, <) // totalgeordnetes Universum“
”
D // Menge von Datensätzen“
”
{false, true}
die Menge aller endlichen Multimengen∗ P ⊆ U × D
∗
Multimenge: Elemente dürfen mehrfach vorkommen, wie z. B. in
{1, 1, 4, 5, 5, 5, 9}.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
83
Mathematisches Modell:
Sorten:
Keys
:
Data
:
Boolean :
PrioQ
:
Operationen:
empty ( ) = ∅
(U, <) // totalgeordnetes Universum“
”
D // Menge von Datensätzen“
”
{false, true}
die Menge aller endlichen Multimengen∗ P ⊆ U × D
// die leere Multimenge
∗
Multimenge: Elemente dürfen mehrfach vorkommen, wie z. B. in
{1, 1, 4, 5, 5, 5, 9}.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
83
Mathematisches Modell:
Sorten:
Keys
:
Data
:
Boolean :
PrioQ
:
Operationen:
empty ( ) = ∅
isempty (P ) =
(U, <) // totalgeordnetes Universum“
”
D // Menge von Datensätzen“
”
{false, true}
die Menge aller endlichen Multimengen∗ P ⊆ U × D
// die leere Multimenge
(
true,
für P = ∅
false, für P 6= ∅
∗
Multimenge: Elemente dürfen mehrfach vorkommen, wie z. B. in
{1, 1, 4, 5, 5, 5, 9}.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
83
Mathematisches Modell (Forts.):
insert(x, d, P ) = P ∪ {(x, d)} (als Multimenge),
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
84
Mathematisches Modell (Forts.):
insert(x, d, P ) = P ∪ {(x, d)} (als Multimenge),
extractMin(P ) =
FG KTuEA, TU Ilmenau
(
undefiniert,
für P = ∅
(x0, d0, P 0), für P 6= ∅,
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
84
Mathematisches Modell (Forts.):
insert(x, d, P ) = P ∪ {(x, d)} (als Multimenge),
extractMin(P ) =
(
undefiniert,
für P = ∅
(x0, d0, P 0), für P 6= ∅,
für ein Element (x0, d0) in P mit
minimalem Schlüssel x0,
und P 0 = P − {(x0, d0)}
(als Multimenge).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
84
Mathematisches Modell (Forts.):
insert(x, d, P ) = P ∪ {(x, d)} (als Multimenge),
extractMin(P ) =
(
undefiniert,
für P = ∅
(x0, d0, P 0), für P 6= ∅,
für ein Element (x0, d0) in P mit
minimalem Schlüssel x0,
und P 0 = P − {(x0, d0)}
(als Multimenge).
Standardimplementierung: (Binäre) Heaps
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
84
Implementierung: Neben Array A[1 . . m]:
Pegel k: Aktuelle Zahl k von Einträgen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
85
Implementierung: Neben Array A[1 . . m]:
Pegel k: Aktuelle Zahl k von Einträgen.
Überlaufprobleme werden ausgeklammert.
(Verdoppelungsstrategie, falls nötig.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
85
Implementierung: Neben Array A[1 . . m]:
Pegel k: Aktuelle Zahl k von Einträgen.
Überlaufprobleme werden ausgeklammert.
(Verdoppelungsstrategie, falls nötig.)
empty(m):
FG KTuEA, TU Ilmenau
// Zeitaufwand: O(1) oder O(m)
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
85
Implementierung: Neben Array A[1 . . m]:
Pegel k: Aktuelle Zahl k von Einträgen.
Überlaufprobleme werden ausgeklammert.
(Verdoppelungsstrategie, falls nötig.)
empty(m):
// Zeitaufwand: O(1) oder O(m)
Lege Array A[1 . . m] an;
Jeder Eintrag ist ein Paar (key, data).
k ← 0.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
85
Implementierung: Neben Array A[1 . . m]:
Pegel k: Aktuelle Zahl k von Einträgen.
Überlaufprobleme werden ausgeklammert.
(Verdoppelungsstrategie, falls nötig.)
empty(m):
// Zeitaufwand: O(1) oder O(m)
Lege Array A[1 . . m] an;
Jeder Eintrag ist ein Paar (key, data).
k ← 0.
isempty():
FG KTuEA, TU Ilmenau
// Zeitaufwand: O(1)
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
85
Implementierung: Neben Array A[1 . . m]:
Pegel k: Aktuelle Zahl k von Einträgen.
Überlaufprobleme werden ausgeklammert.
(Verdoppelungsstrategie, falls nötig.)
empty(m):
// Zeitaufwand: O(1) oder O(m)
Lege Array A[1 . . m] an;
Jeder Eintrag ist ein Paar (key, data).
k ← 0.
isempty():
return(k = 0);
FG KTuEA, TU Ilmenau
// Zeitaufwand: O(1)
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
85
extractMin: Implementierung von extractMin(P ):
Ein Eintrag mit minimalem Schlüssel steht in der Wurzel, d. h.
in Arrayposition 1.
Entnehme A[1] (hier B“) und gib es aus.
”
Loch“ im Binärbaum.– Stopfen“ mit dem letzten Eintrag.
”
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
86
extractMin: Implementierung von extractMin(P ):
Ein Eintrag mit minimalem Schlüssel steht in der Wurzel, d. h.
in Arrayposition 1.
Entnehme A[1] (hier B“) und gib es aus.
”
1
2
3
4
5
6
7
8
9
10
B
E
F
G
E
H
F
H
I
G
11
12
* *
1
B
2
3
E
F
4
5
E
G
8
6
7
H
F
9 10
H
I
G
Loch“ im Binärbaum.– Stopfen“ mit dem letzten Eintrag.
”
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
86
extractMin: Implementierung von extractMin(P ):
Ein Eintrag mit minimalem Schlüssel steht in der Wurzel, d. h.
in Arrayposition 1.
Entnehme A[1] (hier B“) und gib es aus.
”
1
2
3
4
5
6
7
8
9
10
?
E
F
G
E
H
F
H
I
G
11
12
* *
1
?
B
2
3
E
F
4
5
E
G
8
6
7
H
F
9 10
H
I
G
– Stopfen“ mit dem letzten Eintrag.
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
86
extractMin: Implementierung von extractMin(P ):
Ein Eintrag mit minimalem Schlüssel steht in der Wurzel, d. h.
in Arrayposition 1.
Entnehme A[1] (hier B“) und gib es aus.
”
1
2
3
4
5
6
7
8
9
10
?
E
F
G
E
H
F
H
I
G
11
12
* *
1
?
B
2
3
E
F
4
5
E
G
8
6
7
H
F
9 10
H
I
G
Loch“ im Binärbaum.– Stopfen“ mit dem letzten Eintrag.
”
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
86
extractMin: Implementierung von extractMin(P ):
Ein Eintrag mit minimalem Schlüssel steht in der Wurzel, d. h.
in Arrayposition 1.
Entnehme A[1] (hier B“) und gib es aus.
”
11
12
1
2
3
4
5
6
7
8
9
10
G
E
F
G
E
H
F
H
I
* * *
1
G
2
3
E
F
4
5
E
G
8
6
7
H
F
9 10
H
I
*
Loch“ im Binärbaum. – Stopfen“ mit dem letzten Eintrag.
”
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
86
Bleibt Aufgabe: Heap reparieren
11
12
1
2
3
4
5
6
7
8
9
10
G
E
F
G
E
H
F
H
I
* * *
1
G
2
3
E
F
5
4
E
G
8
6
7
H
F
9
H
FG KTuEA, TU Ilmenau
I
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
87
Bleibt Aufgabe: Heap reparieren
11
12
1
2
3
4
5
6
7
8
9
10
G
E
F
G
E
H
F
H
I
* * *
1
G
2
3
E
F
5
4
E
G
8
6
7
H
F
9
H
I
Höchstens A[1] ist zu groß, also:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
87
Bleibt Aufgabe: Heap reparieren
11
12
1
2
3
4
5
6
7
8
9
10
G
E
F
G
E
H
F
H
I
* * *
1
G
2
3
E
F
5
4
E
G
8
6
7
H
F
9
H
I
Höchstens A[1] ist zu groß, also:
bubbleDown hilft hier!
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
87
Prozedur extractMin
// Entnehmen eines minimalen Eintrags aus Priority-Queue
// Ausgangspunkt: Pegelstand k, A[1 . . k] ist Heap, k ≥ 1
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
88
Prozedur extractMin
// Entnehmen eines minimalen Eintrags aus Priority-Queue
// Ausgangspunkt: Pegelstand k, A[1 . . k] ist Heap, k ≥ 1
(0) if k = 0 then Fehlerbehandlung“;
”
(1) x ← A[1].key; d ← A[1].data;
(2) A[1] ← A[k];
(3) k--;
(4) if k > 1 then bubbleDown(1, k);
(5) return (x, d);
Korrektheit: klar wegen Korrektheit von bubbleDown(1, k).
Zeitaufwand: O(log(k)), wobei k (in k) die aktuelle Größe
des Heaps ist.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
88
Implementierung von insert(x, d):
Voraussetzung: A[1..k] ist Heap; 1 ≤ k < m;
k enthält k.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
89
Implementierung von insert(x, d):
Voraussetzung: A[1..k] ist Heap; 1 ≤ k < m;
k enthält k.
k++;
A[k] ← (x, d).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
89
Implementierung von insert(x, d):
Voraussetzung: A[1..k] ist Heap; 1 ≤ k < m;
k enthält k.
k++;
A[k] ← (x, d).
An der Stelle k 0 = k + 1 ist nun eventuell die Heapeigenschaft
gestört, weil x zu klein ist.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
89
Implementierung von insert(x, d):
Voraussetzung: A[1..k] ist Heap; 1 ≤ k < m;
k enthält k.
k++;
A[k] ← (x, d).
An der Stelle k 0 = k + 1 ist nun eventuell die Heapeigenschaft
gestört, weil x zu klein ist.
Definition
Höchstens A[j] ist zu klein :⇔
es entsteht ein Heap, wenn man u = A[j].key durch einen
geeigneten Schlüssel x ≥ u ersetzt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
89
Heap:
1
2
3
4
5
6
7
8
9
10
C
E
F
G
J
K
F
H
L
Q
11
12
* *
1
C
2
3
E
F
4
5
G
J
8
6
7
K
F
9 10
H
FG KTuEA, TU Ilmenau
L
Q
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
90
Einfügen von D“ an Stelle k = 11.
”
1
2
3
4
5
6
7
8
9
10
C
E
F
G
J
K
F
H
L
Q
11
D
12
*
1
C
2
3
E
F
4
5
G
J
8
9 10
H
FG KTuEA, TU Ilmenau
6
L
7
K
F
11
Q
D
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
90
Reparatur, wenn höchstens ein Schlüssel zu klein: bubbleUp.
1
2
3
4
5
6
7
8
9
10
C
E
F
G
J
K
F
H
L
Q
11
D
12
*
1
C
2
3
E
F
4
5
G
J
8
9 10
H
FG KTuEA, TU Ilmenau
6
L
7
K
F
11
Q
D
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
90
Reparatur, wenn höchstens ein Schlüssel zu klein: bubbleUp.
1
2
3
4
5
6
7
8
9
C
E
F
G
D
K
F
H
L
10
11
Q
J
12
*
1
C
2
3
E
F
4
5
G
6
K
D
8
9 10
H
FG KTuEA, TU Ilmenau
L
7
F
11
Q
J
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
90
Reparatur, wenn höchstens ein Schlüssel zu klein: bubbleUp.
1
2
3
4
5
6
7
8
9
C
E
F
G
D
K
F
H
L
10
11
Q
J
12
*
1
C
2
3
E
F
4
5
G
6
K
D
8
9 10
H
FG KTuEA, TU Ilmenau
L
7
F
11
Q
J
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
90
Reparatur, wenn höchstens ein Schlüssel zu klein: bubbleUp.
1
2
3
4
5
6
7
8
9
C
D
F
G
E
K
F
H
L
10
11
Q
J
12
*
1
C
2
3
D
F
4
5
G
6
K
E
8
9 10
H
FG KTuEA, TU Ilmenau
L
7
F
11
Q
J
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
90
Reparatur, wenn höchstens ein Schlüssel zu klein: bubbleUp.
1
2
3
4
5
6
7
8
9
C
D
F
G
E
K
F
H
L
10
11
Q
J
12
*
1
C
2
3
D
F
4
5
G
6
K
E
8
9 10
H
FG KTuEA, TU Ilmenau
L
7
F
11
Q
J
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
90
Reparatur, wenn höchstens ein Schlüssel zu klein: bubbleUp.
1
2
3
4
5
6
7
8
9
C
D
F
G
E
K
F
H
L
10
11
Q
J
12
*
1
C
2
3
D
F
4
5
G
6
K
E
8
9 10
H
FG KTuEA, TU Ilmenau
L
7
F
11
Q
J
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
90
Prozedur bubbleUp(i) // Heapreparatur ab A[i] nach oben
(1) j ← i;
(2) h ← bj/2c;
(3) while h ≥ 1 and A[h].key > A[j].key do
(4)
vertausche A[j] mit A[h];
(5)
j ← h;
(6)
h ← bj/2c.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
91
1
2
3
4
5
6
7
8
9
10
C
E
F
G
J
K
F
H
L
Q
11
D
12
*
1
C
2
3
E
F
4
5
G
J
8
9 10
H
6
L
7
K
F
11
Q
D
Anschaulich: Auf dem Weg von A[i] zur Wurzel werden alle
Elemente, deren Schlüssel größer als der (alte) Eintrag in A[i])
ist, um eine Position (auf dem Weg) nach unten gezogen.
Eintrag A[i] landet in der freigewordenen Position.
Man kann dies auch effizienter (wie in StraightInsertionSort) programmieren.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
92
1
2
3
4
5
6
7
8
9
C
D
F
G
E
K
F
H
L
10
11
Q
J
12
*
1
C
2
3
D
F
4
5
G
6
K
E
8
9 10
H
L
7
F
11
Q
J
Anschaulich: Auf dem Weg von A[i] zur Wurzel werden alle
Elemente, deren Schlüssel größer als der (alte) Eintrag in A[i])
ist, um eine Position (auf dem Weg) nach unten gezogen.
Eintrag A[i] landet in der freigewordenen Position.
Man kann dies auch effizienter (wie in StraightInsertionSort) programmieren.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
92
Behauptung 6.5.1
Wenn in A[1..k] höchstens A[i] zu klein ist
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
93
Behauptung 6.5.1
Wenn in A[1..k] höchstens A[i] zu klein ist
dann ist nach Ausführung von bubbleUp(i) das Array
A[1..k] ein Heap.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
93
Behauptung 6.5.1
Wenn in A[1..k] höchstens A[i] zu klein ist
dann ist nach Ausführung von bubbleUp(i) das Array
A[1..k] ein Heap.
Der Zeitaufwand ist O(log i), die Anzahl der Schlüsselvergleiche ist höchstens das Level von i im Baum, also die Anzahl
der Bits in der Binärdarstellung bin(i), d. h. dlog(i + 1)e.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
93
Behauptung 6.5.1
Wenn in A[1..k] höchstens A[i] zu klein ist
dann ist nach Ausführung von bubbleUp(i) das Array
A[1..k] ein Heap.
Der Zeitaufwand ist O(log i), die Anzahl der Schlüsselvergleiche ist höchstens das Level von i im Baum, also die Anzahl
der Bits in der Binärdarstellung bin(i), d. h. dlog(i + 1)e.
Beweis: Ähnlich wie bei bubbleDown.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
93
Prozedur insert(x, d)
// Einfügen eines neuen Eintrags in Priority-Queue
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
94
Prozedur insert(x, d)
// Einfügen eines neuen Eintrags in Priority-Queue
// Ausgangspunkt: Pegel k, A[1 . . k] ist Heap, k < m
(1) if k = m then Überlauf-Fehler“;
”
(2) k++;
(3) A[k] ← (x, d);
(4) bubbleUp(k).
Korrektheit: klar wegen Korrektheit von bubbleUp(k).
Zeitaufwand: O(log(k)).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
94
Wir können bubbleUp(i) sogar für eine etwas allgemeinere
Operation verwenden (Korrektheitsbeweis gilt weiter):
Wir ersetzen einen beliebigen Schlüssel im Heap (Position i)
durch einen kleineren.
Mit bubbleUp(i) kann die Heapeigenschaft wieder hergestellt
werden.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
95
Wir können bubbleUp(i) sogar für eine etwas allgemeinere
Operation verwenden (Korrektheitsbeweis gilt weiter):
Wir ersetzen einen beliebigen Schlüssel im Heap (Position i)
durch einen kleineren.
Mit bubbleUp(i) kann die Heapeigenschaft wieder hergestellt
werden.
Prozedur decreaseKey(x, i)
// (Erniedrigen des Schlüssels an Arrayposition i auf x)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
95
Wir können bubbleUp(i) sogar für eine etwas allgemeinere
Operation verwenden (Korrektheitsbeweis gilt weiter):
Wir ersetzen einen beliebigen Schlüssel im Heap (Position i)
durch einen kleineren.
Mit bubbleUp(i) kann die Heapeigenschaft wieder hergestellt
werden.
Prozedur decreaseKey(x, i)
// (Erniedrigen des Schlüssels an Arrayposition i auf x)
(1) if A[i].key < x then Fehlerbehandlung;
(2) A[i].key ← x;
(3) bubbleUp(i).
// Zeitaufwand: O(log(i))
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
95
SimplePriorityQueue plus decreaseKey“:
”
Prioritätswarteschlange.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
96
SimplePriorityQueue plus decreaseKey“:
”
Prioritätswarteschlange.
Satz 6.5.2
Der Datentyp “Prioritätswarteschlange” kann mit Hilfe eines
Heaps implementiert werden.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
96
SimplePriorityQueue plus decreaseKey“:
”
Prioritätswarteschlange.
Satz 6.5.2
Der Datentyp “Prioritätswarteschlange” kann mit Hilfe eines
Heaps implementiert werden.
Dabei erfordern empty und isempty (und das Ermitteln des
kleinsten Eintrags) konstante Zeit
und insert, extractMin und decreaseKey benötigen jeweils Zeit
O(log n).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
96
SimplePriorityQueue plus decreaseKey“:
”
Prioritätswarteschlange.
Satz 6.5.2
Der Datentyp “Prioritätswarteschlange” kann mit Hilfe eines
Heaps implementiert werden.
Dabei erfordern empty und isempty (und das Ermitteln des
kleinsten Eintrags) konstante Zeit
und insert, extractMin und decreaseKey benötigen jeweils Zeit
O(log n).
Dabei ist n jeweils der aktuelle Pegelstand, also die Anzahl
der Einträge in der Prioritätswarteschlange.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
96
Technisches Problem:
Wie soll man der Datenstruktur mitteilen“, welches Objekt
”
gemeint ist, wenn decreaseKey auf einen Eintrag angewendet
werden soll?
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
97
Technisches Problem:
Wie soll man der Datenstruktur mitteilen“, welches Objekt
”
gemeint ist, wenn decreaseKey auf einen Eintrag angewendet
werden soll?
Bei (binärem) Heap: Positionen der Einträge im Array ändern
sich die ganze Zeit, durch die durch insert und extractMin
verursachten Verschiebungen im Array.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
97
Technisches Problem:
Wie soll man der Datenstruktur mitteilen“, welches Objekt
”
gemeint ist, wenn decreaseKey auf einen Eintrag angewendet
werden soll?
Bei (binärem) Heap: Positionen der Einträge im Array ändern
sich die ganze Zeit, durch die durch insert und extractMin
verursachten Verschiebungen im Array.
Technisch unsauber (widerspricht dem Prinzip der Kapselung
einer Datenstruktur):
dem Benutzer stets mitteilen, an welcher Stelle im Array ein
Eintrag sitzt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
97
Besser: Erweiterung der Datenstruktur:
Objekt (x, d) erhält bei Ausführung von insert(x, d) eine
eindeutige Identität“ p zugeteilt, die sich nie ändert, und
”
über die dieses Objekt angesprochen werden kann.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
98
Besser: Erweiterung der Datenstruktur:
Objekt (x, d) erhält bei Ausführung von insert(x, d) eine
eindeutige Identität“ p zugeteilt, die sich nie ändert, und
”
über die dieses Objekt angesprochen werden kann.
Damit können auch verschiedene Kopien eines Datensatzes
unterschieden werden!
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
98
Besser: Erweiterung der Datenstruktur:
Objekt (x, d) erhält bei Ausführung von insert(x, d) eine
eindeutige Identität“ p zugeteilt, die sich nie ändert, und
”
über die dieses Objekt angesprochen werden kann.
Damit können auch verschiedene Kopien eines Datensatzes
unterschieden werden!
p wird dem Benutzer als Reaktion auf die Einfügung mitgeteilt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
98
Besser: Erweiterung der Datenstruktur:
Objekt (x, d) erhält bei Ausführung von insert(x, d) eine
eindeutige Identität“ p zugeteilt, die sich nie ändert, und
”
über die dieses Objekt angesprochen werden kann.
Damit können auch verschiedene Kopien eines Datensatzes
unterschieden werden!
p wird dem Benutzer als Reaktion auf die Einfügung mitgeteilt.
Der Benutzer kann dann irgendwann den Schlüssel eines Eintrags mit Identität p ändern.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
98
Technische Realisierung:
Im Heap gespeicherte Objekte ((Daten, Schlüssel)-Paare) stehen an fester Stelle. Zugriff über Zeiger/Referenz. Im Heaparray werden nur Zeiger/Referenzen auf diese Objekte gehalten, so dass diese selber nie verschoben werden müssen.
Version 1: Identität p ist der Zeiger auf das Objekt im Heap.
Das Objekt enthält seine jeweilige Position im Heap-Array als Komponente.
(Nachteil: Kapselung der Datenstruktur ist durchbrochen – der Benutzer
kann über den Zeiger direkt auf die Objekte zugreifen.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
99
Technische Realisierung:
Im Heap gespeicherte Objekte ((Daten, Schlüssel)-Paare) stehen an fester Stelle. Zugriff über Zeiger/Referenz. Im Heaparray werden nur Zeiger/Referenzen auf diese Objekte gehalten, so dass diese selber nie verschoben werden müssen.
Version 1: Identität p ist der Zeiger auf das Objekt im Heap.
Das Objekt enthält seine jeweilige Position im Heap-Array als Komponente.
(Nachteil: Kapselung der Datenstruktur ist durchbrochen – der Benutzer
kann über den Zeiger direkt auf die Objekte zugreifen.)
Version 2: Eine beliebige (laufende) Nummer wird vergeben (z. B. durch
Durchzählen der Einfügungen). Diese Nummer ist die Identität p. Die
Datenstruktur hält intern in einem Hilfsarray für jede dieser Nummern
die Adresse des entsprechenden Objekts. Das Objekt enthält Daten und
Schlüssel und seine jeweilige Position im Heap-Array als Komponenten.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
99
Technische Realisierung:
Im Heap gespeicherte Objekte ((Daten, Schlüssel)-Paare) stehen an fester Stelle. Zugriff über Zeiger/Referenz. Im Heaparray werden nur Zeiger/Referenzen auf diese Objekte gehalten, so dass diese selber nie verschoben werden müssen.
Version 1: Identität p ist der Zeiger auf das Objekt im Heap.
Das Objekt enthält seine jeweilige Position im Heap-Array als Komponente.
(Nachteil: Kapselung der Datenstruktur ist durchbrochen – der Benutzer
kann über den Zeiger direkt auf die Objekte zugreifen.)
Version 2: Eine beliebige (laufende) Nummer wird vergeben (z. B. durch
Durchzählen der Einfügungen). Diese Nummer ist die Identität p. Die
Datenstruktur hält intern in einem Hilfsarray für jede dieser Nummern
die Adresse des entsprechenden Objekts. Das Objekt enthält Daten und
Schlüssel und seine jeweilige Position im Heap-Array als Komponenten.
(Nachteil: Platzbedarf des Hilfsarrays entspricht der Anzahl der Einfügungen, nicht der maximalen Größe der Prioritätswarteschlange.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
99
Technische Realisierung:
Im Heap gespeicherte Objekte ((Daten, Schlüssel)-Paare) stehen an fester Stelle. Zugriff über Zeiger/Referenz. Im Heaparray werden nur Zeiger/Referenzen auf diese Objekte gehalten, so dass diese selber nie verschoben werden müssen.
Version 1: Identität p ist der Zeiger auf das Objekt im Heap.
Das Objekt enthält seine jeweilige Position im Heap-Array als Komponente.
(Nachteil: Kapselung der Datenstruktur ist durchbrochen – der Benutzer
kann über den Zeiger direkt auf die Objekte zugreifen.)
Version 2: Eine beliebige (laufende) Nummer wird vergeben (z. B. durch
Durchzählen der Einfügungen). Diese Nummer ist die Identität p. Die
Datenstruktur hält intern in einem Hilfsarray für jede dieser Nummern
die Adresse des entsprechenden Objekts. Das Objekt enthält Daten und
Schlüssel und seine jeweilige Position im Heap-Array als Komponenten.
(Nachteil: Platzbedarf des Hilfsarrays entspricht der Anzahl der Einfügungen, nicht der maximalen Größe der Prioritätswarteschlange.)
Version 3: Wie Version 2, aber die Identität p eines durch ExtractMin
aus dem Heap gelöschten Eintrags kann wieder vergeben werden.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
99
Beispiel:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitäten nicht mehr benutzt werden, nachdem das entsprechende Objekt (durch ein extractMin) wieder aus der Datenstruktur verschwunden ist.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitäten nicht mehr benutzt werden, nachdem das entsprechende Objekt (durch ein extractMin) wieder aus der Datenstruktur verschwunden ist.
Runde
1
Operation
empty
FG KTuEA, TU Ilmenau
innerer Zustand
∅
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitäten nicht mehr benutzt werden, nachdem das entsprechende Objekt (durch ein extractMin) wieder aus der Datenstruktur verschwunden ist.
Runde
1
2
Operation
empty
insert(D)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
{(1,D)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
1
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitäten nicht mehr benutzt werden, nachdem das entsprechende Objekt (durch ein extractMin) wieder aus der Datenstruktur verschwunden ist.
Runde
1
2
3
Operation
empty
insert(D)
insert(B)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
{(1,D)}
{(1,D), (2,B)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
1
2
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitäten nicht mehr benutzt werden, nachdem das entsprechende Objekt (durch ein extractMin) wieder aus der Datenstruktur verschwunden ist.
Runde
1
2
3
4
Operation
empty
insert(D)
insert(B)
insert(D)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
{(1,D)}
{(1,D), (2,B)}
{(1,D), (2,B), (3,D)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
1
2
3
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitäten nicht mehr benutzt werden, nachdem das entsprechende Objekt (durch ein extractMin) wieder aus der Datenstruktur verschwunden ist.
Runde
1
2
3
4
5
Operation
empty
insert(D)
insert(B)
insert(D)
insert(E)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
{(1,D)}
{(1,D), (2,B)}
{(1,D), (2,B), (3,D)}
{(1,D), (2,B), (3,D), (4,E)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
1
2
3
4
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitäten nicht mehr benutzt werden, nachdem das entsprechende Objekt (durch ein extractMin) wieder aus der Datenstruktur verschwunden ist.
Runde
1
2
3
4
5
6
Operation
empty
insert(D)
insert(B)
insert(D)
insert(E)
insert(G)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
{(1,D)}
{(1,D), (2,B)}
{(1,D), (2,B), (3,D)}
{(1,D), (2,B), (3,D), (4,E)}
{(1,D), (2,B),
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
1
2
3
4
5
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitäten nicht mehr benutzt werden, nachdem das entsprechende Objekt (durch ein extractMin) wieder aus der Datenstruktur verschwunden ist.
Runde
1
2
3
4
5
6
Operation
empty
insert(D)
insert(B)
insert(D)
insert(E)
insert(G)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
{(1,D)}
{(1,D), (2,B)}
{(1,D), (2,B), (3,D)}
{(1,D), (2,B), (3,D), (4,E)}
{(1,D), (2,B),
(3,D), (4,E), (5,G)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
1
2
3
4
5
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitäten nicht mehr benutzt werden, nachdem das entsprechende Objekt (durch ein extractMin) wieder aus der Datenstruktur verschwunden ist.
Runde
1
2
3
4
5
6
7
Operation
empty
insert(D)
insert(B)
insert(D)
insert(E)
insert(G)
decreaseKey (5,D)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
{(1,D)}
{(1,D), (2,B)}
{(1,D), (2,B), (3,D)}
{(1,D), (2,B), (3,D), (4,E)}
{(1,D), (2,B),
(3,D), (4,E), (5,G)}
{(1,D), (2,B),
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
1
2
3
4
5
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitäten nicht mehr benutzt werden, nachdem das entsprechende Objekt (durch ein extractMin) wieder aus der Datenstruktur verschwunden ist.
Runde
1
2
3
4
5
6
7
Operation
empty
insert(D)
insert(B)
insert(D)
insert(E)
insert(G)
decreaseKey (5,D)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
{(1,D)}
{(1,D), (2,B)}
{(1,D), (2,B), (3,D)}
{(1,D), (2,B), (3,D), (4,E)}
{(1,D), (2,B),
(3,D), (4,E), (5,G)}
{(1,D), (2,B),
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
1
2
3
4
5
–
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitäten nicht mehr benutzt werden, nachdem das entsprechende Objekt (durch ein extractMin) wieder aus der Datenstruktur verschwunden ist.
Runde
1
2
3
4
5
6
7
Operation
empty
insert(D)
insert(B)
insert(D)
insert(E)
insert(G)
decreaseKey (5,D)
FG KTuEA, TU Ilmenau
innerer Zustand
∅
{(1,D)}
{(1,D), (2,B)}
{(1,D), (2,B), (3,D)}
{(1,D), (2,B), (3,D), (4,E)}
{(1,D), (2,B),
(3,D), (4,E), (5,G)}
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
–
1
2
3
4
5
–
100
Runde
Operation
FG KTuEA, TU Ilmenau
innerer Zustand
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
101
Runde
...
Operation
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
101
Runde
...
Operation
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
101
Runde
...
Operation
8
extractMin
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
{(1,D), (3,D), (4,E), (5,D)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
(2,B)
101
Runde
...
Operation
8
9
extractMin
extractMin
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
{(1,D), (3,D), (4,E), (5,D)}
{(1,D), (4,E), (5,D)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
(2,B)
(3,D)
101
Runde
...
8
9
10
Operation
extractMin
extractMin
decreaseKey (4,B)
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
{(1,D), (3,D), (4,E), (5,D)}
{(1,D), (4,E), (5,D)}
{(1,D), (4,B), (5,D)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
(2,B)
(3,D)
101
Runde
...
8
9
10
Operation
extractMin
extractMin
decreaseKey (4,B)
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
{(1,D), (3,D), (4,E), (5,D)}
{(1,D), (4,E), (5,D)}
{(1,D), (4,B), (5,D)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
(2,B)
(3,D)
–
101
Runde
...
8
9
10
11
Operation
extractMin
extractMin
decreaseKey (4,B)
extractMin
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
{(1,D), (3,D), (4,E), (5,D)}
{(1,D), (4,E), (5,D)}
{(1,D), (4,B), (5,D)}
{(1,D), (5,D)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
(2,B)
(3,D)
–
(4,B)
101
Runde
...
8
9
10
11
12
Operation
extractMin
extractMin
decreaseKey (4,B)
extractMin
insert(F)
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
{(1,D), (3,D), (4,E), (5,D)}
{(1,D), (4,E), (5,D)}
{(1,D), (4,B), (5,D)}
{(1,D), (5,D)}
{(1,D), (5,D), (6,F)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
(2,B)
(3,D)
–
(4,B)
6
101
Runde
...
8
9
10
11
12
13
Operation
extractMin
extractMin
decreaseKey (4,B)
extractMin
insert(F)
decreaseKey (6,C)
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
{(1,D), (3,D), (4,E), (5,D)}
{(1,D), (4,E), (5,D)}
{(1,D), (4,B), (5,D)}
{(1,D), (5,D)}
{(1,D), (5,D), (6,F)}
{(1,D), (5,D), (6,C)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
(2,B)
(3,D)
–
(4,B)
6
101
Runde
...
8
9
10
11
12
13
Operation
extractMin
extractMin
decreaseKey (4,B)
extractMin
insert(F)
decreaseKey (6,C)
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
{(1,D), (3,D), (4,E), (5,D)}
{(1,D), (4,E), (5,D)}
{(1,D), (4,B), (5,D)}
{(1,D), (5,D)}
{(1,D), (5,D), (6,F)}
{(1,D), (5,D), (6,C)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
(2,B)
(3,D)
–
(4,B)
6
–
101
Runde
...
8
9
10
11
12
13
14
Operation
extractMin
extractMin
decreaseKey (4,B)
extractMin
insert(F)
decreaseKey (6,C)
extractMin
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
{(1,D), (3,D), (4,E), (5,D)}
{(1,D), (4,E), (5,D)}
{(1,D), (4,B), (5,D)}
{(1,D), (5,D)}
{(1,D), (5,D), (6,F)}
{(1,D), (5,D), (6,C)}
{(1,D), (5,D)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
(2,B)
(3,D)
–
(4,B)
6
–
(6,C)
101
Runde
...
8
9
10
11
12
13
14
15
Operation
extractMin
extractMin
decreaseKey (4,B)
extractMin
insert(F)
decreaseKey (6,C)
extractMin
extractMin
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
{(1,D), (3,D), (4,E), (5,D)}
{(1,D), (4,E), (5,D)}
{(1,D), (4,B), (5,D)}
{(1,D), (5,D)}
{(1,D), (5,D), (6,F)}
{(1,D), (5,D), (6,C)}
{(1,D), (5,D)}
{(1,D)}
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
(2,B)
(3,D)
–
(4,B)
6
–
(6,C)
(5,D)
101
Runde
...
8
9
10
11
12
13
14
15
16
Operation
extractMin
extractMin
decreaseKey (4,B)
extractMin
insert(F)
decreaseKey (6,C)
extractMin
extractMin
extractMin
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
{(1,D), (3,D), (4,E), (5,D)}
{(1,D), (4,E), (5,D)}
{(1,D), (4,B), (5,D)}
{(1,D), (5,D)}
{(1,D), (5,D), (6,F)}
{(1,D), (5,D), (6,C)}
{(1,D), (5,D)}
{(1,D)}
∅
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
(2,B)
(3,D)
–
(4,B)
6
–
(6,C)
(5,D)
(1,D)
101
Runde
...
8
9
10
11
12
13
14
15
16
17
Operation
extractMin
extractMin
decreaseKey (4,B)
extractMin
insert(F)
decreaseKey (6,C)
extractMin
extractMin
extractMin
isempty
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
{(1,D), (3,D), (4,E), (5,D)}
{(1,D), (4,E), (5,D)}
{(1,D), (4,B), (5,D)}
{(1,D), (5,D)}
{(1,D), (5,D), (6,F)}
{(1,D), (5,D), (6,C)}
{(1,D), (5,D)}
{(1,D)}
∅
∅
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
Ausgabe
(2,B)
(3,D)
–
(4,B)
6
–
(6,C)
(5,D)
(1,D)
true.
101
Runde
...
8
9
10
11
12
13
14
15
16
17
Operation
extractMin
extractMin
decreaseKey (4,B)
extractMin
insert(F)
decreaseKey (6,C)
extractMin
extractMin
extractMin
isempty
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
{(1,D), (3,D), (4,E), (5,D)}
{(1,D), (4,E), (5,D)}
{(1,D), (4,B), (5,D)}
{(1,D), (5,D)}
{(1,D), (5,D), (6,F)}
{(1,D), (5,D), (6,C)}
{(1,D), (5,D)}
{(1,D)}
∅
∅
Ausgabe
(2,B)
(3,D)
–
(4,B)
6
–
(6,C)
(5,D)
(1,D)
true.
In Runde 13 wäre zum Beispiel die Operation
decreaseKey (3,A) nicht legal, da das (eindeutig bestimmte)
Objekt mit Identität 3 in Runde 9 aus der Datenstruktur
verschwunden ist.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
101
Datentyp: PriorityQueue (Prioritätswarteschlange)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
102
Datentyp: PriorityQueue (Prioritätswarteschlange)
Signatur:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
102
Datentyp: PriorityQueue (Prioritätswarteschlange)
Signatur:
Sorten:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
102
Datentyp: PriorityQueue (Prioritätswarteschlange)
Signatur:
Sorten:
Keys
Data
Id // Identitäten“
”
PrioQ
Boolean
Operatoren:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
102
Datentyp: PriorityQueue (Prioritätswarteschlange)
Signatur:
Sorten:
Keys
Data
Id // Identitäten“
”
PrioQ
Boolean
Operatoren:
empty : → PrioQ
isempty : PrioQ → Boolean
insert : Keys × Data × PrioQ → PrioQ × Id
extractMin: PrioQ → Id × Keys × Data × PrioQ
decreaseKey : Id × Keys × PrioQ → PrioQ
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
102
Mathematisches Modell:
Keys
: (U, <)
// totalgeordnetes Universum“
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
103
Mathematisches Modell:
Keys
: (U, <)
// totalgeordnetes Universum“
”
Data
: D // Menge von Datensätzen“
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
103
Mathematisches Modell:
Keys
: (U, <)
// totalgeordnetes Universum“
”
Data
: D // Menge von Datensätzen“
”
Id
: N = {0, 1, 2, . . .}
// unendliche Menge möglicher Identitäten“
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
103
Mathematisches Modell:
Keys
: (U, <)
// totalgeordnetes Universum“
”
Data
: D // Menge von Datensätzen“
”
Id
: N = {0, 1, 2, . . .}
// unendliche Menge möglicher Identitäten“
”
Boolean : {false, true}
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
103
Mathematisches Modell:
Keys
: (U, <)
// totalgeordnetes Universum“
”
Data
: D // Menge von Datensätzen“
”
Id
: N = {0, 1, 2, . . .}
// unendliche Menge möglicher Identitäten“
”
Boolean : {false, true}
PrioQ
: die Menge aller Funktionen f : X → U × D,
wobei X = Def (f ) ⊆ N endlich ist
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
103
Mathematisches Modell:
Keys
: (U, <)
// totalgeordnetes Universum“
”
Data
: D // Menge von Datensätzen“
”
Id
: N = {0, 1, 2, . . .}
// unendliche Menge möglicher Identitäten“
”
Boolean : {false, true}
PrioQ
: die Menge aller Funktionen f : X → U × D,
wobei X = Def (f ) ⊆ N endlich ist
empty (()) = ∅
FG KTuEA, TU Ilmenau
// die leere Funktion
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
103
Mathematisches Modell:
Keys
: (U, <)
// totalgeordnetes Universum“
”
Data
: D // Menge von Datensätzen“
”
Id
: N = {0, 1, 2, . . .}
// unendliche Menge möglicher Identitäten“
”
Boolean : {false, true}
PrioQ
: die Menge aller Funktionen f : X → U × D,
wobei X = Def (f ) ⊆ N endlich ist
empty (()) = ∅
// die leere Funktion
(
true, für f = ∅
isempty (f ) =
false, für f =
6 ∅
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
103
insert(x, d, f ) = (f ∪ {(p, (x, d))}, p),
für ein p ∈ N − Def (f )
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
104
insert(x, d, f ) = (f ∪ {(p, (x, d))}, p),
für ein p ∈ N − Def (f )
(
undefiniert,
für f = ∅
extractMin(f ) =
(p0, x0, d0, f 0), für f 6= ∅,
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
104
insert(x, d, f ) = (f ∪ {(p, (x, d))}, p),
für ein p ∈ N − Def (f )
(
undefiniert,
für f = ∅
extractMin(f ) =
(p0, x0, d0, f 0), für f 6= ∅,
wobei im zweiten Fall
p0 ein Element in Def (f ) ist
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
104
insert(x, d, f ) = (f ∪ {(p, (x, d))}, p),
für ein p ∈ N − Def (f )
(
undefiniert,
für f = ∅
extractMin(f ) =
(p0, x0, d0, f 0), für f 6= ∅,
wobei im zweiten Fall
p0 ein Element in Def (f ) ist mit
(x0, d0) = f (p0)
mit x0 = min{x | ∃p ∃d : (p, (x, d)) ∈ f },
und f 0 := f − {(p0, (x0, d0))}.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
104
insert(x, d, f ) = (f ∪ {(p, (x, d))}, p),
für ein p ∈ N − Def (f )
(
undefiniert,
für f = ∅
extractMin(f ) =
(p0, x0, d0, f 0), für f 6= ∅,
wobei im zweiten Fall
p0 ein Element in Def (f ) ist mit
(x0, d0) = f (p0)
mit x0 = min{x | ∃p ∃d : (p, (x, d)) ∈ f },
und f 0 := f − {(p0, (x0, d0))}.
decreaseKey (p, x) = (f − {(p, (y, d))}) ∪ {(p, (x, d))},
falls f (p) = (y, d) mit x ≤ y (sonst Fehlerbeh.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
104
insert(x, d, f ) = (f ∪ {(p, (x, d))}, p),
für ein p ∈ N − Def (f )
(
undefiniert,
für f = ∅
extractMin(f ) =
(p0, x0, d0, f 0), für f 6= ∅,
wobei im zweiten Fall
p0 ein Element in Def (f ) ist mit
(x0, d0) = f (p0)
mit x0 = min{x | ∃p ∃d : (p, (x, d)) ∈ f },
und f 0 := f − {(p0, (x0, d0))}.
decreaseKey (p, x) = (f − {(p, (y, d))}) ∪ {(p, (x, d))},
falls f (p) = (y, d) mit x ≤ y (sonst Fehlerbeh.)
Implementierung: Größere Übungsaufgabe.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
104
6.6 Untere Schranke für Sortieren
Sortieralgorithmus A heißt ein Schlüsselvergleichsverfahren,
wenn
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
105
6.6 Untere Schranke für Sortieren
Sortieralgorithmus A heißt ein Schlüsselvergleichsverfahren,
wenn
in A auf Schlüssel x, y aus U nur Operationen
x<y ?
x≤y ?
x=y ?
sowie Verschieben und Kopieren angewendet werden.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
105
6.6 Untere Schranke für Sortieren
Sortieralgorithmus A heißt ein Schlüsselvergleichsverfahren,
wenn
in A auf Schlüssel x, y aus U nur Operationen
x<y ?
x≤y ?
x=y ?
sowie Verschieben und Kopieren angewendet werden.
Schlüssel sind atomare Objekte“.
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
105
6.6 Untere Schranke für Sortieren
Sortieralgorithmus A heißt ein Schlüsselvergleichsverfahren,
wenn
in A auf Schlüssel x, y aus U nur Operationen
x<y ?
x≤y ?
x=y ?
sowie Verschieben und Kopieren angewendet werden.
Schlüssel sind atomare Objekte“.
”
Mergesort, Quicksort, Heapsort, StraightInsertionSort
sind Schlüsselvergleichsverfahren.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
105
6.6 Untere Schranke für Sortieren
Sortieralgorithmus A heißt ein Schlüsselvergleichsverfahren,
wenn
in A auf Schlüssel x, y aus U nur Operationen
x<y ?
x≤y ?
x=y ?
sowie Verschieben und Kopieren angewendet werden.
Schlüssel sind atomare Objekte“.
”
Mergesort, Quicksort, Heapsort, StraightInsertionSort
sind Schlüsselvergleichsverfahren.
Jeweils: O(n log n) oder O(n2) Vergleiche.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
105
6.6 Untere Schranke für Sortieren
Sortieralgorithmus A heißt ein Schlüsselvergleichsverfahren,
wenn
in A auf Schlüssel x, y aus U nur Operationen
x<y ?
x≤y ?
x=y ?
sowie Verschieben und Kopieren angewendet werden.
Schlüssel sind atomare Objekte“.
”
Mergesort, Quicksort, Heapsort, StraightInsertionSort
sind Schlüsselvergleichsverfahren.
Jeweils: O(n log n) oder O(n2) Vergleiche.
Ziel: Es geht nicht besser als Ω(n log n).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
105
Sei nun A ein Schlüsselvergleichsverfahren.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
106
Sei nun A ein Schlüsselvergleichsverfahren.
Wir wenden A auf die n! verschiedenen Eingaben
(a1, 1), . . . , (an, n)
an, wobei σ = (a1, . . . , an) eine Permutation von {1, . . . , n} ist.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
106
Sei nun A ein Schlüsselvergleichsverfahren.
Wir wenden A auf die n! verschiedenen Eingaben
(a1, 1), . . . , (an, n)
an, wobei σ = (a1, . . . , an) eine Permutation von {1, . . . , n} ist.
Sortierschlüssel: erste Komponente.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
106
Sei nun A ein Schlüsselvergleichsverfahren.
Wir wenden A auf die n! verschiedenen Eingaben
(a1, 1), . . . , (an, n)
an, wobei σ = (a1, . . . , an) eine Permutation von {1, . . . , n} ist.
Sortierschlüssel: erste Komponente.
Beispiel: Aus (2, 1), (4, 2), (1, 3), (3, 4) wird (1, 3), (2, 1), (3, 4), (4, 2).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
106
Sei nun A ein Schlüsselvergleichsverfahren.
Wir wenden A auf die n! verschiedenen Eingaben
(a1, 1), . . . , (an, n)
an, wobei σ = (a1, . . . , an) eine Permutation von {1, . . . , n} ist.
Sortierschlüssel: erste Komponente.
Beispiel: Aus (2, 1), (4, 2), (1, 3), (3, 4) wird (1, 3), (2, 1), (3, 4), (4, 2).
Effekt: In den zweiten Komponenten steht die Permutation
π = σ −1 (im Beispiel π = (3, 1, 4, 2)),
die die Eingabe (a1, . . . , an) sortiert: aπ(1) < · · · < aπ(n).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
106
Sei nun A ein Schlüsselvergleichsverfahren.
Wir wenden A auf die n! verschiedenen Eingaben
(a1, 1), . . . , (an, n)
an, wobei σ = (a1, . . . , an) eine Permutation von {1, . . . , n} ist.
Sortierschlüssel: erste Komponente.
Beispiel: Aus (2, 1), (4, 2), (1, 3), (3, 4) wird (1, 3), (2, 1), (3, 4), (4, 2).
Effekt: In den zweiten Komponenten steht die Permutation
π = σ −1 (im Beispiel π = (3, 1, 4, 2)),
die die Eingabe (a1, . . . , an) sortiert: aπ(1) < · · · < aπ(n).
Also: n! verschiedene Ausgaben, eine für jede Anordnung der
Eingabeobjekte.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
106
Beispiel: Mergesort mit 3 Elementen
a1
a 1< a 2
nein
ja
a 1< a 3
a 2< a 3
nein
ja
nein
231
ja
nein
a 1< a 3
321
a3
a2
a 2< a 3
312
ja
213
nein
132
ja
123
In Blättern: die zweiten Komponenten
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
107
Allgemein: Vergleichsbaum TA,n mit n! Blättern.
Start
0
a i1< a j1
1
a i2< a j2
0
1
a i4< a j4
0
a i3< a j3
0
a i6< a j6
a i5< a j5
1
0
1
1
0
a i7< a j7
1
0
π’’
1
π’’’
a i20< a j20
0
π
FG KTuEA, TU Ilmenau
1
π’
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
108
Allgemein: Jeder vergleichsbasierte Sortieralgorithmus A erzeugt einen Vergleichsbaum TA,n mit genau n! Blättern.
Die Wege im Baum entsprechen den Berechnungen von A auf
den n! genannten Eingaben.
Details: Druckfolien, nicht prüfungsrelevant.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
109
Allgemein: Jeder vergleichsbasierte Sortieralgorithmus A erzeugt einen Vergleichsbaum TA,n mit genau n! Blättern.
Die Wege im Baum entsprechen den Berechnungen von A auf
den n! genannten Eingaben.
Details: Druckfolien, nicht prüfungsrelevant.
Satz 6.6.1
Wenn A ein Schlüsselvergleichsverfahren ist, das das Sortierproblem löst,
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
109
Allgemein: Jeder vergleichsbasierte Sortieralgorithmus A erzeugt einen Vergleichsbaum TA,n mit genau n! Blättern.
Die Wege im Baum entsprechen den Berechnungen von A auf
den n! genannten Eingaben.
Details: Druckfolien, nicht prüfungsrelevant.
Satz 6.6.1
Wenn A ein Schlüsselvergleichsverfahren ist, das das Sortierproblem löst,
dann gibt es eine Eingabe (a1, . . . , an), auf der A mindestens
dlog(n!)e Vergleiche ausführt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
109
Allgemein: Jeder vergleichsbasierte Sortieralgorithmus A erzeugt einen Vergleichsbaum TA,n mit genau n! Blättern.
Die Wege im Baum entsprechen den Berechnungen von A auf
den n! genannten Eingaben.
Details: Druckfolien, nicht prüfungsrelevant.
Satz 6.6.1
Wenn A ein Schlüsselvergleichsverfahren ist, das das Sortierproblem löst,
dann gibt es eine Eingabe (a1, . . . , an), auf der A mindestens
dlog(n!)e Vergleiche ausführt.
Beweis: Der Vergleichsbaum, den A erzeugt, hat n! (externe)
Blätter, also hat er Tiefe ≥ dlog(n!)e (s. Prop. 3.3.2).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
109
Bemerkung:
n! ≥ (n/e)n.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
110
Bemerkung:
n! ≥ (n/e)n.
FG KTuEA, TU Ilmenau
Beweis: nn/n!
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
110
Bemerkung:
n
n! ≥ (n/e) .
FG KTuEA, TU Ilmenau
n
Beweis: n /n! <
ni
i≥0 i!
P
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
110
Bemerkung:
n
n! ≥ (n/e) .
FG KTuEA, TU Ilmenau
n
Beweis: n /n! <
ni
i≥0 i!
P
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
= en .
110
Bemerkung:
n
n! ≥ (n/e) .
n
Beweis: n /n! <
ni
i≥0 i!
P
= en .
Also: log(n!) ≥ log((n/e)n) = n log n − n log e
= n log n − 1,44269 . . . n.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
110
Bemerkung:
n
n! ≥ (n/e) .
n
Beweis: n /n! <
ni
i≥0 i!
P
= en .
Also: log(n!) ≥ log((n/e)n) = n log n − n log e
= n log n − 1,44269 . . . n.
Mitteilung:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
110
Bemerkung:
n
n! ≥ (n/e) .
n
Beweis: n /n! <
ni
i≥0 i!
P
= en .
Also: log(n!) ≥ log((n/e)n) = n log n − n log e
= n log n − 1,44269 . . . n.
Mitteilung:
Für n ≥ 1 gilt (Stirlingsche Formel):
√
FG KTuEA, TU Ilmenau
2πn
n n
e
≤ n! ≤
√
2πn
n n
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
e
e
1
12n
110
Satz 6.6.2
Wenn A ein Schlüsselvergleichsverfahren ist, das das Sortierproblem löst,
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
111
Satz 6.6.2
Wenn A ein Schlüsselvergleichsverfahren ist, das das Sortierproblem löst, dann gilt für die mittlere Vergleichsanzahl V n
(gemittelt über die n! verschiedenen Eingabeanordnungen):
V n ≥ log(n!).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
111
Satz 6.6.2
Wenn A ein Schlüsselvergleichsverfahren ist, das das Sortierproblem löst, dann gilt für die mittlere Vergleichsanzahl V n
(gemittelt über die n! verschiedenen Eingabeanordnungen):
V n ≥ log(n!).
Beweis: Der Vergleichsbaum TA,n, den A erzeugt, hat N =
n! (externe) Blätter.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
111
Satz 6.6.2
Wenn A ein Schlüsselvergleichsverfahren ist, das das Sortierproblem löst, dann gilt für die mittlere Vergleichsanzahl V n
(gemittelt über die n! verschiedenen Eingabeanordnungen):
V n ≥ log(n!).
Beweis: Der Vergleichsbaum TA,n, den A erzeugt, hat N =
n! (externe) Blätter. – Proposition 3.3.5 (zu totaler äußerer
Weglänge) besagt:
TA,n hat N externe Knoten ⇒ TEPL(TA,n) ≥ N log N .
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
111
Satz 6.6.2
Wenn A ein Schlüsselvergleichsverfahren ist, das das Sortierproblem löst, dann gilt für die mittlere Vergleichsanzahl V n
(gemittelt über die n! verschiedenen Eingabeanordnungen):
V n ≥ log(n!).
Beweis: Der Vergleichsbaum TA,n, den A erzeugt, hat N =
n! (externe) Blätter. – Proposition 3.3.5 (zu totaler äußerer
Weglänge) besagt:
TA,n hat N externe Knoten ⇒ TEPL(TA,n) ≥ N log N .
Erwartete, mittlere äußere Weglänge E( N1 TEPL(TA,n)) ist
≥ log(N ).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
111
Satz 6.6.2
Wenn A ein Schlüsselvergleichsverfahren ist, das das Sortierproblem löst, dann gilt für die mittlere Vergleichsanzahl V n
(gemittelt über die n! verschiedenen Eingabeanordnungen):
V n ≥ log(n!).
Beweis: Der Vergleichsbaum TA,n, den A erzeugt, hat N =
n! (externe) Blätter. – Proposition 3.3.5 (zu totaler äußerer
Weglänge) besagt:
TA,n hat N externe Knoten ⇒ TEPL(TA,n) ≥ N log N .
Erwartete, mittlere äußere Weglänge E( N1 TEPL(TA,n)) ist
≥ log(N ).
Daraus: Die mittlere Anzahl von Vergleichen ist ≥ log(n!). FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
111
Satz 6.6.3
Wenn A ein Schlüsselvergleichsverfahren ist, das das Sortierproblem löst und dabei Randomisierung benutzt
(d. h. Zufallsexperimente ausführt, z. B. Randomisiertes Quicksort)
dann gibt es eine Eingabe a = (a1, . . . , an) aus verschiedenen Elementen von U ,
so dass die erwartete Vergleichsanzahl von A auf a
(gemittelt über die Zufallsexperimente von A)
≥ log(n!) ist.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
112
Satz 6.6.3
Wenn A ein Schlüsselvergleichsverfahren ist, das das Sortierproblem löst und dabei Randomisierung benutzt
(d. h. Zufallsexperimente ausführt, z. B. Randomisiertes Quicksort)
dann gibt es eine Eingabe a = (a1, . . . , an) aus verschiedenen Elementen von U ,
so dass die erwartete Vergleichsanzahl von A auf a
(gemittelt über die Zufallsexperimente von A)
≥ log(n!) ist.
Beweis (für Interessierte): Druckfolien.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
112
6.7. Sortieren in Linearzeit
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
113
6.7. Sortieren in Linearzeit
Schlüssel nicht als atomares Objekt, sondern als Index
benutzen
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
113
6.7. Sortieren in Linearzeit
Schlüssel nicht als atomares Objekt, sondern als Index
benutzen
→ untere Schranke gilt nicht.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
113
6.7. Sortieren in Linearzeit
Schlüssel nicht als atomares Objekt, sondern als Index
benutzen
→ untere Schranke gilt nicht.
U = {0, 1, . . . , m − 1} = [m].
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
113
6.7. Sortieren in Linearzeit
Schlüssel nicht als atomares Objekt, sondern als Index
benutzen
→ untere Schranke gilt nicht.
U = {0, 1, . . . , m − 1} = [m].
Gegeben: n Objekte mit Schlüsseln a1, . . . , an aus U . Sortiere!
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
113
6.7. Sortieren in Linearzeit
Schlüssel nicht als atomares Objekt, sondern als Index
benutzen
→ untere Schranke gilt nicht.
U = {0, 1, . . . , m − 1} = [m].
Gegeben: n Objekte mit Schlüsseln a1, . . . , an aus U . Sortiere!
Präziser: Gegeben sind in A[1..n] n Datenobjekte
(a1, d1), . . . , (an, dn)
mit Schlüsseln a1, . . . , an aus U . Sortiere (stabil)!
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
113
(A) Countingsort – Sortieren durch Zählen
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
114
(A) Countingsort – Sortieren durch Zählen
Idee, drei Phasen:
1. Zähle in Komponente C[i] eines Arrays C[0..m − 1], wie
oft der Schlüssel i vorkommt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
114
(A) Countingsort – Sortieren durch Zählen
Idee, drei Phasen:
1. Zähle in Komponente C[i] eines Arrays C[0..m − 1], wie
oft der Schlüssel i vorkommt.
2. Benutze dies (wieder in C[i]), um zu berechnen, wie viele
Einträge in A einen Schlüssel ≤ i haben.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
114
(A) Countingsort – Sortieren durch Zählen
Idee, drei Phasen:
1. Zähle in Komponente C[i] eines Arrays C[0..m − 1], wie
oft der Schlüssel i vorkommt.
2. Benutze dies (wieder in C[i]), um zu berechnen, wie viele
Einträge in A einen Schlüssel ≤ i haben.
3. Übertrage die Einträge mit Schlüssel i aus A in die Positionen
C[i − 1] + 1, . . . ,C[i] in Array B, stabil.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
114
1. Zähle in Komponente C[i] eines Arrays C[0..m − 1], wie
oft der Schlüssel i vorkommt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
115
1. Zähle in Komponente C[i] eines Arrays C[0..m − 1], wie
oft der Schlüssel i vorkommt.
for i from 0 to m − 1 do
(2)
C[i] ← 0; // Zeitaufwand: Θ(m)
(3) for j from 1 to n do C[A[j].key]++;
// Zeitaufwand: Θ(n)
(1)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
115
1. Zähle in Komponente C[i] eines Arrays C[0..m − 1], wie
oft der Schlüssel i vorkommt.
for i from 0 to m − 1 do
(2)
C[i] ← 0; // Zeitaufwand: Θ(m)
(3) for j from 1 to n do C[A[j].key]++;
// Zeitaufwand: Θ(n)
(1)
2. Benutze dies (wieder in C[i]), um zu berechnen, wie viele
Einträge in A einen Schlüssel ≤ i haben.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
115
1. Zähle in Komponente C[i] eines Arrays C[0..m − 1], wie
oft der Schlüssel i vorkommt.
for i from 0 to m − 1 do
(2)
C[i] ← 0; // Zeitaufwand: Θ(m)
(3) for j from 1 to n do C[A[j].key]++;
// Zeitaufwand: Θ(n)
(1)
2. Benutze dies (wieder in C[i]), um zu berechnen, wie viele
Einträge in A einen Schlüssel ≤ i haben.
for i from 1 to m − 1 do
(5)
C[i] ← C[i−1] + C[i]; // Zeitaufwand: Θ(m)
(4)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
115
3. Übertrage die Einträge mit Schlüssel i aus A in die Positionen
C[i − 1] + 1, . . . ,C[i] in Array B, stabil.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
3. Übertrage die Einträge mit Schlüssel i aus A in die Positionen
C[i − 1] + 1, . . . ,C[i] in Array B, stabil.
Geschickt: In A[1..n] einmal von hinten nach vorne laufen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
3. Übertrage die Einträge mit Schlüssel i aus A in die Positionen
C[i − 1] + 1, . . . ,C[i] in Array B, stabil.
Geschickt: In A[1..n] einmal von hinten nach vorne laufen.
Zum Verständnis beobachte: Wenn Eintrag mit Schlüssel i,
der in A am weitesten rechts steht, an Stelle A[j] steht, muss
dieser an die Stelle B[C[i]].
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
3. Übertrage die Einträge mit Schlüssel i aus A in die Positionen
C[i − 1] + 1, . . . ,C[i] in Array B, stabil.
Geschickt: In A[1..n] einmal von hinten nach vorne laufen.
Zum Verständnis beobachte: Wenn Eintrag mit Schlüssel i,
der in A am weitesten rechts steht, an Stelle A[j] steht, muss
dieser an die Stelle B[C[i]]. Der nächste Eintrag mit diesem
Schlüssel muss in das Fach unmittelbar links daneben
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
3. Übertrage die Einträge mit Schlüssel i aus A in die Positionen
C[i − 1] + 1, . . . ,C[i] in Array B, stabil.
Geschickt: In A[1..n] einmal von hinten nach vorne laufen.
Zum Verständnis beobachte: Wenn Eintrag mit Schlüssel i,
der in A am weitesten rechts steht, an Stelle A[j] steht, muss
dieser an die Stelle B[C[i]]. Der nächste Eintrag mit diesem
Schlüssel muss in das Fach unmittelbar links daneben – daher:
übertragen, dann C[i] herunterzählen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
3. Übertrage die Einträge mit Schlüssel i aus A in die Positionen
C[i − 1] + 1, . . . ,C[i] in Array B, stabil.
Geschickt: In A[1..n] einmal von hinten nach vorne laufen.
Zum Verständnis beobachte: Wenn Eintrag mit Schlüssel i,
der in A am weitesten rechts steht, an Stelle A[j] steht, muss
dieser an die Stelle B[C[i]]. Der nächste Eintrag mit diesem
Schlüssel muss in das Fach unmittelbar links daneben – daher:
übertragen, dann C[i] herunterzählen.
for j from n downto 1 do
(7)
i ← A[j].key;
(8)
B[C[i]] ← A[j]; // aktueller Platz für Schlüssel i
(9)
C[i]--; // auf linken Nachbarn umsetzen
// Zeitaufwand: Θ(n)
(6)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
1
2
3
4
5
6
7
8
9
A: 5 1 0 1 6 1 3 1 5 2 6 2 3 2 2 1 3 3
0
1
2
3
4
5
6
1
2
3
4
5
6
7
C:
8
9
B:
Eingabe, Datenstruktur.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
1
2
3
4
5
6
7
8
9
A: 5 1 0 1 6 1 3 1 5 2 6 2 3 2 2 1 3 3
0
1
2
3
4
5
6
C: 1
0
1
3
0
2
2
1
2
3
4
5
6
7
8
9
B:
Nach (1)–(3): Einträge gezählt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
1
2
3
4
5
6
7
8
9
A: 5 1 0 1 6 1 3 1 5 2 6 2 3 2 2 1 3 3
0
1
2
3
4
5
6
C: 1
1
2
5
5
7
9
1
2
3
4
5
6
7
8
9
B:
Nach (4)–(5): Endpunkte der Segmente gleicher Schlüssel
ermittelt.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
1
2
3
4
5
6
7
8
9
A: 5 1 0 1 6 1 3 1 5 2 6 2 3 2 2 1 3 3
0
1
2
3
4
5
6
C: 1
1
2
5
5
7
9
1
2
3
4
5
6
7
8
9
33
B:
Zeile (8): Eintrag kopieren.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
1
2
3
4
5
6
7
8
9
A: 5 1 0 1 6 1 3 1 5 2 6 2 3 2 2 1 3 3
0
1
2
3
4
5
6
C: 1
1
2
4
5
7
9
1
2
3
4
5
6
7
8
9
33
B:
Zeile (9): Index heruntersetzen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
1
2
3
4
5
6
7
8
9
A: 5 1 0 1 6 1 3 1 5 2 6 2 3 2 2 1 3 3
0
1
2
3
4
5
6
C: 1
1
2
4
5
7
9
1
2
3
4
5
6
7
B:
FG KTuEA, TU Ilmenau
8
9
33
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
1
2
3
4
5
6
7
8
9
A: 5 1 0 1 6 1 3 1 5 2 6 2 3 2 2 1 3 3
0
1
2
3
4
5
6
C: 1
1
2
4
5
7
9
1
2
3
4
5
6
7
B:
21
8
9
33
Zeile (8): Eintrag kopieren.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
1
2
3
4
5
6
7
8
9
A: 5 1 0 1 6 1 3 1 5 2 6 2 3 2 2 1 3 3
0
1
2
3
4
5
6
C: 1
1
1
4
5
7
9
1
2
3
4
5
6
7
B:
21
8
9
33
Zeile (9): Index heruntersetzen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
1
2
3
4
5
6
7
8
9
A: 5 1 0 1 6 1 3 1 5 2 6 2 3 2 2 1 3 3
0
1
2
3
4
5
6
C: 1
1
1
4
5
7
9
1
2
3
4
5
6
7
B:
FG KTuEA, TU Ilmenau
21
8
9
33
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
1
2
3
4
5
6
7
8
9
A: 5 1 0 1 6 1 3 1 5 2 6 2 3 2 2 1 3 3
0
1
2
3
4
5
6
C: 1
1
1
4
5
7
9
1
2
3
4
5
6
7
B:
21
8
9
3 2 33
Zeile (8): Eintrag kopieren.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
1
2
3
4
5
6
7
8
9
A: 5 1 0 1 6 1 3 1 5 2 6 2 3 2 2 1 3 3
0
1
2
3
4
5
6
C: 1
1
1
3
5
7
9
1
2
3
4
5
6
7
B:
21
8
9
3 2 33
Zeile (9): Index heruntersetzen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
1
2
3
4
5
6
7
8
9
A: 5 1 0 1 6 1 3 1 5 2 6 2 3 2 2 1 3 3
0
1
2
3
4
5
6
C: 1
1
1
3
5
7
9
1
2
3
4
5
6
7
B:
FG KTuEA, TU Ilmenau
21
8
9
3 2 33
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
1
2
3
4
5
6
7
8
9
A: 5 1 0 1 6 1 3 1 5 2 6 2 3 2 2 1 3 3
0
1
2
3
4
5
6
C: 0
1
1
2
5
5
7
1
2
3
4
5
6
7
8
9
B: 0 1 2 1 3 1 3 2 3 3 5 1 5 2 6 1 6 2
Resultat nach Beendigung der Schleife (6)–(9).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
116
Satz 6.7.1 (Countingsort – Sortieren durch Zählen)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
117
Satz 6.7.1 (Countingsort – Sortieren durch Zählen)
n Objekte mit Schlüsseln aus [m] (gegeben in Array) können
in Zeit Θ(n + m)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
117
Satz 6.7.1 (Countingsort – Sortieren durch Zählen)
n Objekte mit Schlüsseln aus [m] (gegeben in Array) können
in Zeit Θ(n + m) und mit Zusatzplatz Θ(n + m)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
117
Satz 6.7.1 (Countingsort – Sortieren durch Zählen)
n Objekte mit Schlüsseln aus [m] (gegeben in Array) können
in Zeit Θ(n + m) und mit Zusatzplatz Θ(n + m) sortiert
werden.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
117
Satz 6.7.1 (Countingsort – Sortieren durch Zählen)
n Objekte mit Schlüsseln aus [m] (gegeben in Array) können
in Zeit Θ(n + m) und mit Zusatzplatz Θ(n + m) sortiert
werden.
Das Sortierverfahren ist stabil.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
117
Satz 6.7.1 (Countingsort – Sortieren durch Zählen)
n Objekte mit Schlüsseln aus [m] (gegeben in Array) können
in Zeit Θ(n + m) und mit Zusatzplatz Θ(n + m) sortiert
werden.
Das Sortierverfahren ist stabil.
Linearzeit und linearer Platz, falls m ≤ cn, c konstant.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
117
Satz 6.7.1 (Countingsort – Sortieren durch Zählen)
n Objekte mit Schlüsseln aus [m] (gegeben in Array) können
in Zeit Θ(n + m) und mit Zusatzplatz Θ(n + m) sortiert
werden.
Das Sortierverfahren ist stabil.
Linearzeit und linearer Platz, falls m ≤ cn, c konstant.
Countingsort ist auch in der praktischen Anwendung sehr
schnell (wenn auch nicht Cache-freundlich).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
117
(B) Bucketsort – Fachsortieren
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
118
(B) Bucketsort – Fachsortieren
Nun seien die zu sortierenden Objekte mit Schlüsseln aus [m]
als (einfach verkettete) lineare Liste gegeben.
A:
FG KTuEA, TU Ilmenau
5 a
2 a
5 b
3 a
1 b
6 a
5 c
2 b
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
1 a
118
(B) Bucketsort – Fachsortieren
Nun seien die zu sortierenden Objekte mit Schlüsseln aus [m]
als (einfach verkettete) lineare Liste gegeben.
A:
5 a
2 a
5 b
3 a
1 b
6 a
5 c
2 b
1 a
Datenstruktur: Array B[0..m − 1] von Listen L0 . . . , Lm−1.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
118
(B) Bucketsort – Fachsortieren
Nun seien die zu sortierenden Objekte mit Schlüsseln aus [m]
als (einfach verkettete) lineare Liste gegeben.
A:
5 a
2 a
5 b
3 a
1 b
6 a
5 c
2 b
1 a
Datenstruktur: Array B[0..m − 1] von Listen L0 . . . , Lm−1.
Initialisierung mit NULL-Zeigern: Zeit Θ(m).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
118
Durchlaufe Eingabeliste, übertrage Einträge mit Schlüssel i an
den Anfang der Liste Li (angehängt in B[i]): Zeit Θ(n).
Nach Transport in das Listenarray:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
119
Durchlaufe Eingabeliste, übertrage Einträge mit Schlüssel i an
den Anfang der Liste Li (angehängt in B[i]): Zeit Θ(n).
Nach Transport in das Listenarray:
B:
0:
1:
1 b
1 a
2:
2 b
2 a
3:
3 a
4:
FG KTuEA, TU Ilmenau
5:
5 c
6:
6 a
5 b
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
5 a
119
Durchlaufe Eingabeliste, übertrage Einträge mit Schlüssel i an
den Anfang der Liste Li (angehängt in B[i]): Zeit Θ(n).
Nach Transport in das Listenarray:
B:
0:
1:
1 b
1 a
2:
2 b
2 a
3:
3 a
4:
5:
5 c
6:
6 a
5 b
5 a
Bemerke: Identische Schlüssel in umgekehrter Reihenfolge.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
119
Durchlaufe Array B[0..m − 1] von hinten nach vorn, baue
neue sortierte Liste A (anfangs leer).
Für i: lies Elemente der Liste Li aus, hänge sie vorne in die
Liste A ein.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
120
Durchlaufe Array B[0..m − 1] von hinten nach vorn, baue
neue sortierte Liste A (anfangs leer).
Für i: lies Elemente der Liste Li aus, hänge sie vorne in die
Liste A ein.
Nach Auslesen:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
120
Durchlaufe Array B[0..m − 1] von hinten nach vorn, baue
neue sortierte Liste A (anfangs leer).
Für i: lies Elemente der Liste Li aus, hänge sie vorne in die
Liste A ein.
Nach Auslesen:
A:
1 a
FG KTuEA, TU Ilmenau
1 b
2 a
2 b
5 b
5 c
6 a
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
3 a
5 a
120
Algorithmus Bucketsort (Fachsortieren)
(1) Bearbeite Elemente der Liste A nacheinander.
Füge Listenelement
i
data
vorn in Liste B[i] ein.
NB: Reihenfolge von Elementen mit demselben Schlüssel wird umgedreht.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
121
Algorithmus Bucketsort (Fachsortieren)
(1) Bearbeite Elemente der Liste A nacheinander.
Füge Listenelement
i
data
vorn in Liste B[i] ein.
NB: Reihenfolge von Elementen mit demselben Schlüssel wird umgedreht.
(2) Für i = m − 1, . . . , 1, 0: lies B[i] von vorn nach hinten.
Füge Element i data
vorn in Ausgabeliste ein.
NB: Reihenfolge wird erneut umgedreht → Stabilität.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
121
Algorithmus Bucketsort (Fachsortieren)
(1) Bearbeite Elemente der Liste A nacheinander.
Füge Listenelement
i
data
vorn in Liste B[i] ein.
NB: Reihenfolge von Elementen mit demselben Schlüssel wird umgedreht.
(2) Für i = m − 1, . . . , 1, 0: lies B[i] von vorn nach hinten.
Füge Element i data
vorn in Ausgabeliste ein.
NB: Reihenfolge wird erneut umgedreht → Stabilität.
Satz 6.7.2 (Bucketsort/Fachsortieren)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
121
Algorithmus Bucketsort (Fachsortieren)
(1) Bearbeite Elemente der Liste A nacheinander.
Füge Listenelement
i
data
vorn in Liste B[i] ein.
NB: Reihenfolge von Elementen mit demselben Schlüssel wird umgedreht.
(2) Für i = m − 1, . . . , 1, 0: lies B[i] von vorn nach hinten.
Füge Element i data
vorn in Ausgabeliste ein.
NB: Reihenfolge wird erneut umgedreht → Stabilität.
Satz 6.7.2 (Bucketsort/Fachsortieren)
n Objekte mit Schlüsseln aus [m] (gegeben als lineare Liste)
können in Zeit Θ(n + m)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
121
Algorithmus Bucketsort (Fachsortieren)
(1) Bearbeite Elemente der Liste A nacheinander.
Füge Listenelement
i
data
vorn in Liste B[i] ein.
NB: Reihenfolge von Elementen mit demselben Schlüssel wird umgedreht.
(2) Für i = m − 1, . . . , 1, 0: lies B[i] von vorn nach hinten.
Füge Element i data
vorn in Ausgabeliste ein.
NB: Reihenfolge wird erneut umgedreht → Stabilität.
Satz 6.7.2 (Bucketsort/Fachsortieren)
n Objekte mit Schlüsseln aus [m] (gegeben als lineare Liste)
können in Zeit Θ(n + m) und mit Zusatzplatz für m Zeiger
stabil sortiert werden.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
121
Was tun, wenn die Anzahl m der möglichen Schlüssel begrenzt,
aber deutlich größer als n ist? (Beispiel: m ≤ n2.)
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
122
Was tun, wenn die Anzahl m der möglichen Schlüssel begrenzt,
aber deutlich größer als n ist? (Beispiel: m ≤ n2.)
(C) Radixsort – Mehrphasen-Counting-/Bucketsort
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
122
Was tun, wenn die Anzahl m der möglichen Schlüssel begrenzt,
aber deutlich größer als n ist? (Beispiel: m ≤ n2.)
(C) Radixsort – Mehrphasen-Counting-/Bucketsort
Anwendbar in verschiedenen Situationen:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
122
Was tun, wenn die Anzahl m der möglichen Schlüssel begrenzt,
aber deutlich größer als n ist? (Beispiel: m ≤ n2.)
(C) Radixsort – Mehrphasen-Counting-/Bucketsort
Anwendbar in verschiedenen Situationen:
1. Schlüssel sind Folgen x = (x1, . . . , xk ) ∈ U k , U = [m], m ≤ n.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
122
Was tun, wenn die Anzahl m der möglichen Schlüssel begrenzt,
aber deutlich größer als n ist? (Beispiel: m ≤ n2.)
(C) Radixsort – Mehrphasen-Counting-/Bucketsort
Anwendbar in verschiedenen Situationen:
1. Schlüssel sind Folgen x = (x1, . . . , xk ) ∈ U k , U = [m], m ≤ n.
Anordnungskriterium: lexikographisch, d. h.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
122
Was tun, wenn die Anzahl m der möglichen Schlüssel begrenzt,
aber deutlich größer als n ist? (Beispiel: m ≤ n2.)
(C) Radixsort – Mehrphasen-Counting-/Bucketsort
Anwendbar in verschiedenen Situationen:
1. Schlüssel sind Folgen x = (x1, . . . , xk ) ∈ U k , U = [m], m ≤ n.
Anordnungskriterium: lexikographisch, d. h.
(x1, . . . , xk ) < (y1, . . . , yk )
⇔ ∃j ∈ {1, . . . , k} : (x1, . . . , xj−1) = (y1, . . . , yj−1) ∧ xj < yj .
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
122
Was tun, wenn die Anzahl m der möglichen Schlüssel begrenzt,
aber deutlich größer als n ist? (Beispiel: m ≤ n2.)
(C) Radixsort – Mehrphasen-Counting-/Bucketsort
Anwendbar in verschiedenen Situationen:
1. Schlüssel sind Folgen x = (x1, . . . , xk ) ∈ U k , U = [m], m ≤ n.
Anordnungskriterium: lexikographisch, d. h.
(x1, . . . , xk ) < (y1, . . . , yk )
⇔ ∃j ∈ {1, . . . , k} : (x1, . . . , xj−1) = (y1, . . . , yj−1) ∧ xj < yj .
2. Schlüssel sind Zahlen x in U ⊆ {0, 1, . . . , mk − 1}, m ≤ n.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
122
3. k (möglicherweise verschiedene) geordnete Mengen
(U1, <1), . . . , (Uk , <k )
Schlüssel sind Folgen x = (x1, . . . , xk ) ∈ U1 × · · · × Uk
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
123
3. k (möglicherweise verschiedene) geordnete Mengen
(U1, <1), . . . , (Uk , <k )
Schlüssel sind Folgen x = (x1, . . . , xk ) ∈ U1 × · · · × Uk ,
mit lexikographischer Ordnung.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
123
3. k (möglicherweise verschiedene) geordnete Mengen
(U1, <1), . . . , (Uk , <k )
Schlüssel sind Folgen x = (x1, . . . , xk ) ∈ U1 × · · · × Uk ,
mit lexikographischer Ordnung.
Beispiele:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
123
3. k (möglicherweise verschiedene) geordnete Mengen
(U1, <1), . . . , (Uk , <k )
Schlüssel sind Folgen x = (x1, . . . , xk ) ∈ U1 × · · · × Uk ,
mit lexikographischer Ordnung.
Beispiele:
Daten: {1, . . . , 31} × {1, . . . , 12} × {1801, . . . , 2090}.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
123
3. k (möglicherweise verschiedene) geordnete Mengen
(U1, <1), . . . , (Uk , <k )
Schlüssel sind Folgen x = (x1, . . . , xk ) ∈ U1 × · · · × Uk ,
mit lexikographischer Ordnung.
Beispiele:
Daten: {1, . . . , 31} × {1, . . . , 12} × {1801, . . . , 2090}.
Spielkarten: {♦, ♥, ♠, ♣}×{2, . . . , 10, Bube, Dame, König, Ass}.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
123
4. Σ<∞. Dabei: Σ ist Alphabet“, d. h. nichtleere endliche
”
Menge (z. B. ASCII-Alphabet) mit Ordnung <.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
124
4. Σ<∞. Dabei: Σ ist Alphabet“, d. h. nichtleere endliche
”
Menge (z. B. ASCII-Alphabet) mit Ordnung <.
(4a) Lexikographische Ordnung auf Σ<∞ (wie im Lexikon):
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
124
4. Σ<∞. Dabei: Σ ist Alphabet“, d. h. nichtleere endliche
”
Menge (z. B. ASCII-Alphabet) mit Ordnung <.
(4a) Lexikographische Ordnung auf Σ<∞ (wie im Lexikon):
(x1, . . . , xk ) <lex (y1, . . . , y`)
⇔
k < ` ∧ (x1, . . . , xk ) = (y1, . . . , yk ) ∨
∃j ∈ {1, . . . , min{k, `}} : (x1, . . . , xj−1) = (y1, . . . , yj−1) ∧ xj < yj .
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
124
4. Σ<∞. Dabei: Σ ist Alphabet“, d. h. nichtleere endliche
”
Menge (z. B. ASCII-Alphabet) mit Ordnung <.
(4a) Lexikographische Ordnung auf Σ<∞ (wie im Lexikon):
(x1, . . . , xk ) <lex (y1, . . . , y`)
⇔
k < ` ∧ (x1, . . . , xk ) = (y1, . . . , yk ) ∨
∃j ∈ {1, . . . , min{k, `}} : (x1, . . . , xj−1) = (y1, . . . , yj−1) ∧ xj < yj .
(4b) Kanonische Ordnung auf Σ<∞ (kürzere Strings zuerst):
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
124
4. Σ<∞. Dabei: Σ ist Alphabet“, d. h. nichtleere endliche
”
Menge (z. B. ASCII-Alphabet) mit Ordnung <.
(4a) Lexikographische Ordnung auf Σ<∞ (wie im Lexikon):
(x1, . . . , xk ) <lex (y1, . . . , y`)
⇔
k < ` ∧ (x1, . . . , xk ) = (y1, . . . , yk ) ∨
∃j ∈ {1, . . . , min{k, `}} : (x1, . . . , xj−1) = (y1, . . . , yj−1) ∧ xj < yj .
(4b) Kanonische Ordnung auf Σ<∞ (kürzere Strings zuerst):
(x1, . . . , xk ) <kan (y1, . . . , y`)
⇔ k<` ∨
k = ` ∧ ∃j ∈ {1, . . . , k} : (x1, . . . , xj−1) = (y1, . . . , yj−1) ∧ xj < yj .
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
124
Zunächst:
Situation 1, Schlüssel x = (x1, . . . , xk ) ∈ U k , U = [m].
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
125
Zunächst:
Situation 1, Schlüssel x = (x1, . . . , xk ) ∈ U k , U = [m].
Idee: sortiere k-mal mittels Counting-/Bucketsort
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
125
Zunächst:
Situation 1, Schlüssel x = (x1, . . . , xk ) ∈ U k , U = [m].
Idee: sortiere k-mal mittels Counting-/Bucketsort
und zwar gemäß Komponente k,
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
125
Zunächst:
Situation 1, Schlüssel x = (x1, . . . , xk ) ∈ U k , U = [m].
Idee: sortiere k-mal mittels Counting-/Bucketsort
und zwar gemäß Komponente k, dann k − 1,
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
125
Zunächst:
Situation 1, Schlüssel x = (x1, . . . , xk ) ∈ U k , U = [m].
Idee: sortiere k-mal mittels Counting-/Bucketsort
und zwar gemäß Komponente k, dann k − 1, . . . , dann 1
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
125
Zunächst:
Situation 1, Schlüssel x = (x1, . . . , xk ) ∈ U k , U = [m].
Idee: sortiere k-mal mittels Counting-/Bucketsort
und zwar gemäß Komponente k, dann k − 1, . . . , dann 1
(die am wenigsten signifikante“ Komponente zuerst).
”
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
125
Zunächst:
Situation 1, Schlüssel x = (x1, . . . , xk ) ∈ U k , U = [m].
Idee: sortiere k-mal mittels Counting-/Bucketsort
und zwar gemäß Komponente k, dann k − 1, . . . , dann 1
(die am wenigsten signifikante“ Komponente zuerst).
”
Eingabe:
Array/Liste A: Einträge mit Schlüsseln (x1, . . . , xk ) aus [m]k .
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
125
Zunächst:
Situation 1, Schlüssel x = (x1, . . . , xk ) ∈ U k , U = [m].
Idee: sortiere k-mal mittels Counting-/Bucketsort
und zwar gemäß Komponente k, dann k − 1, . . . , dann 1
(die am wenigsten signifikante“ Komponente zuerst).
”
Eingabe:
Array/Liste A: Einträge mit Schlüsseln (x1, . . . , xk ) aus [m]k .
Methode:
für l = k, k − 1, . . . , 1 tue:
sortiere A mittels Counting- bzw. Bucketsort für U = [m]
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
125
Zunächst:
Situation 1, Schlüssel x = (x1, . . . , xk ) ∈ U k , U = [m].
Idee: sortiere k-mal mittels Counting-/Bucketsort
und zwar gemäß Komponente k, dann k − 1, . . . , dann 1
(die am wenigsten signifikante“ Komponente zuerst).
”
Eingabe:
Array/Liste A: Einträge mit Schlüsseln (x1, . . . , xk ) aus [m]k .
Methode:
für l = k, k − 1, . . . , 1 tue:
sortiere A mittels Counting- bzw. Bucketsort für U = [m]
mit Komponente xl aus (x1, . . . , xk ) als Sortierschlüssel.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
125
Zunächst:
Situation 1, Schlüssel x = (x1, . . . , xk ) ∈ U k , U = [m].
Idee: sortiere k-mal mittels Counting-/Bucketsort
und zwar gemäß Komponente k, dann k − 1, . . . , dann 1
(die am wenigsten signifikante“ Komponente zuerst).
”
Eingabe:
Array/Liste A: Einträge mit Schlüsseln (x1, . . . , xk ) aus [m]k .
Methode:
für l = k, k − 1, . . . , 1 tue:
sortiere A mittels Counting- bzw. Bucketsort für U = [m]
mit Komponente xl aus (x1, . . . , xk ) als Sortierschlüssel.
Zeit insgesamt: Θ(k · (n + m))
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
125
Zunächst:
Situation 1, Schlüssel x = (x1, . . . , xk ) ∈ U k , U = [m].
Idee: sortiere k-mal mittels Counting-/Bucketsort
und zwar gemäß Komponente k, dann k − 1, . . . , dann 1
(die am wenigsten signifikante“ Komponente zuerst).
”
Eingabe:
Array/Liste A: Einträge mit Schlüsseln (x1, . . . , xk ) aus [m]k .
Methode:
für l = k, k − 1, . . . , 1 tue:
sortiere A mittels Counting- bzw. Bucketsort für U = [m]
mit Komponente xl aus (x1, . . . , xk ) als Sortierschlüssel.
Zeit insgesamt: Θ(k · (n + m))
Zusatzplatz: Θ(m + n) bzw. Θ(m).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
125
Beispiel:
U = {A,B,C,D}
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
126
Beispiel:
U = {A,B,C,D}
Eingabe A:
FG KTuEA, TU Ilmenau
BCC
ABC
BAC
CAD
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
ABA
126
Beispiel:
U = {A,B,C,D}
Eingabe A:
BCC
ABC
Nach Runde l = 3: ABA
FG KTuEA, TU Ilmenau
BCC
BAC
CAD
ABC
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
BAC
ABA
CAD
126
Beispiel:
U = {A,B,C,D}
Eingabe A:
BCC
ABC
BAC
CAD
ABA
Nach Runde l = 3: ABA
BCC
ABC
BAC
CAD
Nach Runde l = 2: BAC
CAD
ABA
ABC
BCC
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
126
Beispiel:
U = {A,B,C,D}
Eingabe A:
BCC
ABC
BAC
CAD
ABA
Nach Runde l = 3: ABA
BCC
ABC
BAC
CAD
Nach Runde l = 2: BAC
CAD
ABA
ABC
BCC
Nach Runde l = 1: ABA
ABC
BAC
BCC
CAD
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
126
Beispiel:
U = {A,B,C,D}
Eingabe A:
BCC
ABC
BAC
CAD
ABA
Nach Runde l = 3: ABA
BCC
ABC
BAC
CAD
Nach Runde l = 2: BAC
CAD
ABA
ABC
BCC
Nach Runde l = 1: ABA
ABC
BAC
BCC
CAD
Beobachte: Nach Runde für l sind die Objekte gemäß
xl, . . . , xk sortiert.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
126
Satz 6.7.3
Der skizzierte Algorithmus Radixsort sortiert n Objekte mit
Schlüsseln aus [m]k in Zeit Θ(k(n + m)) und Platz Θ(m)
(bzw. Θ(n + m) für Arrays).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
127
Satz 6.7.3
Der skizzierte Algorithmus Radixsort sortiert n Objekte mit
Schlüsseln aus [m]k in Zeit Θ(k(n + m)) und Platz Θ(m)
(bzw. Θ(n + m) für Arrays). Das Verfahren ist stabil.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
127
Satz 6.7.3
Der skizzierte Algorithmus Radixsort sortiert n Objekte mit
Schlüsseln aus [m]k in Zeit Θ(k(n + m)) und Platz Θ(m)
(bzw. Θ(n + m) für Arrays). Das Verfahren ist stabil.
Das Verfahren für U1 × · · · × Uk (Situation 3) ist im wesentlichen dasselbe, nur benötigt man verschiedene B-Arrays (oder
Arrayabschnitte) in den einzelnen Durchgängen.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
127
Satz 6.7.3
Der skizzierte Algorithmus Radixsort sortiert n Objekte mit
Schlüsseln aus [m]k in Zeit Θ(k(n + m)) und Platz Θ(m)
(bzw. Θ(n + m) für Arrays). Das Verfahren ist stabil.
Das Verfahren für U1 × · · · × Uk (Situation 3) ist im wesentlichen dasselbe, nur benötigt man verschiedene B-Arrays (oder
Arrayabschnitte) in den einzelnen Durchgängen.
Zeit: O(kn+|U1|+· · ·+|Uk |); Platz: O(n+max1≤i≤k |Ui|).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
127
Satz 6.7.3
Der skizzierte Algorithmus Radixsort sortiert n Objekte mit
Schlüsseln aus [m]k in Zeit Θ(k(n + m)) und Platz Θ(m)
(bzw. Θ(n + m) für Arrays). Das Verfahren ist stabil.
Das Verfahren für U1 × · · · × Uk (Situation 3) ist im wesentlichen dasselbe, nur benötigt man verschiedene B-Arrays (oder
Arrayabschnitte) in den einzelnen Durchgängen.
Zeit: O(kn+|U1|+· · ·+|Uk |); Platz: O(n+max1≤i≤k |Ui|).
Situation 2: Schlüssel sind Zahlen in {0, 1, . . . , mk − 1}:
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
127
Satz 6.7.3
Der skizzierte Algorithmus Radixsort sortiert n Objekte mit
Schlüsseln aus [m]k in Zeit Θ(k(n + m)) und Platz Θ(m)
(bzw. Θ(n + m) für Arrays). Das Verfahren ist stabil.
Das Verfahren für U1 × · · · × Uk (Situation 3) ist im wesentlichen dasselbe, nur benötigt man verschiedene B-Arrays (oder
Arrayabschnitte) in den einzelnen Durchgängen.
Zeit: O(kn+|U1|+· · ·+|Uk |); Platz: O(n+max1≤i≤k |Ui|).
Situation 2: Schlüssel sind Zahlen in {0, 1, . . . , mk − 1}:
Repräsentiere Zahlen in m-ärer Darstellung (mit k Ziffern);
wende Radixsort an.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
127
Beispiel:
"
m = 10
(Dezimaldarstellung)
531 729 617 312 425 436
!
"
#
!
#
l =3
531
312
425 436 617
729
l =2
312
617
425 729 531
436
l =1
312
FG KTuEA, TU Ilmenau
425
436 531
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
617
729
128
Beispiel:
"
m = 10
(Dezimaldarstellung)
531 729 617 312 425 436
!
"
#
!
#
l =3
531
312
425 436 617
729
l =2
312
617
425 729 531
436
l =1
312
425
436 531
617
729
So kleine m sind nicht typisch.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
128
Beispiel:
"
m = 10
(Dezimaldarstellung)
531 729 617 312 425 436
!
"
#
!
#
l =3
531
312
425 436 617
729
l =2
312
617
425 729 531
436
l =1
312
425
436 531
617
729
So kleine m sind nicht typisch.
Sinnvoll: m ≈ n, m Zweierpotenz, z. B. m = 28 oder 216.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
128
Beispiel:
"
m = 10
(Dezimaldarstellung)
531 729 617 312 425 436
!
"
#
!
#
l =3
531
312
425 436 617
729
l =2
312
617
425 729 531
436
l =1
312
425
436 531
617
729
So kleine m sind nicht typisch.
Sinnvoll: m ≈ n, m Zweierpotenz, z. B. m = 28 oder 216.
Satz 6.7.4 Radixsort für Zahlen sortiert n Objekte mit
Schlüsseln aus [mk ] in Zeit Θ(k(n + m)) und Platz Θ(m)
(bzw. Θ(n + m) für Arrays).
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
128
Beispiel:
"
m = 10
(Dezimaldarstellung)
531 729 617 312 425 436
!
"
#
!
#
l =3
531
312
425 436 617
729
l =2
312
617
425 729 531
436
l =1
312
425
436 531
617
729
So kleine m sind nicht typisch.
Sinnvoll: m ≈ n, m Zweierpotenz, z. B. m = 28 oder 216.
Satz 6.7.4 Radixsort für Zahlen sortiert n Objekte mit
Schlüsseln aus [mk ] in Zeit Θ(k(n + m)) und Platz Θ(m)
(bzw. Θ(n + m) für Arrays). Das Verfahren ist stabil.
FG KTuEA, TU Ilmenau
Algorithmen und Datenstrukturen – SS15 – Kapitel 6
128