Blätterversion

SS11
Effiziente Algorithmen
3. Kapitel
Greedy-Algorithmen: Prinzipien
Martin Dietzfelbinger
Mai 2011
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
Kapitel 3: Greedy-Algorithmen
Greedy∗-Algorithmen sind anwendbar bei Konstruktionsaufgaben zum Finden einer optimalen Struktur.
Sie finden eine Lösung, die sie schrittweise aufbauen, ohne zurückzusetzen. Es werden dabei nicht mehr Teillösungen
konstruiert als unbedingt nötig.
∗
greedy (engl.): gierig.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
1
3.1 Zwei Beispiele
Beispiel 1: Hörsaalbelegung
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
2
3.1 Zwei Beispiele
Beispiel 1: Hörsaalbelegung
Gegeben: Veranstaltungsort (Hörsaal), Zeitspanne [T0, T1)
und eine Menge von n Aktionen (Vorlesungen oder ähnliches),
durch Start- und Endzeit spezifiziert:
[si, fi), für 1 ≤ i ≤ n.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
2
3.1 Zwei Beispiele
Beispiel 1: Hörsaalbelegung
Gegeben: Veranstaltungsort (Hörsaal), Zeitspanne [T0, T1)
und eine Menge von n Aktionen (Vorlesungen oder ähnliches),
durch Start- und Endzeit spezifiziert:
[si, fi), für 1 ≤ i ≤ n.
Gesucht: Belegung des Hörsaals, die möglichst viele Ereignisse mit disjunkten Zeitspannen stattfinden lässt.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
2
3.1 Zwei Beispiele
Beispiel 1: Hörsaalbelegung
Gegeben: Veranstaltungsort (Hörsaal), Zeitspanne [T0, T1)
und eine Menge von n Aktionen (Vorlesungen oder ähnliches),
durch Start- und Endzeit spezifiziert:
[si, fi), für 1 ≤ i ≤ n.
Gesucht: Belegung des Hörsaals, die möglichst viele Ereignisse mit disjunkten Zeitspannen stattfinden lässt.
Nenne eine Menge A ⊆ {1, . . . , n} zulässig, wenn alle [si, fi),
i ∈ A, disjunkt sind.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
2
3.1 Zwei Beispiele
Beispiel 1: Hörsaalbelegung
Gegeben: Veranstaltungsort (Hörsaal), Zeitspanne [T0, T1)
und eine Menge von n Aktionen (Vorlesungen oder ähnliches),
durch Start- und Endzeit spezifiziert:
[si, fi), für 1 ≤ i ≤ n.
Gesucht: Belegung des Hörsaals, die möglichst viele Ereignisse mit disjunkten Zeitspannen stattfinden lässt.
Nenne eine Menge A ⊆ {1, . . . , n} zulässig, wenn alle [si, fi),
i ∈ A, disjunkt sind.
Aufgabe, formal: Finde zulässige Menge A mit |A| so groß
wie möglich.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
2
T1
T0
Eingabe: Aktionen mit Beginn und Ende
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
3
T1
T0
Zulässige Lösung mit 4 Aktionen. Optimal?
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
4
T1
T0
Zulässige Lösung mit 5 Aktionen. Optimal?
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
5
Ansätze, die nicht funktionieren:
• Zuerst kurze Ereignisse planen
T0
T1
• Immer ein Ereignis mit möglichst früher Anfangszeit wählen
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
6
Ansätze, die nicht funktionieren:
• Zuerst kurze Ereignisse planen
T0
T1
• Immer ein Ereignis mit möglichst früher Anfangszeit wählen
T0
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
T1
6
Trick: Bearbeite Ereignisse nach wachsenden Schlusszeiten.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
7
Trick: Bearbeite Ereignisse nach wachsenden Schlusszeiten.
O.B.d.A.: Veranstaltungen nach Schlusszeiten aufsteigend sortiert (Zeitaufwand O(n log n)), also:
f1 ≤ f2 ≤ · · · ≤ fn.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
7
Trick: Bearbeite Ereignisse nach wachsenden Schlusszeiten.
O.B.d.A.: Veranstaltungen nach Schlusszeiten aufsteigend sortiert (Zeitaufwand O(n log n)), also:
f1 ≤ f2 ≤ · · · ≤ fn.
4
9
7
3
1
5
2
12
8
6
10
T1
T0
FG KTuEA, TU Ilmenau
11
Effiziente Algorithmen – SS11 – Kapitel 3
7
Wiederhole: Wähle die wählbare Aktion mit der kleinsten
Schlusszeit und füge sie zum Belegungsplan hinzu.
Eine Aktion ist wählbar, wenn ihre Startzeit mindestens so
groß wie die Schlusszeit der letzten schon geplanten Veranstaltung ist.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
8
Wiederhole: Wähle die wählbare Aktion mit der kleinsten
Schlusszeit und füge sie zum Belegungsplan hinzu.
Eine Aktion ist wählbar, wenn ihre Startzeit mindestens so
groß wie die Schlusszeit der letzten schon geplanten Veranstaltung ist.
T1
T0
Ausgabe von GS: Zulässige Lösung.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
8
Algorithmus Greedy Scheduling (GS)
Eingabe: [T0, T1), [s1, f1), . . . , [sn, fn), nichtleere
reelle Intervalle, [si, fi) ⊆ [T0, T1)
Ausgabe: Maximal großes A ⊆ {1, . . . , n} mit
[si, fi), i ∈ A disjunkt
Methode:
Sortiere Intervalle gemäß f1, . . . , fn aufsteigend;
A ← {1};
flast ← f1;
for i from 2 to n do
if si ≥ flast then (∗ [si, fi) wählbar ∗)
A ← A ∪ {i};
flast ← fi;
return A
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
9
Satz 3.1.1
Der Algorithmus Greedy Scheduling (GS) hat lineare Laufzeit (bis auf die Sortierkosten von O(n log n)) und löst das
Hörsaalplanungsproblem optimal.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
10
Satz 3.1.1
Der Algorithmus Greedy Scheduling (GS) hat lineare Laufzeit (bis auf die Sortierkosten von O(n log n)) und löst das
Hörsaalplanungsproblem optimal.
Beweis: Laufzeit: Sortieren kostet Zeit O(n log n); der restliche Algorithmus hat offensichtlich Laufzeit O(n).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
10
Satz 3.1.1
Der Algorithmus Greedy Scheduling (GS) hat lineare Laufzeit (bis auf die Sortierkosten von O(n log n)) und löst das
Hörsaalplanungsproblem optimal.
Beweis: Laufzeit: Sortieren kostet Zeit O(n log n); der restliche Algorithmus hat offensichtlich Laufzeit O(n).
Korrektheit: Wir behaupten: Algorithmus GS liefert auf Inputs
mit Größe n eine optimale Lösung, und beweisen dies durch
vollständige Induktion.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
10
Satz 3.1.1
Der Algorithmus Greedy Scheduling (GS) hat lineare Laufzeit (bis auf die Sortierkosten von O(n log n)) und löst das
Hörsaalplanungsproblem optimal.
Beweis: Laufzeit: Sortieren kostet Zeit O(n log n); der restliche Algorithmus hat offensichtlich Laufzeit O(n).
Korrektheit: Wir behaupten: Algorithmus GS liefert auf Inputs
mit Größe n eine optimale Lösung, und beweisen dies durch
vollständige Induktion.
Der Fall n = 1 ist trivial.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
10
Sei nun n > 1.
I.V.: GS liefert für Inputs der Länge n0 < n eine optimale
Lösung.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
11
Sei nun n > 1.
I.V.: GS liefert für Inputs der Länge n0 < n eine optimale
Lösung.
Ind.-Schritt: Sei B ⊆ {1, . . . , n} eine optimale Lösung,
|B| = r. (Im Beispiel: r = 5.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
11
Sei nun n > 1.
I.V.: GS liefert für Inputs der Länge n0 < n eine optimale
Lösung.
Ind.-Schritt: Sei B ⊆ {1, . . . , n} eine optimale Lösung,
|B| = r. (Im Beispiel: r = 5.)
T1
T0
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
11
1. Beobachtung:
Es gibt eine Lösung B 0, die mit dem Intervall [s1, f1) (dem
ersten Schritt des Greedy-Algorithmus) startet und ebenfalls r
Ereignisse hat. (Also ist B 0 auch optimal.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
12
1. Beobachtung:
Es gibt eine Lösung B 0, die mit dem Intervall [s1, f1) (dem
ersten Schritt des Greedy-Algorithmus) startet und ebenfalls r
Ereignisse hat. (Also ist B 0 auch optimal.)
T1
T0
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
12
1. Beobachtung:
Es gibt eine Lösung B 0, die mit dem Intervall [s1, f1) (dem
ersten Schritt des Greedy-Algorithmus) startet und ebenfalls r
Ereignisse hat. (Also ist B 0 auch optimal.)
T1
T0
Setze B 0 := (B − {min(B)}) ∪ {1}.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
12
1. Beobachtung:
Es gibt eine Lösung B 0, die mit dem Intervall [s1, f1) (dem
ersten Schritt des Greedy-Algorithmus) startet und ebenfalls r
Ereignisse hat. (Also ist B 0 auch optimal.)
T1
T0
Setze B 0 := (B − {min(B)}) ∪ {1}.
Intervalle aufsteigend sortiert ⇒ f1 ≤ fmin(B).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
12
2. Beobachtung:
Die Menge B − {min(B)} löst das Teilproblem
(∗)
[f1, T1), {[si, fi) | si ≥ f1}
optimal, das heißt:
in [f1, T1) können maximal r − 1 Ereignisse untergebracht
werden.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
13
2. Beobachtung:
Die Menge B − {min(B)} löst das Teilproblem
(∗)
[f1, T1), {[si, fi) | si ≥ f1}
optimal, das heißt:
in [f1, T1) können maximal r − 1 Ereignisse untergebracht
werden.
Wieso?
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
13
2. Beobachtung:
Die Menge B − {min(B)} löst das Teilproblem
(∗)
[f1, T1), {[si, fi) | si ≥ f1}
optimal, das heißt:
in [f1, T1) können maximal r − 1 Ereignisse untergebracht
werden.
Wieso? Sonst würden wir [s1, f1) mit einer besseren Lösung
für (∗) zu einer besseren Lösung für das Gesamtproblem
kombinieren: Widerspruch zur Optimalität von B.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
13
3. Beobachtung:
Algorithmus GS auf Eingabe {[si, fi) | 1 ≤ i ≤ n} hat ab
Iteration i = 2 genau dasselbe Verhalten wie wenn man GS
auf [f1, T1), {[si, fi) | si ≥ f1} starten würde.
Nach I.V. liefert also dieser Teil des Algorithmus eine optimale
Lösung mit r − 1 Ereignissen für (∗).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
14
3. Beobachtung:
Algorithmus GS auf Eingabe {[si, fi) | 1 ≤ i ≤ n} hat ab
Iteration i = 2 genau dasselbe Verhalten wie wenn man GS
auf [f1, T1), {[si, fi) | si ≥ f1} starten würde.
Nach I.V. liefert also dieser Teil des Algorithmus eine optimale
Lösung mit r − 1 Ereignissen für (∗).
Also liefert Greedy Scheduling insgesamt eine optimale Lösung
der Größe r.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
14
Beispiel 2: Fraktionales ( teilbares“) Rucksackproblem
”
Veranschaulichung: Ein Dieb stiehlt Säckchen mit Edelmetallkrümeln, die
beliebig teilbar sind. Der Wert pro Volumeneinheit ist unterschiedlich für
unterschiedliche Materialien. Was soll er in seinen Rucksack mit Volumen
b packen, um den Wert zu maximieren?
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
15
Beispiel 2: Fraktionales ( teilbares“) Rucksackproblem
”
Veranschaulichung: Ein Dieb stiehlt Säckchen mit Edelmetallkrümeln, die
beliebig teilbar sind. Der Wert pro Volumeneinheit ist unterschiedlich für
unterschiedliche Materialien. Was soll er in seinen Rucksack mit Volumen
b packen, um den Wert zu maximieren?
Gegeben: n Objekte mit positiven Volumina a1, . . . , an und
positiven Nutzenwerten c1, . . . , cn,
sowie eine Volumenschranke b.
Gesucht: Vektor (λ1, . . . , λn) ∈ [0, 1]n, so dass
λ1a1 + . . . + λnan ≤ b ( zulässig“)
”
und
λ1c1 + . . . + λncn maximal.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
15
Beim 0-1-Rucksackproblem“ werden nur 0-1-Vektoren mit
”
λi ∈ {0, 1} zugelassen.
Mitteilung (im Vorgriff auf BuK, 5. Sem.): Die {0, 1}-Version ist NPvollständig, besitzt also wahrscheinlich keinen effizienten Algorithmus.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
16
Beim 0-1-Rucksackproblem“ werden nur 0-1-Vektoren mit
”
λi ∈ {0, 1} zugelassen.
Mitteilung (im Vorgriff auf BuK, 5. Sem.): Die {0, 1}-Version ist NPvollständig, besitzt also wahrscheinlich keinen effizienten Algorithmus.
Das fraktionale Rucksackproblem ist mit einem GreedyAlgorithmus in Zeit O(n log n) lösbar.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
16
Beim 0-1-Rucksackproblem“ werden nur 0-1-Vektoren mit
”
λi ∈ {0, 1} zugelassen.
Mitteilung (im Vorgriff auf BuK, 5. Sem.): Die {0, 1}-Version ist NPvollständig, besitzt also wahrscheinlich keinen effizienten Algorithmus.
Das fraktionale Rucksackproblem ist mit einem GreedyAlgorithmus in Zeit O(n log n) lösbar.
Kern der Lösungsidee: Berechne Nutzendichte“
”
di = ci/ai, 1 ≤ i ≤ n,
und sortiere die Objekte gemäß di fallend.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
16
Beim 0-1-Rucksackproblem“ werden nur 0-1-Vektoren mit
”
λi ∈ {0, 1} zugelassen.
Mitteilung (im Vorgriff auf BuK, 5. Sem.): Die {0, 1}-Version ist NPvollständig, besitzt also wahrscheinlich keinen effizienten Algorithmus.
Das fraktionale Rucksackproblem ist mit einem GreedyAlgorithmus in Zeit O(n log n) lösbar.
Kern der Lösungsidee: Berechne Nutzendichte“
”
di = ci/ai, 1 ≤ i ≤ n,
und sortiere die Objekte gemäß di fallend.
Nehme von vorne beginnend möglichst viele ganze Objekte,
bis schließlich das letzte Objekt teilweise genommen wird, so
dass die Gewichtsschranke vollständig ausgenutzt wird.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
16
c1
c2
c
3
cn
a1
a2
a3
b
an
Input, sortiert nach Nutzendichte di = ci/ai.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
17
c1
c2
c
3
cn
a1
a2
a3
b
an
Input, sortiert nach Nutzendichte di = ci/ai.
Höhe von Kasten Nummer i ist di = ci/ai.
Breite ist ai.
Fläche ist ci.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
17
Algorithmus Greedy Fractional Knapsack (GFKS)
for i from 1 to n do
di ← ci/ai;
λi ← 0;
Sortiere Objekte gemäß di fallend;
i ← 0;
r ← b; (* Inhalt r ist das verfügbare Rest-Volumen *)
while r > 0 do
i++;
if ai ≤ r
then λi ← 1; r ← r − ai;
else λi ← r/ai;
r ← 0;
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
18
c1
c2
c
3
cn
a1
a2
a3
b
an
Vom Greedy-Algorithmus gelieferte Lösung.
Gesamtnutzen: grün.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
19
c1
c2
c
3
cn
a1
a2
a3
b
an
Zulässige Lösung, nicht optimal.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
20
c1
c2
c
3
cn
a1
a2
a3
b
an
Zulässige Lösung, nicht optimal. Gesamtnutzen: blau.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
20
c1
c2
c
3
cn
a1
a2
a3
c1
c2
c
b
an
3
cn
a1
a2
a3
b
an
Anschaulich: Greedy-Lösung nie schlechter als beliebige
Lösung.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
21
c1
c2
c
3
cn
a1
a2
a3
c1
c2
c
b
an
3
cn
a1
a2
a3
b
an
Anschaulich: Greedy-Lösung nie schlechter als beliebige
Lösung. Gleich: Vollständiger Beweis.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
21
Satz 3.1.2
Der Algorithmus GFKS ist korrekt (liefert eine zulässige Lösung
mit maximalem Gesamtnutzen) und hat Laufzeit O(n log n).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
22
Satz 3.1.2
Der Algorithmus GFKS ist korrekt (liefert eine zulässige Lösung
mit maximalem Gesamtnutzen) und hat Laufzeit O(n log n).
Beweis: Sei x = (a1, . . . , an, c1, . . . , cn, b) die Eingabe.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
22
Satz 3.1.2
Der Algorithmus GFKS ist korrekt (liefert eine zulässige Lösung
mit maximalem Gesamtnutzen) und hat Laufzeit O(n log n).
Beweis: Sei x = (a1, . . . , an, c1, . . . , cn, b) die Eingabe.
P
O.B.d.A.: i ai > b (sonst ist (λ1, . . . , λn) = (1, . . . , 1) optimal und wird von GFKS gefunden).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
22
Satz 3.1.2
Der Algorithmus GFKS ist korrekt (liefert eine zulässige Lösung
mit maximalem Gesamtnutzen) und hat Laufzeit O(n log n).
Beweis: Sei x = (a1, . . . , an, c1, . . . , cn, b) die Eingabe.
P
O.B.d.A.: i ai > b (sonst ist (λ1, . . . , λn) = (1, . . . , 1) optimal und wird von GFKS gefunden).
Sei (λ1, . . . , λn) ∈ [0, 1]n die Ausgabe des Algorithmus.
Laufzeit: klar.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
22
Satz 3.1.2
Der Algorithmus GFKS ist korrekt (liefert eine zulässige Lösung
mit maximalem Gesamtnutzen) und hat Laufzeit O(n log n).
Beweis: Sei x = (a1, . . . , an, c1, . . . , cn, b) die Eingabe.
P
O.B.d.A.: i ai > b (sonst ist (λ1, . . . , λn) = (1, . . . , 1) optimal und wird von GFKS gefunden).
Sei (λ1, . . . , λn) ∈ [0, 1]n die Ausgabe des Algorithmus.
Laufzeit: klar.
Korrektheit: Zulässigkeit klar. Zu zeigen: Optimalität.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
22
Satz 3.1.2
Der Algorithmus GFKS ist korrekt (liefert eine zulässige Lösung
mit maximalem Gesamtnutzen) und hat Laufzeit O(n log n).
Beweis: Sei x = (a1, . . . , an, c1, . . . , cn, b) die Eingabe.
P
O.B.d.A.: i ai > b (sonst ist (λ1, . . . , λn) = (1, . . . , 1) optimal und wird von GFKS gefunden).
Sei (λ1, . . . , λn) ∈ [0, 1]n die Ausgabe des Algorithmus.
Laufzeit: klar.
Korrektheit: Zulässigkeit klar. Zu zeigen: Optimalität.
Sei (λ01, . . . , λ0n) ∈ [0, 1]n eine optimale Lösung.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
22
Satz 3.1.2
Der Algorithmus GFKS ist korrekt (liefert eine zulässige Lösung
mit maximalem Gesamtnutzen) und hat Laufzeit O(n log n).
Beweis: Sei x = (a1, . . . , an, c1, . . . , cn, b) die Eingabe.
P
O.B.d.A.: i ai > b (sonst ist (λ1, . . . , λn) = (1, . . . , 1) optimal und wird von GFKS gefunden).
Sei (λ1, . . . , λn) ∈ [0, 1]n die Ausgabe des Algorithmus.
Laufzeit: klar.
Korrektheit: Zulässigkeit klar. Zu zeigen: Optimalität.
Sei (λ01, . . . , λ0n) ∈ [0, 1]n eine optimale Lösung.
P 0
Offensichtlich: i λiai = b (sonst verbesserbar).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
22
Satz 3.1.2
Der Algorithmus GFKS ist korrekt (liefert eine zulässige Lösung
mit maximalem Gesamtnutzen) und hat Laufzeit O(n log n).
Beweis: Sei x = (a1, . . . , an, c1, . . . , cn, b) die Eingabe.
P
O.B.d.A.: i ai > b (sonst ist (λ1, . . . , λn) = (1, . . . , 1) optimal und wird von GFKS gefunden).
Sei (λ1, . . . , λn) ∈ [0, 1]n die Ausgabe des Algorithmus.
Laufzeit: klar.
Korrektheit: Zulässigkeit klar. Zu zeigen: Optimalität.
Sei (λ01, . . . , λ0n) ∈ [0, 1]n eine optimale Lösung.
P 0
Offensichtlich: i λiai = b (sonst verbesserbar).
P
P 0
Durch Induktion über n zeigen wir: i λici = i λici.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
22
I.A.: n = 1. Dann liefert der Algorithmus offensichtlich die
optimale Lösung: Packe genau den Bruchteil λ1 = b/a1, der
in den Rucksack passt.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
23
I.A.: n = 1. Dann liefert der Algorithmus offensichtlich die
optimale Lösung: Packe genau den Bruchteil λ1 = b/a1, der
in den Rucksack passt.
Ind.-Schritt: n > 1.
1. Fall: a1 ≥ b.
GFKS wählt λ1 = b/a1,
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
23
I.A.: n = 1. Dann liefert der Algorithmus offensichtlich die
optimale Lösung: Packe genau den Bruchteil λ1 = b/a1, der
in den Rucksack passt.
Ind.-Schritt: n > 1.
1. Fall: a1 ≥ b.
GFKS wählt λ1 = b/a1, und das ist optimal:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
23
I.A.: n = 1. Dann liefert der Algorithmus offensichtlich die
optimale Lösung: Packe genau den Bruchteil λ1 = b/a1, der
in den Rucksack passt.
Ind.-Schritt: n > 1.
1. Fall: a1 ≥ b.
GFKS wählt λ1 = b/a1, und das ist optimal: Weil d1 ≥ di für
alle i, gilt:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
23
I.A.: n = 1. Dann liefert der Algorithmus offensichtlich die
optimale Lösung: Packe genau den Bruchteil λ1 = b/a1, der
in den Rucksack passt.
Ind.-Schritt: n > 1.
1. Fall: a1 ≥ b.
GFKS wählt λ1 = b/a1, und das ist optimal: Weil d1 ≥ di für
alle i, gilt:
λ1c1
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
23
I.A.: n = 1. Dann liefert der Algorithmus offensichtlich die
optimale Lösung: Packe genau den Bruchteil λ1 = b/a1, der
in den Rucksack passt.
Ind.-Schritt: n > 1.
1. Fall: a1 ≥ b.
GFKS wählt λ1 = b/a1, und das ist optimal: Weil d1 ≥ di für
alle i, gilt:
λ1c1 = bd1
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
23
I.A.: n = 1. Dann liefert der Algorithmus offensichtlich die
optimale Lösung: Packe genau den Bruchteil λ1 = b/a1, der
in den Rucksack passt.
Ind.-Schritt: n > 1.
1. Fall: a1 ≥ b.
GFKS wählt λ1 = b/a1, und das ist optimal: Weil d1 ≥ di für
alle i, gilt:
P 0
λ1c1 = bd1 = ( i λiai)d1
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
23
I.A.: n = 1. Dann liefert der Algorithmus offensichtlich die
optimale Lösung: Packe genau den Bruchteil λ1 = b/a1, der
in den Rucksack passt.
Ind.-Schritt: n > 1.
1. Fall: a1 ≥ b.
GFKS wählt λ1 = b/a1, und das ist optimal: Weil d1 ≥ di für
alle i, gilt:
P 0
P 0
λ1c1 = bd1 = ( i λiai)d1 ≥ i λiaidi
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
23
I.A.: n = 1. Dann liefert der Algorithmus offensichtlich die
optimale Lösung: Packe genau den Bruchteil λ1 = b/a1, der
in den Rucksack passt.
Ind.-Schritt: n > 1.
1. Fall: a1 ≥ b.
GFKS wählt λ1 = b/a1, und das ist optimal: Weil d1 ≥ di für
alle i, gilt:
P 0
P 0
P 0
λ1c1 = bd1 = ( i λiai)d1 ≥ i λiaidi = i λici.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
23
(Ind.-Schritt:)
FG KTuEA, TU Ilmenau
2. Fall: a1 < b.
Effiziente Algorithmen – SS11 – Kapitel 3
24
(Ind.-Schritt:)
2. Fall: a1 < b.
Behauptung: Wir können o.B.d.A. λ01 = 1 annehmen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
24
(Ind.-Schritt:)
2. Fall: a1 < b.
Behauptung: Wir können o.B.d.A. λ01 = 1 annehmen.
( Der erste Schritt des Greedy-Algorithmus ist nicht falsch.“)
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
24
(Ind.-Schritt:)
2. Fall: a1 < b.
Behauptung: Wir können o.B.d.A. λ01 = 1 annehmen.
( Der erste Schritt des Greedy-Algorithmus ist nicht falsch.“)
”
P
0
Denn: Wenn λ1 < 1, kann man wegen 1≤i≤n λ0iai = b
Werte λ001 = 1, 0 ≤ λ002 ≤ λ02, . . . , 0 ≤ λ00n ≤ λ0n finden, so dass
P
0
(1 − λ1)a1 = 2≤i≤n(λ0i − λ00i )ai.
(∗)
(Verringere Gewicht bei späteren“ Objekten zugunsten von Objekt 1.)
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
24
(Ind.-Schritt:)
2. Fall: a1 < b.
Behauptung: Wir können o.B.d.A. λ01 = 1 annehmen.
( Der erste Schritt des Greedy-Algorithmus ist nicht falsch.“)
”
P
0
Denn: Wenn λ1 < 1, kann man wegen 1≤i≤n λ0iai = b
Werte λ001 = 1, 0 ≤ λ002 ≤ λ02, . . . , 0 ≤ λ00n ≤ λ0n finden, so dass
P
0
(1 − λ1)a1 = 2≤i≤n(λ0i − λ00i )ai.
(∗)
(Verringere Gewicht bei späteren“ Objekten zugunsten von Objekt 1.)
”
Dann ist (λ001 , . . . , λ00n) zulässig
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
24
2. Fall: a1 < b.
(Ind.-Schritt:)
Behauptung: Wir können o.B.d.A. λ01 = 1 annehmen.
( Der erste Schritt des Greedy-Algorithmus ist nicht falsch.“)
”
P
0
Denn: Wenn λ1 < 1, kann man wegen 1≤i≤n λ0iai = b
Werte λ001 = 1, 0 ≤ λ002 ≤ λ02, . . . , 0 ≤ λ00n ≤ λ0n finden, so dass
P
0
(1 − λ1)a1 = 2≤i≤n(λ0i − λ00i )ai.
(∗)
(Verringere Gewicht bei späteren“ Objekten zugunsten von Objekt 1.)
”
Dann ist (λ001 , . . . , λ00n) zulässig und
X
X
X
(λ0i − λ00i )aidi .
λ00i ci =
λ0ici + (1 − λ01)a1d1 −
i
FG KTuEA, TU Ilmenau
i
2≤i≤n
Effiziente Algorithmen – SS11 – Kapitel 3
24
2. Fall: a1 < b.
(Ind.-Schritt:)
Behauptung: Wir können o.B.d.A. λ01 = 1 annehmen.
( Der erste Schritt des Greedy-Algorithmus ist nicht falsch.“)
”
P
0
Denn: Wenn λ1 < 1, kann man wegen 1≤i≤n λ0iai = b
Werte λ001 = 1, 0 ≤ λ002 ≤ λ02, . . . , 0 ≤ λ00n ≤ λ0n finden, so dass
P
0
(1 − λ1)a1 = 2≤i≤n(λ0i − λ00i )ai.
(∗)
(Verringere Gewicht bei späteren“ Objekten zugunsten von Objekt 1.)
”
Dann ist (λ001 , . . . , λ00n) zulässig und
X
X
X
(λ0i − λ00i )aidi .
λ00i ci =
λ0ici + (1 − λ01)a1d1 −
i
i
2≤i≤n
Aus (∗) und d1 ≥ di folgt, dass die letzte Klammer nichtneP 00
P 0
gativ ist, also i λi ci ≥ i λici gilt. (Sogar Gleichheit.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
24
Wissen nun: 1 = λ1 = λ01.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
25
Wissen nun: 1 = λ1 = λ01.
Wir wenden die Induktionsvoraussetzung auf den modifizierten
Input x− = (a2, . . . , an, c2, . . . , cn, b − a1) an.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
25
Wissen nun: 1 = λ1 = λ01.
Wir wenden die Induktionsvoraussetzung auf den modifizierten
Input x− = (a2, . . . , an, c2, . . . , cn, b − a1) an.
GFKS läuft in Schleifendurchläufen 2 bis n ebenso wie GFKS
auf x−, liefert also für x− eine optimale Lösung: (λ2, . . . , λn).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
25
Wissen nun: 1 = λ1 = λ01.
Wir wenden die Induktionsvoraussetzung auf den modifizierten
Input x− = (a2, . . . , an, c2, . . . , cn, b − a1) an.
GFKS läuft in Schleifendurchläufen 2 bis n ebenso wie GFKS
auf x−, liefert also für x− eine optimale Lösung: (λ2, . . . , λn).
Klar: (λ02, . . . , λ0n) muss für x− optimal sein.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
25
Wissen nun: 1 = λ1 = λ01.
Wir wenden die Induktionsvoraussetzung auf den modifizierten
Input x− = (a2, . . . , an, c2, . . . , cn, b − a1) an.
GFKS läuft in Schleifendurchläufen 2 bis n ebenso wie GFKS
auf x−, liefert also für x− eine optimale Lösung: (λ2, . . . , λn).
Klar: (λ02, . . . , λ0n) muss für x− optimal sein.
(Wenn (λ002 , . . . , λ00n) besser wäre, dann wäre (1, λ002 , . . . , λ00n) eine bessere
Lösung für x als (1, λ02, . . . , λ0n). Das kann nicht sein.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
25
Wissen nun: 1 = λ1 = λ01.
Wir wenden die Induktionsvoraussetzung auf den modifizierten
Input x− = (a2, . . . , an, c2, . . . , cn, b − a1) an.
GFKS läuft in Schleifendurchläufen 2 bis n ebenso wie GFKS
auf x−, liefert also für x− eine optimale Lösung: (λ2, . . . , λn).
Klar: (λ02, . . . , λ0n) muss für x− optimal sein.
(Wenn (λ002 , . . . , λ00n) besser wäre, dann wäre (1, λ002 , . . . , λ00n) eine bessere
Lösung für x als (1, λ02, . . . , λ0n). Das kann nicht sein.)
Nach I.V. gilt
FG KTuEA, TU Ilmenau
P
2≤i≤n λici =
0
λ
2≤i≤n ici.
P
Effiziente Algorithmen – SS11 – Kapitel 3
25
Wissen nun: 1 = λ1 = λ01.
Wir wenden die Induktionsvoraussetzung auf den modifizierten
Input x− = (a2, . . . , an, c2, . . . , cn, b − a1) an.
GFKS läuft in Schleifendurchläufen 2 bis n ebenso wie GFKS
auf x−, liefert also für x− eine optimale Lösung: (λ2, . . . , λn).
Klar: (λ02, . . . , λ0n) muss für x− optimal sein.
(Wenn (λ002 , . . . , λ00n) besser wäre, dann wäre (1, λ002 , . . . , λ00n) eine bessere
Lösung für x als (1, λ02, . . . , λ0n). Das kann nicht sein.)
Nach I.V. gilt
P
2≤i≤n λici =
0
λ
2≤i≤n ici.
P
Also haben auch die Lösungen (1, λ02, . . . , λ0n)
(1, λ2, . . . , λn) für x denselben Nutzenwert.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
und
25
An den Beispielen zu beobachtende Charakteristika der
Greedy-Methode:
1. Der erste Schritt der Greedy-Lösung ist nicht falsch. Es
gibt eine optimale Lösung, die als Fortsetzung des ersten
Schrittes konstruiert werden kann.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
26
An den Beispielen zu beobachtende Charakteristika der
Greedy-Methode:
1. Der erste Schritt der Greedy-Lösung ist nicht falsch. Es
gibt eine optimale Lösung, die als Fortsetzung des ersten
Schrittes konstruiert werden kann.
2. Prinzip der optimalen Substruktur“: Entfernt man aus
”
einer optimalen Lösung die erste(n) Komponente(n), so
bleibt als Rest die optimale Lösung für einen Teil oder Rest
des Inputs.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
26
An den Beispielen zu beobachtende Charakteristika der
Greedy-Methode:
1. Der erste Schritt der Greedy-Lösung ist nicht falsch. Es
gibt eine optimale Lösung, die als Fortsetzung des ersten
Schrittes konstruiert werden kann.
2. Prinzip der optimalen Substruktur“: Entfernt man aus
”
einer optimalen Lösung die erste(n) Komponente(n), so
bleibt als Rest die optimale Lösung für einen Teil oder Rest
des Inputs.
3. Der Korrektheitsbeweis wird mit vollständiger Induktion
geführt.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
26
3.2 Huffman-Codes
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
27
3.2 Huffman-Codes
Gegeben: Alphabet Σ und Wahrscheinlichkeiten“
”
p(a) ∈ [0, 1] für jeden Buchstaben a ∈ Σ.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
27
3.2 Huffman-Codes
Gegeben: Alphabet Σ und Wahrscheinlichkeiten“
P
”
p(a) = 1.
p(a) ∈ [0, 1] für jeden Buchstaben a ∈ Σ. Also:
a∈Σ
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
27
3.2 Huffman-Codes
Gegeben: Alphabet Σ und Wahrscheinlichkeiten“
P
”
p(a) = 1.
p(a) ∈ [0, 1] für jeden Buchstaben a ∈ Σ. Also:
a∈Σ
Beispiel:
a
p(a)
A
0,15
FG KTuEA, TU Ilmenau
B
0,08
C
0,07
D
0,10
E
0,21
Effiziente Algorithmen – SS11 – Kapitel 3
F
0,08
G
0,07
H
0,09
I
0,06
K
0,09
27
3.2 Huffman-Codes
Gegeben: Alphabet Σ und Wahrscheinlichkeiten“
P
”
p(a) = 1.
p(a) ∈ [0, 1] für jeden Buchstaben a ∈ Σ. Also:
a∈Σ
Beispiel:
a
p(a)
A
0,15
B
0,08
C
0,07
D
0,10
E
0,21
F
0,08
G
0,07
H
0,09
I
0,06
K
0,09
Herkunft der Wahrscheinlichkeiten:
(1) Buchstabenhäufigkeit in natürlicher Sprache
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
27
3.2 Huffman-Codes
Gegeben: Alphabet Σ und Wahrscheinlichkeiten“
P
”
p(a) = 1.
p(a) ∈ [0, 1] für jeden Buchstaben a ∈ Σ. Also:
a∈Σ
Beispiel:
a
p(a)
A
0,15
B
0,08
C
0,07
D
0,10
E
0,21
F
0,08
G
0,07
H
0,09
I
0,06
K
0,09
Herkunft der Wahrscheinlichkeiten:
(1) Buchstabenhäufigkeit in natürlicher Sprache oder
(2) empirische relative Häufigkeiten in einem
gegebenen Text w = a1 . . . an:
Anteil des Buchstabens a an w ist (p(a) · 100)%.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
27
Gesucht: ein guter“ binärer Präfixcode für (Σ, p).
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
28
Gesucht: ein guter“ binärer Präfixcode für (Σ, p).
”
Definition 3.2.1 Präfixcode:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
28
Gesucht: ein guter“ binärer Präfixcode für (Σ, p).
”
Definition 3.2.1 Präfixcode:
Jedem a ∈ Σ ist binärer Code“ c(a) ∈ {0, 1}+ zugeordnet,
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
28
Gesucht: ein guter“ binärer Präfixcode für (Σ, p).
”
Definition 3.2.1 Präfixcode:
Jedem a ∈ Σ ist binärer Code“ c(a) ∈ {0, 1}+ zugeordnet,
”
mit Eigenschaft Präfixfreiheit:
Für a, b ∈ Σ, a 6= b ist c(a) kein Präfix von c(b).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
28
Gesucht: ein guter“ binärer Präfixcode für (Σ, p).
”
Definition 3.2.1 Präfixcode:
Jedem a ∈ Σ ist binärer Code“ c(a) ∈ {0, 1}+ zugeordnet,
”
mit Eigenschaft Präfixfreiheit:
Für a, b ∈ Σ, a 6= b ist c(a) kein Präfix von c(b).
Beispiel:
A
B
1100 0110
FG KTuEA, TU Ilmenau
C
000
D
111
E
10
F
0011
Effiziente Algorithmen – SS11 – Kapitel 3
G
010
H
0010
I
0111
K
1101
28
Gesucht: ein guter“ binärer Präfixcode für (Σ, p).
”
Definition 3.2.1 Präfixcode:
Jedem a ∈ Σ ist binärer Code“ c(a) ∈ {0, 1}+ zugeordnet,
”
mit Eigenschaft Präfixfreiheit:
Für a, b ∈ Σ, a 6= b ist c(a) kein Präfix von c(b).
Beispiel:
A
B
1100 0110
C
000
D
111
E
10
F
0011
G
010
H
0010
I
0111
K
1101
Codierung von Wörtern (Zeichenreihen):
c(a1 . . . an) = c(a1) · · · c(an) ∈ {0, 1}∗.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
28
Gesucht: ein guter“ binärer Präfixcode für (Σ, p).
”
Definition 3.2.1 Präfixcode:
Jedem a ∈ Σ ist binärer Code“ c(a) ∈ {0, 1}+ zugeordnet,
”
mit Eigenschaft Präfixfreiheit:
Für a, b ∈ Σ, a 6= b ist c(a) kein Präfix von c(b).
Beispiel:
A
B
1100 0110
C
000
D
111
E
10
F
0011
G
010
H
0010
I
0111
K
1101
Codierung von Wörtern (Zeichenreihen):
c(a1 . . . an) = c(a1) · · · c(an) ∈ {0, 1}∗.
Zur Codierung benutzt man (konzeptuell) direkt die Tabelle.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
28
Gesucht: ein guter“ binärer Präfixcode für (Σ, p).
”
Definition 3.2.1 Präfixcode:
Jedem a ∈ Σ ist binärer Code“ c(a) ∈ {0, 1}+ zugeordnet,
”
mit Eigenschaft Präfixfreiheit:
Für a, b ∈ Σ, a 6= b ist c(a) kein Präfix von c(b).
Beispiel:
A
B
1100 0110
C
000
D
111
E
10
F
0011
G
010
H
0010
I
0111
K
1101
Codierung von Wörtern (Zeichenreihen):
c(a1 . . . an) = c(a1) · · · c(an) ∈ {0, 1}∗.
Zur Codierung benutzt man (konzeptuell) direkt die Tabelle.
Beispiel: c(F E I G E ) =
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
28
Gesucht: ein guter“ binärer Präfixcode für (Σ, p).
”
Definition 3.2.1 Präfixcode:
Jedem a ∈ Σ ist binärer Code“ c(a) ∈ {0, 1}+ zugeordnet,
”
mit Eigenschaft Präfixfreiheit:
Für a, b ∈ Σ, a 6= b ist c(a) kein Präfix von c(b).
Beispiel:
A
B
1100 0110
C
000
D
111
E
10
F
0011
G
010
H
0010
I
0111
K
1101
Codierung von Wörtern (Zeichenreihen):
c(a1 . . . an) = c(a1) · · · c(an) ∈ {0, 1}∗.
Zur Codierung benutzt man (konzeptuell) direkt die Tabelle.
Beispiel: c(F E I G E ) = 0011
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
28
Gesucht: ein guter“ binärer Präfixcode für (Σ, p).
”
Definition 3.2.1 Präfixcode:
Jedem a ∈ Σ ist binärer Code“ c(a) ∈ {0, 1}+ zugeordnet,
”
mit Eigenschaft Präfixfreiheit:
Für a, b ∈ Σ, a 6= b ist c(a) kein Präfix von c(b).
Beispiel:
A
B
1100 0110
C
000
D
111
E
10
F
0011
G
010
H
0010
I
0111
K
1101
Codierung von Wörtern (Zeichenreihen):
c(a1 . . . an) = c(a1) · · · c(an) ∈ {0, 1}∗.
Zur Codierung benutzt man (konzeptuell) direkt die Tabelle.
Beispiel: c(F E I G E ) = 0011 10
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
28
Gesucht: ein guter“ binärer Präfixcode für (Σ, p).
”
Definition 3.2.1 Präfixcode:
Jedem a ∈ Σ ist binärer Code“ c(a) ∈ {0, 1}+ zugeordnet,
”
mit Eigenschaft Präfixfreiheit:
Für a, b ∈ Σ, a 6= b ist c(a) kein Präfix von c(b).
Beispiel:
A
B
1100 0110
C
000
D
111
E
10
F
0011
G
010
H
0010
I
0111
K
1101
Codierung von Wörtern (Zeichenreihen):
c(a1 . . . an) = c(a1) · · · c(an) ∈ {0, 1}∗.
Zur Codierung benutzt man (konzeptuell) direkt die Tabelle.
Beispiel: c(F E I G E ) = 0011 10 0111
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
28
Gesucht: ein guter“ binärer Präfixcode für (Σ, p).
”
Definition 3.2.1 Präfixcode:
Jedem a ∈ Σ ist binärer Code“ c(a) ∈ {0, 1}+ zugeordnet,
”
mit Eigenschaft Präfixfreiheit:
Für a, b ∈ Σ, a 6= b ist c(a) kein Präfix von c(b).
Beispiel:
A
B
1100 0110
C
000
D
111
E
10
F
0011
G
010
H
0010
I
0111
K
1101
Codierung von Wörtern (Zeichenreihen):
c(a1 . . . an) = c(a1) · · · c(an) ∈ {0, 1}∗.
Zur Codierung benutzt man (konzeptuell) direkt die Tabelle.
Beispiel: c(F E I G E ) = 0011 10 0111 010
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
28
Gesucht: ein guter“ binärer Präfixcode für (Σ, p).
”
Definition 3.2.1 Präfixcode:
Jedem a ∈ Σ ist binärer Code“ c(a) ∈ {0, 1}+ zugeordnet,
”
mit Eigenschaft Präfixfreiheit:
Für a, b ∈ Σ, a 6= b ist c(a) kein Präfix von c(b).
Beispiel:
A
B
1100 0110
C
000
D
111
E
10
F
0011
G
010
H
0010
I
0111
K
1101
Codierung von Wörtern (Zeichenreihen):
c(a1 . . . an) = c(a1) · · · c(an) ∈ {0, 1}∗.
Zur Codierung benutzt man (konzeptuell) direkt die Tabelle.
Beispiel: c(F E I G E ) = 0011 10 0111 010 10.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
28
Kompakte Repräsentation des Codes als Binärbaum:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
29
Kompakte Repräsentation des Codes als Binärbaum:
0
0
0
C
FG KTuEA, TU Ilmenau
1
1
0
H
1
1
F
0
G
0
E
0
1
0
B
1
1
I
Effiziente Algorithmen – SS11 – Kapitel 3
0
A
1
D
1
K
29
Kompakte Repräsentation des Codes als Binärbaum:
0
0
0
C
1
1
0
H
1
1
F
0
G
0
E
0
1
0
B
1
1
I
0
A
1
D
1
K
Blätter sind mit Buchstaben markiert; Weg von der Wurzel
zum Blatt gibt das Codewort wieder (links: 0, rechts: 1).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
29
Kompakte Repräsentation des Codes als Binärbaum:
0
0
0
C
1
1
0
H
1
1
F
0
G
0
E
0
1
0
B
1
1
I
0
A
1
D
1
K
Blätter sind mit Buchstaben markiert; Weg von der Wurzel
zum Blatt gibt das Codewort wieder (links: 0, rechts: 1).
Decodierung: Laufe Weg im Baum, vom Codewort gesteuert,
bis zum Blatt.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
29
Kompakte Repräsentation des Codes als Binärbaum:
0
0
0
C
1
1
0
H
1
1
F
0
G
0
E
0
1
0
B
1
1
I
0
A
1
D
1
K
Blätter sind mit Buchstaben markiert; Weg von der Wurzel
zum Blatt gibt das Codewort wieder (links: 0, rechts: 1).
Decodierung: Laufe Weg im Baum, vom Codewort gesteuert,
bis zum Blatt. Wiederhole mit dem Restwort, bis nichts mehr
übrig ist. – Präfixeigenschaft ⇒ keine Zwischenräume nötig.
Beispiel: 001111000000010 liefert
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
29
Kompakte Repräsentation des Codes als Binärbaum:
0
0
0
C
1
1
0
H
1
1
F
0
G
0
E
0
1
0
B
1
1
I
0
A
1
D
1
K
Blätter sind mit Buchstaben markiert; Weg von der Wurzel
zum Blatt gibt das Codewort wieder (links: 0, rechts: 1).
Decodierung: Laufe Weg im Baum, vom Codewort gesteuert,
bis zum Blatt. Wiederhole mit dem Restwort, bis nichts mehr
übrig ist. – Präfixeigenschaft ⇒ keine Zwischenräume nötig.
Beispiel: 001111000000010 liefert
FG KTuEA, TU Ilmenau
”
Effiziente Algorithmen – SS11 – Kapitel 3
29
Kompakte Repräsentation des Codes als Binärbaum:
0
0
0
C
1
1
0
H
1
1
F
0
G
0
E
0
1
0
B
1
1
I
0
A
1
D
1
K
Blätter sind mit Buchstaben markiert; Weg von der Wurzel
zum Blatt gibt das Codewort wieder (links: 0, rechts: 1).
Decodierung: Laufe Weg im Baum, vom Codewort gesteuert,
bis zum Blatt. Wiederhole mit dem Restwort, bis nichts mehr
übrig ist. – Präfixeigenschaft ⇒ keine Zwischenräume nötig.
Beispiel: 001111000000010 liefert F
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
29
Kompakte Repräsentation des Codes als Binärbaum:
0
0
0
C
1
1
0
H
1
1
F
0
G
0
E
0
1
0
B
1
1
I
0
A
1
D
1
K
Blätter sind mit Buchstaben markiert; Weg von der Wurzel
zum Blatt gibt das Codewort wieder (links: 0, rechts: 1).
Decodierung: Laufe Weg im Baum, vom Codewort gesteuert,
bis zum Blatt. Wiederhole mit dem Restwort, bis nichts mehr
übrig ist. – Präfixeigenschaft ⇒ keine Zwischenräume nötig.
Beispiel: 001111000000010 liefert FA
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
29
Kompakte Repräsentation des Codes als Binärbaum:
0
0
0
C
1
1
0
H
1
1
F
0
G
0
E
0
1
0
B
1
1
I
0
A
1
D
1
K
Blätter sind mit Buchstaben markiert; Weg von der Wurzel
zum Blatt gibt das Codewort wieder (links: 0, rechts: 1).
Decodierung: Laufe Weg im Baum, vom Codewort gesteuert,
bis zum Blatt. Wiederhole mit dem Restwort, bis nichts mehr
übrig ist. – Präfixeigenschaft ⇒ keine Zwischenräume nötig.
Beispiel: 001111000000010 liefert FAC
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
29
Kompakte Repräsentation des Codes als Binärbaum:
0
0
0
C
1
1
0
H
1
1
F
0
G
0
E
0
1
0
B
1
1
I
0
A
1
D
1
K
Blätter sind mit Buchstaben markiert; Weg von der Wurzel
zum Blatt gibt das Codewort wieder (links: 0, rechts: 1).
Decodierung: Laufe Weg im Baum, vom Codewort gesteuert,
bis zum Blatt. Wiederhole mit dem Restwort, bis nichts mehr
übrig ist. – Präfixeigenschaft ⇒ keine Zwischenräume nötig.
Beispiel: 001111000000010 liefert FACH“.
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
29
1. Idee: Mache alle Codewörter c(a) gleich lang;
am besten ist dann eine Länge von dlog2 |Σ|e Bits.
⇒ c(a1 . . . an) hat Länge dlog2 |Σ|e · n.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
30
1. Idee: Mache alle Codewörter c(a) gleich lang;
am besten ist dann eine Länge von dlog2 |Σ|e Bits.
⇒ c(a1 . . . an) hat Länge dlog2 |Σ|e · n.
(Beispiele: 52 Groß- und Kleinbuchstaben plus Leerzeichen und Satzzeichen: log 64 = 6 Bits pro Codewort. ASCII-Code: 8 Bits pro Codewort.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
30
1. Idee: Mache alle Codewörter c(a) gleich lang;
am besten ist dann eine Länge von dlog2 |Σ|e Bits.
⇒ c(a1 . . . an) hat Länge dlog2 |Σ|e · n.
(Beispiele: 52 Groß- und Kleinbuchstaben plus Leerzeichen und Satzzeichen: log 64 = 6 Bits pro Codewort. ASCII-Code: 8 Bits pro Codewort.)
2. Idee: Einsparmöglichkeit: Häufige Buchstaben mit kürzeren
Codes codieren als seltenere Buchstaben.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
30
1. Idee: Mache alle Codewörter c(a) gleich lang;
am besten ist dann eine Länge von dlog2 |Σ|e Bits.
⇒ c(a1 . . . an) hat Länge dlog2 |Σ|e · n.
(Beispiele: 52 Groß- und Kleinbuchstaben plus Leerzeichen und Satzzeichen: log 64 = 6 Bits pro Codewort. ASCII-Code: 8 Bits pro Codewort.)
2. Idee: Einsparmöglichkeit: Häufige Buchstaben mit kürzeren
Codes codieren als seltenere Buchstaben.
Ein erster Ansatz zur Datenkompression
(platzsparendes Speichern, zeitsparendes Übermitteln)!
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
30
1. Idee: Mache alle Codewörter c(a) gleich lang;
am besten ist dann eine Länge von dlog2 |Σ|e Bits.
⇒ c(a1 . . . an) hat Länge dlog2 |Σ|e · n.
(Beispiele: 52 Groß- und Kleinbuchstaben plus Leerzeichen und Satzzeichen: log 64 = 6 Bits pro Codewort. ASCII-Code: 8 Bits pro Codewort.)
2. Idee: Einsparmöglichkeit: Häufige Buchstaben mit kürzeren
Codes codieren als seltenere Buchstaben.
Ein erster Ansatz zur Datenkompression
(platzsparendes Speichern, zeitsparendes Übermitteln)!
Hier: verlustfreie Kompression“ – die Information ist un”
verändert vorhanden.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
30
1. Idee: Mache alle Codewörter c(a) gleich lang;
am besten ist dann eine Länge von dlog2 |Σ|e Bits.
⇒ c(a1 . . . an) hat Länge dlog2 |Σ|e · n.
(Beispiele: 52 Groß- und Kleinbuchstaben plus Leerzeichen und Satzzeichen: log 64 = 6 Bits pro Codewort. ASCII-Code: 8 Bits pro Codewort.)
2. Idee: Einsparmöglichkeit: Häufige Buchstaben mit kürzeren
Codes codieren als seltenere Buchstaben.
Ein erster Ansatz zur Datenkompression
(platzsparendes Speichern, zeitsparendes Übermitteln)!
Hier: verlustfreie Kompression“ – die Information ist un”
verändert vorhanden.
Gegensatz: MP3: Informationsverlust bei der Kompression.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
30
p(a)
c1
c2
A
0,15
0000
1100
B
0,08
0001
0110
FG KTuEA, TU Ilmenau
C
0,07
0010
000
D
0,10
0011
111
E
0,21
0100
10
Effiziente Algorithmen – SS11 – Kapitel 3
F
0,08
0101
0011
G
0,07
0110
010
H
0,09
0111
0010
I
0,06
1000
0111
K
0,09
1001
1101
31
p(a)
c1
c2
A
0,15
0000
1100
B
0,08
0001
0110
C
0,07
0010
000
D
0,10
0011
111
E
0,21
0100
10
F
0,08
0101
0011
G
0,07
0110
010
H
0,09
0111
0010
I
0,06
1000
0111
K
0,09
1001
1101
Wir codieren eine Datei T mit 100000 Buchstaben aus Σ,
wobei die relative Häufigkeit von a ∈ Σ durch p(a) gegeben
ist.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
31
p(a)
c1
c2
A
0,15
0000
1100
B
0,08
0001
0110
C
0,07
0010
000
D
0,10
0011
111
E
0,21
0100
10
F
0,08
0101
0011
G
0,07
0110
010
H
0,09
0111
0010
I
0,06
1000
0111
K
0,09
1001
1101
Wir codieren eine Datei T mit 100000 Buchstaben aus Σ,
wobei die relative Häufigkeit von a ∈ Σ durch p(a) gegeben
ist.
Mit c1 (fixe Codewortlänge): 400000 Bits.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
31
p(a)
c1
c2
A
0,15
0000
1100
B
0,08
0001
0110
C
0,07
0010
000
D
0,10
0011
111
E
0,21
0100
10
F
0,08
0101
0011
G
0,07
0110
010
H
0,09
0111
0010
I
0,06
1000
0111
K
0,09
1001
1101
Wir codieren eine Datei T mit 100000 Buchstaben aus Σ,
wobei die relative Häufigkeit von a ∈ Σ durch p(a) gegeben
ist.
Mit c1 (fixe Codewortlänge): 400000 Bits.
Mit c2 (variable Codewortlänge):
(4 · (0, 15 + 0,08 + 0,08 + 0,09 + 0,06 + 0,09)) + 3 · (0,07 +
0,10 + 0,07) + 2 · 0,21 · 100000 = 334000 Bits.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
31
p(a)
c1
c2
A
0,15
0000
1100
B
0,08
0001
0110
C
0,07
0010
000
D
0,10
0011
111
E
0,21
0100
10
F
0,08
0101
0011
G
0,07
0110
010
H
0,09
0111
0010
I
0,06
1000
0111
K
0,09
1001
1101
Wir codieren eine Datei T mit 100000 Buchstaben aus Σ,
wobei die relative Häufigkeit von a ∈ Σ durch p(a) gegeben
ist.
Mit c1 (fixe Codewortlänge): 400000 Bits.
Mit c2 (variable Codewortlänge):
(4 · (0, 15 + 0,08 + 0,08 + 0,09 + 0,06 + 0,09)) + 3 · (0,07 +
0,10 + 0,07) + 2 · 0,21 · 100000 = 334000 Bits.
Bei langen Dateien und wenn die Übertragung teuer oder langsam ist,
lohnt es sich, die Buchstaben abzuzählen, die relativen Häufigkeiten p(a)
zu bestimmen und einen guten Code mit unterschiedlichen Codewortlängen
zu suchen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
31
Definition 3.2.2
Ein Codierungsbaum für Σ ist ein Binärbaum T , in dem
• die Kante in einem inneren Knoten zum linken bzw. rechten
Kind (implizit) mit 0 bzw. 1 markiert ist;
• jedem Buchstaben a ∈ Σ ein Blatt (externer Knoten) von
T exklusiv zugeordnet ist.
cT (a) ist die Kanteninschrift auf dem Weg von der Wurzel
zum Blatt mit Inschrift a.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
32
Definition 3.2.2
Ein Codierungsbaum für Σ ist ein Binärbaum T , in dem
• die Kante in einem inneren Knoten zum linken bzw. rechten
Kind (implizit) mit 0 bzw. 1 markiert ist;
• jedem Buchstaben a ∈ Σ ein Blatt (externer Knoten) von
T exklusiv zugeordnet ist.
cT (a) ist die Kanteninschrift auf dem Weg von der Wurzel
zum Blatt mit Inschrift a.
Die Kosten von T unter p sind definiert als:
X
B(T, p) =
p(a) · dT (a),
a∈Σ
wobei dT (a) die Tiefe des a-Blatts in T ist.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
32
Beispiel: Wenn T unser Beispielbaum ist und p die Beispielverteilung von oben, dann ist B(T, p) = 3,34.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
33
Beispiel: Wenn T unser Beispielbaum ist und p die Beispielverteilung von oben, dann ist B(T, p) = 3,34.
0
0
0
C
FG KTuEA, TU Ilmenau
1
1
0
H
1
1
F
0
G
0
E
0
1
0
B
1
1
I
Effiziente Algorithmen – SS11 – Kapitel 3
0
A
1
D
1
K
33
Beispiel: Wenn T unser Beispielbaum ist und p die Beispielverteilung von oben, dann ist B(T, p) = 3,34.
0
0
0
C
1
1
0
H
1
1
F
0
G
0
E
0
1
0
B
1
1
I
0
A
1
D
1
K
Leicht zu sehen: B(T, p) = |cT (a1 . . . an)|/n, wenn die relative Häufigkeit
von a in w = a1 . . . an durch p(a) gegeben ist,
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
33
Beispiel: Wenn T unser Beispielbaum ist und p die Beispielverteilung von oben, dann ist B(T, p) = 3,34.
0
0
0
C
1
1
0
H
1
1
F
0
G
0
E
0
1
0
B
1
1
I
0
A
1
D
1
K
Leicht zu sehen: B(T, p) = |cT (a1 . . . an)|/n, wenn die relative Häufigkeit
von a in w = a1 . . . an durch p(a) gegeben ist,
oder B(T, p) = die erwartete Bitzahl pro Buchstabe, wenn die
Buchstabenwahrscheinlichkeiten durch p(a), a ∈ Σ, gegeben sind.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
33
Definition 3.2.3
Ein Codierungsbaum T für Σ heißt optimal oder
redundanzminimal für p, wenn B(T, p) ≤ B(T 0, p)
für alle Codierungsbäume T 0 für Σ.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
34
Definition 3.2.3
Ein Codierungsbaum T für Σ heißt optimal oder
redundanzminimal für p, wenn B(T, p) ≤ B(T 0, p)
für alle Codierungsbäume T 0 für Σ.
Aufgabe: Zu gegebenem p : Σ → [0, 1] finde einen optimalen
Baum T .
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
34
Definition 3.2.3
Ein Codierungsbaum T für Σ heißt optimal oder
redundanzminimal für p, wenn B(T, p) ≤ B(T 0, p)
für alle Codierungsbäume T 0 für Σ.
Aufgabe: Zu gegebenem p : Σ → [0, 1] finde einen optimalen
Baum T .
Existiert immer ein optimaler Baum?
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
34
Definition 3.2.3
Ein Codierungsbaum T für Σ heißt optimal oder
redundanzminimal für p, wenn B(T, p) ≤ B(T 0, p)
für alle Codierungsbäume T 0 für Σ.
Aufgabe: Zu gegebenem p : Σ → [0, 1] finde einen optimalen
Baum T .
Existiert immer ein optimaler Baum?
(Zu Σ gibt es unendlich viele Codierungsbäume!)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
34
Lemma 3.2.4 Wenn T Codierungsbaum und p Verteilung für
Σ ist, dann gibt es einen Codierungsbaum T 0 mit B(T 0, p) ≤
B(T, p), so dass in T 0 jeder innere Knoten zwei Kinder hat.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
35
Lemma 3.2.4 Wenn T Codierungsbaum und p Verteilung für
Σ ist, dann gibt es einen Codierungsbaum T 0 mit B(T 0, p) ≤
B(T, p), so dass in T 0 jeder innere Knoten zwei Kinder hat.
Beweisidee:
T:
T’:
w
w
1
1
v
x
0
Tx
u
fehlt
Umbau:
Überspringe v
x
u
Tx
Tu
Tu
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
35
Lemma 3.2.4 Wenn T Codierungsbaum und p Verteilung für
Σ ist, dann gibt es einen Codierungsbaum T 0 mit B(T 0, p) ≤
B(T, p), so dass in T 0 jeder innere Knoten zwei Kinder hat.
Beweisidee:
T:
T’:
w
w
1
1
v
x
0
Tx
u
fehlt
Umbau:
Überspringe v
x
u
Tx
Tu
Tu
Resultat: T 0 für Σ mit denselben markierten Blättern wie T ,
und B(T 0, p) ≤ B(T, p).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
35
Lemma 3.2.4 Wenn T Codierungsbaum und p Verteilung für
Σ ist, dann gibt es einen Codierungsbaum T 0 mit B(T 0, p) ≤
B(T, p), so dass in T 0 jeder innere Knoten zwei Kinder hat.
Beweisidee:
T:
T’:
w
w
1
1
v
x
0
Tx
u
fehlt
Umbau:
Überspringe v
x
u
Tx
Tu
Tu
Resultat: T 0 für Σ mit denselben markierten Blättern wie T ,
und B(T 0, p) ≤ B(T, p).
Folgerung: Man kann sich bei der Suche nach optimalen Bäumen auf
solche beschränken, in denen jeder innere Knoten zwei Kinder hat.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
35
Weil es für festes Σ nur endlich viele Σ-Codierungsbäume T
gibt, in denen jeder innere Knoten zwei Kinder hat, gibt es für
(Σ, p) optimale Codierungsbäume.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
36
Weil es für festes Σ nur endlich viele Σ-Codierungsbäume T
gibt, in denen jeder innere Knoten zwei Kinder hat, gibt es für
(Σ, p) optimale Codierungsbäume.
Optimale Bäume sind i. A. nicht eindeutig.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
36
Weil es für festes Σ nur endlich viele Σ-Codierungsbäume T
gibt, in denen jeder innere Knoten zwei Kinder hat, gibt es für
(Σ, p) optimale Codierungsbäume.
Optimale Bäume sind i. A. nicht eindeutig.
Aufgabe: Gegeben (Σ, p), finde einen optimalen Baum.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
36
Weil es für festes Σ nur endlich viele Σ-Codierungsbäume T
gibt, in denen jeder innere Knoten zwei Kinder hat, gibt es für
(Σ, p) optimale Codierungsbäume.
Optimale Bäume sind i. A. nicht eindeutig.
Aufgabe: Gegeben (Σ, p), finde einen optimalen Baum.
Methode: Greedy“.
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
36
Lemma 3.2.5
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
37
Lemma 3.2.5
Es seien a, a0 zwei Buchstaben mit p(a), p(a0) ≤ p(b) für alle
b ∈ Σ − {a, a0}.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
37
Lemma 3.2.5
Es seien a, a0 zwei Buchstaben mit p(a), p(a0) ≤ p(b) für alle
b ∈ Σ − {a, a0}. (a, a0 sind zwei seltenste“ Buchstaben.)
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
37
Lemma 3.2.5
Es seien a, a0 zwei Buchstaben mit p(a), p(a0) ≤ p(b) für alle
b ∈ Σ − {a, a0}. (a, a0 sind zwei seltenste“ Buchstaben.)
”
Dann gibt es einen optimalen Baum, in dem die a- und a0Blätter Kinder desselben inneren Knotens sind.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
37
Lemma 3.2.5
Es seien a, a0 zwei Buchstaben mit p(a), p(a0) ≤ p(b) für alle
b ∈ Σ − {a, a0}. (a, a0 sind zwei seltenste“ Buchstaben.)
”
Dann gibt es einen optimalen Baum, in dem die a- und a0Blätter Kinder desselben inneren Knotens sind.
Beweis:
Starte mit beliebigem optimalen Baum T .
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
37
Lemma 3.2.5
Es seien a, a0 zwei Buchstaben mit p(a), p(a0) ≤ p(b) für alle
b ∈ Σ − {a, a0}. (a, a0 sind zwei seltenste“ Buchstaben.)
”
Dann gibt es einen optimalen Baum, in dem die a- und a0Blätter Kinder desselben inneren Knotens sind.
Beweis:
Starte mit beliebigem optimalen Baum T .
O.B.d.A. (Le. 3.2.4): Alle inneren Knoten haben zwei Kinder.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
37
Lemma 3.2.5
Es seien a, a0 zwei Buchstaben mit p(a), p(a0) ≤ p(b) für alle
b ∈ Σ − {a, a0}. (a, a0 sind zwei seltenste“ Buchstaben.)
”
Dann gibt es einen optimalen Baum, in dem die a- und a0Blätter Kinder desselben inneren Knotens sind.
Beweis:
Starte mit beliebigem optimalen Baum T .
O.B.d.A. (Le. 3.2.4): Alle inneren Knoten haben zwei Kinder.
a und a0 sitzen in Blättern von T , Tiefen d(a) und d(a0).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
37
Lemma 3.2.5
Es seien a, a0 zwei Buchstaben mit p(a), p(a0) ≤ p(b) für alle
b ∈ Σ − {a, a0}. (a, a0 sind zwei seltenste“ Buchstaben.)
”
Dann gibt es einen optimalen Baum, in dem die a- und a0Blätter Kinder desselben inneren Knotens sind.
Beweis:
Starte mit beliebigem optimalen Baum T .
O.B.d.A. (Le. 3.2.4): Alle inneren Knoten haben zwei Kinder.
a und a0 sitzen in Blättern von T , Tiefen d(a) und d(a0).
O.B.d.A.: (∗)
FG KTuEA, TU Ilmenau
dT (a) ≥ dT (a0) (sonst umbenennen).
Effiziente Algorithmen – SS11 – Kapitel 3
37
Lemma 3.2.5
Es seien a, a0 zwei Buchstaben mit p(a), p(a0) ≤ p(b) für alle
b ∈ Σ − {a, a0}. (a, a0 sind zwei seltenste“ Buchstaben.)
”
Dann gibt es einen optimalen Baum, in dem die a- und a0Blätter Kinder desselben inneren Knotens sind.
Beweis:
Starte mit beliebigem optimalen Baum T .
O.B.d.A. (Le. 3.2.4): Alle inneren Knoten haben zwei Kinder.
a und a0 sitzen in Blättern von T , Tiefen d(a) und d(a0).
O.B.d.A.: (∗)
dT (a) ≥ dT (a0) (sonst umbenennen).
Der a-Knoten hat einen Geschwisterknoten v
(innerer Knoten oder Blatt).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
37
T:
a
Tv :
v
a’
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
38
T:
a
Tv :
v
a’
1. Fall: Der a0-Knoten liegt im Unterbaum Tv mit Wurzel v.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
38
T:
a
Tv :
v
a’
1. Fall: Der a0-Knoten liegt im Unterbaum Tv mit Wurzel v.
Wegen (∗) muss er gleich v sein, und a-Knoten und a0-Knoten
sind Geschwisterknoten in T .
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
38
T:
a’
a
Tv :
v
2. Fall: Der a0-Knoten liegt nicht in Tv .
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
39
T:
a’
a
Tv :
v
2. Fall: Der a0-Knoten liegt nicht in Tv .
Weil Tv mindestens ein Blatt hat und p(b) ≥ p(a0) für alle
b ∈ Σ − {a, a0} gilt, haben wir
P
p(b) ≥ p(a0).
b in Tv
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
39
T:
T’:
Tv :
a’
a
Tv :
v
v
a
a’
Vertauschen von Blatt a0 und Tv liefert Baum T 0, in dem a
und a0 Geschwister sind,
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
40
T:
T’:
Tv :
a’
a
Tv :
v
v
a
a’
Vertauschen von Blatt a0 und Tv liefert Baum T 0, in dem a
und a0 Geschwister sind, mit:
B(T 0, p)−B(T, p)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
40
T:
T’:
Tv :
a’
a
Tv :
v
v
a
a’
Vertauschen von Blatt a0 und Tv liefert Baum T 0, in dem a
und a0 Geschwister sind, mit:
B(T 0, p)−B(T, p) = (dT (a)−dT (a0))·
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
40
T:
T’:
Tv :
a’
a
Tv :
v
v
a
a’
Vertauschen von Blatt a0 und Tv liefert Baum T 0, in dem a
und a0 Geschwister sind, mit:
X
0
0
0
p(b))
B(T , p)−B(T, p) = (dT (a)−dT (a ))·(p(a )−
b in Tv
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
40
T:
T’:
Tv :
a’
a
Tv :
v
v
a
a’
Vertauschen von Blatt a0 und Tv liefert Baum T 0, in dem a
und a0 Geschwister sind, mit:
X
0
0
0
p(b)) ≤ 0.
B(T , p)−B(T, p) = (dT (a)−dT (a ))·(p(a )−
b in Tv
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
40
T:
T’:
Tv :
a’
a
Tv :
v
v
a
a’
Vertauschen von Blatt a0 und Tv liefert Baum T 0, in dem a
und a0 Geschwister sind, mit:
X
0
0
0
p(b)) ≤ 0.
B(T , p)−B(T, p) = (dT (a)−dT (a ))·(p(a )−
b in Tv
Das heißt: auch T 0 ist ein optimaler Baum für (Σ, p).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
40
Damit ist der erste Schritt zur Realisierung eines GreedyAnsatzes getan!
Man beginnt den Algorithmus mit
Mache die beiden seltensten Buchstaben zu Geschwistern“.
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
41
Damit ist der erste Schritt zur Realisierung eines GreedyAnsatzes getan!
Man beginnt den Algorithmus mit
Mache die beiden seltensten Buchstaben zu Geschwistern“.
”
Dann ist man sicher, dass dies stets zu einer optimalen Lösung
ausgebaut werden kann.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
41
Damit ist der erste Schritt zur Realisierung eines GreedyAnsatzes getan!
Man beginnt den Algorithmus mit
Mache die beiden seltensten Buchstaben zu Geschwistern“.
”
Dann ist man sicher, dass dies stets zu einer optimalen Lösung
ausgebaut werden kann.
Diese optimale Lösung findet man rekursiv (konzeptuell) bzw.
dann in der Realisierung iterativ.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
41
Damit ist der erste Schritt zur Realisierung eines GreedyAnsatzes getan!
Man beginnt den Algorithmus mit
Mache die beiden seltensten Buchstaben zu Geschwistern“.
”
Dann ist man sicher, dass dies stets zu einer optimalen Lösung
ausgebaut werden kann.
Diese optimale Lösung findet man rekursiv (konzeptuell) bzw.
dann in der Realisierung iterativ.
Algorithmus stammt von D. A. Huffman (1925–1999), am. Informatiker.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
41
Huffman-Algorithmus (rekursiv):
Wir bauen bottom-up“ einen Baum auf.
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
42
Huffman-Algorithmus (rekursiv):
Wir bauen bottom-up“ einen Baum auf.
”
Wenn |Σ| = 1: fertig, man benötigt nur einen Knoten, der
auch Blatt ist.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
42
Huffman-Algorithmus (rekursiv):
Wir bauen bottom-up“ einen Baum auf.
”
Wenn |Σ| = 1: fertig, man benötigt nur einen Knoten, der
auch Blatt ist.
Optimalität: Klar.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
42
Huffman-Algorithmus (rekursiv):
Wir bauen bottom-up“ einen Baum auf.
”
Wenn |Σ| = 1: fertig, man benötigt nur einen Knoten, der
auch Blatt ist.
Optimalität: Klar.
Sonst werden zwei seltenste“ Buchstaben a, a0 aus Σ zu
”
benachbarten Blättern gemacht.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
42
Huffman-Algorithmus (rekursiv):
Wir bauen bottom-up“ einen Baum auf.
”
Wenn |Σ| = 1: fertig, man benötigt nur einen Knoten, der
auch Blatt ist.
Optimalität: Klar.
Sonst werden zwei seltenste“ Buchstaben a, a0 aus Σ zu
”
benachbarten Blättern gemacht.
0
1
a
a’
b
pa + pa’
pa p
a’
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
42
Die Wurzel des so erzeugten Mini-Baums wird als ein Kunst”
0
buchstabe“ b aufgefasst mit p(b) = p(a) + p(a ).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
43
Die Wurzel des so erzeugten Mini-Baums wird als ein Kunst”
0
buchstabe“ b aufgefasst mit p(b) = p(a) + p(a ).
Neues Alphabet: Σ0 := (Σ − {a, a0}) ∪ {b};
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
43
Die Wurzel des so erzeugten Mini-Baums wird als ein Kunst”
0
buchstabe“ b aufgefasst mit p(b) = p(a) + p(a ).
Neues Alphabet: Σ0 := (Σ − {a, a0}) ∪ {b}; neue Verteilung:
0
p (d) :=
FG KTuEA, TU Ilmenau
p(d)
falls d 6= b
p(a) + p(a0) falls d = b
Effiziente Algorithmen – SS11 – Kapitel 3
43
Die Wurzel des so erzeugten Mini-Baums wird als ein Kunst”
0
buchstabe“ b aufgefasst mit p(b) = p(a) + p(a ).
Neues Alphabet: Σ0 := (Σ − {a, a0}) ∪ {b}; neue Verteilung:
0
p (d) :=
p(d)
falls d 6= b
p(a) + p(a0) falls d = b
Nun bauen wir durch rekursive Verwendung des Algorithmus
einen Baum T 0 für Σ0 und p0.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
43
Die Wurzel des so erzeugten Mini-Baums wird als ein Kunst”
0
buchstabe“ b aufgefasst mit p(b) = p(a) + p(a ).
Neues Alphabet: Σ0 := (Σ − {a, a0}) ∪ {b}; neue Verteilung:
0
p (d) :=
p(d)
falls d 6= b
p(a) + p(a0) falls d = b
Nun bauen wir durch rekursive Verwendung des Algorithmus
einen Baum T 0 für Σ0 und p0.
In T 0 fügen wir an der Stelle des b-Knotens den a, a0-Baum
ein.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
43
Die Wurzel des so erzeugten Mini-Baums wird als ein Kunst”
0
buchstabe“ b aufgefasst mit p(b) = p(a) + p(a ).
Neues Alphabet: Σ0 := (Σ − {a, a0}) ∪ {b}; neue Verteilung:
0
p (d) :=
p(d)
falls d 6= b
p(a) + p(a0) falls d = b
Nun bauen wir durch rekursive Verwendung des Algorithmus
einen Baum T 0 für Σ0 und p0.
In T 0 fügen wir an der Stelle des b-Knotens den a, a0-Baum
ein.
Ergebnis: Ein Codierungsbaum T für Σ,
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
43
Die Wurzel des so erzeugten Mini-Baums wird als ein Kunst”
0
buchstabe“ b aufgefasst mit p(b) = p(a) + p(a ).
Neues Alphabet: Σ0 := (Σ − {a, a0}) ∪ {b}; neue Verteilung:
0
p (d) :=
p(d)
falls d 6= b
p(a) + p(a0) falls d = b
Nun bauen wir durch rekursive Verwendung des Algorithmus
einen Baum T 0 für Σ0 und p0.
In T 0 fügen wir an der Stelle des b-Knotens den a, a0-Baum
ein.
Ergebnis: Ein Codierungsbaum T für Σ,
mit B(T, p)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
43
Die Wurzel des so erzeugten Mini-Baums wird als ein Kunst”
0
buchstabe“ b aufgefasst mit p(b) = p(a) + p(a ).
Neues Alphabet: Σ0 := (Σ − {a, a0}) ∪ {b}; neue Verteilung:
0
p (d) :=
p(d)
falls d 6= b
p(a) + p(a0) falls d = b
Nun bauen wir durch rekursive Verwendung des Algorithmus
einen Baum T 0 für Σ0 und p0.
In T 0 fügen wir an der Stelle des b-Knotens den a, a0-Baum
ein.
Ergebnis: Ein Codierungsbaum T für Σ,
mit B(T, p) = B(T 0, p) + (p(a) + p(a0)).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
43
Die Wurzel des so erzeugten Mini-Baums wird als ein Kunst”
0
buchstabe“ b aufgefasst mit p(b) = p(a) + p(a ).
Neues Alphabet: Σ0 := (Σ − {a, a0}) ∪ {b}; neue Verteilung:
0
p (d) :=
p(d)
falls d 6= b
p(a) + p(a0) falls d = b
Nun bauen wir durch rekursive Verwendung des Algorithmus
einen Baum T 0 für Σ0 und p0.
In T 0 fügen wir an der Stelle des b-Knotens den a, a0-Baum
ein.
Ergebnis: Ein Codierungsbaum T für Σ,
mit B(T, p) = B(T 0, p) + (p(a) + p(a0)).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
(Checken!)
43
Lemma 3.2.6
FG KTuEA, TU Ilmenau
T ist optimaler Baum für (Σ, p).
Effiziente Algorithmen – SS11 – Kapitel 3
44
Lemma 3.2.6
T ist optimaler Baum für (Σ, p).
Beweis:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
44
Lemma 3.2.6
T ist optimaler Baum für (Σ, p).
Beweis: Durch Induktion über die rekursiven Aufrufe.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
44
Lemma 3.2.6
T ist optimaler Baum für (Σ, p).
Beweis: Durch Induktion über die rekursiven Aufrufe.
Nach Lemma 3.2.5. gibt es einen optimalen Baum T1 für
(Σ, p), in dem a- und a0-Knoten Geschwister sind.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
44
Lemma 3.2.6
T ist optimaler Baum für (Σ, p).
Beweis: Durch Induktion über die rekursiven Aufrufe.
Nach Lemma 3.2.5. gibt es einen optimalen Baum T1 für
(Σ, p), in dem a- und a0-Knoten Geschwister sind.
Aus T1 bilden wir T10 durch Ersetzen des a, a0-Teilbaums durch
den Kunstknoten b.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
44
Lemma 3.2.6
T ist optimaler Baum für (Σ, p).
Beweis: Durch Induktion über die rekursiven Aufrufe.
Nach Lemma 3.2.5. gibt es einen optimalen Baum T1 für
(Σ, p), in dem a- und a0-Knoten Geschwister sind.
Aus T1 bilden wir T10 durch Ersetzen des a, a0-Teilbaums durch
den Kunstknoten b. Dann ist T10 Codierungsbaum für Σ0.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
44
Lemma 3.2.6
T ist optimaler Baum für (Σ, p).
Beweis: Durch Induktion über die rekursiven Aufrufe.
Nach Lemma 3.2.5. gibt es einen optimalen Baum T1 für
(Σ, p), in dem a- und a0-Knoten Geschwister sind.
Aus T1 bilden wir T10 durch Ersetzen des a, a0-Teilbaums durch
den Kunstknoten b. Dann ist T10 Codierungsbaum für Σ0.
Nach I.V. für den rekursiven Aufruf ist T 0 optimal für (Σ0, p0),
also B(T 0, p0) ≤ B(T10 , p0).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
44
Lemma 3.2.6
T ist optimaler Baum für (Σ, p).
Beweis: Durch Induktion über die rekursiven Aufrufe.
Nach Lemma 3.2.5. gibt es einen optimalen Baum T1 für
(Σ, p), in dem a- und a0-Knoten Geschwister sind.
Aus T1 bilden wir T10 durch Ersetzen des a, a0-Teilbaums durch
den Kunstknoten b. Dann ist T10 Codierungsbaum für Σ0.
Nach I.V. für den rekursiven Aufruf ist T 0 optimal für (Σ0, p0),
also B(T 0, p0) ≤ B(T10 , p0). Daher:
B(T, p)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
44
Lemma 3.2.6
T ist optimaler Baum für (Σ, p).
Beweis: Durch Induktion über die rekursiven Aufrufe.
Nach Lemma 3.2.5. gibt es einen optimalen Baum T1 für
(Σ, p), in dem a- und a0-Knoten Geschwister sind.
Aus T1 bilden wir T10 durch Ersetzen des a, a0-Teilbaums durch
den Kunstknoten b. Dann ist T10 Codierungsbaum für Σ0.
Nach I.V. für den rekursiven Aufruf ist T 0 optimal für (Σ0, p0),
also B(T 0, p0) ≤ B(T10 , p0). Daher:
B(T, p) = B(T 0, p0)+p(a)+p(a0)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
44
Lemma 3.2.6
T ist optimaler Baum für (Σ, p).
Beweis: Durch Induktion über die rekursiven Aufrufe.
Nach Lemma 3.2.5. gibt es einen optimalen Baum T1 für
(Σ, p), in dem a- und a0-Knoten Geschwister sind.
Aus T1 bilden wir T10 durch Ersetzen des a, a0-Teilbaums durch
den Kunstknoten b. Dann ist T10 Codierungsbaum für Σ0.
Nach I.V. für den rekursiven Aufruf ist T 0 optimal für (Σ0, p0),
also B(T 0, p0) ≤ B(T10 , p0). Daher:
B(T, p) = B(T 0, p0)+p(a)+p(a0) ≤ B(T10 , p0)+p(a)+p(a0)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
44
Lemma 3.2.6
T ist optimaler Baum für (Σ, p).
Beweis: Durch Induktion über die rekursiven Aufrufe.
Nach Lemma 3.2.5. gibt es einen optimalen Baum T1 für
(Σ, p), in dem a- und a0-Knoten Geschwister sind.
Aus T1 bilden wir T10 durch Ersetzen des a, a0-Teilbaums durch
den Kunstknoten b. Dann ist T10 Codierungsbaum für Σ0.
Nach I.V. für den rekursiven Aufruf ist T 0 optimal für (Σ0, p0),
also B(T 0, p0) ≤ B(T10 , p0). Daher:
B(T, p) = B(T 0, p0)+p(a)+p(a0) ≤ B(T10 , p0)+p(a)+p(a0) = B(T1, p).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
44
Lemma 3.2.6
T ist optimaler Baum für (Σ, p).
Beweis: Durch Induktion über die rekursiven Aufrufe.
Nach Lemma 3.2.5. gibt es einen optimalen Baum T1 für
(Σ, p), in dem a- und a0-Knoten Geschwister sind.
Aus T1 bilden wir T10 durch Ersetzen des a, a0-Teilbaums durch
den Kunstknoten b. Dann ist T10 Codierungsbaum für Σ0.
Nach I.V. für den rekursiven Aufruf ist T 0 optimal für (Σ0, p0),
also B(T 0, p0) ≤ B(T10 , p0). Daher:
B(T, p) = B(T 0, p0)+p(a)+p(a0) ≤ B(T10 , p0)+p(a)+p(a0) = B(T1, p).
Weil T1 optimaler Baum für (Σ, p) ist:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
44
Lemma 3.2.6
T ist optimaler Baum für (Σ, p).
Beweis: Durch Induktion über die rekursiven Aufrufe.
Nach Lemma 3.2.5. gibt es einen optimalen Baum T1 für
(Σ, p), in dem a- und a0-Knoten Geschwister sind.
Aus T1 bilden wir T10 durch Ersetzen des a, a0-Teilbaums durch
den Kunstknoten b. Dann ist T10 Codierungsbaum für Σ0.
Nach I.V. für den rekursiven Aufruf ist T 0 optimal für (Σ0, p0),
also B(T 0, p0) ≤ B(T10 , p0). Daher:
B(T, p) = B(T 0, p0)+p(a)+p(a0) ≤ B(T10 , p0)+p(a)+p(a0) = B(T1, p).
Weil T1 optimaler Baum für (Σ, p) ist:
B(T, p) = B(T1, p), und auch T ist optimal.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
44
Noch nachzutragen:
Implementierungsdetails.
Laufzeitanalyse.
Vergleich von B(T, p) für optimale Bäume mit der Entropie
H((pa)a∈Σ).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
45
Man könnte nach dem angegebenen Muster eine rekursive
Prozedur programmieren.
PQ: Datenstruktur Priority Queue,
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
46
Man könnte nach dem angegebenen Muster eine rekursive
Prozedur programmieren.
PQ: Datenstruktur Priority Queue,
Einträge: Buchstaben und Kunstbuchstaben;
Schlüssel: die Gewichte p(b), b (Kunst-)Buchstabe.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
46
Man könnte nach dem angegebenen Muster eine rekursive
Prozedur programmieren.
PQ: Datenstruktur Priority Queue,
Einträge: Buchstaben und Kunstbuchstaben;
Schlüssel: die Gewichte p(b), b (Kunst-)Buchstabe.
Operationen: PQ.insert: Einfügen eines neuen Eintrags;
PQ.extractMin: Entnehmen des Eintrags mit kleinstem
Schlüssel.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
46
Man könnte nach dem angegebenen Muster eine rekursive
Prozedur programmieren.
PQ: Datenstruktur Priority Queue,
Einträge: Buchstaben und Kunstbuchstaben;
Schlüssel: die Gewichte p(b), b (Kunst-)Buchstabe.
Operationen: PQ.insert: Einfügen eines neuen Eintrags;
PQ.extractMin: Entnehmen des Eintrags mit kleinstem
Schlüssel.
Beide Operationen benötigen logarithmische Zeit (siehe 3.3).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
46
Man könnte nach dem angegebenen Muster eine rekursive
Prozedur programmieren.
PQ: Datenstruktur Priority Queue,
Einträge: Buchstaben und Kunstbuchstaben;
Schlüssel: die Gewichte p(b), b (Kunst-)Buchstabe.
Operationen: PQ.insert: Einfügen eines neuen Eintrags;
PQ.extractMin: Entnehmen des Eintrags mit kleinstem
Schlüssel.
Beide Operationen benötigen logarithmische Zeit (siehe 3.3).
Anfangs in PQ: Buchstaben a ∈ Σ mit Gewichten p(a) als
Schlüssel.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
46
Man könnte nach dem angegebenen Muster eine rekursive
Prozedur programmieren.
PQ: Datenstruktur Priority Queue,
Einträge: Buchstaben und Kunstbuchstaben;
Schlüssel: die Gewichte p(b), b (Kunst-)Buchstabe.
Operationen: PQ.insert: Einfügen eines neuen Eintrags;
PQ.extractMin: Entnehmen des Eintrags mit kleinstem
Schlüssel.
Beide Operationen benötigen logarithmische Zeit (siehe 3.3).
Anfangs in PQ: Buchstaben a ∈ Σ mit Gewichten p(a) als
Schlüssel.
Ermitteln und Entfernen der beiden leichtesten“ Buchstaben
”
0
a, a durch zwei Aufrufe PQ.extractMin;
Einfügen des neuen Kunstbuchstabens b durch PQ.insert(b).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
46
Iterative Implementierung wird effizienter.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
47
Iterative Implementierung wird effizienter.
Eine spezielle Repräsentation des Baums (nur Vorgänger-Zeiger, die durch
Indizes dargestellt werden) ermöglicht es, ganz ohne Zeiger auszukommen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
47
Iterative Implementierung wird effizienter.
Eine spezielle Repräsentation des Baums (nur Vorgänger-Zeiger, die durch
Indizes dargestellt werden) ermöglicht es, ganz ohne Zeiger auszukommen.
Datenstruktur:
Arrays p, pred, mark mit Indizes 1..2m − 1, m = |Σ|.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
47
Iterative Implementierung wird effizienter.
Eine spezielle Repräsentation des Baums (nur Vorgänger-Zeiger, die durch
Indizes dargestellt werden) ermöglicht es, ganz ohne Zeiger auszukommen.
Datenstruktur:
Arrays p, pred, mark mit Indizes 1..2m − 1, m = |Σ|.
Dabei repräsentieren
• die Positionen 1, . . . , m die Buchstaben a1, . . . , am in Σ,
also die Blätter des Baumes,
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
47
Iterative Implementierung wird effizienter.
Eine spezielle Repräsentation des Baums (nur Vorgänger-Zeiger, die durch
Indizes dargestellt werden) ermöglicht es, ganz ohne Zeiger auszukommen.
Datenstruktur:
Arrays p, pred, mark mit Indizes 1..2m − 1, m = |Σ|.
Dabei repräsentieren
• die Positionen 1, . . . , m die Buchstaben a1, . . . , am in Σ,
also die Blätter des Baumes,
• die Positionen m + 1, . . . , 2m − 1 die m − 1 Kunstbuch”
staben“, also die inneren Knoten des Baums.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
47
Iterative Implementierung wird effizienter.
Eine spezielle Repräsentation des Baums (nur Vorgänger-Zeiger, die durch
Indizes dargestellt werden) ermöglicht es, ganz ohne Zeiger auszukommen.
Datenstruktur:
Arrays p, pred, mark mit Indizes 1..2m − 1, m = |Σ|.
Dabei repräsentieren
• die Positionen 1, . . . , m die Buchstaben a1, . . . , am in Σ,
also die Blätter des Baumes,
• die Positionen m + 1, . . . , 2m − 1 die m − 1 Kunstbuch”
staben“, also die inneren Knoten des Baums.
Für den Algorithmus tut man so, als ob 1, . . . , m die Buchstaben und
m + 1, . . . , 2m − 1 die Kunstbuchstaben“ wären.
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
47
p[1..2m − 1] ist ein Array, das in den Positionen 1, . . . , m
die Gewichte p1, . . . , pm enthält.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
48
p[1..2m − 1] ist ein Array, das in den Positionen 1, . . . , m
die Gewichte p1, . . . , pm enthält.
Positionen p[m + 1..2m − 1]: Gewichte der m − 1 Kunst”
buchstaben“.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
48
p[1..2m − 1] ist ein Array, das in den Positionen 1, . . . , m
die Gewichte p1, . . . , pm enthält.
Positionen p[m + 1..2m − 1]: Gewichte der m − 1 Kunst”
buchstaben“.
Das Array pred[1..2m − 1] speichert die Vorgänger der
Knoten im Baum
(Knoten 2m − 1 ist die Wurzel und hat keinen Vorgänger).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
48
p[1..2m − 1] ist ein Array, das in den Positionen 1, . . . , m
die Gewichte p1, . . . , pm enthält.
Positionen p[m + 1..2m − 1]: Gewichte der m − 1 Kunst”
buchstaben“.
Das Array pred[1..2m − 1] speichert die Vorgänger der
Knoten im Baum
(Knoten 2m − 1 ist die Wurzel und hat keinen Vorgänger).
In Bitarray mark[1..2m − 1] führt man mit, ob ein Knoten
linkes ( 0“) oder rechtes ( 1“) Kind ist.
”
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
48
p[1..2m − 1] ist ein Array, das in den Positionen 1, . . . , m
die Gewichte p1, . . . , pm enthält.
Positionen p[m + 1..2m − 1]: Gewichte der m − 1 Kunst”
buchstaben“.
Das Array pred[1..2m − 1] speichert die Vorgänger der
Knoten im Baum
(Knoten 2m − 1 ist die Wurzel und hat keinen Vorgänger).
In Bitarray mark[1..2m − 1] führt man mit, ob ein Knoten
linkes ( 0“) oder rechtes ( 1“) Kind ist.
”
”
PQ: Priority Queue,
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
48
p[1..2m − 1] ist ein Array, das in den Positionen 1, . . . , m
die Gewichte p1, . . . , pm enthält.
Positionen p[m + 1..2m − 1]: Gewichte der m − 1 Kunst”
buchstaben“.
Das Array pred[1..2m − 1] speichert die Vorgänger der
Knoten im Baum
(Knoten 2m − 1 ist die Wurzel und hat keinen Vorgänger).
In Bitarray mark[1..2m − 1] führt man mit, ob ein Knoten
linkes ( 0“) oder rechtes ( 1“) Kind ist.
”
”
PQ: Priority Queue, Einträge: a ∈ {1, . . . , 2m − 1};
Schlüssel: die Gewichte p[a].
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
48
Algorithmus Huffman(p[1..m])
Eingabe: Gewichtsvektor p[1..m]
Ausgabe: Implizite Darstellung eines Huffman-Baums
(1)
for a from 1 to m do
(2)
PQ.insert(a); (∗ Buchstabe a hat Priorität p[a] ∗)
(3)
for b from m + 1 to 2m − 1 do
(4)
a ← PQ.extractMin;
(5)
aa ← PQ.extractMin;
(6)
pred[a] ← b;
(7)
mark[a] ← 0;
(8)
pred[aa] ← b;
(9)
mark[aa] ← 1;
(10)
p[b] ← p[a] + p[aa];
(11)
PQ.insert(b);
(12)
Ausgabe: pred[1..2m − 1] und mark[1..2m − 1].
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
49
Aus pred[1..2m − 1] und mark[1..2m − 1] baut man den
Huffman-Baum wie folgt:
Allokiere ein Array leaf[1..m] mit Blattknoten-Objekten
und ein Array inner[m + 1..2m − 1] mit Objekten für innere
Knoten.
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
for i from 1 to m do
leaf[i].letter ← Buchstabe ai.
if mark[i] = 0
then inner[pred[i]].left ← leaf[i]
else inner[pred[i]].right ← leaf[i]
for i from m + 1 to 2m − 2 do
if mark[i] = 0
then inner[pred[i]].left ← inner[i]
else inner[pred[i]].right ← inner[i]
return inner[2m − 1] (∗ Wurzelknoten ∗)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
50
ai
i
pi
pred
mark
A
1
0,15
FG KTuEA, TU Ilmenau
B
2
0,08
C
3
0,07
D
4
0,10
E
5
0,21
Effiziente Algorithmen – SS11 – Kapitel 3
F
6
0,08
G
7
0,07
H
8
0,09
I
9
0,06
K
10
0,09
51
ai
i
pi
pred
mark
A
1
0,15
B
2
0,08
C
3
0,07
i
pi
pred
mark
11
12
13
FG KTuEA, TU Ilmenau
D
4
0,10
E
5
0,21
14
Effiziente Algorithmen – SS11 – Kapitel 3
15
F
6
0,08
G
7
0,07
16
H
8
0,09
17
I
9
0,06
18
K
10
0,09
19
51
ai
i
pi
pred
mark
A
1
0,15
B
2
0,08
C
3
0,07
i
pi
pred
mark
11
0,13
12
13
FG KTuEA, TU Ilmenau
D
4
0,10
E
5
0,21
14
Effiziente Algorithmen – SS11 – Kapitel 3
15
F
6
0,08
G
7
0,07
11
0
16
H
8
0,09
17
I
9
0,06
11
1
18
K
10
0,09
19
51
ai
i
pi
pred
mark
A
1
0,15
B
2
0,08
C
3
0,07
i
pi
pred
mark
11
0,13
12
13
FG KTuEA, TU Ilmenau
D
4
0,10
E
5
0,21
14
Effiziente Algorithmen – SS11 – Kapitel 3
15
F
6
0,08
G
7
0,07
11
0
16
H
8
0,09
17
I
9
0,06
11
1
18
K
10
0,09
19
51
ai
i
pi
pred
mark
A
1
0,15
B
2
0,08
i
pi
pred
mark
11
0,13
12
0,15
FG KTuEA, TU Ilmenau
C
3
0,07
12
0
13
D
4
0,10
E
5
0,21
14
Effiziente Algorithmen – SS11 – Kapitel 3
15
F
6
0,08
12
1
G
7
0,07
11
0
16
H
8
0,09
17
I
9
0,06
11
1
18
K
10
0,09
19
51
ai
i
pi
pred
mark
A
1
0,15
i
pi
pred
mark
11
0,13
FG KTuEA, TU Ilmenau
B
2
0,08
12
0,15
C
3
0,07
12
0
13
D
4
0,10
E
5
0,21
14
Effiziente Algorithmen – SS11 – Kapitel 3
15
F
6
0,08
12
1
G
7
0,07
11
0
16
H
8
0,09
17
I
9
0,06
11
1
18
K
10
0,09
19
51
ai
i
pi
pred
mark
A
1
0,15
i
pi
pred
mark
11
0,13
FG KTuEA, TU Ilmenau
B
2
0,08
13
0
12
0,15
C
3
0,07
12
0
13
0,17
D
4
0,10
E
5
0,21
14
Effiziente Algorithmen – SS11 – Kapitel 3
15
F
6
0,08
12
1
G
7
0,07
11
0
16
H
8
0,09
17
I
9
0,06
11
1
18
K
10
0,09
13
1
19
51
ai
i
pi
pred
mark
A
1
0,15
i
pi
pred
mark
11
0,13
FG KTuEA, TU Ilmenau
B
2
0,08
13
0
12
0,15
C
3
0,07
12
0
13
0,17
D
4
0,10
E
5
0,21
14
Effiziente Algorithmen – SS11 – Kapitel 3
15
F
6
0,08
12
1
G
7
0,07
11
0
16
H
8
0,09
17
I
9
0,06
11
1
18
K
10
0,09
13
1
19
51
ai
i
pi
pred
mark
A
1
0,15
i
pi
pred
mark
11
0,13
FG KTuEA, TU Ilmenau
B
2
0,08
13
0
12
0,15
C
3
0,07
12
0
13
0,17
D
4
0,10
14
0
E
5
0,21
14
0,19
Effiziente Algorithmen – SS11 – Kapitel 3
15
F
6
0,08
12
1
G
7
0,07
11
0
16
H
8
0,09
14
1
17
I
9
0,06
11
1
18
K
10
0,09
13
1
19
51
ai
i
pi
pred
mark
A
1
0,15
i
pi
pred
mark
11
0,13
FG KTuEA, TU Ilmenau
B
2
0,08
13
0
12
0,15
C
3
0,07
12
0
13
0,17
D
4
0,10
14
0
E
5
0,21
14
0,19
Effiziente Algorithmen – SS11 – Kapitel 3
15
F
6
0,08
12
1
G
7
0,07
11
0
16
H
8
0,09
14
1
17
I
9
0,06
11
1
18
K
10
0,09
13
1
19
51
ai
i
pi
pred
mark
A
1
0,15
15
0
i
pi
pred
mark
11
0,13
15
1
FG KTuEA, TU Ilmenau
B
2
0,08
13
0
12
0,15
C
3
0,07
12
0
13
0,17
D
4
0,10
14
0
14
0,19
E
5
0,21
F
6
0,08
12
1
15
0,28
Effiziente Algorithmen – SS11 – Kapitel 3
G
7
0,07
11
0
16
H
8
0,09
14
1
17
I
9
0,06
11
1
18
K
10
0,09
13
1
19
51
ai
i
pi
pred
mark
A
1
0,15
15
0
i
pi
pred
mark
11
0,13
15
1
FG KTuEA, TU Ilmenau
B
2
0,08
13
0
12
0,15
C
3
0,07
12
0
13
0,17
D
4
0,10
14
0
14
0,19
E
5
0,21
15
0,28
Effiziente Algorithmen – SS11 – Kapitel 3
F
6
0,08
12
1
G
7
0,07
11
0
16
H
8
0,09
14
1
17
I
9
0,06
11
1
18
K
10
0,09
13
1
19
51
ai
i
pi
pred
mark
A
1
0,15
15
0
i
pi
pred
mark
11
0,13
15
1
FG KTuEA, TU Ilmenau
B
2
0,08
13
0
12
0,15
16
0
C
3
0,07
12
0
13
0,17
16
1
D
4
0,10
14
0
14
0,19
E
5
0,21
15
0,28
Effiziente Algorithmen – SS11 – Kapitel 3
F
6
0,08
12
1
G
7
0,07
11
0
16
0,32
H
8
0,09
14
1
17
I
9
0,06
11
1
18
K
10
0,09
13
1
19
51
ai
i
pi
pred
mark
A
1
0,15
15
0
i
pi
pred
mark
11
0,13
15
1
FG KTuEA, TU Ilmenau
B
2
0,08
13
0
12
0,15
16
0
C
3
0,07
12
0
13
0,17
16
1
D
4
0,10
14
0
14
0,19
E
5
0,21
15
0,28
Effiziente Algorithmen – SS11 – Kapitel 3
F
6
0,08
12
1
G
7
0,07
11
0
16
0,32
H
8
0,09
14
1
17
I
9
0,06
11
1
18
K
10
0,09
13
1
19
51
ai
i
pi
pred
mark
A
1
0,15
15
0
i
pi
pred
mark
11
0,13
15
1
FG KTuEA, TU Ilmenau
B
2
0,08
13
0
12
0,15
16
0
C
3
0,07
12
0
13
0,17
16
1
D
4
0,10
14
0
14
0,19
17
1
E
5
0,21
17
0
15
0,28
Effiziente Algorithmen – SS11 – Kapitel 3
F
6
0,08
12
1
G
7
0,07
11
0
16
0,32
H
8
0,09
14
1
17
0,40
I
9
0,06
11
1
18
K
10
0,09
13
1
19
51
ai
i
pi
pred
mark
A
1
0,15
15
0
i
pi
pred
mark
11
0,13
15
1
FG KTuEA, TU Ilmenau
B
2
0,08
13
0
12
0,15
16
0
C
3
0,07
12
0
13
0,17
16
1
D
4
0,10
14
0
14
0,19
17
1
E
5
0,21
17
0
15
0,28
Effiziente Algorithmen – SS11 – Kapitel 3
F
6
0,08
12
1
G
7
0,07
11
0
16
0,32
H
8
0,09
14
1
17
0,40
I
9
0,06
11
1
18
K
10
0,09
13
1
19
51
ai
i
pi
pred
mark
A
1
0,15
15
0
i
pi
pred
mark
11
0,13
15
1
FG KTuEA, TU Ilmenau
B
2
0,08
13
0
12
0,15
16
0
C
3
0,07
12
0
13
0,17
16
1
D
4
0,10
14
0
14
0,19
17
1
E
5
0,21
17
0
15
0,28
18
0
Effiziente Algorithmen – SS11 – Kapitel 3
F
6
0,08
12
1
G
7
0,07
11
0
16
0,32
18
1
H
8
0,09
14
1
17
0,40
I
9
0,06
11
1
18
0,60
K
10
0,09
13
1
19
51
ai
i
pi
pred
mark
A
1
0,15
15
0
i
pi
pred
mark
11
0,13
15
1
FG KTuEA, TU Ilmenau
B
2
0,08
13
0
12
0,15
16
0
C
3
0,07
12
0
13
0,17
16
1
D
4
0,10
14
0
14
0,19
17
1
E
5
0,21
17
0
15
0,28
18
0
Effiziente Algorithmen – SS11 – Kapitel 3
F
6
0,08
12
1
G
7
0,07
11
0
16
0,32
18
1
H
8
0,09
14
1
17
0,40
I
9
0,06
11
1
18
0,60
K
10
0,09
13
1
19
51
ai
i
pi
pred
mark
A
1
0,15
15
0
i
pi
pred
mark
11
0,13
15
1
FG KTuEA, TU Ilmenau
B
2
0,08
13
0
12
0,15
16
0
C
3
0,07
12
0
13
0,17
16
1
D
4
0,10
14
0
14
0,19
17
1
E
5
0,21
17
0
15
0,28
18
0
Effiziente Algorithmen – SS11 – Kapitel 3
F
6
0,08
12
1
G
7
0,07
11
0
16
0,32
18
1
H
8
0,09
14
1
17
0,40
19
0
I
9
0,06
11
1
18
0,60
19
1
K
10
0,09
13
1
19
1,00
51
ai
i
pi
pred
mark
A
1
0,15
15
0
i
pi
pred
mark
11
0,13
15
1
FG KTuEA, TU Ilmenau
B
2
0,08
13
0
12
0,15
16
0
C
3
0,07
12
0
13
0,17
16
1
D
4
0,10
14
0
14
0,19
17
1
E
5
0,21
17
0
15
0,28
18
0
Effiziente Algorithmen – SS11 – Kapitel 3
F
6
0,08
12
1
G
7
0,07
11
0
16
0,32
18
1
H
8
0,09
14
1
17
0,40
19
0
I
9
0,06
11
1
18
0,60
19
1
K
10
0,09
13
1
19
1,00
–
–
51
Resultierender optimaler Codierungsbaum T :
19
0
1
18
17
0
5
0
0
1
8
11
1
7
p(a)
c3
A
0,15
100
B
0,08
1110
FG KTuEA, TU Ilmenau
C
0,07
1100
D
0,10
010
1
0
1
A
H
D
4
16
15
14
E
1
0
1
12
13
0
1
0
1
G
I
C
F
9
E
0,21
00
Effiziente Algorithmen – SS11 – Kapitel 3
3
F
0,08
1101
6
1
0
B
2
G
0,07
1010
K
10
H
0,09
011
I
0,06
1011
K
0,09
1111
52
Resultierender optimaler Codierungsbaum T :
19
0
1
18
17
0
5
0
0
1
8
11
1
7
p(a)
c3
A
0,15
100
B
0,08
1110
C
0,07
1100
D
0,10
010
1
0
1
A
H
D
4
16
15
14
E
1
0
1
12
13
0
1
0
1
G
I
C
F
9
E
0,21
00
3
F
0,08
1101
6
1
0
B
2
G
0,07
1010
K
10
H
0,09
011
I
0,06
1011
K
0,09
1111
B(T, p) =
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
52
Resultierender optimaler Codierungsbaum T :
19
0
1
18
17
0
5
0
0
1
8
11
1
7
p(a)
c3
A
0,15
100
B
0,08
1110
C
0,07
1100
D
0,10
010
1
0
1
A
H
D
4
16
15
14
E
1
0
1
12
13
0
1
0
1
G
I
C
F
9
E
0,21
00
3
F
0,08
1101
6
1
0
B
2
G
0,07
1010
K
10
H
0,09
011
I
0,06
1011
K
0,09
1111
B(T, p) = 0,21 · 2
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
52
Resultierender optimaler Codierungsbaum T :
19
0
1
18
17
0
5
0
0
1
8
11
1
7
p(a)
c3
A
0,15
100
B
0,08
1110
C
0,07
1100
D
0,10
010
1
0
1
A
H
D
4
16
15
14
E
1
0
1
12
13
0
1
0
1
G
I
C
F
9
E
0,21
00
3
F
0,08
1101
6
1
0
B
2
G
0,07
1010
K
10
H
0,09
011
I
0,06
1011
K
0,09
1111
B(T, p) = 0,21 · 2 + (0,1 + 0,09 + 0,15) · 3
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
52
Resultierender optimaler Codierungsbaum T :
19
0
1
18
17
0
5
0
0
1
8
11
1
7
p(a)
c3
A
0,15
100
B
0,08
1110
C
0,07
1100
D
0,10
010
1
0
1
A
H
D
4
16
15
14
E
1
0
1
12
13
0
1
0
1
G
I
C
F
9
E
0,21
00
3
F
0,08
1101
6
1
0
B
2
G
0,07
1010
K
10
H
0,09
011
I
0,06
1011
K
0,09
1111
B(T, p) = 0,21 · 2 + (0,1 + 0,09 + 0,15) · 3 + 0,45 · 4
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
52
Resultierender optimaler Codierungsbaum T :
19
0
1
18
17
0
5
0
0
1
8
11
1
7
p(a)
c3
A
0,15
100
B
0,08
1110
C
0,07
1100
D
0,10
010
1
0
1
A
H
D
4
16
15
14
E
1
0
1
12
13
0
1
0
1
G
I
C
F
9
E
0,21
00
3
F
0,08
1101
6
1
0
B
2
G
0,07
1010
K
10
H
0,09
011
I
0,06
1011
K
0,09
1111
B(T, p) = 0,21 · 2 + (0,1 + 0,09 + 0,15) · 3 + 0,45 · 4 = 3,24.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
52
Satz 3.2.7
Der Algorithmus Huffman ist korrekt und hat Laufzeit
O(m log m), wenn m die Anzahl der Buchstaben des Alphabets Σ bezeichnet.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
53
Satz 3.2.7
Der Algorithmus Huffman ist korrekt und hat Laufzeit
O(m log m), wenn m die Anzahl der Buchstaben des Alphabets Σ bezeichnet.
Beweis: Laufzeit: Aufbau der Priority Queue dauert
O(m log m); mit Tricks könnte man auch mit Zeit O(m)
auskommen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
53
Satz 3.2.7
Der Algorithmus Huffman ist korrekt und hat Laufzeit
O(m log m), wenn m die Anzahl der Buchstaben des Alphabets Σ bezeichnet.
Beweis: Laufzeit: Aufbau der Priority Queue dauert
O(m log m); mit Tricks könnte man auch mit Zeit O(m)
auskommen.
Die Schleife wird (m − 1)-mal durchlaufen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
53
Satz 3.2.7
Der Algorithmus Huffman ist korrekt und hat Laufzeit
O(m log m), wenn m die Anzahl der Buchstaben des Alphabets Σ bezeichnet.
Beweis: Laufzeit: Aufbau der Priority Queue dauert
O(m log m); mit Tricks könnte man auch mit Zeit O(m)
auskommen.
Die Schleife wird (m − 1)-mal durchlaufen. In jedem Durchlauf
gibt es maximal 3 PQ-Operationen, mit Kosten O(log m).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
53
Satz 3.2.7
Der Algorithmus Huffman ist korrekt und hat Laufzeit
O(m log m), wenn m die Anzahl der Buchstaben des Alphabets Σ bezeichnet.
Beweis: Laufzeit: Aufbau der Priority Queue dauert
O(m log m); mit Tricks könnte man auch mit Zeit O(m)
auskommen.
Die Schleife wird (m − 1)-mal durchlaufen. In jedem Durchlauf
gibt es maximal 3 PQ-Operationen, mit Kosten O(log m).
Korrektheit: Folgt aus der Korrektheit der rekursiven Version.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
53
Kann man B(T, p) für einen optimalen Baum einfach aus
den Häufigkeiten p(a1), . . . , p(an) berechnen, ohne T zu
konstruieren?
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
54
Kann man B(T, p) für einen optimalen Baum einfach aus
den Häufigkeiten p(a1), . . . , p(an) berechnen, ohne T zu
konstruieren?
Antwort: Ja, zumindest näherungsweise.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
54
Kann man B(T, p) für einen optimalen Baum einfach aus
den Häufigkeiten p(a1), . . . , p(an) berechnen, ohne T zu
konstruieren?
Antwort: Ja, zumindest näherungsweise.
Definition
Sind p1, . . . , pn ≥ 0 mit
Pn
i=1 pi
H(p1, . . . , pn) :=
= 1, setzt man
n
X
pi · log(1/pi).
i=1
H(p1, . . . , pn) heißt die Entropie der Verteilung p1, . . . , pn.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
54
Kann man B(T, p) für einen optimalen Baum einfach aus
den Häufigkeiten p(a1), . . . , p(an) berechnen, ohne T zu
konstruieren?
Antwort: Ja, zumindest näherungsweise.
Definition
Sind p1, . . . , pn ≥ 0 mit
Pn
i=1 pi
H(p1, . . . , pn) :=
= 1, setzt man
n
X
pi · log(1/pi).
i=1
H(p1, . . . , pn) heißt die Entropie der Verteilung p1, . . . , pn.
(Wenn pi = 0 ist, setzt man pi log(1/pi) = 0, was vernünftig
ist, weil limx&0 x · log(1/x) = 0.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
54
Kann man B(T, p) für einen optimalen Baum einfach aus
den Häufigkeiten p(a1), . . . , p(an) berechnen, ohne T zu
konstruieren?
Antwort: Ja, zumindest näherungsweise.
Definition
Sind p1, . . . , pn ≥ 0 mit
Pn
i=1 pi
H(p1, . . . , pn) :=
= 1, setzt man
n
X
pi · log(1/pi).
i=1
H(p1, . . . , pn) heißt die Entropie der Verteilung p1, . . . , pn.
(Wenn pi = 0 ist, setzt man pi log(1/pi) = 0, was vernünftig
ist, weil limx&0 x · log(1/x) = 0.)
Bsp.: H( 21 , 14 , 14 ) = 12 · 1 + 2 · 14 · 2 = 32 .
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
54
Interessant: Zusammenhang zwischen Entropie H(p1, . . . , pn)
und der erwarteten Bitlänge eines Textes, in dem n = |Σ|
Buchstaben mit Wahrscheinlichkeiten p1, . . . , pn auftreten.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
55
Interessant: Zusammenhang zwischen Entropie H(p1, . . . , pn)
und der erwarteten Bitlänge eines Textes, in dem n = |Σ|
Buchstaben mit Wahrscheinlichkeiten p1, . . . , pn auftreten.
Klassisches Resultat:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
55
Interessant: Zusammenhang zwischen Entropie H(p1, . . . , pn)
und der erwarteten Bitlänge eines Textes, in dem n = |Σ|
Buchstaben mit Wahrscheinlichkeiten p1, . . . , pn auftreten.
Klassisches Resultat:
Lemma 3.2.8 (Lemma von Gibb)
Pn
Pn
Sind q1, . . . , qn > 0 mit i=1 qi ≤ 1 = i=1 pi, so gilt
n
X
pi log(1/qi) ≥
i=1
FG KTuEA, TU Ilmenau
n
X
pi log(1/pi) = H(p1, . . . , pn).
i=1
Effiziente Algorithmen – SS11 – Kapitel 3
55
Interessant: Zusammenhang zwischen Entropie H(p1, . . . , pn)
und der erwarteten Bitlänge eines Textes, in dem n = |Σ|
Buchstaben mit Wahrscheinlichkeiten p1, . . . , pn auftreten.
Klassisches Resultat:
Lemma 3.2.8 (Lemma von Gibb)
Pn
Pn
Sind q1, . . . , qn > 0 mit i=1 qi ≤ 1 = i=1 pi, so gilt
n
X
pi log(1/qi) ≥
i=1
n
X
pi log(1/pi) = H(p1, . . . , pn).
i=1
(Voraussetzung kann zu pi > 0 ⇒ qi > 0 abgeschwächt werden.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
55
Beweis:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
56
Beweis:
Weil log2 x = ln x/ ln 2 ist, darf man mit dem natürlichen
Logarithmus rechnen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
56
Beweis:
Weil log2 x = ln x/ ln 2 ist, darf man mit dem natürlichen
Logarithmus rechnen.
X
n
1
1
pi ln
−
pi ln
pi
qi
i=1
i=1
n
X
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
56
Beweis:
Weil log2 x = ln x/ ln 2 ist, darf man mit dem natürlichen
Logarithmus rechnen.
X
n
1
1
pi ln
−
pi ln
pi
qi
i=1
i=1
n
X
qi
=
pi ln
pi
i=1
n
X
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
56
Beweis:
Weil log2 x = ln x/ ln 2 ist, darf man mit dem natürlichen
Logarithmus rechnen.
X
n
1
1
pi ln
−
pi ln
pi
qi
i=1
i=1
(∗) X
n
n
X
qi
qi
=
pi ln
≤
pi
−1
pi
pi
i=1
i=1
n
X
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
56
Beweis:
Weil log2 x = ln x/ ln 2 ist, darf man mit dem natürlichen
Logarithmus rechnen.
X
n
1
1
pi ln
−
pi ln
pi
qi
i=1
i=1
(∗) X
n
n
X
qi
qi
=
pi ln
≤
pi
−1
pi
pi
i=1
i=1
n
X
=
n
X
i=1
FG KTuEA, TU Ilmenau
(qi − pi) =
n
X
i=1
Effiziente Algorithmen – SS11 – Kapitel 3
qi −
n
X
pi ≤ 0.
i=1
56
Beweis:
Weil log2 x = ln x/ ln 2 ist, darf man mit dem natürlichen
Logarithmus rechnen.
X
n
1
1
pi ln
−
pi ln
pi
qi
i=1
i=1
(∗) X
n
n
X
qi
qi
=
pi ln
≤
pi
−1
pi
pi
i=1
i=1
n
X
=
n
X
i=1
(qi − pi) =
n
X
i=1
qi −
n
X
pi ≤ 0.
i=1
(∗): Es gilt ln(x) ≤ x − 1, für alle x ∈ R.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
56
Beweis:
Weil log2 x = ln x/ ln 2 ist, darf man mit dem natürlichen
Logarithmus rechnen.
X
n
1
1
pi ln
−
pi ln
pi
qi
i=1
i=1
(∗) X
n
n
X
qi
qi
=
pi ln
≤
pi
−1
pi
pi
i=1
i=1
n
X
=
n
X
i=1
(qi − pi) =
n
X
i=1
qi −
n
X
pi ≤ 0.
i=1
(∗): Es gilt ln(x) ≤ x − 1, für alle x ∈ R.
(Summanden für i mit pi = qi = 0 lässt man einfach weg.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
56
Satz 3.2.9 (Ungleichung von Kraft/McMillan)
Es seien n ≥ 1, l1, . . . , ln ∈ N. Dann gilt: Es gibt einen
Präfixcode mit Codewortlängen l1, . . . , ln genau dann wenn
n
X
2−li ≤ 1.
i=1
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
57
Satz 3.2.9 (Ungleichung von Kraft/McMillan)
Es seien n ≥ 1, l1, . . . , ln ∈ N. Dann gilt: Es gibt einen
Präfixcode mit Codewortlängen l1, . . . , ln genau dann wenn
n
X
2−li ≤ 1.
i=1
⇒“: Nach den Bemerkungen am Anfang von Abschnitt 3.2
”
kann man statt Existenz eines Präfixcodes“ auch Existenz
”
”
eines Binärbaums mit Blättern auf Tiefe l1, . . . , ln“ sagen.
http://www.tu-ilmenau.de/fakia/Algorithmen-und-Date.aud_ss10.
0.html
AuD-Vorlesung 2010, 3. Kapitel, Satz 3.3.4, Folie 43.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
57
Pn
⇐“: Nun seien l1, . . . , ln ≥ 0 gegeben, mit i=1 2−li ≤ 1.
”
Wir benutzen Induktion über n ≥ 1
(äquivalent: einen rekursiven Algorithmus),
um die behauptete Existenz eines passenden präfixfreien Codes
zu zeigen.
n = 1: Wähle ein beliebiges Codewort x1 aus {0, 1}l1 .
(Achtung: Wenn l1 = 0, ist x1 = ε, das leere Wort. Dies
entspricht einem Codierungsbaum, der nur aus der Wurzel
besteht.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
58
Nun sei n ≥ 2. Wir ordnen (o.B.d.A.) die l1, . . . , ln so an,
Pn l −l
dass l1 ≥ l2 ≥ · · · ≥ ln gilt. Nach Vor.: i=2 2 1 i < 2l1 ;
die Summe ist durch 2l1−l2 teilbar.
Pn l −l
Also: i=2 2 1 i ≤ 2l1 − 2l1−l2 .
Pn l −l
l1−l2
Daraus: 2 · 2
+ i=3 2 1 i ≤ 2l1 , d. h.
Pn −l
−(l2−1)
2
+ i=3 2 i ≤ 1.
Setze l10 := l2 − 1 und finde (nach Induktionsvoraussetzung bzw. rekursiv) einen Präfixcode {x01, x3, x4, . . . , xn} für
l10 , l3, . . . , ln. Nun bilde x2 := x011 und x1 := x010 . . . 0 (mit
l1 − l2 + 1 angehängten Nullen). Es ist leicht zu sehen, dass
auch {x1, . . . , xn} präfixfrei ist.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
59
Beispiel:
(l1, . . . , l6) = (1, 4, 5, 3, 6, 3); sortiert: (6, 5, 4, 3, 3, 1).
Dies führt zu rekursiven Aufrufen für:
1) (4, 4, 3, 3, 1)
2) (3, 3, 3, 1)
3) (2, 3, 1), sortiert: (3, 2, 1)
4) (1, 1)
5) (1).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
60
Die Präfixcodes für diese Aufrufe:
5) {}
4) {0, 1}
3) {000, 01, 1}, also {01, 000, 1}
2) {010, 011, 000, 1}
1) {0100, 0101, 011, 000, 1}
Gesamtlösung: {010000, 01001, 0101, 011, 000, 1}
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
61
Satz 3.2.10 (Huffman versus Entropie)
P
Ist p : Σ → [0, 1] mit a∈Σ p(a) = 1 gegeben, so gilt für einen
optimalen Codierungsbaum T zu (Σ, p):
H(p1, . . . , pn) ≤ B(T, p) ≤ H(p1, . . . , pn) + 1.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
62
Satz 3.2.10 (Huffman versus Entropie)
P
Ist p : Σ → [0, 1] mit a∈Σ p(a) = 1 gegeben, so gilt für einen
optimalen Codierungsbaum T zu (Σ, p):
H(p1, . . . , pn) ≤ B(T, p) ≤ H(p1, . . . , pn) + 1.
(Informal: Setze pi = p(ai), für Σ = {a1, . . . , an}.
Die erwartete Zahl von Bits, die man braucht, um einen Text
t1 . . . tN über Σ zu codieren, liegt zwischen N · H(p1, . . . , pn)
und N · (H(p1, . . . , pn) + 1).)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
62
Beweis: 1. Ungleichung: Es seien l1, . . . , ln die Tiefen der
Blätter in T zu den Buchstaben a1, . . . , an. Dann gilt
Pn −l
i ≤ 1 nach Satz 3.2.9. Damit können wir Satz 3.2.8
2
i=1
mit qi = 2−li anwenden und erhalten
B(T, p) =
n
X
i=1
FG KTuEA, TU Ilmenau
pi · li =
n
X
pi · log(1/2−li ) ≥ H(p1, . . . , pn).
i=1
Effiziente Algorithmen – SS11 – Kapitel 3
63
Für die 2. Ungleichung genügt es zu zeigen, dass ein Codierungsbaum T 0 für a1, . . . , an existiert, in dem B(T 0, p) ≤
H(p1, . . . , pn) + 1 gilt.
(Der optimale Baum T erfüllt ja B(T, p) ≤ B(T 0, p).)
Wir setzen li := dlog(1/pi)e, für 1 ≤ i ≤ n, und beobachten:
n
X
2−li =
i=1
=
n
X
i=1
n
X
2−dlog(1/pi)e ≤
n
X
2− log(1/pi)
i=1
pi = 1.
i=1
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
64
Nach Satz 3.2.9 existiert also ein Präfixcode mit Codewortlängen (l1, . . . , ln); im entsprechenden Codierungsbaum
T 0 ordnen wir dem Blatt auf Tiefe li den Buchstaben ai zu.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
65
Nach Satz 3.2.9 existiert also ein Präfixcode mit Codewortlängen (l1, . . . , ln); im entsprechenden Codierungsbaum
T 0 ordnen wir dem Blatt auf Tiefe li den Buchstaben ai zu.
Dann ist
B(T 0, p) =
n
X
pi · li
i=1
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
65
Nach Satz 3.2.9 existiert also ein Präfixcode mit Codewortlängen (l1, . . . , ln); im entsprechenden Codierungsbaum
T 0 ordnen wir dem Blatt auf Tiefe li den Buchstaben ai zu.
Dann ist
B(T 0, p) =
n
X
i=1
FG KTuEA, TU Ilmenau
pi · li ≤
n
X
pi · (log(1/pi) + 1)
i=1
Effiziente Algorithmen – SS11 – Kapitel 3
65
Nach Satz 3.2.9 existiert also ein Präfixcode mit Codewortlängen (l1, . . . , ln); im entsprechenden Codierungsbaum
T 0 ordnen wir dem Blatt auf Tiefe li den Buchstaben ai zu.
Dann ist
B(T 0, p) =
n
X
i=1
pi · li ≤
n
X
pi · (log(1/pi) + 1)
i=1
= H(p1, . . . , pn) +
n
X
pi
i=1
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
65
Nach Satz 3.2.9 existiert also ein Präfixcode mit Codewortlängen (l1, . . . , ln); im entsprechenden Codierungsbaum
T 0 ordnen wir dem Blatt auf Tiefe li den Buchstaben ai zu.
Dann ist
B(T 0, p) =
n
X
i=1
pi · li ≤
n
X
pi · (log(1/pi) + 1)
i=1
= H(p1, . . . , pn) +
n
X
pi
i=1
= H(p1, . . . , pn) + 1.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
65
Nach Satz 3.2.9 existiert also ein Präfixcode mit Codewortlängen (l1, . . . , ln); im entsprechenden Codierungsbaum
T 0 ordnen wir dem Blatt auf Tiefe li den Buchstaben ai zu.
Dann ist
B(T 0, p) =
n
X
i=1
pi · li ≤
n
X
pi · (log(1/pi) + 1)
i=1
= H(p1, . . . , pn) +
n
X
pi
i=1
= H(p1, . . . , pn) + 1.
Bemerkung: Es gibt bessere Kodierungsverfahren als das
von Huffman (z.B. arithmetische Kodierung“; diese vermei”
den den Verlust von bis zu einem Bit pro Buchstabe), aber
Huffman-Kodierung ist ein guter Anfang . . .
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
65
3.3 (Hilfs-)Datenstruktur Priority Queues
(oder: Vorrangswarteschlangen)
Datensätze mit Schlüssel aus sortiertem Universum (U, <)
werden eingefügt und entnommen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
66
3.3 (Hilfs-)Datenstruktur Priority Queues
(oder: Vorrangswarteschlangen)
Datensätze mit Schlüssel aus sortiertem Universum (U, <)
werden eingefügt und entnommen.
Beim Entnehmen wird immer der Eintrag mit dem kleinsten
Schlüssel gewählt.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
66
3.3 (Hilfs-)Datenstruktur Priority Queues
(oder: Vorrangswarteschlangen)
Datensätze mit Schlüssel aus sortiertem Universum (U, <)
werden eingefügt und entnommen.
Beim Entnehmen wird immer der Eintrag mit dem kleinsten
Schlüssel gewählt. Schlüssel =
b Prioritäten“.
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
66
3.3 (Hilfs-)Datenstruktur Priority Queues
(oder: Vorrangswarteschlangen)
Datensätze mit Schlüssel aus sortiertem Universum (U, <)
werden eingefügt und entnommen.
Beim Entnehmen wird immer der Eintrag mit dem kleinsten
Schlüssel gewählt. Schlüssel =
b Prioritäten“.
”
Beim Huffman-Algorithmus: Datensätze sind
(Kunst-)Buchstaben, Prioritäten/Schlüssel sind die Gewichte.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
66
3.3 (Hilfs-)Datenstruktur Priority Queues
(oder: Vorrangswarteschlangen)
Datensätze mit Schlüssel aus sortiertem Universum (U, <)
werden eingefügt und entnommen.
Beim Entnehmen wird immer der Eintrag mit dem kleinsten
Schlüssel gewählt. Schlüssel =
b Prioritäten“.
”
Beim Huffman-Algorithmus: Datensätze sind
(Kunst-)Buchstaben, Prioritäten/Schlüssel sind die Gewichte.
Vorlesung Algorithmen und Datenstrukturen“:
”
Spezifikation und Realisierung mit Binärheaps.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
66
Anwendungen:
1) Prozessverwaltung in Multitask-System
Jeder Prozess hat einen Namen (eine ID“) und eine Priorität
”
(Zahl in N).
(Üblich: kleinere Zahlen bedeuten höhere Prioritäten.)
Aktuell rechenbereite Prozesse befinden sich in der Prozesswarteschlange. Bei Freiwerden eines Prozessors (z. B. durch
Unterbrechen eines Prozesses) wird einer der Prozesse mit
höchster Priorität aus der Warteschlange entnommen und
weitergeführt.
Mögliche Operation: Änderung einer Priorität.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
67
Anwendungen:
2) Discrete Event Simulation“
”
System von Aktionen soll auf dem Rechner simuliert werden.
Jeder ausführbaren Aktion A ist ein Zeitpunkt tA ∈ [0, ∞)
zugeordnet.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
68
Anwendungen:
2) Discrete Event Simulation“
”
System von Aktionen soll auf dem Rechner simuliert werden.
Jeder ausführbaren Aktion A ist ein Zeitpunkt tA ∈ [0, ∞)
zugeordnet.
Die Ausführung einer Aktion A kann neue Aktionen A0 erzeugen oder ausführbar machen, mit neuen Zeitpunkten tA0 > tA.
Oder: Zeitpunkt tA0 für Aktion A0 wird auf neuen Wert
verkleinert.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
68
Anwendungen:
2) Discrete Event Simulation“
”
System von Aktionen soll auf dem Rechner simuliert werden.
Jeder ausführbaren Aktion A ist ein Zeitpunkt tA ∈ [0, ∞)
zugeordnet.
Die Ausführung einer Aktion A kann neue Aktionen A0 erzeugen oder ausführbar machen, mit neuen Zeitpunkten tA0 > tA.
Oder: Zeitpunkt tA0 für Aktion A0 wird auf neuen Wert
verkleinert.
Ein Schritt: Wähle diejenige noch nicht ausgeführte Aktion
mit dem frühesten Ausführungszeitpunkt und führe sie aus.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
68
Anwendungen:
2) Discrete Event Simulation“
”
System von Aktionen soll auf dem Rechner simuliert werden.
Jeder ausführbaren Aktion A ist ein Zeitpunkt tA ∈ [0, ∞)
zugeordnet.
Die Ausführung einer Aktion A kann neue Aktionen A0 erzeugen oder ausführbar machen, mit neuen Zeitpunkten tA0 > tA.
Oder: Zeitpunkt tA0 für Aktion A0 wird auf neuen Wert
verkleinert.
Ein Schritt: Wähle diejenige noch nicht ausgeführte Aktion
mit dem frühesten Ausführungszeitpunkt und führe sie aus.
3) Innerhalb von Algorithmen
(Huffman, Dijkstra, Jarnı́k/Prim, u. a.).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
68
Formale Beschreibung (siehe AuD-Vorlesung):
Datentyp: SimplePriorityQueue (Einfache Vorrangswarteschlange)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
69
Formale Beschreibung (siehe AuD-Vorlesung):
Datentyp: SimplePriorityQueue (Einfache Vorrangswarteschlange)
Signatur:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
69
Formale Beschreibung (siehe AuD-Vorlesung):
Datentyp: SimplePriorityQueue (Einfache Vorrangswarteschlange)
Signatur:
Sorten:
Keys
Data
PrioQ
Boolean
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
69
Formale Beschreibung (siehe AuD-Vorlesung):
Datentyp: SimplePriorityQueue (Einfache Vorrangswarteschlange)
Signatur:
Sorten:
Keys
Data
PrioQ
Boolean
Operationen:
empty : → PrioQ
isempty : PrioQ → Boolean
insert : Keys × Data × PrioQ → PrioQ
extractMin: PrioQ → Keys × Data × PrioQ
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
69
Mathematisches Modell:
Sorten:
Keys
: (U, <)
FG KTuEA, TU Ilmenau
(∗ totalgeordnetes Universum“ ∗)
”
Effiziente Algorithmen – SS11 – Kapitel 3
70
Mathematisches Modell:
Sorten:
Keys
Data
: (U, <)
: D
FG KTuEA, TU Ilmenau
(∗ totalgeordnetes Universum“ ∗)
”
(∗ Menge von Datensätzen“ ∗)
”
Effiziente Algorithmen – SS11 – Kapitel 3
70
Mathematisches Modell:
Sorten:
Keys
: (U, <)
(∗ totalgeordnetes Universum“ ∗)
”
Data
: D
(∗ Menge von Datensätzen“ ∗)
”
Boolean : {false, true}
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
70
Mathematisches Modell:
Sorten:
Keys
Data
Boolean
PrioQ
:
:
:
:
FG KTuEA, TU Ilmenau
(U, <)
(∗ totalgeordnetes Universum“ ∗)
”
D
(∗ Menge von Datensätzen“ ∗)
”
{false, true}
die Menge aller endlichen Multimengen P ⊆ U × D
Effiziente Algorithmen – SS11 – Kapitel 3
70
Mathematisches Modell:
Sorten:
Keys
:
Data
:
Boolean :
PrioQ
:
Operationen:
empty ( ) = ∅
FG KTuEA, TU Ilmenau
(U, <)
(∗ totalgeordnetes Universum“ ∗)
”
D
(∗ Menge von Datensätzen“ ∗)
”
{false, true}
die Menge aller endlichen Multimengen P ⊆ U × D
(∗ die leere Multimenge ∗)
Effiziente Algorithmen – SS11 – Kapitel 3
70
Mathematisches Modell:
Sorten:
Keys
:
Data
:
Boolean :
PrioQ
:
Operationen:
empty ( ) = ∅
isempty (P ) =
FG KTuEA, TU Ilmenau
(U, <)
(∗ totalgeordnetes Universum“ ∗)
”
D
(∗ Menge von Datensätzen“ ∗)
”
{false, true}
die Menge aller endlichen Multimengen P ⊆ U × D
(∗ die leere Multimenge ∗)
(
true,
für P = ∅
false, für P 6= ∅
Effiziente Algorithmen – SS11 – Kapitel 3
70
Mathematisches Modell (Forts.):
insert(x, d, P ) = P ∪ {(x, d)} (als Multimenge),
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
71
Mathematisches Modell (Forts.):
insert(x, d, P ) = P ∪ {(x, d)} (als Multimenge),
extractMin(P ) =
FG KTuEA, TU Ilmenau
(
undefiniert,
für P = ∅
(x0, d0, P 0), für P 6= ∅,
Effiziente Algorithmen – SS11 – Kapitel 3
71
Mathematisches Modell (Forts.):
insert(x, d, P ) = P ∪ {(x, d)} (als Multimenge),
extractMin(P ) =
(
undefiniert,
für P = ∅
(x0, d0, P 0), für P 6= ∅,
für ein Element (x0, d0) in P mit
minimalem Schlüssel x0,
und P 0 = P − {(x0, d0)}
(als Multimenge).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
71
Mathematisches Modell (Forts.):
insert(x, d, P ) = P ∪ {(x, d)} (als Multimenge),
extractMin(P ) =
(
undefiniert,
für P = ∅
(x0, d0, P 0), für P 6= ∅,
für ein Element (x0, d0) in P mit
minimalem Schlüssel x0,
und P 0 = P − {(x0, d0)}
(als Multimenge).
Standardimplementierung: (Binäre) Heaps
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
71
Mathematisches Modell (Forts.):
insert(x, d, P ) = P ∪ {(x, d)} (als Multimenge),
extractMin(P ) =
(
undefiniert,
für P = ∅
(x0, d0, P 0), für P 6= ∅,
für ein Element (x0, d0) in P mit
minimalem Schlüssel x0,
und P 0 = P − {(x0, d0)}
(als Multimenge).
Standardimplementierung: (Binäre) Heaps
Heaps als Hilfsmittel bei Heapsort: bekannt aus AuD.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
71
Definition 3.3.1
Ein Binärbaum T mit Knotenbeschriftungen m(v) aus (U, <)
heißt min-heapgeordnet (oft: heapgeordnet),
wenn für jeden Knoten v gilt:
w Kind von v ⇒ m(v) ≤ m(w).
B
E
F
G
N
FG KTuEA, TU Ilmenau
E
P
H
F
N
Effiziente Algorithmen – SS11 – Kapitel 3
72
B
E
F
G
N
E
P
H
F
N
NB: T heapgeordnet ⇒ in Knoten v steht der minimale
Eintrag des Teilbaums Tv mit Wurzel v.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
73
Ein linksvollständiger Binärbaum:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
74
Ein linksvollständiger Binä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.
Können gut als Arrays dargestellt werden!
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
74
Nummerierung von Knoten in unendlichem, vollständigen
Binärbaum
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
75
Nummerierung von Knoten in unendlichem, vollständigen
Binärbaum in Levelorder:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
75
Nummerierung von Knoten in unendlichem, vollständigen
Binärbaum in Levelorder:
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
Effiziente Algorithmen – SS11 – Kapitel 3
75
Nummerierung von Knoten in unendlichem, vollständigen
Binärbaum in Levelorder:
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
Effiziente Algorithmen – SS11 – Kapitel 3
75
Wenn s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von
der Wurzel zu Knoten i auf Level l ist, dann ist 1s1 · · · sl die
Binärdarstellung von i.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
76
Wenn s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von
der Wurzel zu Knoten i auf Level l ist, dann ist 1s1 · · · sl die
Binärdarstellung von i.
Knoten 1 ist die Wurzel;
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
76
Wenn s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von
der Wurzel zu Knoten i auf Level l ist, dann ist 1s1 · · · sl die
Binärdarstellung von i.
Knoten 1 ist die Wurzel;
Knoten 2i ist linkes Kind von i;
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
76
Wenn s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von
der Wurzel zu Knoten i auf Level l ist, dann ist 1s1 · · · sl die
Binä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
Effiziente Algorithmen – SS11 – Kapitel 3
76
Wenn s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von
der Wurzel zu Knoten i auf Level l ist, dann ist 1s1 · · · sl die
Binä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 Vater bi/2c.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
76
Wenn s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von
der Wurzel zu Knoten i auf Level l ist, dann ist 1s1 · · · sl die
Binä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 Vater bi/2c.
Damit: Array-Darstellung für linksvollständige Binärbaume:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
76
Wenn s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von
der Wurzel zu Knoten i auf Level l ist, dann ist 1s1 · · · sl die
Binä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 Vater bi/2c.
Damit: Array-Darstellung für linksvollständige Binärbaume:
Speichere Einträge in Knoten 1, . . . , n in Array A[1 . . n].
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
76
Wenn s1 · · · sl ∈ {0, 1}l die Markierung auf dem Weg von
der Wurzel zu Knoten i auf Level l ist, dann ist 1s1 · · · sl die
Binä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 Vater bi/2c.
Damit: Array-Darstellung für linksvollständige Binärbaume:
Speichere Einträge in Knoten 1, . . . , n in Array A[1 . . n].
Spart den Platz für die Zeiger!
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
76
Kombiniere Heapbedingung, Array-Darstellung, Datenkomponenten:
Definition 3.3.2
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
77
Kombiniere Heapbedingung, Array-Darstellung, Datenkomponenten:
Definition 3.3.2 Sei (U, <) Totalordnung.
Ein (Teil-)Array A[1 . . k] mit Einträgen aus U × D
heißt ein Min-Heap (oder Heap),
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
77
Kombiniere Heapbedingung, Array-Darstellung, Datenkomponenten:
Definition 3.3.2 Sei (U, <) Totalordnung.
Ein (Teil-)Array A[1 . . k] mit Einträgen aus U × D
heißt ein Min-Heap (oder Heap), wenn der entsprechende
linksvollständige Binärbaum mit k Knoten
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
77
Kombiniere Heapbedingung, Array-Darstellung, Datenkomponenten:
Definition 3.3.2 Sei (U, <) Totalordnung.
Ein (Teil-)Array A[1 . . k] mit Einträgen aus U × D
heißt ein Min-Heap (oder Heap), wenn der entsprechende
linksvollständige Binärbaum mit k Knoten
(Knoten i mit A[i.key] ∈ U A[i.data] ∈ D und beschriftet)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
77
Kombiniere Heapbedingung, Array-Darstellung, Datenkomponenten:
Definition 3.3.2 Sei (U, <) Totalordnung.
Ein (Teil-)Array A[1 . . k] mit Einträgen aus U × D
heißt ein Min-Heap (oder Heap), wenn der entsprechende
linksvollständige Binärbaum mit k Knoten
(Knoten i mit A[i.key] ∈ U A[i.data] ∈ D und beschriftet)
bezüglich der key-Komponenten (min-)heapgeordnet ist.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
77
Kombiniere Heapbedingung, Array-Darstellung, Datenkomponenten:
Definition 3.3.2 Sei (U, <) Totalordnung.
Ein (Teil-)Array A[1 . . k] mit Einträgen aus U × D
heißt ein Min-Heap (oder Heap), wenn der entsprechende
linksvollständige Binärbaum mit k Knoten
(Knoten i mit A[i.key] ∈ U A[i.data] ∈ D und beschriftet)
bezüglich der key-Komponenten (min-)heapgeordnet ist.
Das heißt: Ein (Teil-)Array A[1 . . k] ist ein Heap, falls für
1 ≤ i ≤ k gilt:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
77
Kombiniere Heapbedingung, Array-Darstellung, Datenkomponenten:
Definition 3.3.2 Sei (U, <) Totalordnung.
Ein (Teil-)Array A[1 . . k] mit Einträgen aus U × D
heißt ein Min-Heap (oder Heap), wenn der entsprechende
linksvollständige Binärbaum mit k Knoten
(Knoten i mit A[i.key] ∈ U A[i.data] ∈ D und beschriftet)
bezüglich der key-Komponenten (min-)heapgeordnet ist.
Das heißt: Ein (Teil-)Array A[1 . . k] ist ein Heap, falls für
1 ≤ i ≤ k gilt:
2i ≤ k ⇒ A[i].key ≤ A[2i].key und
2i + 1 ≤ k ⇒ A[i].key ≤ A[2i + 1].key.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
77
Kombiniere Heapbedingung, Array-Darstellung, Datenkomponenten:
Definition 3.3.2 Sei (U, <) Totalordnung.
Ein (Teil-)Array A[1 . . k] mit Einträgen aus U × D
heißt ein Min-Heap (oder Heap), wenn der entsprechende
linksvollständige Binärbaum mit k Knoten
(Knoten i mit A[i.key] ∈ U A[i.data] ∈ D und beschriftet)
bezüglich der key-Komponenten (min-)heapgeordnet ist.
Das heißt: Ein (Teil-)Array A[1 . . k] ist ein Heap, falls für
1 ≤ i ≤ k gilt:
2i ≤ k ⇒ A[i].key ≤ A[2i].key und
2i + 1 ≤ k ⇒ A[i].key ≤ A[2i + 1].key.
Diese Definition erwähnt den (gedachten) Binärbaum nicht mehr explizit.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
77
Beispiel: U = {A, B, C, . . . , Z} mit der Standardordnung.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
78
Beispiel: U = {A, B, C, . . . , Z} mit der Standardordnung.
Im Beispiel: Daten weggelassen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
78
Beispiel: U = {A, B, C, . . . , Z} mit der Standardordnung.
Im Beispiel: 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
Effiziente Algorithmen – SS11 – Kapitel 3
78
Implementierung einer Priority Queue: Neben Array A[1 . . m]:
Pegel k: Aktuelle Zahl k von Einträgen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
79
Implementierung einer Priority Queue: Neben Array A[1 . . m]:
Pegel k: Aktuelle Zahl k von Einträgen.
Überlaufprobleme werden ausgeklammert.
(Verdoppelungsstrategie, falls nötig.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
79
Implementierung einer Priority Queue: Neben Array A[1 . . m]:
Pegel k: Aktuelle Zahl k von Einträgen.
Überlaufprobleme werden ausgeklammert.
(Verdoppelungsstrategie, falls nötig.)
empty(m):
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
79
Implementierung einer Priority Queue: Neben Array A[1 . . m]:
Pegel k: Aktuelle Zahl k von Einträgen.
Überlaufprobleme werden ausgeklammert.
(Verdoppelungsstrategie, falls nötig.)
empty(m):
Lege Array A[1 . . m] an;
(∗ Jeder Eintrag ist ein Paar (key, data). ∗)
k ← 0. (∗ Zeitaufwand: O(1) oder O(m) ∗)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
79
Implementierung einer Priority Queue: Neben Array A[1 . . m]:
Pegel k: Aktuelle Zahl k von Einträgen.
Überlaufprobleme werden ausgeklammert.
(Verdoppelungsstrategie, falls nötig.)
empty(m):
Lege Array A[1 . . m] an;
(∗ Jeder Eintrag ist ein Paar (key, data). ∗)
k ← 0. (∗ Zeitaufwand: O(1) oder O(m) ∗)
isempty():
return(k = 0); (∗ Zeitaufwand: O(1) ∗)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
79
extractMin: Implementierung von extractMin(P ):
Ein Eintrag mit minimalem Schlüssel steht in der Wurzel, d. h.
in Arrayposition 1.
Entnehme A[1] (hier B“) und gib es aus.
”
Loch“ im Binärbaum.– stopfen“ mit dem letzten Eintrag.
”
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
80
extractMin: Implementierung von extractMin(P ):
Ein Eintrag mit minimalem Schlü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 Binärbaum.– stopfen“ mit dem letzten Eintrag.
”
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
80
extractMin: Implementierung von extractMin(P ):
Ein Eintrag mit minimalem Schlü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 Binärbaum.– stopfen“ mit dem letzten Eintrag.
”
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
80
Bleibt 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
FG KTuEA, TU Ilmenau
I
Effiziente Algorithmen – SS11 – Kapitel 3
81
Bleibt 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
Abwärts-Fast-Heap“ bzgl. Position 1 (Wurzel), d. h.:
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
81
Bleibt 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
Abwärts-Fast-Heap“ bzgl. Position 1 (Wurzel), d. h.:
”
Wenn man den Eintrag in A[1] passend verkleinert (z. B. auf
den alten Wurzeleintrag, hier: B), entsteht ein Heap.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
81
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 der beiden Kinder des aktuellen Knotens.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
82
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 der beiden Kinder des aktuellen Knotens.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
82
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
Effiziente Algorithmen – SS11 – Kapitel 3
82
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
Effiziente Algorithmen – SS11 – Kapitel 3
82
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
Vertauschen des kleineren“ Kinds mit dem aktuellen Knoten.
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
82
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
Vertauschen des kleineren“ Kinds mit dem aktuellen Knoten.
”
Ergibt Abwärts-Fast-Heap, aktueller Knoten ein Level tiefer.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
82
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
Effiziente Algorithmen – SS11 – Kapitel 3
82
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
Effiziente Algorithmen – SS11 – Kapitel 3
82
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.
”
Abwärts-Fast-Heap, aktueller Knoten ein Level tiefer.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
82
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.
”
Abwärts-Fast-Heap, aktueller Knoten ein Level tiefer.
Aktueller Knoten hat keine Kinder.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
82
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
Effiziente Algorithmen – SS11 – Kapitel 3
82
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 Möglichkeit für Ende: Eintrag im aktuellen Knoten ist
kleiner als der im kleineren Kind“.
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
82
bubbleDown(1, k) (∗ Heap-Reparatur in A[1 . . k] ∗)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
83
bubbleDown(1, k) (∗ Heap-Reparatur in A[1 . . k] ∗)
(∗ Muss wissen: A[1 . . k] ist Abwärts-Fast-Heap bzgl. Position 1 ∗)
(1)
j ← 1; m ← 2; done ← false;
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
83
bubbleDown(1, k) (∗ Heap-Reparatur in A[1 . . k] ∗)
(∗ Muss wissen: A[1 . . k] ist Abwärts-Fast-Heap bzgl. Position 1 ∗)
(1)
j ← 1; m ← 2; done ← false;
(2)
while not done and m + 1 ≤ k do
(∗ Abwärts-Fast-Heap bzgl. Position j, A[j] hat 2 Kinder ∗)
(3)
if A[m+1].key < A[m].key
(4)
then (∗ A[m]: kleineres“ Kind ∗)
”
(5)
m ← m + 1;
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
83
bubbleDown(1, k) (∗ Heap-Reparatur in A[1 . . k] ∗)
(∗ Muss wissen: A[1 . . k] ist Abwärts-Fast-Heap bzgl. Position 1 ∗)
(1)
j ← 1; m ← 2; done ← false;
(2)
while not done and m + 1 ≤ k do
(∗ Abwärts-Fast-Heap bzgl. Position j, A[j] hat 2 Kinder ∗)
(3)
if A[m+1].key < A[m].key
(4)
then (∗ A[m]: kleineres“ Kind ∗)
”
(5)
m ← m + 1;
(6)
if A[m].key < A[j].key
(7)
then vertausche A[m] mit A[j]; j ← m; m ← 2 ∗ j;
(8)
(∗ nun wieder: Abwärts-Fast-Heap bzgl. j ∗)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
83
bubbleDown(1, k) (∗ Heap-Reparatur in A[1 . . k] ∗)
(∗ Muss wissen: A[1 . . k] ist Abwärts-Fast-Heap bzgl. Position 1 ∗)
(1)
j ← 1; m ← 2; done ← false;
(2)
while not done and m + 1 ≤ k do
(∗ Abwärts-Fast-Heap bzgl. Position j, A[j] hat 2 Kinder ∗)
(3)
if A[m+1].key < A[m].key
(4)
then (∗ A[m]: kleineres“ Kind ∗)
”
(5)
m ← m + 1;
(6)
if A[m].key < A[j].key
(7)
then vertausche A[m] mit A[j]; j ← m; m ← 2 ∗ j;
(8)
(∗ nun wieder: Abwärts-Fast-Heap bzgl. j ∗)
(9)
else (∗ fertig, kein Fehler mehr ∗)
(10)
done ← true;
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
83
bubbleDown(1, k) (∗ Heap-Reparatur in A[1 . . k] ∗)
(∗ Muss wissen: A[1 . . k] ist Abwärts-Fast-Heap bzgl. Position 1 ∗)
(1)
j ← 1; m ← 2; done ← false;
(2)
while not done and m + 1 ≤ k do
(∗ Abwärts-Fast-Heap bzgl. Position j, A[j] hat 2 Kinder ∗)
(3)
if A[m+1].key < A[m].key
(4)
then (∗ A[m]: kleineres“ Kind ∗)
”
(5)
m ← m + 1;
(6)
if A[m].key < A[j].key
(7)
then vertausche A[m] mit A[j]; j ← m; m ← 2 ∗ j;
(8)
(∗ nun wieder: Abwärts-Fast-Heap bzgl. j ∗)
(9)
else (∗ fertig, kein Fehler mehr ∗)
(10)
done ← true;
(11)
if not done then
(12)
if m ≤ k then (∗ Abwärts-Fast-Heap bzgl. j, ein Kind in A[m] ∗)
(13)
if A[m].key < A[j].key
(14)
then vertausche A[m] mit A[j];
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
83
Korrektheit: Wenn vor dem Aufruf von bubbleDown(1, k) das Teilarray
A[1 . . k] ein Abwärts-Fast-Heap bzg. Position 1 war,
d. h.: es gibt einen Schlüssel x ≤ A[1].key derart, dass durch Ersetzen
von A[1].key durch x ein Heap entsteht,
dann ist nach dem Aufruf A[1 . . k] ein Heap.
Beweis: Man zeigt folgende Behauptung durch Induktion über die
Schleifendurchläufe:
(IBj )
Zu Beginn des Durchlaufs, in dem j die Zahl j enthält, ist
A[1 . . k] ein Abwärts-Fast-Heap bzgl. j.
Wir formulieren den Beweis in der Baum-Terminologie.
Der I. A. ist klar nach Voraussetzung.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
84
Betrachte Schleifendurchlauf für Knoten j.
Es gibt keine Konflikte mit Einträgen außerhalb des Unterbaums mit Wurzel
j, weil nach (IBj ) Erniedrigen des Eintrags in j einen Heap herstellt. Wir
können also alles außerhalb dieses Unterbaums ignorieren.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
85
Betrachte Schleifendurchlauf für Knoten j.
Es gibt keine Konflikte mit Einträgen außerhalb des Unterbaums mit Wurzel
j, weil nach (IBj ) Erniedrigen des Eintrags in j einen Heap herstellt. Wir
können also alles außerhalb dieses Unterbaums ignorieren.
1. Fall: In Zeile (7) wird A[j] mit A[2j] vertauscht.
Nach (IBj ): die Teilbäume unter 2j und 2j + 1 sind Heaps.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
85
Betrachte Schleifendurchlauf für Knoten j.
Es gibt keine Konflikte mit Einträgen außerhalb des Unterbaums mit Wurzel
j, weil nach (IBj ) Erniedrigen des Eintrags in j einen Heap herstellt. Wir
können also alles außerhalb dieses Unterbaums ignorieren.
1. Fall: In Zeile (7) wird A[j] mit A[2j] vertauscht.
Nach (IBj ): die Teilbäume unter 2j und 2j + 1 sind Heaps.
Wegen Vergleich in Zeile (3): A[2j] ist kleineres Kind“.
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
85
Betrachte Schleifendurchlauf für Knoten j.
Es gibt keine Konflikte mit Einträgen außerhalb des Unterbaums mit Wurzel
j, weil nach (IBj ) Erniedrigen des Eintrags in j einen Heap herstellt. Wir
können also alles außerhalb dieses Unterbaums ignorieren.
1. Fall: In Zeile (7) wird A[j] mit A[2j] vertauscht.
Nach (IBj ): die Teilbäume unter 2j und 2j + 1 sind Heaps.
Wegen Vergleich in Zeile (3): A[2j] ist kleineres Kind“.
”
⇒ nach dem Tausch steht das Minimum des Baums mit Wurzel j in
A[j], und der rechte Unterbaum unter 2j + 1 ist (unverändert, also) Heap.
Im linken Unterbaum wurde die Wurzel A[2j] durch einen größeren Eintrag
ersetzt. Daraus folgt sofort (IB2j ).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
85
Betrachte Schleifendurchlauf für Knoten j.
Es gibt keine Konflikte mit Einträgen außerhalb des Unterbaums mit Wurzel
j, weil nach (IBj ) Erniedrigen des Eintrags in j einen Heap herstellt. Wir
können also alles außerhalb dieses Unterbaums ignorieren.
1. Fall: In Zeile (7) wird A[j] mit A[2j] vertauscht.
Nach (IBj ): die Teilbäume unter 2j und 2j + 1 sind Heaps.
Wegen Vergleich in Zeile (3): A[2j] ist kleineres Kind“.
”
⇒ nach dem Tausch steht das Minimum des Baums mit Wurzel j in
A[j], und der rechte Unterbaum unter 2j + 1 ist (unverändert, also) Heap.
Im linken Unterbaum wurde die Wurzel A[2j] durch einen größeren Eintrag
ersetzt. Daraus folgt sofort (IB2j ).
2. Fall: In Zeile (7) wird A[j] mit A[2j + 1] vertauscht: analog.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
85
Betrachte Schleifendurchlauf für Knoten j.
Es gibt keine Konflikte mit Einträgen außerhalb des Unterbaums mit Wurzel
j, weil nach (IBj ) Erniedrigen des Eintrags in j einen Heap herstellt. Wir
können also alles außerhalb dieses Unterbaums ignorieren.
1. Fall: In Zeile (7) wird A[j] mit A[2j] vertauscht.
Nach (IBj ): die Teilbäume unter 2j und 2j + 1 sind Heaps.
Wegen Vergleich in Zeile (3): A[2j] ist kleineres Kind“.
”
⇒ nach dem Tausch steht das Minimum des Baums mit Wurzel j in
A[j], und der rechte Unterbaum unter 2j + 1 ist (unverändert, also) Heap.
Im linken Unterbaum wurde die Wurzel A[2j] durch einen größeren Eintrag
ersetzt. Daraus folgt sofort (IB2j ).
2. Fall: In Zeile (7) wird A[j] mit A[2j + 1] vertauscht: analog.
3. Fall: In Zeile (14) wird vertauscht: analog.
Korrektheit des Endes: Wenn (IBj ) gilt und A[j] Blatt ist, ist A[1 . . k]
Heap.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
85
Kosten:
Im Binärbaum gibt es maximal dlog(k + 1)e Levels; für jedes
Level maximal einen Schleifendurchlauf.
Also Kosten: O(log k).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
86
extractMin
(∗ Entnehmen eines minimalen Eintrags aus Priority-Queue ∗)
(∗ Ausgangspunkt: Pegel k, A[1 . . k] ist Heap, k ≥ 1 ∗)
(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)).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
87
Implementierung von insert(x, d):
Voraussetzung: A[1..k] ist Heap; 1 ≤ i ≤ k < m.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
88
Implementierung von insert(x, d):
Voraussetzung: A[1..k] ist Heap; 1 ≤ i ≤ k < m.
k++;
A[k] ← (x, d).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
88
Implementierung von insert(x, d):
Voraussetzung: A[1..k] ist Heap; 1 ≤ i ≤ k < m.
k++;
A[k] ← (x, d).
An der Stelle k ist nun eventuell die Heapeigenschaft gestört
(x zu klein).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
88
Implementierung von insert(x, d):
Voraussetzung: A[1..k] ist Heap; 1 ≤ i ≤ k < m.
k++;
A[k] ← (x, d).
An der Stelle k ist nun eventuell die Heapeigenschaft gestört
(x zu klein).
Wir nennen A[1..k] einen Aufwärts-Fast-Heap bzgl. k.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
88
Implementierung von insert(x, d):
Voraussetzung: A[1..k] ist Heap; 1 ≤ i ≤ k < m.
k++;
A[k] ← (x, d).
An der Stelle k ist nun eventuell die Heapeigenschaft gestört
(x zu klein).
Wir nennen A[1..k] einen Aufwärts-Fast-Heap bzgl. k.
Heißt: Es gibt einen Schlüssel z ≥ A[k].key, so dass ein Heap
entsteht, wenn man A[k].key durch z ersetzt.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
88
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
Effiziente Algorithmen – SS11 – Kapitel 3
89
Einfü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
Effiziente Algorithmen – SS11 – Kapitel 3
89
Heapreparatur bei Aufwärts-Fast-Heaps: 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
Effiziente Algorithmen – SS11 – Kapitel 3
89
Heapreparatur bei Aufwärts-Fast-Heaps: 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
Effiziente Algorithmen – SS11 – Kapitel 3
89
Heapreparatur bei Aufwärts-Fast-Heaps: 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
Effiziente Algorithmen – SS11 – Kapitel 3
89
Heapreparatur bei Aufwärts-Fast-Heaps: 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
Effiziente Algorithmen – SS11 – Kapitel 3
89
Heapreparatur bei Aufwärts-Fast-Heaps: 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
Effiziente Algorithmen – SS11 – Kapitel 3
89
Heapreparatur bei Aufwärts-Fast-Heaps: 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
Effiziente Algorithmen – SS11 – Kapitel 3
89
Prozedur bubbleUp(i) (∗ Heapreparatur ab A[i] nach oben ∗)
(1) j ← i;
(2) h ← j div 2;
(4) while h ≥ 1 and A[h].key < A[j].key do
(5)
vertausche A[j] mit A[h];
(6)
j ← h;
(7)
h ← j div 2.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
90
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 Schlüssel größer als x (= der neue 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 StraigtInsertionSort) programmieren.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
91
Behauptung 3.3.3
Wenn A[1..k] ein Aufwärts-Fast-Heap bzgl. i ist
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
92
Behauptung 3.3.3
Wenn A[1..k] ein Aufwärts-Fast-Heap bzgl. i ist
d. h.: durch Ersetzen von A[i] durch einen Schlüssel z ≥ A[i] ergibt sich
ein Heap,
dann ist nach Ausführung von bubbleUp(i) das Array
A[1..k] ein Heap.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
92
Behauptung 3.3.3
Wenn A[1..k] ein Aufwärts-Fast-Heap bzgl. i ist
d. h.: durch Ersetzen von A[i] durch einen Schlüssel z ≥ A[i] ergibt sich
ein Heap,
dann ist nach Ausführung von bubbleUp(i) das Array
A[1..k] ein Heap.
Der Zeitaufwand ist O(log i), die Anzahl der Schlüsselvergleiche ist höchstens das Level von i im Baum, also die Anzahl
der Bits in der Binärdarstellung bin(i), d.h. dlog(i + 1)e.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
92
Behauptung 3.3.3
Wenn A[1..k] ein Aufwärts-Fast-Heap bzgl. i ist
d. h.: durch Ersetzen von A[i] durch einen Schlüssel z ≥ A[i] ergibt sich
ein Heap,
dann ist nach Ausführung von bubbleUp(i) das Array
A[1..k] ein Heap.
Der Zeitaufwand ist O(log i), die Anzahl der Schlüsselvergleiche ist höchstens das Level von i im Baum, also die Anzahl
der Bits in der Binärdarstellung bin(i), d.h. dlog(i + 1)e.
Beweis: (Nur Korrektheit.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
92
Behauptung 3.3.3
Wenn A[1..k] ein Aufwärts-Fast-Heap bzgl. i ist
d. h.: durch Ersetzen von A[i] durch einen Schlüssel z ≥ A[i] ergibt sich
ein Heap,
dann ist nach Ausführung von bubbleUp(i) das Array
A[1..k] ein Heap.
Der Zeitaufwand ist O(log i), die Anzahl der Schlüsselvergleiche ist höchstens das Level von i im Baum, also die Anzahl
der Bits in der Binärdarstellung bin(i), d.h. dlog(i + 1)e.
Beweis: (Nur Korrektheit.) Durch Induktion zeigt man:
(IBj )
Zu Beginn des Schleifendurchlaufs für j liegt ein AufwärtsFast-Heap bzgl. j vor.
Zu Beginn stimmt dies nach Annahme über die Eingabe.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
92
Nun betrachte einen Schleifendurchlauf für j.
Wegen des Tests für h wissen wir, dass j ≥ 2 ist und h = bj/2c der Vater ist.
1. Fall: x = A[j].key < y = A[h].key, es wird getauscht.
Im Unterbaum mit Wurzel j liegt dann ein Heap vor, da nach (IBj ) kein
Eintrag in diesem Baum kleiner als der neue Wurzeleintrag y ist.
Falls j einen Geschwisterknoten ` = j ± 1 hat, so hat sich der Baum
mit Wurzel ` nicht geändert, also liegt auch dort ein Heap vor. Der neue
Eintrag x in Knoten h ist kleiner als alle Einträge in diesem Baum, weil
dies schon für y galt.
Bleibt Knoten h: Wenn man den Schlüssel x in h auf y erhöht, entsteht
ein Heap. Das heißt: (IBh) gilt.
2. Fall: x = A[j].key ≥ y = A[h].key, Schluss.
Wegen (IBj ) können wir x durch einen Schlüssel z ≥ x ersetzen, so dass
A[1..k] Heap wird. Dann muss aber auch mit Schlüssel x ein Heap
vorliegen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
93
Prozedur insert(x, d)
(∗ Einfügen eines neuen Eintrags in Priority-Queue ∗)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
94
Prozedur insert(x, d)
(∗ Einfügen eines neuen Eintrags in Priority-Queue ∗)
(∗ Ausgangspunkt: Pegel k, A[1 . . k] ist Heap, k < m ∗)
(1) if k = m then Ü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
Effiziente Algorithmen – SS11 – Kapitel 3
94
Wir können bubbleUp(i) sogar für eine etwas allgemeinere
Operation verwenden (Korrektheitsbeweis gilt weiter):
Wir ersetzen einen beliebigen Schlüssel im Heap (Position i)
durch einen kleineren.
Mit bubbleUp(i) kann die Heapeigenschaft wieder hergestellt
werden.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
95
Wir können bubbleUp(i) sogar für eine etwas allgemeinere
Operation verwenden (Korrektheitsbeweis gilt weiter):
Wir ersetzen einen beliebigen Schlüssel im Heap (Position i)
durch einen kleineren.
Mit bubbleUp(i) kann die Heapeigenschaft wieder hergestellt
werden.
Prozedur decreaseKey(x, i)
(∗ (Erniedrigen des Schlüssels an Arrayposition i auf x) ∗)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
95
Wir können bubbleUp(i) sogar für eine etwas allgemeinere
Operation verwenden (Korrektheitsbeweis gilt weiter):
Wir ersetzen einen beliebigen Schlüssel im Heap (Position i)
durch einen kleineren.
Mit bubbleUp(i) kann die Heapeigenschaft wieder hergestellt
werden.
Prozedur decreaseKey(x, i)
(∗ (Erniedrigen des Schlü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
Effiziente Algorithmen – SS11 – Kapitel 3
95
SimplePriorityQueue plus decreaseKey“: Priority Queue.
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
96
SimplePriorityQueue plus decreaseKey“: Priority Queue.
”
Satz 3.3.4
Der Datentyp “Priority Queue” kann mit Hilfe eines Heaps
implementiert werden.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
96
SimplePriorityQueue plus decreaseKey“: Priority Queue.
”
Satz 3.3.4
Der Datentyp “Priority Queue” 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 benötigen jeweils Zeit
O(log n).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
96
SimplePriorityQueue plus decreaseKey“: Priority Queue.
”
Satz 3.3.4
Der Datentyp “Priority Queue” 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 benötigen jeweils Zeit
O(log n).
Dabei ist n jeweils der aktuelle Pegelstand, also die Anzahl
der Einträge in der Priority Queue.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
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
Effiziente Algorithmen – SS11 – Kapitel 3
97
Technisches Problem:
Wie soll man der Datenstruktur mitteilen“, welches Objekt
”
gemeint ist, wenn decreaseKey auf einen Eintrag angewendet
werden soll?
Bei (binärem) Heap: Positionen der Einträge im Array ändern
sich die ganze Zeit, durch die durch insert und extractMin
verursachten Verschiebungen im Array.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
97
Technisches Problem:
Wie soll man der Datenstruktur mitteilen“, welches Objekt
”
gemeint ist, wenn decreaseKey auf einen Eintrag angewendet
werden soll?
Bei (binärem) Heap: Positionen der Einträge im Array ä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
Effiziente Algorithmen – SS11 – Kapitel 3
97
Besser: Erweiterung der Datenstruktur:
Objekt (x, d) erhält bei Ausführung von insert(x, d) eine
eindeutige Identität“ p zugeteilt, die sich nie ändert, und
”
über die dieses Objekt angesprochen werden kann.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
98
Besser: Erweiterung der Datenstruktur:
Objekt (x, d) erhält bei Ausführung von insert(x, d) eine
eindeutige Identität“ p zugeteilt, die sich nie ändert, und
”
über die dieses Objekt angesprochen werden kann.
Damit können auch verschiedene Kopien eines Datensatzes
unterschieden werden!
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
98
Besser: Erweiterung der Datenstruktur:
Objekt (x, d) erhält bei Ausführung von insert(x, d) eine
eindeutige Identität“ p zugeteilt, die sich nie ändert, und
”
über die dieses Objekt angesprochen werden kann.
Damit können auch verschiedene Kopien eines Datensatzes
unterschieden werden!
p wird dem Benutzer als Reaktion auf die Einfügung mitgeteilt.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
98
Besser: Erweiterung der Datenstruktur:
Objekt (x, d) erhält bei Ausführung von insert(x, d) eine
eindeutige Identität“ p zugeteilt, die sich nie ändert, und
”
über die dieses Objekt angesprochen werden kann.
Damit können auch verschiedene Kopien eines Datensatzes
unterschieden werden!
p wird dem Benutzer als Reaktion auf die Einfügung mitgeteilt.
Der Benutzer kann dann irgendwann den Schlüssel eines Eintrags mit Identität p ändern.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
98
Technische Realisierung:
Im Heap gespeicherte Objekte ((Daten, Schlüssel)-Paare) stehen an fester Stelle. Zugriff über Zeiger/Referenz. Im Heaparray werden nur Zeiger/Referenzen auf diese Objekte gehalten, so dass diese selber nie verschoben werden müssen.
Version 1: Identität p ist der Zeiger auf das Objekt im Heap.
Das Objekt enthält seine jeweilige Position im Heap-Array als Komponente.
(Nachteil: Kapselung der Datenstruktur ist durchbrochen – der Benutzer
kann über den Zeiger direkt auf die Objekte zugreifen.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
99
Technische Realisierung:
Im Heap gespeicherte Objekte ((Daten, Schlüssel)-Paare) stehen an fester Stelle. Zugriff über Zeiger/Referenz. Im Heaparray werden nur Zeiger/Referenzen auf diese Objekte gehalten, so dass diese selber nie verschoben werden müssen.
Version 1: Identität p ist der Zeiger auf das Objekt im Heap.
Das Objekt enthält seine jeweilige Position im Heap-Array als Komponente.
(Nachteil: Kapselung der Datenstruktur ist durchbrochen – der Benutzer
kann über den Zeiger direkt auf die Objekte zugreifen.)
Version 2: Eine beliebige (laufende) Nummer wird vergeben (z. B. durch
Durchzählen der Einfügungen). Diese Nummer ist die Identität p. Die
Datenstruktur hält intern in einem Hilfsarray für jede dieser Nummern
die Adresse des entsprechenden Objekts. Das Objekt enthält Daten und
Schlüssel und seine jeweilige Position im Heap-Array als Komponenten.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
99
Technische Realisierung:
Im Heap gespeicherte Objekte ((Daten, Schlüssel)-Paare) stehen an fester Stelle. Zugriff über Zeiger/Referenz. Im Heaparray werden nur Zeiger/Referenzen auf diese Objekte gehalten, so dass diese selber nie verschoben werden müssen.
Version 1: Identität p ist der Zeiger auf das Objekt im Heap.
Das Objekt enthält seine jeweilige Position im Heap-Array als Komponente.
(Nachteil: Kapselung der Datenstruktur ist durchbrochen – der Benutzer
kann über den Zeiger direkt auf die Objekte zugreifen.)
Version 2: Eine beliebige (laufende) Nummer wird vergeben (z. B. durch
Durchzählen der Einfügungen). Diese Nummer ist die Identität p. Die
Datenstruktur hält intern in einem Hilfsarray für jede dieser Nummern
die Adresse des entsprechenden Objekts. Das Objekt enthält Daten und
Schlüssel und seine jeweilige Position im Heap-Array als Komponenten.
(Nachteil: Platzbedarf des Hilfsarrays entspricht der Anzahl der Einfügungen, nicht der maximalen Größe der Priority Queue.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
99
Technische Realisierung:
Im Heap gespeicherte Objekte ((Daten, Schlüssel)-Paare) stehen an fester Stelle. Zugriff über Zeiger/Referenz. Im Heaparray werden nur Zeiger/Referenzen auf diese Objekte gehalten, so dass diese selber nie verschoben werden müssen.
Version 1: Identität p ist der Zeiger auf das Objekt im Heap.
Das Objekt enthält seine jeweilige Position im Heap-Array als Komponente.
(Nachteil: Kapselung der Datenstruktur ist durchbrochen – der Benutzer
kann über den Zeiger direkt auf die Objekte zugreifen.)
Version 2: Eine beliebige (laufende) Nummer wird vergeben (z. B. durch
Durchzählen der Einfügungen). Diese Nummer ist die Identität p. Die
Datenstruktur hält intern in einem Hilfsarray für jede dieser Nummern
die Adresse des entsprechenden Objekts. Das Objekt enthält Daten und
Schlüssel und seine jeweilige Position im Heap-Array als Komponenten.
(Nachteil: Platzbedarf des Hilfsarrays entspricht der Anzahl der Einfügungen, nicht der maximalen Größe der Priority Queue.)
Version 3: Wie Version 2, aber die Identität p eines durch ExtractMin
aus dem Heap gelöschten Eintrags kann wieder vergeben werden.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
99
Beispiel:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitäten nicht mehr benutzt werden, nachdem das entsprechende Objekt (durch ein extractMin) wieder aus der Datenstruktur verschwunden ist.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitä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
∅
Effiziente Algorithmen – SS11 – Kapitel 3
Ausgabe
–
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitä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)}
Effiziente Algorithmen – SS11 – Kapitel 3
Ausgabe
–
1
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitä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)}
Effiziente Algorithmen – SS11 – Kapitel 3
Ausgabe
–
1
2
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitä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)}
Effiziente Algorithmen – SS11 – Kapitel 3
Ausgabe
–
1
2
3
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitä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)}
Effiziente Algorithmen – SS11 – Kapitel 3
Ausgabe
–
1
2
3
4
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitä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),
Effiziente Algorithmen – SS11 – Kapitel 3
Ausgabe
–
1
2
3
4
5
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitä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)}
Effiziente Algorithmen – SS11 – Kapitel 3
Ausgabe
–
1
2
3
4
5
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitä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),
Effiziente Algorithmen – SS11 – Kapitel 3
Ausgabe
–
1
2
3
4
5
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitä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),
Effiziente Algorithmen – SS11 – Kapitel 3
Ausgabe
–
1
2
3
4
5
–
100
Beispiel: Datensatz = Schlüssel = Eintrag aus {A, . . . , Z}.
Wir vergeben Nummern als Identitäten.
Der Benutzer der Datenstruktur muss sicherstellen, dass Identitä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)}
Effiziente Algorithmen – SS11 – Kapitel 3
Ausgabe
–
1
2
3
4
5
–
100
Runde
Operation
FG KTuEA, TU Ilmenau
innerer Zustand
Effiziente Algorithmen – SS11 – Kapitel 3
Ausgabe
101
Runde
...
Operation
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
Effiziente Algorithmen – SS11 – Kapitel 3
Ausgabe
101
Runde
...
Operation
FG KTuEA, TU Ilmenau
innerer Zustand
{(1,D), (2,B),
(3,D), (4,E), (5,D)}
Effiziente Algorithmen – SS11 – Kapitel 3
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)}
Effiziente Algorithmen – SS11 – Kapitel 3
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)}
Effiziente Algorithmen – SS11 – Kapitel 3
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)}
Effiziente Algorithmen – SS11 – Kapitel 3
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)}
Effiziente Algorithmen – SS11 – Kapitel 3
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)}
Effiziente Algorithmen – SS11 – Kapitel 3
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)}
Effiziente Algorithmen – SS11 – Kapitel 3
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)}
Effiziente Algorithmen – SS11 – Kapitel 3
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)}
Effiziente Algorithmen – SS11 – Kapitel 3
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)}
Effiziente Algorithmen – SS11 – Kapitel 3
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)}
Effiziente Algorithmen – SS11 – Kapitel 3
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)}
∅
Effiziente Algorithmen – SS11 – Kapitel 3
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)}
∅
∅
Effiziente Algorithmen – SS11 – Kapitel 3
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 wäre zum Beispiel die Operation
decreaseKey (3,A) nicht legal, da das (eindeutig bestimmte)
Objekt mit Identität 3 in Runde 9 aus der Datenstruktur
verschwunden ist.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
101
Datentyp: PriorityQueue (Vorrangswarteschlange)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
102
Datentyp: PriorityQueue (Vorrangswarteschlange)
Signatur:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
102
Datentyp: PriorityQueue (Vorrangswarteschlange)
Signatur:
Sorten:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
102
Datentyp: PriorityQueue (Vorrangswarteschlange)
Signatur:
Sorten:
Keys
Data
Id (∗ Identitäten“ ∗)
”
PrioQ
Boolean
Operatoren:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
102
Datentyp: PriorityQueue (Vorrangswarteschlange)
Signatur:
Sorten:
Keys
Data
Id (∗ Identitä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
Effiziente Algorithmen – SS11 – Kapitel 3
102
Mathematisches Modell:
Keys
: (U, <)
(∗ totalgeordnetes Universum“ ∗)
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
103
Mathematisches Modell:
Keys
: (U, <)
(∗ totalgeordnetes Universum“ ∗)
”
Data
: D (∗ Menge von Datensätzen“ ∗)
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
103
Mathematisches Modell:
Keys
: (U, <)
(∗ totalgeordnetes Universum“ ∗)
”
Data
: D (∗ Menge von Datensätzen“ ∗)
”
Id
: N = {0, 1, 2, . . .}
(∗ unendliche Menge möglicher Identitäten“ ∗)
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
103
Mathematisches Modell:
Keys
: (U, <)
(∗ totalgeordnetes Universum“ ∗)
”
Data
: D (∗ Menge von Datensätzen“ ∗)
”
Id
: N = {0, 1, 2, . . .}
(∗ unendliche Menge möglicher Identitäten“ ∗)
”
Boolean : {false, true}
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
103
Mathematisches Modell:
Keys
: (U, <)
(∗ totalgeordnetes Universum“ ∗)
”
Data
: D (∗ Menge von Datensätzen“ ∗)
”
Id
: N = {0, 1, 2, . . .}
(∗ unendliche Menge möglicher Identitäten“ ∗)
”
Boolean : {false, true}
PrioQ
: die Menge aller Funktionen f : X → U × D,
wobei X = Def (f ) ⊆ N endlich ist
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
103
Mathematisches Modell:
Keys
: (U, <)
(∗ totalgeordnetes Universum“ ∗)
”
Data
: D (∗ Menge von Datensätzen“ ∗)
”
Id
: N = {0, 1, 2, . . .}
(∗ unendliche Menge möglicher Identitä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 ∗)
Effiziente Algorithmen – SS11 – Kapitel 3
103
Mathematisches Modell:
Keys
: (U, <)
(∗ totalgeordnetes Universum“ ∗)
”
Data
: D (∗ Menge von Datensätzen“ ∗)
”
Id
: N = {0, 1, 2, . . .}
(∗ unendliche Menge möglicher Identitä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, für f = ∅
isempty (f ) =
false, für f =
6 ∅
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
103
insert(x, d, f ) = (f ∪ {(p, (x, d))}, p),
für ein p ∈ N − Def (f )
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
104
insert(x, d, f ) = (f ∪ {(p, (x, d))}, p),
für ein p ∈ N − Def (f )
extractMin(f ) =
FG KTuEA, TU Ilmenau
(
undefiniert,
für f = ∅
(p0, x0, d0, f 0), für f 6= ∅,
Effiziente Algorithmen – SS11 – Kapitel 3
104
insert(x, d, f ) = (f ∪ {(p, (x, d))}, p),
für ein p ∈ N − Def (f )
extractMin(f ) =
(
undefiniert,
für f = ∅
(p0, x0, d0, f 0), für f 6= ∅,
wobei im zweiten Fall
p0 ein Element in Def (f ) ist
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
104
insert(x, d, f ) = (f ∪ {(p, (x, d))}, p),
für ein p ∈ N − Def (f )
extractMin(f ) =
(
undefiniert,
für f = ∅
(p0, x0, d0, f 0), fü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
Effiziente Algorithmen – SS11 – Kapitel 3
104
insert(x, d, f ) = (f ∪ {(p, (x, d))}, p),
für ein p ∈ N − Def (f )
extractMin(f ) =
(
undefiniert,
für f = ∅
(p0, x0, d0, f 0), fü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))}.
Implementierung:
Größere Übungsaufgabe.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
104
3.4 Set Cover
oder: Mengenüberdeckung
Input x besteht aus: Menge A = {1, . . . , n} (von Punkten“),
”
Mengen C1, . . . , Cr ⊆ A mit C1 ∪ . . . ∪ Cr = A.
Aufgabe: Finde I ⊆ {1, . . . , r} mit |I| möglichst klein, so
S
dass j∈I Cj = A.
Überdecke A mit einer möglichst kleinen Auswahl der Mengen.
S
opt(x) := min{|I| I ⊆ {1, . . . , r}, A =
Cj = A}.
j∈I
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
105
Idee ( greedy“):
”
Als erste Menge Cj1 wähle eine, die möglichst viele Punkte
überdeckt.
D1 := Cj1 ; R1 := A − D1.
Runde t: Wenn C1, . . . , Cjt−1 gewählt und Rt−1 6= ∅,
wähle als Menge Cjt eine, die möglichst viele Punkte von Rt−1
überdeckt.
Ende: Wenn Rt = ∅ ist, ist Runde t die letzte, setze T := t.
Ausgabe: I = {j1, . . . , jT } bzw. Cj1 , . . . , CjT .
Wert: T .
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
106
Algorithmus Greedy Set Cover (GSC)
S
Eingabe: x = (n, C1, . . . , Cr ) mit A = {1, . . . , n} = 1≤j≤r Cj .
S
Ausgabe: I ⊆ {1, . . . , r} mit j∈I Cj = A.
Methode:
t := 0; I := ∅; D := ∅; R := {1, . . . , n};
repeat
t := t + 1;
wähle ein j mit |R ∩ Cj | maximal;
I := I ∪ {j};
D := D ∪ Cj ;
R := R − Cj ;
until R = ∅.
return I.
Den Rundenzähler t braucht man eigentlich nicht.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
107
Ein einfaches Beispiel x mit n = 2(2k − 1) und opt(x) = 2,
aber T = k zeigt, dass im schlechtesten Fall T um einen
Faktor Ω(log n) größer als opt(x) sein kann.
Wir zeigen: Die Approximationsgüte“ des Algorithmus GSC
”
ist nicht schlechter als dies.
Satz 3.4.1
Wenn T die Größe des Ergebnisses des Algorithmus GSC auf
Eingabe x ist, dann gilt T /opt(x) ≤ 1 + ln n.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
108
Beweis: Sei nt = |Rt|, wo Rt die Menge ist, die nach Runde t
in R steht. (Rest nach Runde t.)
Sei k = opt(x).
Wähle eine Überdeckung B1, . . . , Bk von A = {1, . . . , n}.
Für Runde t mit nt > 0 gilt:
Die Mengen B1, . . . , Bk überdecken Rt−1. Mindestens eine
dieser Mengen muss also nt−1/k Punkte von Rt−1 enthalten.
Diese Menge spielt bei der Konkurrenz mit, in der Cjt gewählt
wird.
Also: Anzahl neu überdeckter Punkte = nt−1 − nt ≥ nt−1/k.
Also: nt ≤ (1 − k1 )nt−1.
Beginn: n0 = n.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
109
Daraus: nt ≤ (1 − k1 )tn < e−t/k n.
Wenn e−t/k n < 1, ist T ≤ t.
Daraus: Wenn ln n < t/k, ist T ≤ t.
Daraus: T ≤ 1 + bk · ln nc < 1 + (ln n)opt(x).
Erweiterung: Die Mengen C1, . . . , Cr haben Kosten“
”
w1, . . . , wr ≥ 0.
S
P
Finde I mit A = j∈I Cj = A und j∈I wj möglichst klein.
Die Verallgemeinerung des Algorithmus GSC liegt auf der Hand:
In Runde t wähle eine Menge Cj , die die durchschnittlichen
Kosten wj /|Rt−1 ∩ Cj | für neu überdeckte Punkte minimiert.
Auch Approximationsgüte 1 + ln n, etwas schwierigerer Beweis.
→ Master-Veranstaltung Approximationsalgorithmen“.
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS11 – Kapitel 3
110