ADS – Vorlesung Prof. Dr. Wolfram Conen

ADS – Vorlesung 

Prof. Dr. Wolfram Conen 

Inhalte: 

- Greedy-Algorithmen 

- Matroide 

- Greedy-Beispiel Huffman-Codierung 

11.06.2008 (c) W. Conen, FH GE, ADS 1

Greedy-Optimierung 

• Nehmen Sie an, sie brechen nachts in eine Villa ein und 

wollen 

soviel an Werten mitnehmen, wie sie tragen können 

so schnell wie möglich wieder raus 

• Es gelten folgende Nebenbedingungen 

Die Bewohner sind verreist, wir haben im Prinzip 

„reichlich Zeit“ 

Wir kennen den Wert aller Wertgegenstände 

Wir können nicht alles mitnehmen, nur ein bestimmtes 

Gewicht (sonst wäre „Alles mitnehmen“ optimal) 

Die Gewichte kennen wir auch (Handwaage ist immer 

dabei!) 



• Dieses Problem ist (in krimineller Verkleidung) das 

klassische Knapsack Problem (Rucksack-Problem), formal: 

Gegeben ist eine Menge M = {1,..,n} von Gegenständen 

mit den Werten v i und den Gewichten w i . Gesucht ist M‘ 

⊆ M mit 

∑ i ∈ M‘ w i ≤ w max 

 

d.h. die Summe der Gewichte der Gegenstände in M‘ 

überschreitet ein vorgegebenes Maximalgewicht nicht. 

Der Wert der Gegenstände soll so groß wie möglich sein: 

Max M‘ ⊆ M ← ∑ i ∈ M‘ v i 



• Lösungsidee: 

 

 

Gegenstände nach dem Verhältnis von Wert zu Gewicht 

(„Wert pro Kilo“) absteigend sortieren (der mit dem 

größten Wert pro Gewichtseinheit steht also vorne), z.B. 

in einer PQueue 

Dann nehmen wir solange Gegenstände aus der PQueue, 

wie wir sie noch tragen können 

• Diese Strategie ist „gierig“! (English: Greedy) – man nimmt 

das „Vielversprechendste“ zuerst usw. 

• Ist das immer sinnvoll? 



• Natürlich nicht (würde ich sonst so fragen...) 

• Wir können maximal 50kg tragen, es gibt die folgenden 

Gegenstände 

 

 

 

Lehrbuch über Algorithmen und Datenstrukturen, 

Gewicht w 1 

= 10kg, Wert v 1 

= 60 Euro, d.h. 6 Euro pro kg 

Taschenrechner mit eingebautem Dijkstra, 

Gewicht w 2 



Allegorische Statue, die die ewige Schönheit von (bottom-up) 

Heapsort symbolisiert, 

Gewicht w 3 



• Was liefert die Greedy-Strategie als Resultat? 

• Wie sieht das optimale Resultat aus? 



• Aber manchmal geht es auch...sogar immer, wenn die 

Problemstellung entsprechend ist. 

• Andere Gegenstände: 

Ein Haufen Schnipsel mit Klausurlösungen, 

Gewicht 10kg, Wert 60 Euro, 6 Euro pro kg 

Ein Haufen Goldstaub, 

 


Ein Haufen Silberstaub, 


• Jetzt können wir die Gegenstände beliebig teilen: 

• Also nehmen wir die Klausurschnipsel, den Goldstaub, und füllen 

unseren Rucksack mit Silberstaub auf (zu einem Gesamtwert von 

60+100+80 = 240 Euro) 

• Besser geht es natürlich nicht! 



 

Probleme des ersten Typs (mit unteilbaren Gegenständen) 

heißen 

0-1 Knapsack Probleme 

 

Probleme des zweiten Typs (mit beliebig teilbaren 

Gegenständen) heißen 

Fractional Knapsack 

 

 

Fractional Knapsack Probleme lassen sich immer „greedy“ 

lösen! 

0-1 Knapsacks nur ab und an „zufällig“! 



 

Unser „kürzeste-Wege-Problem“ lässt sich auch „Greedy“ 

lösen – und genau das tut der Dijkstra auch! 

 

Das gleiche gilt für das „Minimum Spanning Tree“- 

Problem, und auch Kruskal bzw. Prim lösen das Problem 

„greedy“ 

 

Ein guter Hinweis darauf ist oft die Verwendung einer 

PQueue... 


Arbeitsweise von Greedy-Algorithmen 

 

Wir haben folgendes zur Verfügung 

• Eine Menge von Kandidaten C, aus denen wir die Lösung 

konstruieren wollen (z.B. Kanten beim MST) 

• Eine Teilmenge S ⊆ C, die bereits ausgewählt wurde 

• Boole‘sche Funktion solution, die sagt, ob eine Menge von 

Kandidaten eine legale Lösung des Problems darstellt 

(unabhängig davon, ob die Lösung optimal ist) 

• Eine Testfunktion feasible, die sagt, ob eine Teillösung unter 

Umständen zu einer kompletten legalen Lösung erweitert 

werden kann 

• Eine Auswahlfunktion select, die den nächsten 

„vielversprechendsten“ Kandidaten liefert 

• Eine Zielfunktion value, die uns den Wert einer Lösung 

angibt 


Arbeitsweise von Greedy-Algorithmen 

Function greedy(c) 

S ← ∅ 

while not solution(S) and C ≠ ∅ do 

x ← select(C) 

C ← C - {x} 

if feasible(S ∪ {x}) then 

S ← S ∪ {x} 

if solution(S) then 

return S 

else return „There_is_no_solution“ 

Mit der Funktion value(S) kann man am Ende den Wert der 

gefundenen Lösung bestimmen (falls es eine gab...) 


Welche Probleme sind „greedy“ lösbar? 

• Wenn das Problem sich als Matroid modellieren läßt, dann kann 

man es „Greedy“ lösen! 

• Aber was ist ein Matroid? [s. Literaturempfehlungen] 

• Es gilt sogar: ein Problem lässt sich genau dann „greedy“ lösen 

(allgemein für jede Gewichtungsfunktion der Elemente in die 

positiven reellen Zahlen), wenn es eine Matroid-Struktur aufweist 

(s. auch „Das Geheimnis des kürzesten Weges“, Literaturhinweis 

zu Gin1b) 


Noch ein wichtiges Problem, das man „greedy“ angehen kann: 

Datenkompression 

• Ist ihre Festplatte ständig zu klein? 

• ...oder ihre Internet-Anbindung zu langsam? 

• Dann ist Datenkompression ein Thema für Sie! 

• Ziele: 

 

 

möglichst platzsparende Datenspeicherung bzw. 

Übertragung 

entpacken möglich, ohne Fehler in den Daten zu 

hinterlassen 



• Zwei Teilprozesse: 

 

 

Kompression: Ein Prozess, der Daten in einer komprimierte, 

also „kleinere“, Form überführt 

Expansion: Ein Prozess, der aus der komprimierten Form die 

Ausgangsdaten rekonstruiert 

• Beispielfälle für „Original“-Daten: 

 

 

Ein Text aus 256.000 Zeichen, jedes der 256 möglichen 

(ASCII-)Zeichen tritt genau 1000-mal auf 

Der Text besteht aus 256.000-mal dem Zeichen ‚a‘ 

• Beide Texte nehmen 256.000*8 = 2.048.000 Bit Plattenplatz ein. 



 

Betrachten wir einmal die Wahrscheinlichkeit, dass an 

einer bestimmten Stelle der Files ein bestimmtes Zeichen 

auftaucht: 

• Im ersten File ist die Wahrscheinlichkeit für das 

Auftauchen jedes Zeichens an der ersten betrachteten 

Position gleich, nämlich 1/256, z.B. für ‚a‘ 

An später betrachteten Positionen verschieben sich 

die Wahrscheinlichkeiten abhängig von den vorher 

bereits betrachteten Zeichen (wenn es z.B. gar kein 

a mehr gibt), aber „ungefähr“ bleibt es bei der 

Wahrscheinlichkeit 1/256 auch an den anderen 

Positionen 

• Im zweiten Fall ist die Wahrscheinlichkeit für das 

Auftauchen von ‚a‘ an jeder Position 1. 



• Im ersten Fall besteht eine hohe Unsicherheit darüber, 

welches Zeichen an der betrachteten Position auftritt. 

• Um zwischen den verschiedenen möglichen „Ereignissen“ 

(das Auftreten eines bestimmten der 256 Zeichen) zu 

unterscheiden, müssen wir den aufgetretenen Fall genau 

angeben 

• Um 256 Ereignisse zu unterscheiden, brauchen wir 

log 2 256 Bit, also 8 ;-) 



• Im zweiten Fall wissen wir mit Sicherheit, welches 

Zeichen an der betrachteten Position auftritt (nämlich „a“) 

• Um zwischen den verschiedenen möglichen „Ereignissen“ zu 

unterscheiden, brauchen wir eigentlich gar keine 

Information 

• Wir müssen nur wissen, wieviele „a“ auftreten 

• Insgesamt können wir das File durch „Jetzt kommen 

256.000 ‚a‘“ vollständig beschreiben (also mit ungefähr 150 

Bit) 

• Intuitiv ist klar, dass man im ersten Fall nicht sehr viel 

komprimieren kann, im zweiten aber schon! 



• Zum Komprimieren muss man den „Eingabetext“ sinnvoll 

kodieren. 

• Elementare Idee: 

Zeichen, die häufig vorkommen, erhalten 

vergleichsweise kurze Codes 

• Das nennt man „variable Kodierung“ 

• Sie soll den folgenden Ausdruck minimieren 

∑ l(c i )*f(c i ), 1 ≤ i ≤ n 

 

 

 

n = Anzahl der Zeichen 

l(c i ) = Länge der Codierung des Zeichens c i 

f(c i ) = Häufigkeit von c i im Text 



a b c d e f 

Häufigkeit 45 13 12 16 9 5 

ASCII 01100001 01100010 01100011 01100100 01100101 01100110 

Code 1 0 011 100 101 0011 1100 

Code 2 0 101 100 111 1101 1100 

Was ist schlecht am Code 1? Probieren Sie mal, 001100101 zu expandieren! 

Man könnte natürlich die Länge des nächsten Codes abspeichern, aber so 

recht macht das keinen Sinn...bei Code 2 geht das auch so! 



a b c d e f 

Häufigkeit 45 13 12 16 9 5 

Code 1 0 011 100 101 0011 1100 

Code 2 0 101 100 111 1101 1100 

• Dekodieren des Wortes 001100101 mit Code 1: 

• Stellen sie sich vor, sie lesen die Eingabe Zeichen für Zeichen 

von links nach rechts und müssen Entscheidungen treffen... 

0 

0 

f f 

1 f 

a,b,c,d,e,f 

1 

0 

0 

c,d,f 

b,e 

a 

1 

0 

0 

c,d 

b 

e 

1 

1 

0 

b 

d 

c 

1 1 e e 




• Stellen sie sich vor, sie lesen die Eingabe Zeichen für Zeichen 

von links nach rechts 

• Zu Beginn sind noch alle Codes möglich 

• Aber bereits beim ersten Knoten können sie nicht exakt 

entscheiden, ob die 0 für ein a oder für b oder e steht... 

1 

f 

0 

f 

0 

f 

a,b,c,d,e,f 

0? 

1 

0 

0 

c,d,f 

b,e 

a 

0 

1 

0 

c,d 

b 

e 

1 

1 

0 

b 

d 

c 

1 1 e e 



a b c d e f 

Häufigkeit 45 13 12 16 9 5 

Code 2 0 101 100 111 1101 1100 


1 

d 

1 

a,b,c,d,e,f 

0 

d,e,f 

1 0 

e,f 

b,c,d,e,f 

0 

b,c 

1 b 

0 c 

a 

1 e 

0 f 

aafb 



• Definition: Eine Codierung heißt präfix-frei, wenn kein 

Code Anfangsstück (=Präfix) eines anderen Codes ist 

• Einen solchen Code kann man offensichtlich mit Hilfe von 

binären Entscheidungsbäumen beschreiben: 

 

 

 

 

Die Blätter sind die zu kodierenden Zeichen 

Die Codes ergeben sich aus den Wegen im Baum, die 

von der Wurzel zu den Zeichen führen 

Eine Zweig nach links steht für ein 0, ein Zweig nach 

rechts für eine 1 

Eine solche Kodierung ist immer präfix-frei, weil zu jeder 

Zeit klar ist, wie es im Baum weitergeht (es gibt keine 

Wahlmöglichkeiten) 


Präfix-freie Codes 

• Einige mögliche binäre Codebäume für die Zeichen a,b,c 

a,b,c 

a,b,c 

a,b,c 

•„unschlau“ 

a 

b,c 

b 

a,c 

a 

b,c 

b 

c 

a 

c 

b 

c 

c 

a,b,c 

a,b 

a b 

•„normal“ 

• Welcher Baum ist nun optimal? 

• Der rechte Baum auf keinen Fall! 

• Bei den anderen drei Bäumen hängt 

das von den Auftretenshäufigkeiten der 

Buchstaben ab 

c 



• Einige mögliche binäre Codebäume für die Zeichen a,b,c 

(1) a,b,c (2) a,b,c (3) 

a,b,c 

a 

b,c 

b 

a,c 

c 

a,b 

b 

c 

a 

c 

a 

b 


a/1,b/1, 

c/1 

Baum 1 1+2+2= 

5 

Baum 2 2+1+2= 

5 

Baum 3 2+2+1= 

5 

a/2,b/1, 

c/1 

2*1+2+2= 

6 

2*2+1+2= 

7 

2*2+2+1= 

7 

a/3,b/1, 

c/1 

3*1+2+2 

=7 

3*2+1+2 

=9 

3*2+2+1 

=9 

a/3,b/2, 

c/1 

3*1+2*2+2 

=9 

3*2+2*1+2 

=10 

3*2+2*2+1 

=11 

a/1,b/2,c/2 

1*1+2*2+2*2 

=9 

1*2+2*1+2*2 

=8 

1*2+2*2+2*1 

=8 



• Zwei mögliche binäre Codebäume für die Zeichen a,b,c,d,e,f 

„balanciert“ 

a,b,c,d,e,f 

a,b,c,d,e,f 

„kettenförmig“ 

a,b,c 

d,e,f 

a 

b,c,d,e,f 

a 

b,c 

d 

e,f 

b 

c,d,e,f 

b 

c 

e 

f 

c 

d,e,f 


• Alle Buchstaben gleichhäufig, z.B. einmal: 

2+3+3+2+3+3 = 16 (links), 

1+2+3+4+5+5 = 20 (rechts) 

• Häufigkeiten: a/6,b/5,c/4,d/3,e/2,f/1 

6*2+5*3+4*3+3*2+2*3+1*3=54 (links), 

6*1+5*2+4*3+3*4+2*5+1*5=55 (rechts) 

d 

e 

e,f 

f 





a,b,c,d,e,f 

a,b,c,d,e,f 


a,b,c 

d,e,f 

a 

b,c,d,e,f 

a 

b,c 

d 

e,f 

b 

c,d,e,f 

b 

c 

e 

f 

c 

d,e,f 



12*2+10*3+8*3+6*2+4*3+2*3=108 (links), 

12*1+10*2+8*3+6*4+4*5+2*5=110 (rechts) 


50*2+30*3+12*3+6*2+4*3+2*3=256 (links), 

50*1+30*2+12*3+6*4+4*5+2*5=200 (rechts) 

d 

e 

e,f 

f 





a,b,c,d,e,f 

104 104 

a,b,c,d,e,f 


a 

a,b,c 

b 

b,c 

c 

d,e,f 

• Warum ist der rechte Baum soviel besser bei der 

letzten Verteilung? 

• Eine gleichmäßige Aufteilung führt zu einer 

Minimierung der gewichteten Höhen 

(=Codelänge * Vorkommen) der Knoten! 

a 

b,c,d,e,f 

92 12 

54 

50 

42 

d 

6 

e 

e,f 

30 12 4 2 

f 

6 

50 

b 

30 

c 

12 

d 

6 

c,d,e,f 

d,e,f 

e 

e,f 

24 

f 

4 2 

12 

6 



• Geht das noch besser? Hm... probieren wir mal... 

104 

a,b,c,d,e,f 

104 

a,b,c,d,e,f 

a,f 

b,c,d,e 

a f b c,d,e 

50 2 30 

30 

c d,e 

12 

12 

6 4 6 

• Links von oben „lokal optimal“ aufgeteilt 

• Chiffrelänge links: 244, rechts: 200! Aua! 

a 

50 

b 

b,c,d,e,f 

52 52 54 

d e 

d 

c 

c,d,e,f 

22 24 

d,e,f 

10 12 

e,f 

e f 

4 2 

6 



• Unsere „neue“ Aufgabe ist also: 

 

 

Gegeben ist eine Datei mit zu komprimierenden Daten 

Man konstruiere einen binären Entscheidungsbaum, der 

zu einer optimalen präfix-freien Codierung des 

Dateiinhalts führt. 

• Das Problem ist das Finden der besten Struktur des 

Baumes! 

• Drei Ideen folgen... 



• Idee 1 („Brute-Force“, „vollständige Enumeration“): 

Wir bauen alle möglichen Binärbaumstrukturen ohne überflüssige 

Knoten (also keine Bäume vom Typ „unschlau“) 

Wir bestimmen die Chiffrelängen all dieser Bäume 

..und wählen dann den besten Baum aus (also den bzw, einen 

derjenigen mit der kürzesten Chiffrelänge) 

• Problem hier: 

Es gibt „fürchterlich viele“ mögliche Baumstrukturen! 

Wieviele können sie für 3 Knoten bauen? 

Wieviele für 4 Knoten, wieviele für n Knoten? 

• Diese Lösungsidee ist VIEL ZU TEUER! 

• Aber: sie ist optimal, d.h. sie wählt sicher den besten Baum aus! 



• Idee 2 (Shannon-Fano): 

Wir ordnen die Buchstaben nach Häufigkeit absteigend in einer Liste an, 

z.B. [13, 9,4,3,2,2,1] 

Jetzt suchen wir einen sogenannten Splitpunkt, an dem wir die Liste in 

zwei Teile spalten. Diese Suche wird rekursiv für jede Teilliste wiederholt. 

Dieser Splitpunkt soll unter allen möglichen Splitpunkten so gewählt sein, 

dass die Summen der Häufigkeiten in den beiden Listenteilen möglichst 

nah beieinander liegen - mit anderen Worten: die Differenz zwischen den 

beiden Häufigkeitsummen soll minimiert werden 

Mögliche Aufteilungen: 

• [] (Gewicht 0), [13,9,4,3,2,2,1] (Gewicht 34), Differenz: 34 

• [13] (Gewicht 13), [9,4,3,2,2,1] (Gewicht 21), Differenz: 8 

• [13,9] (22) [4,3,2,2,1] (12), Differenz: 10 

• [13,9,4] (18) [3,2,2,1] (8) ... 

• Wenn man von links die Differenzen betrachtet, dann hat man einen 

Splitpunkt gefunden, sobald die Differenz wieder anwächst (die wird 

erst kleiner und steigt dann unweigerlich wieder) 

• Es kann Gleichstände zwischen max. zwei Splitpunkten geben, dann 

wählt man den linken/oberen oder rechten/unteren, je nach Vorgabe 



• Idee 2 (Shannon-Fano): 

Vorteile: 

• Das Verfahren ist sehr günstig zu rechnen – die Knoten 

werden sortiert (n log n) und dann werden n-1 Splitpunkte 

bestimmt (schlimmstenfalls wird immer bis zur „Mitte“+1 

jeder Liste aufsummiert, O(log n * (n/2 + 1)), insgesamt 

also O(n log n). 

 

Nachteile: 

• Das Verfahren ist NICHT optimal! 

• Beispiel s. Übung 



• Idee 3 (Huffman): 

Wir ordnen Knoten, die die einzelnen Buchstaben repräsentieren, nach Häufigkeit 

AUFSTEIGEND in einer Liste an, z.B. [a/1,b/2,c/2,d/3,e/4,f/9,g/13], Ablage am 

besten in einer PQueue 

Jetzt entnehmen wir die beiden vorderen Knoten und erzeugen daraus einen neuen 

Vaterknoten für die beiden entnommenen Knoten. 

Der neue Knoten erhält als Gewicht die Summen der Gewichte seiner beiden Kinder. 

Er wird in die PQueue eingefügt! 

Das wiederholen wir solange, bis nur noch ein Knoten in der PQueue ist. 

• Machen wir das einmal „abstrakt“ für die Liste oben: 

Initial: [a/1,b/2,c/2,d/3,e/4,f/9,g/13], a und b entnehmen, (a,b) mit Gewicht 

1+2=3 einstellen (kann vor oder auch hinter d/3 landen – das ist nicht festgelegt!) 

[c/2,d/3,(a,b)/3,e/4,f/9,g/13], c und d entnehmen, (c,d) mit Gewicht 5 einstellen 

[(a,b)/3,e/4,(c,d)/5,f/9,g/13], (a,b) und e entnehmen, (a,b,e) mit Gewicht 7 

einstellen 

[(c,d)/5,(a,b,e)/7,f/9,g/13], (c,d) und (a,b,e) entnehmen, (a,b,c,d,e) mit Gewicht 

12 einstellen 

[f/9,(a,b,c,d,e)/12,g/13], f und (a,b,c,d,e) entnehmen, (a,b,c,d,e,f) mit Gewicht 21 

einstellen 

[(a,b,c,d,e,f)/21,g/13], (a,b,c,d,e,f) und g entnehmen, (a,b,c,d,e,f,g) mit Gewicht 

34 einstellen 

Fertig! 




• Zur Erinnerung hier nochmal die Operationen auf der PQueue: 

a,b raus -> (a,b) rein; c,d -> (c,d); (a,b), e -> (a,b,e); 

(c,d), (a,b,e) -> (a,b,c,d,e); f , (a,b,c,d,e) -> (a,b,c,d,e,f); 

(a,b,c,d,e,f),g -> (a,b,c,d,e,f,g) 

• Der Algorithmus baut also folgenden Codebaum „auf dem Kopf“: 

a 

b 

e 

a,b c d 

a,b,e 

c,d 

f 

a,b,c,d,e 

a,b,c,d,e,f 

g 

a,b,c,d,e,f,g 




Vorteile: 

• Das Verfahren ist sehr günstig zu rechnen – die Knoten 

werden (teil-)sortiert (O(n log n)) und dann werden O(n-1) 

innere Knoten gebildet (und dabei wird die Pqueue aufrecht 

erhalten zu Kosten von jeweils O(log n) pro Operation bei 

einer Heapimplementierung mit n-1 Inserts und 2(n-1) 

DeleteMins im Worstcase), also Kosten von O(n log n) 

insgesamt 

• Das Verfahren ist – unglaublich, aber wahr – optimal! 

 

Nachteile: 

• Keine 


Huffman-Codierung 

• Baum zur Kodierung auf Basis der Zeichenhäufigkeit 

optimal aufbauen 

• Infos über die gewählte Codierung in der erzeugten Datei 

mit der Komprimierung speichern 

• Führt je nach Daten zu Komprimierungen ca. zwischen 

20%-70% (im worst-case spart man nix...im Gegenteil, die 

Codetabelle kostet ja auch etwas) 


Huffman-Codierung: Ablauf 

1. Ein Durchlauf zur Bestimmung der vorkommenden 

Zeichen und zur Ermittlung ihrer Vorkommenshäufigkeit 

2. Aufbau des optimalen Codebaums 

3. Ableiten der Codes und Codelängen aus dem Baum 

4. Abspeichern der Codeinformationen in der Ausgabedatei 

5. Zweiter Durchlauf, um die Zeichen zu codieren, nebst 

Ablage in der Ausgabedatei 


Huffman-Codierung: Ablauf 

• Häufigkeitsermittlung ist klar 

• Aufbau des Codebaums: 

 

„Gierige“ Suche nach einem optimalen Baum (Gierig, 

weil die Zeichen in der Reihenfolge „absteigende 

Häufigkeit“ genau einmal angepackt werden) 

• Aus dem Baum kann die Codetabelle abgeleitet werden 

• Vollständiges Beispiel s. Übungsaufgabe bzw. Mitschrieb 


Huffman-Codierung: Expansion 

 

 

 

Die Codetabelle wird in der Ausgabedatei abgespeichert 

Aus der Codetabelle kann man direkt den Baum 

rekonstruieren 

• 0 = links, 1 = rechts, die Tiefe eines Zeichens entspricht 

der Länge des Codes für ein Zeichen 

Die Expansion läßt dann den binären „Codestring“ durch den 

Baum rieseln: 

1. Beginn mit dem ersten Zeichen des Codestrings 

2. Wegwahl entsprechend der binären Ziffern entlang des 

Baumes, beginnend mit der Wurzel, bis ein Blatt erreicht 

wird 

3. Zum Blatt gehöriges Zeichen ausgeben und auf die Wurzel 

zurückgehen, wenn noch nicht alles expandiert ist, zum 

Schritt 2 zurückkehren 


Literatur 

• Zum generellen Greedy-Ablauf und zur Huffman-Codierung: 

B. Owsnicki-Klewe: Algorithmen und Datenstrukturen, 4. 

Auflage, Wißner-Verlag, Augsburg, 2002 (gut lesbares 

Buch, launig-nett geschrieben, kann beim Verstehen 

sicher helfen, kaum/keine Beweise, wenig Aufgaben, 

keine Lösungen, aber dafür nicht sehr teuer, ca. 15 Euro, 

und berührt viele unserer Themen) 

Ansonsten finden sie praktisch in allen genannten 

Büchern Informationen zu Greedy-Algorithmen und 

Codierungen 

• Zu Matroiden: In allen guten Büchern zu Optimierung (z.B. 

dem von Korte und Nguyen) oder auch in Cormen, Rivest, 

Leierson, Stein oder bei Schöning (s. frühere 

Literaturangaben).

ADS – Vorlesung Prof. Dr. Wolfram Conen

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?