Folienkopien zur Vorlesung
Informatik II
Sommersemester 2000
Dipl.-Inform. Guido Rößling
Berufsakademie Mannheim
EMail: [email protected]
Inhaltsverzeichnis
Einleitung
1.1
Zahlendarstellung
2.1
Stellenwertsysteme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2
Beispiel mit Basis 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3
Horner-Schema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5
Zahlenbasis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.6
Natürliche Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.7
Binärzahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.7
Oktalzahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.9
Hexadezimalzahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.10
Ganze Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.12
Vorzeichen-Absolutbetrag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.13
Zweierkomplement (K2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.16
Rechenregeln Zweierkomplement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.20
Gleitpunktzahlen nach IEEE Standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.21
Anforderungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.22
Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.23
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.24
Auswertung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.25
Sonderfälle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.26
Vor- und Nachteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.27
Vergleich von Gleitpunktzahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.29
Fehlerfortpflanzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.30
Fehlerquellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.32
Fehlertypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.33
Absoluter Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.34
Relativer Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.35
Ergebnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.41
Datenstrukturen
3.1
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1
Primitive Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.4
Characters und Sonderzeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.5
Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.8
Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.10
Einschränkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.11
Größenänderung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.12
Mehrdimensionale Felder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.13
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.15
Vor- und Nachteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.16
Listen
4.1
Verkettete Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1
Aufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2
Navigation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3
Einfügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.4
Löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.8
Vor- und Nachteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.13
Doppelt verkettete Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.14
Aufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.15
Einfügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.16
Löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.21
Vor- und Nachteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.28
Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.29
Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.30
Postfix-Auswertung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.32
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.34
Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.35
Vor- und Nachteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.36
Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.37
Operationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.38
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.39
Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.40
Vor- und Nachteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.41
Bäume
5.1
Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2
Knoten, Kanten, Vorgänger und Nachfolger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3
Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.4
Wurzel, Blatt, Zyklus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.4
Nachfolger und Vorgänger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.5
Zyklen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.6
Pfad und Stufe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.7
Pfadlänge, n-ärer und geordneter Baum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.8
Binärer Baum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.9
Spezielle Formen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.10
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.12
Traversierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.17
Vor- und Nachteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.20
Spezielle Baumstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.21
Heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.21
Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.22
Erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.23
Löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.26
Vor- und Nachteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.28
Priority Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.29
Einfügen und Löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.30
Vor- und Nachteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.31
Binärer Suchbaum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.32
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.33
Einfügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.34
Löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.36
Vor- und Nachteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.38
AVL-Baum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.39
Einfügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.41
Rotationstypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.42
Beispiel zum Einfügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.45
Löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.49
Vor- und Nachteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.50
B-Baum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.51
Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.52
Aufbau eines Knotens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.53
Einfügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.54
Löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.59
Vor- und Nachteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.62
Weitere Baumstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.63
Sonstige Datentypen
6.1
Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2
Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4
Bag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.5
File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.6
Zugriff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.7
Dateiverarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.8
Graphentheorie
7.1
Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2
Gerichteter und ungerichteter Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.3
Darstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4
Teilgraphen und Isomorphie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.5
Kantenfolge, -zug, Weg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.6
Zyklus und Länge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.7
Speicherung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.8
Adjazenzmatrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.9
Adjazenzliste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.10
doppelt verkettete Adjazenzliste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.11
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.12
Gewichtung von Kanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.13
Durchlaufen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.16
Tiefensuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.16
Breitensuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.20
Graphenalgorithmen
8.1
Minimaler spannender Baum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1
Alg. von Prim . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.3
Algorithmus von Kruskal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.5
Transitive Hülle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.7
Alg. von Warschall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.8
Topologische Sortierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.10
Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.11
Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.12
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.13
Kürzeste Pfade - Algorithmus von Dijkstra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.14
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.15
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.17
Kürzeste Pfade - Algorithmus von Floyd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.18
Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.19
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.20
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.22
Elementare Suchalgorithmen
9.1
Sequentielle Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.4
Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.5
Erweiterung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.6
Binäre Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.8
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.9
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.11
Interpolationssuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.12
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.13
Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.14
Selbstanordnende Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.15
Binärer Suchbaum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.16
Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.17
Einfügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.18
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.19
Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.20
AVL-Baum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.21
B-Baum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.22
Suche in Zeichenfolgen
10.1
Brute Force . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.2
Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.2
Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.3
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.4
KMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.5
Vorgehensweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.6
Bsp. Bestimmung next . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.7
Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.8
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.9
Algorithmus f. initNext . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.10
Ausw. der Modifikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.11
Implementierung initNext . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.12
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.13
Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.14
Weitere Suchalgorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.15
Sortieralgorithmen
11.1
Problemstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.1
Konventionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2
Hilfsroutine swap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3
Sortieren durch Auswahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.4
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.5
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.6
Komplexität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.7
Sortieren durch Einfügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.8
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.9
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.10
Komplexität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.11
Bubble Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.12
Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.12
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.13
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.14
Komplexität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.15
Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.16
Shellsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.17
Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.18
Verbesserter Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.19
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.20
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.21
Komplexität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.22
Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.23
Schematische Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.24
Ablauf von partition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.25
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.26
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.27
Komplexität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.28
Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.29
Alternative Pivotwahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.30
Binärer Suchbaum, AVL- und B-Baum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.31
Heapsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.32
Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.33
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.34
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.35
Komplexität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.37
Mergesort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.38
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.39
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.40
Komplexität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.41
Sonstige Sortierverfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.42
Hashing
12.1
Formale Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.2
Statisches Hashing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.3
Beispiele für Hash-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4
Kollisionsbehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.5
Überläuferliste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.6
Sondierungsverfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.7
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.8
Vor- und Nachteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.9
Dynamisches Hashing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.10
Kompressionsverfahren
13.1
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.1
Definitionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4
Kompressionstypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.5
Kompressionsgüte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.6
Intuitive Kompression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.7
Braille-Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.7
Front Compression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.9
Lauflängenkodierung RLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.10
Statistische Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.13
Informationsgehalt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.15
Huffman-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.16
Arithmetische Kodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.20
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.21
Dekodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.23
Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.25
Dictionary-basierte Kodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.26
Bildkompression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.29
JPEG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.31
Soundkompression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.33
Videokompression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.34
Verschlüsselungsverfahren
14.1
Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.2
Einfache Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4
Cäsar-Chiffre, Tabellenkodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4
Vigenère-Chiffre, Vernam-Chiffre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.6
RSA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.7
PGP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.8
Voraussetzungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.9
Vorgehensweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.10
Bestimmung
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.12
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.13
Anhang
15.1
Abbildungsverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.1
Tabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.5
Listings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.6
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.8
Allgemeines zur Informatik II
Inhalte der Informatik II:
❑ Zahlendarstellung und Fehlerfortpflanzung
❑ Datenstrukturen zur Modellierung und Speicherung von Daten
❑ Graphentheorie – Graphen und Graphenalgorithmen
❑ Algorithmen
☞ Suchalgorithmen
☞ Sortieralgorithmen
☞ Hashing
☞ Kompressionsverfahren
☞ Kryptologie
Informatik II – c Guido Rößling
Einleitung
1.1
Einführung in die Informatik II
Ziel der Informatik II“ ist es,
”
❑ die Grundlagen der Zahlendarstellung im Computer zu vermitteln sowie bei dem Rechnen
auftretende Fehler zu untersuchen,
❑ elementare Datentypen einzuführen, die im täglichen Leben“ benötigt werden,
”
❑ sowie die grundlegenden Algorithmen auf den Gebieten Suche, Sortieren, Hashing, Kompressionsverfahren und Kryptologie vorzustellen.
Als Grundlage für den größten Teil der Vorlesung dient das Buch [Sed92].
Es ist auch für andere Programmiersprachen erhältlich, z.B. PASCAL ( Algorithmen“) und
”
C++ ( Algorithmen in C++“).
”
Informatik II – c Guido Rößling
Einleitung
1.2
Informatik II – c Guido Rößling
Kryptologie
Graphentheorie
Graphenalgorithmen
Suchalgorithmen
Suche in Zeichenfolgen
Sortieralgorithmen
Hashing
Kompressionsverfahren
Primitive Datentypen
Listenstrukturen
Bäume
Sonstige Datentypen
Einleitung
Zahlendarstellung
Wo sind wir ?
Einleitung
1.3
Zahlendarstellung
Um die normalen arithmetischen Rechenoperationen zu unterstützen, müssen im Rechner
Zahlen in einem computergeeigneten Format dargestellt werden.
Verglichen mit der Mathematik ergeben sich dabei insbesondere folgende Unterschiede:
❑ Die Basis der Zahlendarstellung ist nicht 10, sondern 2, 8 oder 16
❑ Zur Darstellung von Zahlen steht nur jeweils eine feste Anzahl Stellen zur Verfügung; der
Bereich der darstellbaren Zahlen ist also endlich.
❑ Einige Zahlen innerhalb dieses Bereichs der darstellbaren Zahlen haben evtl. keine oder
mehr als eine Art der Darstellung ☞ sowie Darstellungsvarianten von 0
❑ Bei Rechnungen können Fehler durch Verlassen des Bereiches der darstellbaren Zahlen
bzw. eines nicht darstellbaren Ergebnisses auftreten.
❑ Die Fehler bei Rechenoperationen können sich durch mehrere Rechnungen fortpflanzen
und dadurch vergrößern.
Im folgenden werden die oben aufgeführten Unterschiede anhand der üblichen Zahldarstellung untersucht.
Informatik II – c Guido Rößling
Zahlendarstellung
2.1
Stellenwertsysteme
❑ Die meisten Zahlensysteme sind Stellenwertsysteme, bei denen die Position einer Ziffer
in der Zahl die Wertigkeit angibt
☞ bei Basis b hat Stelle von rechts bei 0 beginnend die Wertigkeit ❑ Eine Ausnahme sind beispielsweise die römischen Zahlen, bei denen die Wertigkeit durch
verschiedene Zeichen codiert wurde. Entsprechend schwer fällt auch die Rechnung mit
römischen Zahlen ☞ V + V = X, aber VL + V = L XL
❑ Das Standardbeispiel für ein Stellenwertsystem ist das Dezimalsystem, in dem Zahlen zur
Basis 10 dargestellt werden.
Jede Zahl des Dezimalsystems besteht nur aus den Ziffern 0 bis 9; der Wert der Zahl wird
durch die Anordnung der Ziffern festgelegt.
❑ Generell werden in einem Zahlensystem mit Basis n Zeichen mit den Wertigkeiten
0, 1, , n-1 verwendet. Gängig ist dabei die Verwendung der Ziffern (0 - 9)
sowie gegebenfalls der Zuhilfenahme des (lateinischen) Alphabets
☞ A 10, B 11, Informatik II – c Guido Rößling
Zahlendarstellung – Stellenwertsysteme
2.2
Beispiel mit Basis 10
Für fünfstellige Zahlen im Zehnersystem erhält man folgende Interpretation:
1
5 Wertigkeit
! "
2
5 3
5 5
4
5
5 "
Ergebnis
$#%'&)(*#%+&),*#%-&/.0#!1!2&)34#%"
= 10000 + 2000 + 300 + 40 + 5 = 12345
5 # & 5 # & 5 # & 5 # & 5 " # " 6 9 # 5 :
"
87
Jede Zahl im Dezimalsystem wird durch die Reihenfolge der einzelnen Ziffern eindeutig
dargestellt.
❑ Die Wertigkeit nimmt von rechts nach links zu; entsprechend werden die Stellen von
rechts nach links (bei 0 beginnend) numeriert.
9<; &= :
-stellige Zahl ist der Nachfolger der größten n-stelligen
❑ Die kleinste darstellbare
Zahl, d.h. es werden keine Zahlen übersprungen bei Hinzunahme einer weiteren Stelle.
Informatik II – c Guido Rößling
Zahlendarstellung – Stellenwertsysteme : Beispiel mit Basis 10
2.3
Auswertung mit dem Horner-Schema
❑ Für die Auswertung nach dem Schema der letzten Folie sind folgende Schritte auszuführen:
1. Bestimme die Wertigkeit der Stellen (von rechts nach links)
2. Multipliziere die Einzelstellen mit der Wertigkeit der Stelle
3. Summiere die Werte aus Schritt 2
❑ Diese Auswertung führt leicht zu Rechenfehlern
❑ Praktischer ist das Horner-Schema, hier für Zahlenbasis b:
;/> (
1. Setze i = n - 2, wenn die Zahl
Stellen hat, d.h. als 5%?@ 5 " vorliegt.
2. Setze value = 5A?@
#
3. Setze value = value b + 5
4. Setze i = i - 1
>
5. Falls i
0, fahre fort mit Schritt 3
6. value enthält den Wert der in a abgelegten Zahl als Dezimalzahl.
Informatik II – c Guido Rößling
Zahlendarstellung – Horner-Schema
2.4
Beispiel zum Horner-Schema
Für das Beispiel auf Seite 2.3 mit der Zahl 12345, Zahlenbasis mit dem Horner-Schema:
und
; 3
ergibt sich
Schritt i value
2
3 = BDC = 1
3
3 = 1 E 10 + B1F = 10 + 2 = 12
4
2 12
3
2 = 12 E 10 + BG = 120 + 3 = 123
4
1 123
3
1 = 123 E 10 + BH = 1230 + 4 = 1234
4
0 1234
3
0 = 1234 E 10 + B1I = 12340 + 5 = 12345
4
-1 12345
Tabelle 1: Beispiel zur Auswertung mit dem Horner-Schema
In abgekürzter Schreibweise:
(,.J3
K" 9L9L9 $#%$&M( : #%N&M, : #%N&O. : #%$&M3
☞ Es sind also generell nur Multiplikationen mit der Zahlenbasis und einfache
(dezimale) Additionen auszuführen.
Informatik II – c Guido Rößling
Zahlendarstellung – Horner-Schema : Beispiel
2.5
Zahlenbasis
❑ Gegeben sei eine Zahlenbasis b (mit 4PRQTSVUWYX ).
❑ Jede natürliche Zahl 5 kann wie folgt dargestellt werden:
?
9 # 5 :
5 "
87
❑ Für 5 sind dabei nur Zeichen mit Wertigkeit von bis einschließlich [Z
zulässig.
3 U 5 ,(\ , d. h. 5 \ U 5 ,\ U 5 " (\ , so ergibt
❑ Verwendet man beispielsweise
9 3$&), : #3$&M( .JN&M( .J(
,(\ 9 N#3$&M, : #3]&M(
sich 5 =
=
❑ Gängig sind Zahlensysteme zur Basis 10, 2 ( Binär“), 8 ( Oktal“) sowie 16 ( Hexadezi”
”
”
mal“).
❑ Im folgenden werden die einzelnen System sowie eine Methode zur Bestimmung der
Darstellung von natürlichen Zahlen in den Systemen vorgestellt.
Informatik II – c Guido Rößling
Zahlendarstellung – Zahlenbasis
2.6
Binärzahlen
❑ Binärzahlen werden zur Basis 2 dargestellt
☞ jede Ziffer ist entweder 0 oder 1 (vgl. Folie 2.6.)
❑ Aufgrund der technischen Gegebenheiten sind Binärzahlen die in Computern verwendete
Art der Zahlendarstellung
☞ Ziffern sind über kein Strom/Strom“ bzw. Transistor sperrt/leitet“ darstellbar
”
”
❑ Die einzelnen Stellen der Binärzahl werden als Bit bezeichnet (für Binary Digit, d.h.
binäre Ziffer).
❑ Für Gruppen von Bits gibt es ebenfalls Namen: Nibble für 4 Bit, Byte für 8 Bit, Word für
16 Bit sowie Longword oder Double word für 32 Bit.
A
ist zu
❑ Die Auswertung von Binärzahlen erfolgt wie im Dezimalsystem: die Zahl
$#( &)4#( &^$#( &_$#( "
&M( &_
K"
K" = a" .
lesen als
= ` K"
(
❑ Einfacher ist auch hier die Verwendung des Horner-Schemas mit :
99 $#($&) : #(N&_ : #(N&_
9 (*#($&^ : #($&_ 34#($&_
A
=
☞
=
=
= 11
Informatik II – c Guido Rößling
Zahlendarstellung – Natürliche Zahlen : Binärzahlen
2.7
Konversion von Dezimal nach Binär
;
Der folgende Algorithmus transformiert eine gegebene Dezimalzahl in das Zahlensystem
mit Basis :
1. Setze 2. Setze 5 = n % b
3. Setze n = n / b (Ganzzahl-Division!)
4. Falls 5 X , setze i = i + 1 und fahre mit Schritt 2 fort.
5. Das Ergebnis ist die Zahl a = 5 5 @ 5 5 " .
6 9 b # 5 b:
;
und ist identisch zur Zahl .
Die Wertigkeit von a entspricht b
"
7
Durch Anpassen der Division und Modulo-Operation an die Zahlenbasis kann der Algorithmus für die Umrechnung von Dezimalzahlen zu einer beliebigen Zahlenbasis benutzt werden
(
☞ Einsetzen von ergibt also eine Transformation von Dezimal in das
Binärsystem
Informatik II – c Guido Rößling
Zahlendarstellung – Natürliche Zahlen : Binärzahlen
2.8
Oktalzahlen
❑ Oktalzahlen stellen die Zahlen zur Basis 8 dar.
☞ Für die einzelnen Stellen werden die Zeichen 0 bis 7 verwendet
❑ Der auf Seite 2.8 angegebene Algorithmus kann für die Umrechnung von Dezimalzahlen
in Oktalzahlen verwendet werden
☞ Setze b = 8
❑ Oktalzahlen werden vielfach in Zeichensätzen und Textverarbeitung zur Anzeige von
nicht druckbaren Zeichen verwendet.
c
Die Darstellung erfolgt in der Regel etwa als 216“ für das ASCII-Zeichen mit Wert
(Ade (*# &_]# &Md .J(
”
K" ( Ä“).
`
`
”
❑ Oktalzahlen entstehen durch einfache Gruppierung der Einzelstellen aus Binärzahlen.
☞ Jeweils drei Binärstellen entsprechen dabei – von rechts nach links gruppiert –
einer Oktalstelle.
AA fAgA g,h( e ,( e 9 $# &), : # &M( ji K"
`
`
❑ Beispiel:
Informatik II – c Guido Rößling
Zahlendarstellung – Natürliche Zahlen : Oktalzahlen
2.9
Hexadezimalzahlen
❑ Hexadezimalzahlen stellen die Zahlen zur Basis 16 dar.
☞ Es werden die Zeichen 0 bis 9 sowie A, B, C, D, E, F verwendet
☞ Keine Unterscheidung zwischen Groß- und Kleinschreibung von A - F
❑ Die Buchstaben besitzen gemäß Folie 2.2 die Wertigkeit
A=10, B=11, C=12, D=13, E=14, F=15
❑ Die Zahl kann direkt durch das Horner-Schema ausgewertet werden
☞ Setze b = 16
❑ Der auf Folie 2.8 angegebene Algorithmus kann für die Umrechnung von Dezimalzahlen
in Hexadezimalzahlen verwendet werden
☞ Setze b = 16
Informatik II – c Guido Rößling
Zahlendarstellung – Natürliche Zahlen : Hexadezimalzahlen
2.10
Verwendung von Hexadezimalzahlen
❑ Binärzahlen haben eine sehr große Länge (z.B. 32 Bit)
☞ Verwendung von Hexadezimalzahlen
❑ Für die Anzeige von Hexadezimalzahlen ist keine Auswertung der Binärzahl erforderlich,
wie dies bei dezimaler Darstellung der Fall ist.
❑ Hexadezimalzahlen können durch einfache Gruppierung der Einzelstellen aus Binärzahlen gewonnen werden.
☞ Jeweils vier Binärstellen entsprechen – von rechts nach links gruppiert – einer
Hexadezimalstelle.
AA AhA 3hk
3k
3*#%d$&^ mi Kl Kl a"
❑ Beispiel:
Informatik II – c Guido Rößling
Zahlendarstellung – Natürliche Zahlen : Hexadezimalzahlen
2.11
Darstellung von ganzen Zahlen
❑ Um den Bereich der ganzen Zahlen abzudecken, langt es, die natürlichen Zahlen um ein
Vorzeichen zu erweitern (vgl. BNF in Informatik I).
\
❑ Hierfür wird einfach die höchstwertigste Stelle, d.h. üblicherweise 5on U 5 oder 5 p , für das
Vorzeichen reserviert
;
Stellen zur Verfügung
☞ für den Wert der Zahl stehen nur noch Z
❑ Bei negativen Zahlen ist das Vorzeichenbit b - 1, sonst 0.
❑ Im folgenden wird unterstellt, daß die Zahlenbasis immer 2 ist
☞ Das Vorzeichen ist also 0 (positive Zahl) oder 1 (negative Zahl)
❑ Der einfachste Ansatz ist die Vorzeichen-Absolutbetrag Darstellung
;
☞ Codiere den Betrag der Zahl in den untersten Z
Bit
☞ Setze das Vorzeichenbit auf 0 (positiv) oder 1 (negativ)
;
( ?@ &_ ( ?@
ts
U
Z
❑ Bei Bit zur Verfügung sind damit alle Zahlen von qrZ
darstellbar
☞ die 0 besitzt dabei zwei Darstellungen: 000 0 ( +0“) und 100 0 ( -0“)
”
”
Zahlendarstellung – Ganze Zahlen
Informatik II – c Guido Rößling
2.12
Auswertung mit dem Horner-Schema
Die Auswertung von Zahlen in Vorzeichen-Absolutbetrag-Darstellung kann durch ein modifiziertes Horner-Schema erfolgen:
;O> (
1. Setze i = n - 3, wenn die Zahl
Stellen hat, d.h. als 5%?@ 5 " vorliegt.
2. Setze value = 5A?@ #
3. Setze value = value 2 + 5
4. Setze i = i - 1
>
0, fahre fort mit Schritt 3
5. Falls i
6. Falls 5%?@ == 1, setze value = - value
7. value enthält den Wert der in a abgelegten Zahl als Dezimalzahl.
Informatik II – c Guido Rößling
Zahlendarstellung – Ganze Zahlen : Vorzeichen-Absolutbetrag
2.13
Zahlenkreis für Vorzeichen-Absolutbetrag
Die Zahlen sind bei Vorzeichen-Absolutbetrag-Darstellung wie folgt angeordnet:
1111
-7
0000
0
0001
1
1110
-6
0010
2
0011
3
1101
-5
0100
4
1100
-4
0101
5
1011
-3
0110
6
1010
-2
1001
-1
1000
-0
0111
7
Abbildung 1: Zahlenkreis für Vorzeichen-Absolutbetrag Darstellung
Informatik II – c Guido Rößling
Zahlendarstellung – Ganze Zahlen : Vorzeichen-Absolutbetrag
2.14
Nachteile Vorzeichen-Absolutbetrag-Darstellung
Diese einfache Art der Darstellung hat leider ein paar Nachteile:
❑ Die 0 existiert als (+)0“ und als -0“, hat also keine eindeutige Codierung.
”
”
❑ Zur Subtraktion muß die betragsmäßig kleinere Zahl von der größeren abgezogen werden.
☞ Das Vorzeichen wird von der größeren Zahl übernommen.
☞ Anstatt also a-b zu rechnen, ist a + (-b) bzw. zu rechnen, was zusätzlichen
Aufwand verursacht.
☞ Um diese Nachteile zu umgehen, wird eine andere Art der Darstellung gewählt:
das Zweierkomplement
Informatik II – c Guido Rößling
Zahlendarstellung – Ganze Zahlen : Vorzeichen-Absolutbetrag
2.15
Zweierkomplement
❑ Positive Zahlen werden wie gewohnt codiert.
;
❑ Für negative Zahlen wird die -Bit-Darstellung des Betrags der Zahl invertiert, d.h. die
Nullen und Einsen vertauscht, und anschließend 1 addiert.
❑ Die Formel für die Bestimmung der Darstellung einer Zahl u lautet also
&^
Z*u u
☞ u steht dabei für die bitweise Invertierung von u
❑ Die Formel gilt unabhängig vom Vorzeichen von u , d.h.
☞ zum Konvertieren von Positiv nach Negativ
☞ zum Konvertieren von Negativ nach Positiv
❑ Beispiel:
v
A
K" =
v
A
Z K" =
Informatik II – c Guido Rößling
v
&_
A
=
☞ Z K" =
v
A _
& A
K" =
=
☞
Zahlendarstellung – Ganze Zahlen : Zweierkomplement (K2)
2.16
Auswertung mit Horner-Schema
Die Auswertung von Zahlen im Zweierkomplement kann mit einem modifizierten HornerSchema erfolgen:
1. Setze i = n - 3, wenn die Zahl
2. Setze value = 5A?@ #
3. Setze value = value b + 5
;O>
(
Stellen hat, d.h. als 5 ?@
5 " vorliegt.
4. Setze i = i - 1
>
0, fahre fort mit Schritt 3
5. Falls i
( ?@
%
5
?
@
w
6. Falls
, setze value = value 7. value enthält den Wert der in a abgelegten Zahl als Dezimalzahl.
Informatik II – c Guido Rößling
Zahlendarstellung – Ganze Zahlen : Zweierkomplement (K2)
2.17
Zahlenkreis für Zweierkomplement
Die Anordnung der Zahlen beim Zweierkomplement kann man dem folgenden Zahlenkreis
für vierstellige Binärzahlen entnehmen:
0000
0
1111
-1
0001
1
1110
-2
0010
2
0011
3
1101
-3
1100
-4
0100
4
1011
-5
0101
5
1010
-6
0110
6
1001
-7
1000
-8
0111
7
Abbildung 2: Zahlenkreis für Zweierkomplement-Darstellung
Informatik II – c Guido Rößling
Zahlendarstellung – Ganze Zahlen : Zweierkomplement (K2)
2.18
Vorteile des Zweierkomplements
❑ Es gibt nur eine Darstellung der 0
☞ jede darstellbare Zahl ist eindeutig
❑ der Bereich der negativen Zahlen ist um eins größer als der der positiven Zahlen (bei
Ausblendung der 0)
;
( ?@ ( ?@
s
darstellbar
☞ bei Bit sind alle Zahlen des Intervalls qrZ
U
Z
❑ Addition und Subtraktion erfolgen nach Schulmethode“
”
☞ die Bits werden stellenweise von rechts nach links addiert bzw. subtrahiert
❑ Rechenregeln für Bits 5 Ut sowie Übertrag x (engl. Carry):
☞ Eine hochgestellte 1 in der letzten Zeile gibt einen Übertrag bzw. Borgen“ an
”
0 0 0 0 1 1 1 1
0 0 0 0 1 1 1 1
BDz y
BDz y
y
y
0 0 1 1 0 0 1 1
0 0 1 1 0 0 1 1
{y
{
y
I H I H I H I H
I H I H I H I H
z
z
{
{
BDy1| y1| y 0 1 1 } 0 1 } 0 } 0 } 1
By~ y~ y 0 } 1 } 1 } 0 1 0 0 } 1
Tabelle 2: Rechenregeln für Addition und Subtraktion im Zweierkomplement
Informatik II – c Guido Rößling
Zahlendarstellung – Ganze Zahlen : Zweierkomplement (K2)
2.19
Anmerkung zu den Rechenregeln
❑ Die Rechnung erfolgt von rechts nach links und endet nach Bearbeitung des Vorzeichenbits.
☞ Das Vorzeichenbit wird normal mitgerechnet, als ob es eine Wertigkeit hätte
❑ Tritt dabei ein Überlauf aus dem Vorzeichenbit auf, so ist das Ergebnis nur in den folgenden Fällen korrekt:
☞ Addition: 5%?@ ?@ , d.h. Addition einer negativen mit einer positiven Zahl;
☞ Subtraktion: 5%?@ ?@ , d.h. Subtraktion von zwei Zahlen mit gleichem Vorzeichen
❑ In allen anderen Fällen handelt es sich um eine Über- bzw. Unterschreitung des Bereichs
der darstellbaren Zahlen (engl. Overflow bzw. Underflow)
;
v
.
. &M3 A &)AA A K"
gilt z.B. K"
☞ für Z K" .
Informatik II – c Guido Rößling
Zahlendarstellung – Ganze Zahlen : Rechenregeln Zweierkomplement
2.20
Gleitpunktzahlen – Motivation
❑ Neben natürlichen und ganzen Zahlen treten Gleitpunktzahlen auf, d.h. Zahlen mit Nachkommaanteil sowie ggf. einem Exponenten
☞ der Exponent gibt dabei die Verschiebung der Zahl auf dem Zahlenstrahl um
eine Potenz der Zahlenbasis an
❑ Die typische Notation dieser Zahlen
ist vom Taschenrechner bekannt:
G
d d v ,(*#A @ T
(Gravitationskonstante, in €-‚Lƒ G )
❑ Jede Gleitpunktzahl besteht aus
☞ dem Vorzeichen der Zahl
☞ der Mantisse, d.h. den Wert der Zahl
☞ sowie dem Exponent, der die Verschiebung des Wertes um (Zweier-)Potenzen angibt.
❑ Für die Gravitationskonstante ergibt sich somit
Vorzeichen Mantisse Exponent
#
@ T
(+)
6.6732
Informatik II – c Guido Rößling
Zahlendarstellung – Gleitpunktzahlen nach IEEE Standard
2.21
Anforderungen an Gleitpunktzahlen
❑ Es sollen möglichst viele Zahlen darstellbar sein
❑ Es gibt zwei Vorzeichen
☞ Vorzeichen der Mantisse (und damit der Zahl!)
☞ Vorzeichen des Exponenten
❑ Für jede darstellbare Zahl soll nur genau eine Darstellung existieren.
Erfüllung dieser Forderungen durch ❑ Verwendung einer hinreichend großen Anzahl Bits für die Codierung
☞ 32 bzw. 64 Bit für die Datentypen float bzw. double
❑ Reserviere ein Bit für das Vorzeichen der Zahl
❑ Garantie der Eindeutigkeit durch eine normierte Darstellung
Informatik II – c Guido Rößling
Zahlendarstellung – Gleitpunktzahlen nach IEEE Standard : Anforderungen
2.22
Der ANSI-IEEE Standard 754-1985
Die plattformunabhängige Darstellung einer Zahl u als 32-Bit Gleitpunktzahl ist wie folgt:
1. Finde Zahlen „/…† mit ‡ˆ‰‡ Š‹‰Œ „Ž‘’ (normierte Darstellung) mit “•”–„
—
‹
2. Codiere das Vorzeichen wie gewohnt: 0 für positiv, 1 für negativ.
3. Codiere die Mantisse „ in 23 Bit
☞ das vorderste Bit hat Wertigkeit ‘J˜š™ , das letzte Bit Wertigkeit ‘J˜o›œ
Falls die Zahl nicht exakt codierbar ist, wähle die der Zahl „ nächstgelegene
mögliche Codierung.
4. Codiere den Exponenten † in 8 Bit als natürliche Zahl †ž mit Wert †ž † Œ^‹ ‘Ÿ .
Die Werte †ž “ und †ž ‘ sind dabei Sonderfälle
5. Ordne die Bits in der Reihenfolge Vorzeichen Exponent Mantisse an.
Abbildung 3: Vorgehen zur Berechnung einer Gleitpunktdarstellung
64-Bit Gleitpunktzahlen (double) bestehen aus 11 Bit Exponent und 52 Bit Mantisse.
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Gleitpunktzahlen nach IEEE Standard : Definition
2.23
Beispiel zur Gleitpunktdarstellung
Betrachten wir die Darstellung der Zahl -3.5:
£ ¥r ‹ §¥ Ÿ *‘ 1. Es gilt ‡¢¤£¥r ¦‡ ☞ Setze „ “ ¥§Ÿ …t† ¨‹
Š‹‰Œ “¥§Ÿ '‘ ™ .
2. Die Zahl ist negativ; das Vorzeichenbit ist also 1.
3. Für „ “¥§Ÿ gilt “¥§Ÿ “¥r Œ “¥©‘ ‘J˜š™ Œ ‘J˜o› .
☞ Die Codierung der Mantisse „ lautet also ‹ ‹ h
“ ““““ª““““h““““ª““““]““““
4. Für † ‹ ist der Exponent als †ž ‹«Œ_‹ ‘Ÿ ‹ ‘¬ ¨‹ “ ““ª““““ zu codieren.
›
5. Das Ergebnis ist also die Zahl
Mantisse
Vorzeichen Exponent †ž
1 100 0000 0 110 0000 0000 0000 0000 0000
☞ Der Hexadezimalwert der Zahl ist also C0600000
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Gleitpunktzahlen nach IEEE Standard : Beispiel
2.24
Auswertung mit modifizierten Horner-Schema
1. Berechne den Wert des normierten Exponenten e’ mittels dem Horner-Schema
2. Setze † † ž ¢ ‹ ‘Ÿ
3. Setze i = 1 für das vorletzte Bit der Mantisse „
4. Setze value = „¯­
›T›
¥¥¥p„
™
„®­
5. Setze value = value  ™ Œ „±°
›
6. Setze i = i + 1
7. Falls i ”
22, fahre fort mit Schritt 5
8. Setze value = value  ™
›
9. Falls ²
== 1, setze vz = -1, sonst vz = 1
œp™
10. Der Wert der Zahl ² ist dann vz  TŠ ‹«Œ value '‘ ’
Beachten Sie die Sonderfälle für e’=0 und e’=255 auf der nächsten Folie.
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Gleitpunktzahlen nach IEEE Standard : Auswertung
2.25
Sonderfälle der Darstellung
❑ Für den Exponenten sind folgende Fälle zu unterscheiden:
Exponent
-127
Codierung Exponent ³L´
00000000
-127
00000000
-126 ÁÂÁÂÁ 127 00000001 ÁÂÁÃÁ 11111110
128
11111111
128
11111111
Mantissenwert µ
0
¸· 0
µ
0
¸· 0
Interpretation
¶ 0
0.µº¹W»t¼½¿¾¿À
ÄWÁŵº¹W»ÃÆ
¶«Ç
NaN
Tabelle 3: Fallunterscheidung für Exponent bei IEEE-Standard
­
❑ NaN steht für Not a Number“ und markiert Rechenfehler, z.B. ­ oder È ¢ ‹
”
☞ Statt eines Division by Zero Error könnte die Berechnung (und ggf.
das Programm!) fortgesetzt werden, wobei das Ergebnis ignoriert werden muß
❑ Die Mantissenbits bei NaN sind beliebig (mindestens eines muß aber 1 sein)
☞ die NaN kann zusätzliche Informationen enthalten
❑ É ist reserviert für Ergebnisse wie tan Ê“Ë sowie für Ergebnisse, die größer bzw. kleiner
als die größte bzw. kleinste darstellbare Zahl sind.
¡
Zahlendarstellung – Gleitpunktzahlen nach IEEE Standard : Sonderfälle
2.26
Informatik II – c Guido Rößling
Vorteile der Darstellung
❑ Die Normierung stellt sicher, daß jede Gleitpunktzahl nur auf genau eine Art codiert werden kann.
☞ eindeutige Darstellung
❑ Normalerweise kann man die Zahl 8 beispielsweise wie folgt angeben:
¥¥¥…t£‘4‘ ˜o› … ‹Ì ‘ ˜š™ …W¬4‘ ­ …ÃÍ0‘ ™ …t‘4‘ › … ‹ ‘ œ …¥¥¥
☞ Der Vergleich zweier Zahlen wäre schwierig, da sie erst in eine einheitliche
Darstellung – d.h. den gleichen Exponenten – gebracht werden müßten
❑ Es werden keine Bits verschenkt“
”
❑ Rechenfehler (codiert als NaN) können durch die Mantissencodierung genauer spezifiziert
werden
☞ Die Codierung der Mantissenbits ist Sache des Betriebssystems oder Programms und nicht Bestandteil des IEEE-Standards!
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Gleitpunktzahlen nach IEEE Standard : Vor- und Nachteile
2.27
Nachteile der Darstellung
❑ Die Zahlen des Zahlenstrahls sind ungleich verteilt
☞ je kleiner der Absolutbetrag, desto genauer ist die Darstellung
☞ je größer der Absolutbetrag, desto größer sind die Sprünge, da entsprechend
auch die Wertigkeit des letzten Bits der Mantisse wächst
❑ Nicht jede Zahl des Intervalls ist tatsächlich darstellbar.
☞ z.B. Ì £ Ì ¥r““£Ê“ Ì ‘ ‘!™KÎ Œ ™ (warum?)
›TϝÎ
❑ Rechnungen mit nicht darstellbarem Ergebnis liefern ein inkorrektes (ungenaues) Ergebnis.
☞ ‘ ›ÑÐ Œ_‹ª ‘ ›ÑÐ , da Zahl ‘ ›ÑÐ Œ_‹ nicht darstellbar ist
❑ Bei Rechnungen müssen die Zahlen zunächst angeglichen werden.
☞ Hinausschieben von Bits aus der Mantisse kann zu Rechenfehlern führen
☞ Das Ergebnis der Rechnung ist u.U. nicht normiert, so daß erneut normiert werden muß
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Gleitpunktzahlen nach IEEE Standard : Vor- und Nachteile
2.28
Vergleich von zwei Gleitpunktzahlen
1. Ist das Vorzeichen der beiden Zahlen verschieden, so ist die Zahl mit Vorzeichen 1
kleiner als die andere – fertig.
2. Sind die Exponenten verschieden, so ist die Zahl mit kleinerem Exponenten kleiner
als die andere – fertig.
3. Andernfalls ist die Zahl mit kleinerer Mantisse kleiner.
❑ Die Vergleiche können bitweise durchgeführt werden
☞ mit Ausnahme des Vorzeichens ist die kleinere Zahl diejenige, bei der an der
ersten unterschiedlichen Bitposition eine 0 steht
❑ Aufgrund von Rechenungenauigkeiten sowie nicht exakt darstellbaren Zahlen sollte ein
Vergleich auf Identität bei Gleitpunktzahlen in der Regel durch einen Vergleich auf Abweichung kleiner als Ò für ein geeignetes Ò ersetzt werden.
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Gleitpunktzahlen nach IEEE Standard : Vergleich von Gleitpunktzahlen
2.29
Motivation zur Fehlerfortpflanzung
❑ Computer bzw. die auf ihnen laufenden Algorithmen liefern zwar in der Regel relativ
schnell das Ergebnis einer Rechnung, aber dieses Ergebnis ist nicht unbedingt korrekt.
❑ Zu den Fehlergründen zählen
☞ Aspekte, die der jeweilige Programmierer zu verantworten hat
☞ z.B. Nachlässigkeit oder Ignorieren von Sonderfällen
☞ Fehler der Benutzungsoberfläche oder der Laufzeitumgebung
☞ sowie spezifische Hardware-Probleme, wie etwa der Pentium FDIV-Bug oder durch
Überhitzung oder Materialermüdung verursachte Effekte.
❑ Zusätzlich gibt es systemimmanente Fehler, die sich prinzipiell nicht vermeiden lassen.
Diese treten insbesondere bei der Rechnung mit Gleitpunktzahlen zutage und sollen im
folgenden näher betrachtet werden.
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Fehlerfortpflanzung
2.30
Der Intel Pentium FDIV-Bug
❑ 1994/1995 wurde ein Herstellungsfehler bei der Produktion des Intel Pentium Prozessors
publik
❑ In der Divisionstabelle der Gleitkommarecheneinheit waren einige Einträge inkorrekt
❑ Der Fehler wirkte sich bei einigen Gleitpunktdivisionen aus (Befehl: fdiv, daher der Name)
❑ Folge: bestimmte Divisionen ergaben ein falsches Ergebnis, z.B. (1 / a)  a Ô Ó 1
für bestimmte Gleitpunktzahlen ² , z.B. ² Ô £‘‘ ‹ ‘‘ÍJ£‘£¥r“
❑ Intel spielte die Relevanz des Fehlers zunächst herunter ( tritt praktisch nie auf“)
”
❑ Bei wachsendem Druck der Medien und der Öffentlichkeit wurde der Fehler in der nächsten
Herstellungsphase beseitigt und einige Prozessoren ersetzt
❑ Das Image der Firma Intel erlitt dabei einige Schrammen
❑ Es entstanden zahlreiche Witze“ über den Bug
”
❑ Solche Herstellungsfehler sind allerdings alles andere als ungewöhnlich
☞ Erst das Verhalten von Intel provozierte den eigentlichen Skandal
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Fehlerfortpflanzung
2.31
Fehlerquellen bei Gleitpunktzahlarithmetik
Typische Fehlerquellen bei Verwendung von Gleitpunktzahlen sind
❑ Ausführung einer nicht-rationalen Operation, etwa È ˆ , Nullstellenberechnung oder
transzendente Funktionen wie Sinus und Logarithmus.
☞ Diese Operationen müssen durch rationale Operationen approximiert werden,
wobei ein Fehler entstehen kann
❑ Aus mathematischer Sicht beliebig große Zahlen müssen im Rechner durch Zahlen fester
Länge repräsentiert werden.
☞ Es sind nicht alle Zahlen (exakt) darstellbar ☞ Darstellungsfehler
❑ Bei Berechnungen können nicht darstellbare Zwischenergebnisse entstehen
☞ es muß mit einem inkorrekten oder ungenauen Zwischenergebnis weitergerechnet werden: der Fehler pflanzt sich fort
Dieser Fall wird im folgenden betrachtet.
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Fehlerfortpflanzung : Fehlerquellen
2.32
Fehlertypen
❑ Rechenfehler:
☞ Implementierung Õ der Operation Ö
☞ sowie die Anwendung des Algorithmus auf Daten mit möglichen Darstellungsfehlern
Aus Ö Š ˆ× wird somit Õ Š ˆšžØ ; der Rechenfehler beträgt ‡ÅÕ Š ˆÙž§Ú¢^Ö Š ˆ×1‡ .
Beispiele: Funktionsannäherung durch eine Taylor-Reihenentwicklung;
Rechnungen mit (einer Approximation von) Û .
❑ Verfahrensfehler
☞ Die Operation Ö wird durch einen numerischen Algorithmus Õ approximiert
☞ Der entstehende Fehler beträgt ‡ÅÕ Š ˆÜÚ¢_Ö Š ˆÜ‡
❑ Datenfehlereffekte
☞ Idealisierende Annahmen führen dazu, daß die Daten ˆšž nur eine ungenaue Modellierung der Daten ˆ sind
☞ Fehler ‡©Ö Š ˆšžØÙ¢ÝÖ Š ˆ×1‡ ist schwer zu messen, da die wahren“ Daten ˆ bzw. Ö Š ˆ×
”
möglicherweise teilweise nicht oder nicht exakt definierbar sind
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Fehlerfortpflanzung : Fehlertypen
2.33
Absoluter Fehler
❑ Absoluter Fehler: Messen der absoluten Differenz zwischen ˆ und ˆ ž Ô ˆ Œ)Þß … 1Þ ßYà IR
❑ Ausführen Operation op auf den mit absoluten Fehlern behafteten Zahlen ˆÙž Ô ˆ Œ^Þ
™
™
™
und ˆÙž Ô ˆ ŒMÞ
›
›
›
❑ Absolute Fehler ist Differenz des Rechenergebnisses zum eigentlichen Rechenergebnis
ŠŠ ˆ Œ)Þ 
Š Œ)Þ L‡
❑ Der Fehler kann also bestimmt werden als ‡ Š ˆ
™âáä㠈 › Ú¢
™
™ áä㠈 ›
›
❑ Damit ergibt sich:
Operation
Addition
Subtraktion
Multiplikation
Division
Absoluter Fehler
Þ Œ)Þ
Þ ™ ¢ ޛ
™
›
ˆ  Þ Œ ˆ  Þ Œ)Þ  Þ
™ ›
›
™
™ ›
Š ˆ  Þ ¢ºˆ  Þ æå Š ˆ  Š ˆ ŒMÞ L
™ ›
›
™
›
›
›
Tabelle 4: Absolute Fehler bei Operationen mit Gleitpunktzahlen
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Fehlerfortpflanzung : Absoluter Fehler
2.34
Relativer Fehler
❑ Relative Fehler setzen die Abweichung ins Verhältnis zum Wert
☞ eine Abweichung von 1 bei einem Wert von 20 ist etwas völlig anderes als bei
einem Wert von ‘ ›œ
❑ ˆ wird daher dargestellt als ˆç Š‹«Œ)Þ 
☞ Der relative Fehler Þ mißt daher gleichzeitig die prozentuale Abweichung
❑ Beispiel:
☞ Für ˆ Ô ‘ “…Èٞ Ô ‘ ‹ gilt: ‘ ‹ªÔ ‘“* Š‹‰Œ)Þ  ☞ ÞèÔ ™ ­
›
☞ relativer Fehler von “¥r“ (d.h. Abweichung von 5%)
☞ Für ˆ Ô ‘ ›œ , ˆÙž Ô ‘›œ Œ_‹ gilt hingegen: ‘›œ Œ^‹]Ô ‘›œé Š‹«ŒMÞ  ☞ Þ0Ô ‘J˜o›œ
❑ Andererseits gilt
☞ Für ˆ Ô £…È ž Ô Í gilt: Í Ô £4 ŠT‹êŒMÞ  ☞ ÞèÔ ™ sowie
œ ­
­
­
­
☞ Bei ˆ Ô £* ‹ “!™ …pˆÙž Ô Í0 ‹ “!™ gilt ebenfalls Íë ‹ “!™ Ô £* ‹ “!™  Š‹«ŒMÞ 
­
­
☞ ÞèÔ ™ , denn ™ £* ‹ “!™ Ô ‹ “!™ .
œ
œ
Der relative Fehler ist also unabhängig vom Exponenten der betrachteten Zahlen.
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Fehlerfortpflanzung : Relativer Fehler
2.35
Effekte des Rundens
❑ Besitzt die Darstellung einer Gleitpunktzahl mehr als die „ Stellen der Mantisse, muß die
Zahl entsprechend auf die Stellenzahl „ verkürzt werden.
☞ Truncate ( Abschneidung“) übernimmt von der Zahl die ersten „ Bit in der Mantisse.
”
☞ Round (Rundung) wählt das niederwertigste Bit ²%ì der Mantisse gemäß einer mathematischen Rundung
☞ Falls ²AìÚí ÔwÔ ‹ , setze addiere 1 zu ²Aì
™
ì
❑ Die Wertigkeit des niederwertigsten Bits ²Aì der Mantisse ist ‘J˜
ï
ì
‘ ˜ °)
☞ relativer Fehler bei Truncate: Þ —–‘ ˜ (präzise: î
°8ð ì'í ™
Ô
^
Œ
‹
Der Fehler ist maximal für ²Aì
“ªñóòÜôgõ„
¥¥¥É¨¥ Š ² ° Ô ‹  .
ì
ì
☞ relativer Fehler bei Round: Þ ” ™ ‘ ˜ Ô ‘ ˜ ˜š™ .
›
ìÚí
Der Fehler ist maximal für ² ì Ô “*ñö² ìÚí Ô ‹ , wo er durch Aufrundung um ‘ ˜š÷ ™aø
™
entsteht.
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Fehlerfortpflanzung : Relativer Fehler
2.36
Relativer Fehler bei Addition
Bei der Addition von Gleitpunktzahlen kann sich der relative Fehler wie folgt fortpflanzen:
❑ relativer Fehler Þ
mit ˆšž Ô ˆ  Š‹‰Œ)Þ 
™
™
™
Þ
Ô
Š
‰
‹
)
Œ
Þ
ˆ 

❑ relativer Fehler der Zahl ˆ mit ˆ ž
›
›
›
›
›
❑ Rundungsfehler Þ bei der Addition
œ
☞ Š ˆšž Œ ˆšž ' ŠT‹«Œ)Þ  Ô Š ˆ  Š‹«Œ)Þ  Œ ˆ  Š‹‰Œ)Þ L ŠT‹«ŒMÞ 
œ
™
™
›
›
œ
™
›
Þ
Þ
Þ
❑ Unter der Annahme ‡ ‡8…‡ ‡8…‡ ‡æ”–Ò gilt
™
›
œ
Š ˆÙž Œ ˆšž ' Š‹‰ŒMÞ  Ô Š ˆ  ŠT‹«Œ)Þ  Œ ˆ  ŠT‹êŒMÞ L' Š‹‰ŒMÞ 
œ
™
™
›
›
œ
™
›
” ‡ùˆ  ŠT‹«Œ ÒJ Œ ˆ  Š‹‰Œ ÒJâ‡úæ‡ ‹‰Œ Қ‡
Ô ‡ùˆ ™ Œ ˆ ‡ú Š‹‰Œ ÒJ›  ›
û ‡ùˆ ™ Œ ˆ › ‡ú Š‹‰Œ ‘4ÒJ
™
›
☞ Ò › kann bei Ò û “ vernachlässigt werden
™
der Zahl ˆ
™
Der relative Fehler bei Addition kann bis zum doppelten der relativen Fehler der Operanden
anwachsen.
¡
Zahlendarstellung – Fehlerfortpflanzung : Relativer Fehler
2.37
Informatik II – c Guido Rößling
Relativer Fehler bei Subtraktion
❑ Bei der Subtraktion wie auch der Addition von Zahlen mit verschiedenem Vorzeichen gilt
die folgende Beziehung, wenn wieder ‡ Þ ‡8…‡ Þ ‡8…ú‡ Þ ‡o”–Ò gilt:
™
›
œ
Šˆ ž º
¢ ˆ ž ' ŠT‹«ŒMÞ  Ô Š ˆ  ŠT‹«Œ)Þ Ú¢ºˆ  Š‹‰ŒºÞ LÚ Š‹«Œ)Þ 
œ
™
™
›
›
œ
™
›
Ô
Œ
ˆ
Ò (Unterschied nur durch Rundungsfehler)
❑ Schlimmster Fall: ˆ
™
›
‡ Š ˆ  Š‹«Œ)Þ Ú¢üˆ  Š‹«ŒMÞ L' Š‹«ŒMÞ â‡
nächster Schritt
™ Ô
›
œ Š‹‰ŒMÞ
Š‡ ˆ ™ ¢üˆ Œ › ˆ  Þ ¢º
Þ
ˆ  
Ü‡
ˆ Ô ˆ Œ Òo…týóþ!†ô†ÿ×ÕÂ¥
™
›
™
™
›
›
œ
™
›
” Š ‡ˆ ¢ºˆ ‡ Œ ‡ Š ˆ Œ ÒJ' Þ ‡ Œ ‡ˆ  Þ ‡ 'æ‡ ‹«Œ)Þ ‡
ò×ôfõ ‹ ¥¥¥t£¥ Š ‡ Þ ° ‡æ”–ÒJ
™
›
›
™
› ›
œ
” Š ‡ˆ ™ ¢ºˆ › ‡ Œ ‡ Š ˆ › Œ ÒJ'Òš‡ Œ ‡ùˆ › Òš‡ ' Š‹«Œ ÒJÜ‡
Y„öÖ þú„¯
† á
Œ
Œ
Š
‰
‹
Œ
” ‡ùˆ ¢ºˆ ‡ ‘*æ‡ˆ Òš‡ Ò › 
ÒJ-‡
nach Def. ˆ ¢ºˆ Ô Ò
™
›
›
™
›
Ô ‡ùˆ ¢)ˆ ‡ú Š‹‰Œ ‘*æ‡ˆ ‡ Œ ÒJ' Š‹‰Œ ÒJâ‡
ÿ ² ×Õ
û ‡ùˆ ™ ¢)ˆ › ‡ú Š‹‰Œ ‘*æ‡ˆ › ‡ 
™
›
›
Der relative Fehler kann hier also bis zum zweifachen Betrag des Operanden anwachsen.
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Fehlerfortpflanzung : Relativer Fehler
2.38
Relativer Fehler bei Multiplikation
Mit den üblichen Annahmen gilt
Š ˆšž  ˆšž ' ŠT‹«ŒMÞ  Ô
œ
™
›
”
û
Šˆ
 Š ‹«Œ)Þ '
  Š ˆ  ŠT‹êŒMÞ L' Š‹«ŒMÞ L
™
›
›
œ
ˆ  ˆ  ŠT‹êŒ JÒ  œ
™
›
ˆ  ˆ  TŠ ‹êŒ *
£ ÒJ
™
›
™
☞ Der relative Fehler kann sich folglich maximal verdreifachen
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Fehlerfortpflanzung : Relativer Fehler
2.39
Relativer Fehler bei Division
❑ Analog zur Multiplikation gilt
Š ˆ ž å ˆ ž ' Š‹«Œ)Þ  Ô Š ˆ  Š‹‰Œ)Þ æå Š ˆ  Š‹‰ŒMÞ LL' Š‹‰ŒMÞ 
œ
™
™
›
›
œ
™ ›
Þ
Þ
Þ
“ … —j“…
“ .
❑ Der ungünstigste Fall entsteht für
™ ›
œ
❑ Mit der üblichen Beschränkung von Þ ° auf Ò gilt
ß
Š ˆ ž åˆ ž ' Š‹‰ŒºÞ  Ô ß ½ æ‡ ŠT‹«Œ)Þ ¦å Š‹‰Œ)Þ  Š‹‰ŒMÞ â‡
œ
›
œ
ß¾
™ ›
í ™
” ß ½ æ‡ ÷ ™ ø  Š‹‰Œ ÒJÜ‡
˜ Œ
û ßß ¾½ æ‡ ŠT™‹«
Ô ÷ ™ í ø û ²• Š‹«Œ ÒJ
œ
J
Ò

‡
™˜
™˜ ¾
û ßß ¾½  Š‹‰Œ £*ÒJ
¾
☞ Der relative Fehler kann sich also auch hier maximal verdreifachen
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Fehlerfortpflanzung : Relativer Fehler
2.40
Ergebnis
❑ Die insbesondere bei der Verwendung von Gleitpunktzahlen auftretenden Fehler können
in vielen Anwendungen nicht ignoriert werden.
❑ Tabelle 5 faßt die Ergebnisse nochmals zusammen.
Operation
Addition
Subtraktion
Multiplikation
Division
absoluter Fehler
Þ Œ)Þ
Þ ™ ¢ ޛ
™
›
ˆ  Þ Œ ˆ  Þ Œ)Þ  Þ
™ ›
›
™
™ ›
Š ˆ  Þ ¢ºˆ  Þ ¦å Š ˆ  Š ˆ ŒºÞ L
™ ›
›
™
›
›
›
relativer Fehler
‘4Ò
‘4æ‡ùˆ ‡
›
£4Ò
£4Ò
Tabelle 5: Zusammenfassung der Fehlerfortpflanzungsfehler
¡
Informatik II – c Guido Rößling
Zahlendarstellung – Ergebnis
2.41
¡
Informatik II – c Guido Rößling
Zahlendarstellung
Kryptologie
Graphentheorie
Graphenalgorithmen
Suchalgorithmen
Suche in Zeichenfolgen
Sortieralgorithmen
Hashing
Kompressionsverfahren
Primitive Datentypen
Listenstrukturen
Bäume
Sonstige Datentypen
Einleitung
Zahlendarstellung
Wo sind wir ¥¥¥ ?
2.42
Motivation der Datenstrukturen
❑ Computer arbeiten nur mit Zahlen sowie logischen Werten.
❑ Um Objekte sowie Operationen darauf zu repräsentieren, sind daher folgende Schritte
erforderlich:
1. geeignete Modellierung, etwa durch Klassen in einer objektorientierten Programmiersprache,
2. Speicherung und Verwaltung der Objekte in einer geeigneten Datenstruktur
☞ möglichst problemangepaßt
☞ einfacher, geeigneter“ Zugriff
”
3. Implementierung von Algorithmen auf den Datenstrukturen zur Erzielung spezieller Effekte
❑ In diesem Abschnitt werden die grundlegenden Datenstrukturen vorgestellt, die in der
täglichen Arbeit oft auftreten.
¡
Informatik II – c Guido Rößling
Datenstrukturen – Motivation
3.1
Was ist zu beachten?
❑ Für praktisch jedes Problem gibt es eine angepaßte Datenstruktur.
☞ Die Kunst besteht darin, die für die Erreichung des Ziels beste Datenstruktur zu
erkennen!
❑ Datenstrukturen unterscheiden sich in
☞ Zugriff auf die Elemente,
☞ Möglichkeiten des Einfügens und Löschens von Elementen,
☞ Navigieren innerhalb der Daten (optional),
☞ Anordnung der Elemente
☞ Speicherbedarf der Datenstruktur sowie
☞ der Komplexität der Operationen.
☞ Es gibt nicht die Datenstruktur schlechthin; in jedem einzelnen Fall ist zu
prüfen, welche Datenstruktur verwendet werden sollte
¡
Informatik II – c Guido Rößling
Datenstrukturen – Motivation
3.2
Betrachtete Datenstrukturen
Die folgenden Datenstrukturen werden vorgestellt:
❑ Array (Feld) ab Folie 3.10
❑ Verkettete Liste ab Folie 4.1 sowie Doppelt verkettete Liste ab Folie 4.14
❑ Stack (Kellerspeicher) ab Folie 4.29 sowie Queue (Warteschlange) ab Folie 4.37
❑ Allgemeiner Baum mit den Untertypen Binärer Baum, Binärer Suchbaum, AVL-Baum und
B-Baum ab Folie 5.1
❑ Priority Queue (Prioritätswarteschlangen) ab Folie 5.29
❑ Set (Menge) und Bag ( Sack“) ab Folie 6.1
”
❑ sowie File (Datei) ab Folie 6.6
¡
Informatik II – c Guido Rößling
Datenstrukturen – Motivation
3.3
Primitive Datentypen
In Java gibt es folgende primitiven Datentypen:
Datentyp Beschreibung
Standardwert
false
’ ! u0000’
0
0
Wertebereich
boolean
char
byte
short
Wahrheitswerte
16-Bit Unicode Zeichen
8-Bit Ganzzahl
16-Bit Ganzzahl
true, false
’ ! u0000’ ÁÂÁÃÁ ’ ! uFFFF’
-128 ÁÂÁÃÁ 127
-32768 ÁÂÁÂÁ 32767
int
32-Bit Ganzzahl
long
float
double
64-Bit Ganzzahl
& '*),+.- /+10 $ +12)#))*&435),+.- /76 9
0 8:3*6
32-Bit Gleitkommazahl (
& +)=<#+.-*>*> 0@?A3 /+B)#))*&C'*)ED7< D7*> < 098F3*-*6
64-Bit Gleitkommazahl ;
½ ÁÃÁÂÁ #» " ½%$ Ä
- »ÃÀ " ÁÃÁÂÁ û À " $ Ä
- »#"
0
0
0.0
0.0
Tabelle 6: Primitive Datentypen in Java
G
Informatik II – c Guido Rößling
Datenstrukturen – Primitive Datentypen
3.4
ASCII-Tabelle
❑ Tabelle 7 gibt die ASCII-Zeichen von HJIKML bis NPOQKRL an.
❑ Die Zeile gibt dabei die ersten Hexadezimalstelle des Codes an, die Spalte die zweite
☞ F“ steht in Zeile S , Spalte T und hat daher den Code SUTKRL
”
❑ Die Zeichen 0 VVV 31 ( IJIKRLWVVVX F KRL ) sowie 127 ( NPOQKRL ) besitzen keine druckbare Darstellung.
Code 0 1 2 3 4 5 6 7 8 9 A B C D E F
2
3
4
5
6
7
’’
0
@
P
`
p
!
1
A
Q
a
q
”
2
B
R
b
r
#
3
C
S
c
s
$
4
D
T
d
t
%
5
E
U
e
u
&
6
F
V
f
v
´
7
G
W
g
w
(
8
H
X
h
x
)
9
I
Y
i
y
Y
+
;
K
[
k
:
J
Z
j
z ^
,
Z =
L M
\ ]
l m
_
`
.
/
[ ?
N O
]
n o
a
Tabelle 7: ASCII-Tabelle (7-Bit Code)
G
Informatik II – c Guido Rößling
Datenstrukturen – Primitive Datentypen : Characters und Sonderzeichen
3.5
ASCII-Zeichen
Die folgende Tabelle gibt die Codes für häufig verwendete Sonderzeichen an.
ASCII-Code Escape-Sequenz Bedeutung
8
’ \ b’
Backspace
10
’ \ n’
Zeilenvorschub (Newline)
12
’ \ f’
Seitenvorschub (Form Feed)
13
’ \ r’
Rücklauf (Return)
34
’ \ ”’
Anführungszeichen oben (double quote)
39
’\ ’ ’
Apostroph (single quote)
92
’ \b\ ’
Backslash
—
’ \ ddd’
Zeichen im Oktalwert (0 cedfc 7, bis ’ \ 377’)
—
’ \ uXXXX’
Unicode-Zeichen, 0 c X c F
Tabelle 8: ASCII-Codes für Sonderzeichen
G
Informatik II – c Guido Rößling
Datenstrukturen – Primitive Datentypen : Characters und Sonderzeichen
3.6
Unicode und Umlaute in Java
❑ ASCII ist ein 7-Bit-Zeichensatz, der nur Zeichen mit Code 0 VVV 127 definiert.
☞ Umlaute und viele Sonderzeichen liegen aber jenseits dieser Werte
❑ Anstelle der üblichen plattformabhängigen Darstellung der Umlaute unterstützt Java den
Unicode, einen 32-Bit-Code für Zeichen.
❑ Unicode-Zeichen werden in Java auf eine der folgenden Weisen angegeben:
☞ als normaler Character, eingeschlossen in Hochkommata,
☞ durch den Unicode in der Form gihjkjljlj , wobei für j jeweils ein Hexadezimaldigit
eingesetzt werden kann.
Zeichen Unicode
Zeichen Unicode
Ä
’ \ u00C4’
ä
’ \ u00E4’
Ö
’ \ u00D6’
ö
’ \ u00F6’
Ü
’ \ u00DC’
ü
’ \ u00FC’
ß
’ \ u00DF’
Tabelle 9: Unicode für Umlaute
G
Informatik II – c Guido Rößling
Datenstrukturen – Primitive Datentypen : Characters und Sonderzeichen
3.7
Zeiger
❑ Variablen vom Typ eines primitiven Datentyps besitzen als Wert den (Zahlen-)Wert der
Variable.
❑ Bei Zeigern bzw. Zeigervariablen hingegen ist der Wert der Variablen nicht der (Zahlen-)Wert, sondern die Adresse, an der der Wert gespeichert ist.
❑ Neben einer Änderung des Wertes an der Adresse kann damit auch die Adresse selbst
geändert werden.
☞ Dies ist insbesondere bei der Verwendung von Prozeduren und Funktionen
sinnvoll, die u.U. übergebene Parameter ändern wollen oder müssen
❑ In den meisten Programmiersprachen können Routinen nur ein einziges Ergebnis zurücklieferen.
❑ Durch Zeiger können nun auch als Zeiger übergebene Variablen geändert werden und
haben dann auch im aufrufenden Programm den geänderten Wert.
G
Informatik II – c Guido Rößling
Datenstrukturen – Zeiger
3.8
Wann sollten Zeiger verwendet werden?
Generell sollten Zeiger verwendet werden, wenn
❑ Prozeduren oder Funktionen darin Ergebnisse zurückgeben oder den Wert ändern sollen,
❑ das Kopieren der kompletten Daten nicht möglich oder nicht sinnvoll ist
☞ z.B. bei kompletten Feldern (in PASCAL werden Arrays nicht als Einzelwerte,
sondern nur über die Basisadresse übergeben!)
❑ es sich um Datenstrukturen handelt oder gar Objekte.
In Java sind alle nicht-primitiven Datentypen automatisch nur Zeiger auf das jeweilig
dahinterstehende Objekt.
G
Informatik II – c Guido Rößling
Datenstrukturen – Zeiger
3.9
Die Datenstruktur Array“
”
❑ Die wohl grundlegendeste Datenstruktur ist das Array (Feld), das in den meisten Programmiersprachen als Grundelement definiert ist.
❑ Arrays bestehen aus einer festen Anzahl von Elementen gleichen bzw. konformen Typs,
auf die über einen Index zugegriffen wird.
❑ Die in vielen Programmiersprachen übliche Notation für einen Lese- oder Schreibzugriff
ist die Angabe des Feldnamens, gefolgt von dem Index in eckigen Klammern, etwa a[i].
❑ Der Zugriff auf das referenzierte Element erfolgt durch direkte Adressierung: aus der
Basisadresse des Feldes und dem Index kann direkt die Speicheradresse des Elements
berechnet werden.
❑ Es gilt dabei adr(a[i]) = adr(a[minIndex]) + (i - minIndex) m Eintragsgröße
❑ Beispiel: Gegeben sei ein Feld a mit Indizes 0, VVV , 9 und Grundtyp Integer (32
Bit). Die Basisadresse von a sei 1024
☞ Die Adresse von Element 5, d.h. adr(a[5]), ist
adr n a[5] op
G
Informatik II – c Guido Rößling
XbIJHSrqsnutwvxIyozmS{p
XbISJS
Datenstrukturen – Array
3.10
Einschränkungen bei Arrays
❑ In PASCAL werden Arrays bereits an der Stelle der Deklaration erzeugt, es wird also
kein explizites new() benötigt.
❑ Die Konsequenz davon ist leider, daß die Feldgröße bereits bei der Programmierung
(statisch) festgelegt werden muß.
❑ In anderen Programmiersprachen – etwa C und Java – können Felder auch dynamisch
erzeugt werden, d.h. mit einer variablen, erst zur Laufzeit feststehenden Größe.
❑ In PASCAL können die Indizes des Feldes beliebig festgelegt werden.
❑ In den meisten Programmiersprachen beginnt die Zählung immer bei Element 0; das
letzte Element eines Feldes mit Länge n hat dann den Index n-1.
G
Informatik II – c Guido Rößling
Datenstrukturen – Array : Einschränkungen
3.11
Größenänderung von Feldern
❑ Ein Array belegt immer einen Block zusammenhängenden Speichers von der Größe, die
für die Speicherung aller Elemente nötig ist.
❑ Die auf Speicherbereich folgenden Speicherbereiche werden möglicherweise bereits anderweitig benutzt
☞ Das Array kann zur Laufzeit nicht direkt vergrößert werden
❑ Sprachen, die dennoch ein resize() anbieten, realisieren dies durch Anlegen eines entsprechend großen neuen Feldes und Kopieren aller Werte.
☞ Dies ist bei der Verwendung zu berücksichtigen, da es zu großem Zeitaufwand
führen kann!
❑ Bei einem resize sollte man sich daher sorgfältig überlegen, um wieviele Einträge man
das Array verlängern möchte.
❑ Normalerweise sollten Arrays nicht fortlaufend um ein Element vergrößert werden, sondern in Schüben um mehrere Elemente.
G
Informatik II – c Guido Rößling
Datenstrukturen – Array : Größenänderung
3.12
Mehrdimensionale Felder
❑ Arrays können zusätzlich auch geschachtelt werden, so daß man etwa ein Feld von Feldern von Integer-Zahlen erhält.
❑ Die Adressierung eines Elementes kann dann auf die folgenden Arten erfolgen:
☞ Aufzählen nicht aller Dimensionen, etwa a[i] bei einem zweidimensionalen Feld
☞ Das Ergebnis ist dann wiederum ein Feld (oder Feld von Feldern etc.)
☞ Indizes können immer nur in den untersten Dimensionen weggelassen werden;
a[i] greift also auf ein Element der ersten Dimension zu
☞ Aufzählen aller Dimensionen.
☞ Das Ergebnis ist dann das Element vom Grundtyp des Feldes, also z.B. Integer,
das sich an der angegebenen Position befindet
❑ In manchen Programmiersprachen ist die reine Deklaration eines mehrdimensionalen Feldes noch nicht für die Speicheranforderung ausreichend; der Speicher muß dann für jede
Dimension und jedes Element explizit angefordert werden.
G
Informatik II – c Guido Rößling
Datenstrukturen – Array : Mehrdimensionale Felder
3.13
Mehrdimensionale Felder als Matrizen
❑ Für viele Anwendungen ist es hilfreich, sich die Anordnung etwa eines zweidimensionalen Feldes nicht als Feld von Feldern vorzustellen, sondern als zweidimensionale Matrix.
❑ Dies illustriert folgende Abbildung für ein Feld int a[5][4]:
|5}~}
|„}
| €…}
|5‚~}
|b‡ƒ}
|5}u
|~
| €
|5‚u
|b‡R
|5}€
|…€
| €ƒ€
|5‚€
|b‡u€
|5}ƒ‚
|†‚
| €~‚
|5‚ƒ‚
|b‡‚
a[0][0]
a[1][0]
a[2][0]
a[3][0]
a[4][0]
a[0][1]
a[1][1]
a[2][1]
a[3][1]
a[4][1]
a[0][2]
a[1][2]
a[2][2]
a[3][2]
a[4][2]
a[0][3]
a[1][3]
a[2][3]
a[3][3]
a[4][3]
Abbildung 4: Zweidimensionales Feld als Matrix und Zugriff in Java
G
Informatik II – c Guido Rößling
Datenstrukturen – Array : Mehrdimensionale Felder
3.14
Beispiel für die Verwendung in Java
public boolean [ ] s i e v e O f E r a t h o s t e n e s ( i n t s i z e )
^
int i , j ;
/ / Zaehler
boolean [ ] p r i m m a t r i x ;
/ / eigentliche Matrix
i f ( size Z 1 ) return null ;
/ / u n g u e l t i g e Laenge
/ / Anlegen 0 . . . s i z e ? 1
p r i m m a t r i x = new boolean [ s i z e ] ;
for ( i = 2 ; i Z prim matrix . length ; i ++) prim matrix [ i ] = true ;
f o r ( i = 2 ; i Z p r i m m a t r i x . l e n g t h ; i ++)
i f ( prim matrix [ i ] )
/ / i i s t Primzahl
for ( j = i + i ; j Z prim matrix . length ; j += i )
/ / keine Primzahl
prim matrix [ j ] = false ;
return prim matrix ;
/ / Zurueckgeben
`
Listing 1: Sieb des Erathostenes
Deklaration und Allokierung können auch zusammengefaßt werden:
boolean [] prim matrix = new boolean[size ];
☞ Beachten Sie, daß size nicht nach oben beschränkt oder konstant ist! Falls
size negativ oder 0 ist, wird als Ergebnis null zurückgegeben
G
Informatik II – c Guido Rößling
Datenstrukturen – Array : Beispiel
3.15
Vorteile von Arrays
❑ Direkter, unmittelbarer Zugriff auf jedes Element (in ˆ9n‰X5o )
❑ Einfaches sequentielles Durchlaufen, z.B. mit Schleifen
❑ Die aufeinanderfolgende Anordnung im Feld ist die direkte Repräsentation der Anordnung der Elemente im Speicher
❑ direkte Entsprechung der Vektoren (eindimensional) und Matrizen (höherdimensional)
der Mathematik
☞ einfache, unmittelbare Umsetzbarkeit mathematischer Operationen
❑ überschreibendes Einfügen an feste Position erfolgt in konstantem Aufwand ( Š9‹‰Œ5 )
❑ Entfernen eines Elements anhand des Indexes erfolgt ebenfalls in Š9‹ŽŒ5
❑ einfache, intuitive Navigation durch Index
❑ Effizienteste Struktur für Datenzugriffe überhaupt

Informatik II – c Guido Rößling
Datenstrukturen – Array : Vor- und Nachteile
3.16
Nachteile von Arrays
❑ Die Feldgröße ist fest (PASCAL: statisch fest, andere: dynamisch fest)
❑ Bei Einfügen neuer Elemente müssen alle vorhandenen Elemente in den neuen Speicherbereich umkopiert werden ☞ Š4‹‘
❑ nicht-überschreibendes Einfügen oder Löschen erfordert i.d.R. Umkopieren der nachfolgenden Werte, d.h. ebenfalls Š9‹ƒ‘
❑ bei nur dünn besetzten Vektoren oder Matrizen wird viel Speicher verschwendet
❑ Alle Feldelemente müssen den gleichen Typ besitzen oder wenigstens konform dazu sein
(d.h. ein Untertyp des angegebenen Typs sein).

Informatik II – c Guido Rößling
Datenstrukturen – Array : Vor- und Nachteile
3.17

Informatik II – c Guido Rößling
Kryptologie
Graphentheorie
Graphenalgorithmen
Suchalgorithmen
Suche in Zeichenfolgen
Sortieralgorithmen
Hashing
Kompressionsverfahren
Primitive Datentypen
Listenstrukturen
Bäume
Sonstige Datentypen
Einleitung
Zahlendarstellung
Wo sind wir ’’’ ?
Datenstrukturen
3.18
Datenstruktur Verkettete Liste
Eine verkettete Liste (linked list) ist eine dynamische Struktur mit einfachen Einfüge- und
Löschmöglichkeiten. Im Gegensatz zu Arrays können Listen zur Laufzeit beliebig wachsen
und verändert werden.
Jedes Listenelement besteht dabei aus zwei Komponenten:
❑ Einem Objekt oder primitiven Datentyp
Diese Komponente ist das in der Liste abgelegte Element.
❑ Einem Zeiger auf das nächste Element in Form eines Zeigers auf ein Listenelement.
Die prinzipielle Struktur eines Listenelements gibt Abbildung 5 an.
Daten /
Objekt
next
Abbildung 5: Schematischer Aufbau eines Listenelements

Informatik II – c Guido Rößling
Listen – Verkettete Liste
4.1
Aufbau einer Liste
Eine verkettete Liste besteht nun aus dem Aneinanderfügen von mehreren Listenelementen.
Da die next-Komponente ein Zeiger auf ein Listenelement ist, kann dort die Adresse eines
weiteren Elements abgelegt werden.
Die so entstehende Struktur sieht wie folgt aus:
first
Objekt
1
Objekt
2
Objekt
3
Objekt
4
next
next
next
next
Abbildung 6: Schematischer Aufbau einer Liste
Das Zeichen am Listenende steht dabei für einen leeren Zeiger, auch als null bezeichnet.
null bedeutet, daß kein entsprechendes Objekt existiert; in diesem Fall: es kein nächstes
Element gibt, die Liste also bei Objekt 4 endet.

Informatik II – c Guido Rößling
Listen – Verkettete Liste : Aufbau
4.2
Navigation in Listen
Die Navigation in Listen, d.h. das Laufen von einem Element zu einem anderen, erfolgt durch
Zugriffe auf das next Element:
Listenelement f i r s t ;
Listenelement current ;
/ / Z e i g e r a u f das e r s t e Element
/ / Z e i g e r a u f das c u r r e n t e Element
/ / Gehe zum naechsten Element der L i s t e
/ / I s t das c u r r e n t e Element n u l l , gehe zum L i s t e n a n f a n g
public void n a v i g a t e ( )
“
”
i f ( current ! = null )
/ / G i b t es e i n c u r r e n t e s Element?
c u r r e n t = c u r r e n t . getN ext ( ) ; / / F a l l s j a , gehe zum naechsten
else
current = f i r s t ;
/ / Sonst gehe zum e r s t e n Element
Listing 2: Navigation in verketteten Listen

Informatik II – c Guido Rößling
Listen – Verkettete Liste : Navigation
4.3
Einfügen von Elementen
Beim Einfügen eines neuen Elements newElem in eine Liste sind drei Fälle zu unterscheiden:
❑ Einfügen vor dem ersten Listenelement ( prepend“)
”
Das erste Listenelement wird zum Nachfolger des neuen Elements; first zeigt auf das
neue Element.
❑ Einfügen hinter einem gegebenen Element ( insert“)
”
Es wird zu dem gewünschten Element gelaufen. next des neuen Elements übernimmt den
Wert next des aktuellen Elements; anschließend wird current.next auf das neue Element
gesetzt.
❑ Einfügen als letztes Element ( append“)
”
Die Liste wird bis zum letzten Element durchlaufen, d.h. bis current.getNext() == null.
current.next wird auf die Adresse des neuen Elements gesetzt.
☞ Ein Sonderfall von insert“.
”
In den folgenden Abbildungen geben gepunktete Linien die neue Position der vorherigen
Elemente an; gestrichelte Linien markieren geänderte Einträge.

Informatik II – c Guido Rößling
Listen – Verkettete Liste : Einfügen
4.4
Einfügen am Anfang einer Liste
1. newElem.setNext(first) // im Beispiel: newElem == Objekt 1
2. first = newElem
first
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
vorher
first
2
Objekt
1
1
next
nachher
Abbildung 7: Einfügen vor dem ersten Listenelement einer verketteten Liste

Informatik II – c Guido Rößling
Listen – Verkettete Liste : Einfügen
4.5
Einfügen innerhalb der Liste
1. Laufe zu dem Listenelement, hinter dem eingefügt werden soll (hier: Objekt 2)
2. newElem.setNext(current.getNext()) // hier: newElem == Objekt 3
3. current.setNext(newElem)
first
Objekt
1
Objekt
2
Objekt
4
Objekt
5
next
next
next
next
Objekt
1
Objekt
2
next
next
vorher
first
3
Objekt
3
next
2
Objekt
4
Objekt
5
next
next
nachher
Abbildung 8: Einfügen innerhalb einer verketteten Liste

Informatik II – c Guido Rößling
Listen – Verkettete Liste : Einfügen
4.6
Einfügen am Ende der Liste
1. Laufe zum letzten Listenelement (current.getNext()==null), hier: Objekt 4
2. current.setNext(newElem) // im Beispiel: newElem == Objekt 5
first
Objekt
1
Objekt
2
Objekt
3
Objekt
4
next
next
next
next
Objekt
1
Objekt
2
Objekt
3
Objekt
4
next
next
next
next
vorher
first
2
Objekt
5
nachher
next
Abbildung 9: Einfügen nach dem letzten Listenelement einer verketteten Liste

Informatik II – c Guido Rößling
Listen – Verkettete Liste : Einfügen
4.7
Löschen von Elementen
Beim Löschen des Elements delElem einer verketteten Liste sind drei Fälle zu unterscheiden:
❑ Löschen des ersten Listenelement
Setze first = first.getNext()
❑ Löschen innerhalb der Liste
Die Liste wird bis zum Vorgänger des zu löschenden Elements durchlaufen, d.h. bis zu
current.getNext() == delElem.
Setze dann current.setNext(delElem.getNext()).
❑ Löschen des letzten Elements
Ein einfacher Sonderfall des Löschens innerhalb der Liste.

Informatik II – c Guido Rößling
Listen – Verkettete Liste : Löschen
4.8
Löschen des ersten Listenelements
1. first = first.getNext()
2. delElem.setNext(null) (optional)
first
Objekt
1
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
next
vorher
first
1
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
nachher
Objekt
1
next
2
Abbildung 10: Löschen des ersten Listenelements einer verketteten Liste

Informatik II – c Guido Rößling
Listen – Verkettete Liste : Löschen
4.9
Löschen eines inneren Listenelements
1. Durchlaufe die Liste ab first bis current.getNext()==delElem
2. current.setNext(delElem.getNext()) // hier: delElem == Objekt 3
3. delElem.setNext(null) (optional)
Die Abbildung ist auf der nächsten Folie zu sehen.

Informatik II – c Guido Rößling
Listen – Verkettete Liste : Löschen
4.10
Löschen eines inneren Listenelements
first
Objekt
1
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
next
Objekt
1
Objekt
2
Objekt
4
Objekt
5
next
next
next
next
vorher
first
2
nachher
Objekt
3
next
3
Abbildung 11: Löschen eines inneren Listenelements einer verketteten Liste

Informatik II – c Guido Rößling
Listen – Verkettete Liste : Löschen
4.11
Löschen des letzten Listenelements
1. Durchlaufe die Liste ab first bis current.getNext() == delElem
Im Beispiel zeigt danach also current auf Objekt 4.
2. current.setNext(null)
first
Objekt
1
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
next
Objekt
1
Objekt
2
Objekt
3
Objekt
4
Objekt
5
vorher
first
next
next
next
next
2
nachher
next
Abbildung 12: Löschen des letzten Listenelements einer verketteten Liste

Informatik II – c Guido Rößling
Listen – Verkettete Liste : Löschen
4.12
Vor- und Nachteile der verketteten Liste
Vorteile:
❑ Dynamische Länge
❑ Es ist kein Kopieren der Elemente bei Löschen oder Einfügen erforderlich
❑ Keine Speicherverschwendung durch Vorreservierung des Speicherplatzes
❑ Einfache Einfüge- und Löschoperationen
❑ In den Listenelementen enthaltene Objekte können verschiedenen Typ haben
Nachteile:
❑ Zugriff erfolgt immer sequentiell
❑ Positionierung liegt in Š4‹‘
❑ Vorgänger sind nur aufwendig erreichbar: Suche ab first nach Element elem mit
elem.getNext() == current
❑ Operationen Einfügen / Löschen nur hinter dem aktuellen Element möglich, sonst
komplette Positionierung erforderlich

Informatik II – c Guido Rößling
Listen – Verkettete Liste : Vor- und Nachteile
4.13
Datenstruktur Doppelt verkettete Liste
❑ Doppelt verkettete Listen (double-linked lists) beheben die Einschränkung der Navigation
nur zum Nachfolger
❑ Dazu wird neben dem Zeiger next noch ein Zeiger prev eingefügt, der auf das vorherige Element der Liste zeigt, bzw. null ist, falls es sich um das erste Element handelt.
☞ Dieser Zeiger ermöglicht die Navigation zum vorhergehenden Element
❑ Ein Listenelement sieht daher wie folgt aus:
Objekt
next
prev
Abbildung 13: Schematischer Aufbau eines Listenelements einer doppelt verketteten Liste

Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste
4.14
Aufbau
❑ Jedes Element ist mit Nachfolger (über next) und Vorgänger (über prev) verknüpft
❑ Die Komponente next des letzten Elements ist dabei genauso null wie die Komponente
prev des ersten Elements.
❑ Der prinzipielle Aufbau einer doppelt verketteten Liste sieht wie folgt aus:
first
Objekt
1
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
next
prev
prev
prev
prev
prev
Abbildung 14: Prinzipieller Aufbau einer doppelt verketteten Liste
❑ Sonderform: doppelt verkettete zyklische Liste
☞ erstes Element ist Nachfolger des letzten Elements
☞ letztes Element ist Vorgänger des ersten Elements

Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste : Aufbau
4.15
Einfügen von Elementen
❑ Ablauf prinzipiell wie bei einer einfach verketteten Liste.
❑ Es ist dabei auf die richtige Reihenfolge der Zeigeränderung zu achten
☞ Einfügen vor dem ersten Element
Hierzu wird next des neuen Elements auf first gesetzt, anschließend first.prev
und schließlich first jeweils auf das neue Element.
☞ Einfügen innerhalb der Liste
Zunächst werden prev und next des neuen Elements auf die entsprechenden Werte des Elements gesetzt, das sich nach der Einfügeposition befindet. Anschließend
müssen next des vorherigen und prev des nachfolgenden Elements auf das neue
Element zeigen.
☞ Einfügen nach dem letzten Element
Hierzu muß nur next des letzten Elements auf das neue zeigen (vorher: null), und
prev des neuen Elements auf das bisher letzte Element.
Ein Sonderfall des Einfügens innerhalb der Liste.

Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste : Einfügen
4.16
Einfügen am Anfang einer doppelt verketteten Liste
1. Vorwärtsverknüpfung: newElem.next = first (hier: newElem == Objekt 1)
2. first.prev = newElem zur Rückverknüpfung des Listenanfangs
3. first = newElem zum Setzen des neuen Listenanfangs
first
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
prev
prev
prev
prev
Objekt
1
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
next
prev
prev
prev
prev
vorher
first
3
1
prev
2
nachher
Abbildung 15: Einfügen am Anfang einer doppelt verketteten Liste

Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste : Einfügen
4.17
Einfügen innerhalb einer doppelt verketteten Liste
Das einzufügende Element sei nun newElem == Objekt 3.
1. newElem.prev = aktuell.prev
ell==Objekt 4)
zur
Verknüpfung
(hier:
aktu-
2. newElem.next = aktuell zur Vorwärtsverknüpfung
3. newElem.prev.next = newElem
4. aktuell.prev = newElem
Die Abbildung befindet sich auf der nächsten Folie.

Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste : Einfügen
4.18
Einfügen innerhalb einer doppelt verketteten Liste
first
Objekt
1
Objekt
2
Objekt
4
Objekt
5
next
next
next
next
prev
prev
prev
prev
Objekt
1
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
next
prev
prev
prev
prev
vorher
first
3
1
2
prev
4
nachher
Abbildung 16: Einfügen innerhalb einer doppelt verketteten Liste

Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste : Einfügen
4.19
Einfügen am Ende einer doppelt verketteten Liste
1. Laufe über aktuell zum letzten Element der Liste (bis aktuell.next ==
null)
2. aktuell.next = newElem zur Vorwärtsverknüpfung
3. newElem.prev = aktuell zur Rückwärtsverknüpfung
first
Objekt
1
next
Objekt
2
next
Objekt
3
Objekt
4
next
next
prev
prev
prev
prev
Objekt
1
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
next
prev
prev
prev
prev
vorher
first
2
3
nachher
prev
Abbildung 17: Einfügen am Ende einer doppelt verketteten Liste

Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste : Einfügen
4.20
Löschen von Elementen
Es sind drei Fälle zu unterscheiden:
❑ Löschen des ersten Listenelement
Setze first.next.prev auf null und anschließend first auf first.next.
❑ Löschen innerhalb der Liste
Um das Element zu überspringen“, setze aktuell.next.prev = aktuell.prev
”
sowie aktuell.prev.next = aktuell.next. Anschließend kann prev, next,
von aktuell auf null gesetzt werden.
❑ Löschen am Ende der Liste
Setze aktuell.prev.next auf aktuell.next bzw. null (was identisch ist).
Dieser Fall ist ein Sonderfall des Löschens innerhalb der Liste.
☞ Vor dem Löschen ist aktuell.prev in einer Variablen zu speichern und
nach dem Löschen aktuell zuzuweisen und anschließend navigate aufzurufen
•
Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste : Löschen
4.21
Löschen des Anfangs einer doppelt verketteten Liste
1. first.next.prev = null zum Auflösen der Rückverknüpfung
2. first = first.next zum Setzen des neuen Anfangs
3. aktuell.next = null (optional)
Die Abbildung befindet sich auf der nächsten Folie.
•
Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste : Löschen
4.22
Löschen des Anfangs einer doppelt verketteten Liste
first
Objekt
1
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
next
prev
prev
prev
prev
prev
vorher
first
2
1
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
prev
prev
prev
prev
nachher
Objekt
1
next
3
prev
Abbildung 18: Löschen des ersten Elements einer doppelt verketteten Liste
•
Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste : Löschen
4.23
Löschen innerhalb einer doppelt verketteten Liste
aktuell sei nun das zu löschende Element, im Beispiel aktuell == Objekt 3.
1. aktuell.next.prev = aktuell.prev zum Auflösen der Rückverknüpfung
2. aktuell.prev.next = aktuell.next zum Auflösen der Vorwärtsverknüpfung
3. aktuell.prev = null (optional)
4. aktuell.next = null (optional)
Die Abbildung befindet sich auf der nächsten Folie.
•
Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste : Löschen
4.24
Löschen innerhalb einer doppelt verketteten Liste
first
Objekt
1
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
next
prev
prev
prev
prev
prev
Objekt
1
Objekt
2
Objekt
4
Objekt
5
next
next
next
next
prev
prev
prev
prev
vorher
first
2
1
Objekt
3
3
nachher
4
next
prev
Abbildung 19: Löschen innerhalb einer doppelt verketteten Liste
•
Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste : Löschen
4.25
Löschen des Endes einer doppelt verketteten Liste
1. aktuell.prev.next = null zum Auskoppeln“ des letzten Elements
”
2. aktuell.prev = null (optional)
Die Abbildung befindet sich auf der nächsten Folie.
•
Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste : Löschen
4.26
Löschen des Endes einer doppelt verketteten Liste
first
Objekt
1
Objekt
2
Objekt
3
Objekt
4
Objekt
5
next
next
next
next
next
prev
prev
prev
prev
prev
Objekt
1
Objekt
2
Objekt
3
Objekt
4
next
next
next
next
prev
prev
prev
prev
vorher
first
nachher
1
Objekt
5
2
next
prev
Abbildung 20: Löschen des letzten Elements einer doppelt verketteten Liste
•
Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste : Löschen
4.27
Vor- und Nachteile der doppelt verketteten Liste
Vorteile:
❑ Alle Vorteile der verketteten Liste
❑ Vorgängerelemente sind direkt zugreifbar
❑ Löschen und Einfügen sowohl vor als auch nach dem aktuellen Element
Nachteile:
❑ Sequentieller Zugriff (wenn auch bidirektional)
❑ Positionierung immer noch –9—ƒ˜‘™
❑ erhöhter Speicherbedarf gegenüber verketteter Liste
❑ mehr Zeigeränderungen pro Einfüge- oder Löschoperation notwendig
•
Informatik II – c Guido Rößling
Listen – Doppelt verkettete Liste : Vor- und Nachteile
4.28
Datenstruktur Stack
❑ In vielen Fällen ist es nicht erforderlich, auf alle Elemente einer Liste zugreifen zu können
☞ Es wird lediglich das letzte Element benötigt (Beispiel: Ablage)
❑ Hierfür dient die Datenstruktur Stack (Stapel oder Kellerspeicher), die die folgenden Operationen kennt:
☞ push(x) – Lege ein Element x auf den Stack
☞ pop() – entferne das oberste Element vom Stack
☞ top() – lese den Wert des obersten Elements
☞ empty() – true wenn der Stack leer ist, sonst false
❑ Die Operationen top() bzw. pop() sind nur zulässig, wenn der Stack nicht leer ist.
•
Informatik II – c Guido Rößling
Listen – Stack
4.29
Anwendungen für Stacks
Typische Anwendungen für Stacks sind beispielsweise
❑ Verwaltung von Rücksprungadressen
Dies tritt vor allem bei Rekursion oder Routinenaufrufen auf.
❑ Hilfestellung bei der Syntaxanalyse von Programmen
Genauere Informationen dazu kommen im Zuge der Veranstaltung Informatik III.
❑ Auswertung von logischen oder arithmetischen Ausdrücken
Ein einfaches Beispiel dazu folgt auf der nächsten Folie.
•
Informatik II – c Guido Rößling
Listen – Stack : Anwendungen
4.30
Beispiel für Stackanwendung
❑ Ein arithmetischer Ausdruck in Postfix-Notation soll unter Benutzung eines Stacks ausgewertet werden.
❑ Während bei der herkömmlichen (Infix-)Notation das Rechenzeichen immer zwischen den
Operatoren steht ( 5 + 3 š 7“), steht es bei der Postfix-Notation hinter den Operatoren
”
( 5 3 + 7 š “).
”
☞ Der Vorteil dieser Notation ist die leichte Überprüf- und Auswertbarkeit.
Zusätzlich werden keine Klammern benötigt
❑ Im folgenden schematischen Beispiel wird angenommen, daß eine Routine nextToken
existiert, die ein Zeichen zurückgibt, das entweder +“, š “ oder eine Ziffer von 0 bis 9
”
”
ist.
❑ Das Programm schreibt der Reihe nach die gelesenen Zahlen auf den Stack.
❑ Trifft es auf eine Operation (+, š ), so berechnet es das Ergebnis der Operation und schreibt
dieses wieder auf den Stack, bis das Zeichen ’.’ als Eingabeende erkannt wurde.
❑ Zusätzlich sei s vom Typ Stack und bereits auf einen leeren Stack initialisiert.
•
Informatik II – c Guido Rößling
Listen – Stack : Anwendungen
4.31
Pseudo-Programm für Postfix-Auswertung
/ ››
›
Werte einen eingegegeben Ausdruck aus m i t t e l s ei nes Stacks
/
public
int evaluate ( )
œ
›
char v al ue ;
while
( ( v al ue = nextToken ( ) ) ! = ’ . ’ )
œ
Ÿ
Ÿ
/ / Gelesenes Zeichen
/ / Zeichen l es en ; w e i t e r ?
i f ( v al ue = = ’ + ’ )
//
s . push ( s . pop ( ) + s . pop ( ) ) ;
//
else
i f ( v al ue = = ’ › ’ )
//
//
s . push ( s . pop ( ) › s . pop ( ) ) ;
else
i f ( v al ue  = ’ 0 ’ & & v al ue ž = ’ 9 ’ )
s . push ( ( i n t ) v al ue ) ;
//
Addition
Summe der beiden l e t z t e n Werte
Multiplikation
Produkt der l e t z t e n Werte
/ / Zahl ?
Wert auf den Stack s c h r e i b e n
System . out . p r i n t l n ( ” Ergebnis : ” + s . pop ( ) ) ;
Listing 3: Pseudo-Programm für Postfix-Auswertung
•
Informatik II – c Guido Rößling
Listen – Stack : Postfix-Auswertung
4.32
Beispiel zur Postfix-Auswertung
53+7+8*9+2*.
Eingabe:
5
3
+
7
+
8
*
9
+
2
*
Stack:
5
3
5
3
8
7
8
7
15
8
15
8
120
9
120
9
129
2
129
2
258
Operation:
p
p
ppp
p
ppp
p
ppp
p
ppp
p
ppp
gelesenes Zeichen
(p=push,
ppp=push(popop pop)
3
zeigt ein durch "pop" nicht mehr zugreifbares Element an (das aber nicht gelöscht werden muß)
Abbildung 21: Beispiel zur Postfix-Auswertung mittels Stack
Als Ergebnis der Operation wird s.pop() = 258 ausgegeben.
•
Informatik II – c Guido Rößling
Listen – Stack : Postfix-Auswertung
4.33
Implementierung von Stacks
❑ Stacks werden üblicherweise als verkettete Liste implementiert
☞ Das Einfügen und Entfernen erfolgt immer am Anfang der Liste
❑ Falls die maximale Größe, die der Stack annehmen kann, beschränkt ist (oder werden
soll), kann sogar ein Array verwendet werden, in dem man sich die aktuelle Position mit
einer Integer-Variablen merkt.
❑ Es ist nicht notwendig, bei einem pop das oberste Element tatsächlich zu löschen; das
Markieren des vorherigen Elements als letztes Element ist bei geeigneter Implementierung von push bereits ausreichend.
•
Informatik II – c Guido Rößling
Listen – Stack : Implementierung
4.34
Mögliche Fehler beim Stack
Bei Stacks können folgende zwei Fehler auftreten:
❑ Stack Overflow – es soll ein Wert auf einen bereits gefüllten Stack geschrieben werden.
Gründe: Verwendung eines Arrays zur Speicherung der Elemente; knapper Speicher.
❑ Stack Underflow – es soll ein Wert aus einem leeren Stack gelesen werden.
Grund: Es sind mehr pop als push Operationen aufgetreten, d.h. es sollen mehr Werte
gelesen werden, als geschrieben wurden.
•
Informatik II – c Guido Rößling
Listen – Stack : Fehler
4.35
Vor- und Nachteile des Stacks
Vorteile:
❑ extrem nützlich in vielen Anwendungen zur Abarbeitung von Abläufen
❑ sehr effizienter Zugriff, egal ob durch Liste oder Array realisiert: –9—Ž 5™
❑ dynamische Länge (nur bei Verwendung einer Liste)
❑ elementare, einfache Einfüge- (push) und Löschoperationen (pop):
alle –9—‰ 5™
Nachteile:
❑ Nur für LIFO“-Anwendungen benutzbar (Last In, First Out)
”
❑ ( Kein wahlfreier Zugriff auf Elemente )
❑ ( Keine Navigation über die Elemente )
Die beiden letzten Nachteile treten bei den Verwendungsgebieten von Stacks prinzipiell nicht
auf. Sie sind daher als Hinweis zu sehen, daß der Stack die falsche Datenstruktur für den
jeweiligen Zweck ist.
•
Informatik II – c Guido Rößling
Listen – Stack : Vor- und Nachteile
4.36
Datenstruktur Queue
❑ Queues sind dem Stack sehr ähnlich. Während beim Stack aber immer das zuletzt eingefügte Element als erstes entfernt wird (LIFO-Prinzip), ist es bei der Queue immer das
zuerst eingefügte Element (FIFO-Prinzip).
❑ Der Name Queue“ bedeutet Warteschlange: neue Elemente müssen sich am Ende der
”
Queue anstellen“, und immer das erste Element der Queue wird bedient“ und anschlie”
”
ßend aus der Warteschlange entfernt.
❑ Neben dem hintersten Element muß die Queue auch auf das erste Element zugreifen und
besitzt damit zwei Zeiger: head und tail für das erste Element bzw. die erste freie
Position nach dem letzten Element. Falls head == tail gilt, ist die Queue leer.
•
Informatik II – c Guido Rößling
Listen – Queue
4.37
Operationen auf einer Queue
Zur Verfügung stehen dazu die folgenden Operationen:
❑ enqueue(x) – Einfügen des Elements x am Ende der Warteschlange
❑ dequeue() – Entfernen des ersten Elements der Warteschlange
❑ front() – Liefert das erste Element der Warteschlange
❑ empty() – true, wenn die Warteschlange leer ist (head == tail), sonst false
•
Informatik II – c Guido Rößling
Listen – Queue : Operationen
4.38
Beispiel zur Queue
Abbildung 22: Beispiel zur Verwendung einer Queue
•
Informatik II – c Guido Rößling
Listen – Queue : Beispiel
4.39
Anmerkungen zur Queue
Trotz der großen Ähnlichkeit zum Stack ist die Terminologie bei der Queue etwas anders:
❑ Entsprechend des Konzepts der Warteschlangen wird nicht von einem obersten“ bzw.
”
untersten“ Element gesprochen, sondern von dem ersten“ (=ältesten) und dem letzten“
”
”
”
(=neuesten) Element.
❑ Die Operationen push und pop, die das auf den Stapel legen bzw. davon entfernen charakterisieren, werden entsprechend nun als enqueue bzw. dequeue bezeichnet.
Ähnlich wie bei dem Stack ist es auch bei der Queue ausreichend, einfach die Zeiger head
(bei dequeue) bzw. tail (bei enqueue) zu verschieben, ohne das entsprechende Element
zu löschen. Es wird dann beim nächsten Erreichen der Stelle automatisch überschrieben.
Analog zum Stack kann auch eine Queue mittels einer Liste oder eines Arrays implementiert
werden. Bei Verwendung eines Arrays werden die Zeiger jeweils modulo der Arraygröße
hochgesetzt.
•
Informatik II – c Guido Rößling
Listen – Queue : Anmerkungen
4.40
Vor- und Nachteile der Queue
Vorteile:
❑ Identisch zu den Vorteilen des Stacks
Nachteile:
❑ Nur für FIFO“-Anwendungen benutzbar (First In, First Out)
”
❑ ( Kein wahlfreier Zugriff auf Elemente )
❑ ( Keine Navigation über die Elemente )
Wie auch beim Stack sind die beiden letzten Nachteile irrelevant und deuten bei Auftreten
darauf hin, daß die falsche Datenstruktur gewählt wurde.
•
Informatik II – c Guido Rößling
Listen – Queue : Vor- und Nachteile
4.41
•
Informatik II – c Guido Rößling
Kryptologie
Graphentheorie
Graphenalgorithmen
Suchalgorithmen
Suche in Zeichenfolgen
Sortieralgorithmen
Hashing
Kompressionsverfahren
Primitive Datentypen
Listenstrukturen
Bäume
Sonstige Datentypen
Einleitung
Zahlendarstellung
Wo sind wir ¡¡¡ ?
Listen
4.42
Datenstruktur Baum
Der Baum (engl. Tree) ist eine der wichtigsten Datenstrukturen der Informatik.
Bäume sind zwei- oder mehrdimensionale Datenstrukturen, bei denen ein Element mit mehreren anderen Elementen verknüpft sein kann. Sehr viele Algorithmen arbeiten auf Bäumen.
Bäume werden in vielen Bereichen in und außerhalb der Informatik eingesetzt, z.B.
❑ Stammbäume in der Ahnenforschung,
❑ Ablaufstrukturen bei Turnieren wie der Fußball-Weltmeisterschaft (ab der Qualifikationsrunde),
❑ hierarchischer Aufbau von Unternehmensstrukturen,
❑ Syntaxbäume sowie Ableitungsbäume bei der Verarbeitung von Computersprachenprogrammen (vgl. Informatik I und IInformatik III)
Es gibt mehrere Untertypen von Bäumen. Zunächst soll aber ein Überblick über die Terminologie gegeben werden.
•
Informatik II – c Guido Rößling
Bäume
5.1
Terminologie
❑ Ein Baum besteht aus einer Menge von Knoten sowie Kanten.
❑ Knoten sind beliebige Objekte; Kanten verbinden Knoten miteinander.
❑ Die Kanten sind gerichtet und weisen normalerweise von der Wurzel des Baums zu den
Blättern (=Knoten ohne Nachfahren).
❑ Üblicherweise werden aber keine Pfeile an den Kanten angebracht.
❑ Führt eine Kante von Knoten ¢ zu dem Knoten £ , so ist £
und ¢ entsprechend (direkter) Vorgänger von £ .
(direkter) Nachfolger von ¢
❑ Vorgänger eines Knotens ¢ sind alle direkten Vorgänger sowie alle Vorgänger eines direkten Vorgängers (rekursive Definition!)
•
Informatik II – c Guido Rößling
Bäume – Terminologie : Knoten, Kanten, Vorgänger und Nachfolger
5.2
Beispiel für einen Baum
Stufe
Wurzel
E
0
Kante
M
A
B
B
1
I
I
P
U
Blätter
S
E
2
L
3
Anmerkung: Blätter sind ebenfalls Knoten
innere Knoten
Abbildung 23: Beispiel für einen Baum
¤
Informatik II – c Guido Rößling
Bäume – Beispiel
5.3
Wurzeln, Blätter und Zyklen
❑ Knoten ohne Nachfolger werden als Blatt, alle anderen Knoten als innere Knoten bezeichnet.
❑ Bei inneren Knoten gibt die Anzahl Nachfolger den Grad des Knotens an; Blätter besitzen
entsprechend Grad 0. Der Grad des Baums ergibt sich aus dem maximalen Grad aller
Knoten.
❑ Die Wurzel ist das einzige Element des Baums, das keinen Vorgänger hat, d.h. es existiert
keine Kante, die zur Wurzel führt.
❑ Die Wurzel wird stets oben angegeben, so daß sich ihre Nachfolger (auch: Nachfahren,
Söhne) unter ihr befinden.
❑ Jeder Knoten – mit Ausnahme der Wurzel – hat genau einen direkten Vorgänger.
❑ Zyklen, d.h. Knoten, die sich selbst als Vorgänger haben, sind verboten. Treten dennoch
welche auf, so handelt es sich nicht mehr um einen Baum, sondern um einen Graph
(kommt auf Seite 7.1f).
¤
Informatik II – c Guido Rößling
Bäume – Terminologie : Wurzel, Blatt, Zyklus
5.4
Nachfolger und Vorgänger
B
A
D
C
E
Abbildung 24: Baum: Nachfolger und Vorgänger
Knoten Nachfolger
A
B
C
D
E
¥;¦
¥ A, D, C, E ¦
¥b¦
¥ C, E ¦
¥b¦
direkte Nachfolger Vorgänger direkte Vorgänger
¥z¦
¥ A, D ¦
¥b¦
¥ C, E ¦
¥b¦
¥ B¦
¥b¦
¥ D, B ¦
¥ B¦
¥ D, B ¦
¥ B¦
¥b¦
¥ D¦
¥ B¦
¥ D¦
Tabelle 10: Baum: Nachfolger und Vorgänger
¤
Informatik II – c Guido Rößling
Bäume – Terminologie : Nachfolger und Vorgänger
5.5
Zyklen
W
V
Y
X
Z
Abbildung 25: Zyklen
Knoten Nachfolger
V
W
X
Y
Z
§
§
direkte Nachfolger Vorgänger
direkte Vorgänger
W, V, Y, X, Z ¨
V, Y, W, X, Z ¨
§
§
X, Z ¨
Z¨
§
§
§
§
§‰¨
W¨
V, Y ¨
§
X, Z ¨
Z¨
§
§
§Ž¨
§
§
§
W, V ¨
V, W ¨
Y, W, V ¨
W¨
Y, Z, W, V ¨
W¨
§ V¨
§
§
§ Y¨
W, V ¨
Y, Z ¨
Tabelle 11: Kein Baum aufgrund von Zyklen
Die auftretenden Zyklen sind fett hervorgehoben.
¤
Informatik II – c Guido Rößling
Bäume – Terminologie : Zyklen
5.6
Pfad und Stufe
❑ Knoten können durch einen Pfad verbunden sein, d.h. eine Abfolge von durch Kanten
miteinander verbundenen Knoten. In der Abbildung unten sind etwa die Knoten B und E
durch den Pfad B - D - E verbunden.
B
A
D
C
E
❑ Es gibt stets für jeden Knoten einen Pfad von der Wurzel zu dem Knoten.
❑ Die Stufe eines Knoten ist definiert als die Länge des Pfads von der Wurzel zu diesem
Knoten.
Die Wurzel B besitzt also Stufe 0, die Elemente A, D Stufe 1, C und E folglich Stufe 2.
❑ Die Höhe eines Baums ist um eins größer als die maximale Stufe der Knoten.
¤
Informatik II – c Guido Rößling
Bäume – Terminologie : Pfad und Stufe
5.7
Pfadlänge, n-ärer und geordneter Baum
❑ Die Pfadlänge eines Baums ist definiert als die Summe der Pfadlängen zu allen Knoten.
Sie kann noch unterschieden werden in eine innere Pfadlänge, bei der nur die Pfade zu
den inneren Knoten gerechnet wird, und einer äußeren Pfadlänge, bei der alle Knoten
berücksichtigt werden.
B
A
innere Pfadlänge: 1
äußere Pfadlänge: 1+1+2+2 = 6
D
C
E
❑ Die Anzahl Nachfolger, die ein Knoten maximal haben kann, kann festgelegt sein. Es
wird dann von einem n-ären Baum gesprochen (für ©«ª­¬ von einem binären Baum).
❑ Die Reihenfolge der Nachfolger eines Knotens kann wichtig sein. In diesem Fall wird von
einem geordneten Baum gesprochen.
¤
Informatik II – c Guido Rößling
Bäume – Terminologie : Pfadlänge, n-ärer und geordneter Baum
5.8
Datenstruktur Binärer Baum
❑ In einem Binären Baum (auch: Binärbaum) besitzt jeder Knoten einen Grad ® 2, hat also
maximal zwei Nachfolger.
❑ Die Nachfolger eines inneren Knoten werden beim Binären Baum als linker und rechter
Sohn bezeichnet und müssen auch jeweils entsprechend gekennzeichnet werden.
❑ Der linke bzw. rechte Sohn eines inneren Knotens ist wiederum die Wurzel eines Unterbaums.
❑ Folgende rekursive Definition charakterisiert Binärbäume:
☞ Ein einzelner Knoten ist ein Binärbaum (als Wurzel eines Binärbaums).
☞ Ein Knoten, dessen Söhne entweder nicht existieren oder Binärbäume sind, ist ebenfalls ein Binärbaum.
Abbildung 26: Beispiele für Binärbäume
¤
Informatik II – c Guido Rößling
Bäume – Binärer Baum
5.9
Spezielle Formen von Binärbäumen
Es gibt noch einige spezielle Formen von Binärbäumen:
❑ In einem vollständigen Binärbaum der Stufe © ist jeder Knoten auf Stufe © ein Blatt, und
jeder innere Knoten auf Stufe ¯±°s© hat zwei nicht-leere Unterbäume.
☞ Der vollständige Binärbaum enthält also die für seine Höhe maximal mögliche
Anzahl von Knoten.
❑ In fast vollständigen Binärbäumen befinden sich alle Blätter auf Stufe © oder ©³²µ´ . Falls
dabei ein innerer Knoten auf Stufe ©¶² ´ einen rechten Nachfolger hat, muß der linke
Teilbaum dieses Knotens vollständig mit Blättern auf Stufe © sein.
☞ Die Blätter werden also, beginnend auf Stufe ©¶² ´ , von links nach rechts“
”
aufgefüllt.
❑ In strikten Binärbäumen ist jeder Knoten entweder ein Blatt oder besitzt genau zwei nichtleere Unterbäume.
☞ Jeder vollständige Binärbaum ist auch strikt
¤
Informatik II – c Guido Rößling
Bäume – Binärer Baum : Spezielle Formen
5.10
Spezielle Formen von Binärbäumen
Abbildung 27: Vollständiger, fast vollständiger und strikter Binärbaum
¤
Informatik II – c Guido Rößling
Bäume – Binärer Baum : Spezielle Formen
5.11
Implementierung von Binärbäumen
❑ Binärbäume werden ähnlich zu verketteten Listen durch Zeiger auf die Unterbäume implementiert.
❑ Die Struktur eines Binärbaums in Java-Notation ist damit wie auf Seite 5.13f angegeben.
❑ In der den Baum verwendenden Struktur muß der Zeiger auf die Wurzel des Binärbaums
gespeichert werden, da nur eine Verknüpfung zu den Nachfolgern, nicht aber zu den Vorfahren existiert.
¤
Informatik II – c Guido Rößling
Bäume – Binärer Baum : Implementierung
5.12
Implementierung von Binärbäumen
/ ·¸·
·
Diese Klasse i m p l e m e n t i e r t das Geruest e i n e s Binaerbaums
· /
public class BinaryTree ¥
/ ·¸·
· Der l i n k e Unterbaum i s t wieder e i n BinaryTree ( oder n u l l )
· /
BinaryTree l e f t ;
/ ·¸·
·
Der r e c h t e Unterbaum i s t wieder e i n BinaryTree ( oder n u l l )
· /
BinaryTree r i g h t ;
/ ·¸·
·
Der im Wurzelknoten ( dem a k t u e l l e n Knoten ) verm erkte Wert
· /
Object value ;
Listing 4: Binärer Baum, Teil 1
¤
Informatik II – c Guido Rößling
Bäume – Binärer Baum : Implementierung
5.13
Implementierung von Binärbäumen
/ ·¸·
·
Erzeuge einen neuen Binaerbaum aus den gegebenen Objekten
· /
public BinaryTree ( BinaryTree l , O b j e c t v a l , BinaryTree r )
¥
left = l ;
right = r ;
value = val ;
¦
Listing 5: Binärer Baum, Teil 2
¤
Informatik II – c Guido Rößling
Bäume – Binärer Baum : Implementierung
5.14
Alternative Implementierung in einem Array
❑ Neben der Implementierung durch Zeiger ist auch eine Anordnung der Knoten in einem
Feld der Größe ¬J¹ (mit º = Höhe des Baums) möglich.
❑ Dabei erhält die Wurzel den Index 0 und alle Nachfolger werden der Reihe nach fortlaufend durchnumeriert inklusive fehlender Knoten.
❑ Generell hat dabei der linke Sohn eines Knotens mit Index ¯ den Index ¬(»*¯¸¼½´ , der rechte
Sohn Index ¬w»¯B¼¶¬ .
❑ Diese Art der Darstellung ist vor allem für fast vollständige Binärbäume sehr effizient,
verschwendet aber bei weniger dichten“ Binärbäumen viel Speicher.
”
¤
Informatik II – c Guido Rößling
Bäume – Binärer Baum : Implementierung
5.15
Beispiel zur Implementierung
+
1
*
-
2
1
Index
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
value
+
1
¾
null
null
2
null
null
null
null
null
null
1
null
Abbildung 28: Baumdarstellung mit Zeigern und in einem Array
¤
Informatik II – c Guido Rößling
Bäume – Binärer Baum : Implementierung
5.16
Traversierung von Binärbäumen
❑ Eine der Hauptanwendung von Binärbäumen ist die Verarbeitung der Elemente gemäß
ihrer Strukturierung und Anordnung. Dazu müssen die Knoten in einer bestimmten Reihenfolge aufgesucht werden, also der Baum durchlaufen“ ( traversiert“) werden.
”
”
❑ Für die Reihenfolge bezeichnet im folgenden W die Wurzel, L den linken Unterbaum und
R den rechten Unterbaum.
☞ WLR: Verarbeiten der Wurzel; rekursives Durchlaufen des linken und anschließend
rekursives Durchlaufen des rechten Teilbaums.
Üblicherweise als Pre-Order“ ( Durchlauf in Vorordnung“) bezeichnet.
”
”
☞ LWR: rekursives Durchlaufen des linken Teilbaums; Verarbeiten der Wurzel; anschließend rekursives Durchlaufen des rechten Teilbaums.
Üblicherweise als In-Order“ ( Durchlauf in Zwischenordnung“) bezeichnet.
”
”
☞ LRW: rekursives Durchlaufen des linken und anschließend des rechten Teilbaums;
schließlich Verarbeiten der Wurzel
Üblicherweise als Post-Order“ ( Durchlauf in Nachordnung“) bezeichnet.
”
”
¤
Informatik II – c Guido Rößling
Bäume – Binärer Baum : Traversierung
5.17
Schema der Traversierung
In der folgenden Abbildung geben die Zahlen in den Knoten die Reihenfolge des Durchlaufs
an.
1
2
3
5
4
Reihenfolge der
Pre-Order Traversierung
4
5
2
1
5
3
3
4
2
1
Reihenfolge der
Reihenfolge der
In-Order Traversierung
Post-Order Traversierung
Abbildung 29: Schema der Traversierung eines Binärbaums
¤
Informatik II – c Guido Rößling
Bäume – Binärer Baum : Traversierung
5.18
Beispiel zur Traversierung
+
/
a
d
*
e
^
b
c
2
Pre-Order:
-+a*b^c2/de
In-Order:
a+b*c^2-d/e
Post-Order:
abc2^*+de/-
Abbildung 30: Beispiel zur Baumtraversierung
¤
Informatik II – c Guido Rößling
Bäume – Binärer Baum : Traversierung
5.19
Vor- und Nachteile
Vorteile:
❑ In vielen Anwendungen sehr nützlich
❑ Gute Modellierung von hierarchischen Gebilden
❑ Bei ausgeglichenen Bäumen sehr gute Zugriffszeit: ¿4ÀRÁÃÂÄÆÅÇ©‘È
❑ Sehr einfaches Einfügen und Löschen
❑ Durchlauf in Pre-, In- oder Post-Order sehr einfach
❑ (Fast) vollständige Bäume können leicht durch ein Array modelliert werden
Nachteile:
❑ Suche nach Elementen problematisch, da keine Sortierung
❑ Im Extremfall Entartung zur Liste (dann Zugriffe mit ¿9À©ÉÈ )
❑ Navigation durch Verfolgung von Zeigern (statt direktem Zugriff), kann im Extremfall bis
zu ¿4À©‘È führen
Die beiden ersten Nachteile werden durch den Übergang zum binären Suchbaum beseitigt.
¤
Informatik II – c Guido Rößling
Bäume – Binärer Baum : Vor- und Nachteile
5.20
Datenstruktur Heap
❑ Der Heap ist ein Spezialfall des Binärbaums.
❑ Ein Binärbaum mit © Knoten ist ein Heap der Größe © , wenn gilt:
☞ Der Binärbaum ist fast vollständig
☞ Die Werte (oder Schlüssel“) in den Knoten sind so angeordnet, daß der Wert des
”
Vaters immer größer oder gleich dem Wert seiner Nachfolger ist.
❑ Bei Darstellung des Binärbaums in einem Array (s. auf Seite 5.12f) ist die zweite Eigenschaft formalisierbar als
node[ Ê (i-1)/2Ë ] Ì node[¯ ] für ´® ÊÍÀ¯‘²Î´ÈÍÏU¬Ë:°s¯Q®Î© .
¤
Informatik II – c Guido Rößling
Bäume – Heap
5.21
Beispiele zum Heap
gültige Heaps
98
37
2
77
37
12
17
13
2
43
69
56
33
2
27
39
keine gültigen Heaps
72
18
9
2
69
13
7
39
26
37
9
12
9
33
14
Abbildung 31: Beispiel zu Heaps und Nicht-Heaps
¤
Informatik II – c Guido Rößling
Bäume – Heap : Beispiele
5.22
Erstellen eines Heaps
Die Erstellung eines Heaps erfolgt in zwei Schritten:
1. (Unsortiertes) Einfügen aller Elemente in einen fast vollständigen Binärbaum
2. Herstellen der Heap-Eigenschaft von unten her“
”
Unter der Heap-Eigenschaft wird dabei die bereits angeführte Bedingung verstanden, daß die Wurzel eines Teilbaums immer das Maximum aller Werte dieses Teilbaums sein muß.
Auf der nächsten Folie wird ein Algorithmus zum Erstellen eines Heaps vorgestellt.
¤
Informatik II – c Guido Rößling
Bäume – Heap : Erstellen
5.23
Algorithmus zum Erstellen eines Heaps
Zur Herstellung der Heap-Eigenschaft wird folgende Schleife ausgeführt ( versickern“):
”
1. Beginne bei dem letzten inneren Knoten.
2. Falls der Schlüssel des aktuellen Knotens kleiner als das Maximum der Schlüssel
der Unterbäume ist, vertausche den Schlüssel mit dem größten Schlüssel der beiden
Nachfolgerknoten; andernfalls fahre fort bei Schritt 4.
3. Falls durch Schritt 2 die Heap-Eigenschaft des betroffenen Unterbaums verletzt
wurde, führe Schritt 2 rekursiv auf dem Unterbaum aus.
4. Falls sich der Algorithmus bereits auf der Wurzel befindet, ist die Heap-Eigenschaft
hergestellt.
Andernfalls gehe zum nächsten inneren Knoten in Richtung Wurzel und fahre fort
bei Schritt 2.
¤
Informatik II – c Guido Rößling
Bäume – Heap : Erstellen
5.24
Beispiel zum Erstellen eines Heap
Einfügereihenfolge: 3, 7, 6, 11, 2, 9
Erstellen Binärbaum
Test Knoten 2
Test Knoten 1
3
3
3
7
11
6
2
9
7
11
6
2
9
7
11
9
2
6
Test Wurzel (Knoten 0)
Verletzung Heap-Eig.
Heap fertig erstellt.
3
11
11
11
7
3
9
2
6
7
7
9
2
6
3
9
2
6
Abbildung 32: Beispiel zum Erstellen eines Heaps
¤
Informatik II – c Guido Rößling
Bäume – Heap : Erstellen
5.25
Löschen in einem Heap
❑ In Heaps kann nur das oberste Element, d.h. die Wurzel, gelöscht werden.
❑ Zum Löschen der Wurzel wird der Knoten mit höchstem Index (d.h. das auf der untersten
Stufe am weitesten rechts stehende Blatt) zur neuen Wurzel.
❑ Da dieses Blatt als Wurzel in der Regel die Heap-Eigenschaft verletzt, muß der aus dem
Einfügen bekannte Algorithmus zum Versickern (auf Seite 5.24) auf die Wurzel angewendet werden.
❑ Als Ergebnis entsteht wiederum ein Heap.
¤
Informatik II – c Guido Rößling
Bäume – Heap : Löschen
5.26
Beispiel zum Löschen in einem Heap
Ersetzen der Wurzel
durch letztes Blatt
Versickern der Wurzel
6
9
11
7
3
9
2
6
9
7
3
2
7
3
6
2
Abbildung 33: Beispiel zum Löschen in einem Heaps
¤
Informatik II – c Guido Rößling
Bäume – Heap : Löschen
5.27
Vor- und Nachteile
Vorteile:
❑ Vorteile des binären Baums
❑ Elemente sind nach Prioritäten oder Größenordnung sortiert
❑ Basisstruktur für eines der effizientesten Sortierverfahren: Heapsort
Nachteile:
❑ Navigation durch Verfolgung von Zeigern statt direktem Zugriff.
Im schlimmsten Fall führt dies aber nur zu Ð9ÑRÒÔÓÕÆÖÇ×‘Ø .
❑ Suche nach Elementen problematisch, da nur ein grobes Sortierungskriterium vorliegt.
Die beiden aufgeführten Nachteile greifen bei Heaps in der Regel allerdings nicht, da keine
Navigation oder Suche vorgesehen ist.
¤
Informatik II – c Guido Rößling
Bäume – Heap : Vor- und Nachteile
5.28
Priority Queue
❑ Ab Folie 4.37 wurde die Datenstruktur Queue (Warteschlange) vorgestellt. Warteschlangen eignen sich gut für viele Probleme; in manchen Fällen sollen aber Ereignisse wie etwa
Interrupts nicht einfach nach Reihenfolge des Auftretens behandelt werden
☞ Anordnung z.B. nach Dringlichkeit oder Priorität
❑ Dazu bietet sich eine Priority Queue an
❑ Statt Einfügen der Elemente am Ende und Entnahme am Anfang erfolgt die Einordnung
neuer Elemente gemäß ihrer Priorität
❑ Eine Priority Queue läßt sich zunächst leicht mit einer verketteten Liste implementieren.
☞ Aufgrund des Aufwands ( Ð4Ñ×‘Ø ) zur Bestimmung der korrekten Einfügeposition
ist dies aber relativ ineffizient
❑ Eine einfache und elegante Möglichkeit zur Implementierung bietet der Heap an.
¤
Informatik II – c Guido Rößling
Bäume – Priority Queue
5.29
Einfügen und Löschen
❑ Zum Einfügen eines neuen Elements wird dieses einfach an die erste freie Blattposition
eingefügt.
❑ Nun wird die Heap-Eigenschaft wiederhergestellt, indem das neue Element solange mit
seinem direkten Vorfahren vertauscht wird, bis sein Wert kleiner als der seines direkten
Vorgängers ist.
☞ Das Ergebnis dieses Vorgangs ist wieder ein Heap und gleichzeitig eine Priority
Queue
❑ Um das Element mit der höchsten Priorität zu entnehmen, muß lediglich die Wurzel durch
das Blatt mit höchstem Index ersetzt und danach die Heap-Eigenschaft hergestellt werden.
☞ Die entnommene Wurzel ist das Element mit der höchsten Priorität
☞ Das Ergebnis dieser Operation ist wieder ein Heap und ebenfalls eine Priority
Queue
Der Heap eignet sich also hervorragend zur Modellierung einer Priority Queue.
¤
Informatik II – c Guido Rößling
Bäume – Priority Queue : Einfügen und Löschen
5.30
Vor- und Nachteile
❑ Da die Priority Queue in der Regel direkt einen Heap verwendet, sind die Vor- und Nachteile zu denen des Heaps identisch.
❑ Für die Verwendung von Prioritätslisten erhält man mit dem Heap eine sehr effiziente
Implementierung, die bei Beschränkung der Queue-Länge auf eine feste Größe auch noch
auf ein Array abgestützt werden kann.
¤
Informatik II – c Guido Rößling
Bäume – Priority Queue : Vor- und Nachteile
5.31
Binärer Suchbaum
Ein binärer Suchbaum ist ein weiterer wichtiger Spezialfall des Binärbaums.
Binäre Suchbäume existieren nur für sortierbare“ Einträge, d.h. Einträge, auf denen die Ope”
ration “ verfügbar ist (oder vom Programmierer implementiert wurde).
”Ù
Der binäre Suchbaum ist wie folgt definiert:
❑ Alle Schlüssel im linken Teilbaum eines Knotens sind kleiner als der Schlüssel in
der Wurzel
❑ Alle Schlüssel im rechten Teilbaum eines Knotens sind größer als der Schlüssel
in der Wurzel
❑ der linke und rechte Unterbaum eines jeden Knotens sind ebenfalls binäre
Suchbäume (sofern sie existieren).
Entsprechend ist das kleinste Element stets der am weitesten links angeordnete Knoten; das
größte Element der am weitesten rechts stehende Knoten.
¤
Informatik II – c Guido Rößling
Bäume – Binärer Suchbaum
5.32
Beispiel zu binären Suchbäumen
v
>v
<v
a)
Grundschema des
binären Suchbaums:
linker Unterbaum kleiner,
rechter größer als die Wurzel
c)
b)
7
7
5
4
3
13
6
12
7
13
4
5
5
12
13
4
6
6
a) und b) sind binäre Suchbäume;
c) ist kein binärer Suchbaum:
4<5, aber im rechten Unterbaum der 5
6<7, aber im rechten Unterbaum der Wurzel 7
Abbildung 34: Beispiele für binäre Suchbäume
¤
Informatik II – c Guido Rößling
Bäume – Binärer Suchbaum : Beispiel
5.33
Einfügen in binären Suchbäumen
❑ Beim Einfügen eines Knotens muß die passende“ Position bestimmt werden: Ist der
”
Schlüssel des Knotens kleiner als der Schlüssel der Wurzel, so wird im linken Unterbaum
weitergesucht; andernfalls im rechten Unterbaum.
❑ Falls der gleiche Schlüssel bereits im Baum enthalten ist, wird er nicht erneut eingefügt.
Jeder Schlüssel kommt also nur genau einmal vor.
❑ Der Aufbau des binären Suchbaums ist von der Reihenfolge der Einfügeoperationen abhängig.
¤
Informatik II – c Guido Rößling
Bäume – Binärer Suchbaum : Einfügen
5.34
Beispiel zum Einfügen im binären Suchbaum
Einfügereihenfolge: 2, 5, 3, 1, 4
2
2
2
2
5
5
2
1
5
3
1
5
3
3
4
Einfügereihenfolge: 4, 5, 2, 3, 1
4
4
4
5
2
4
5
2
4
2
5
3
1
5
3
Abbildung 35: Beispiel zum Einfügen in einen binären Suchbaum
¤
Informatik II – c Guido Rößling
Bäume – Binärer Suchbaum : Einfügen
5.35
Löschen im binären Suchbaum
Das Löschen in einem binären Suchbaum ist etwas aufwendiger als das Einfügen.
Nach Bestimmung der Position des zu löschenden Elements sind drei Fälle zu unterscheiden:
❑ Der zu löschende Knoten ist ein Blatt.
In diesem Fall kann er einfach entfernt werden; die Operation ist abgeschlossen.
❑ Der zu löschende Knoten hat genau einen Unterbaum.
In diesem Fall wird der Knoten entfernt und durch die Wurzel seines Unterbaums ersetzt.
❑ Der zu löschende Knoten hat zwei nicht-leere Unterbäume.
In diesem Fall wird der Knoten entweder durch den größten Schlüssel im linken Teilbaum
oder durch den kleinsten Schlüssel im rechten Teilbaum ersetzt.
Dieses Element ist immer entweder ein Blatt oder ein Knoten mit nur einem Unterbaum,
so daß das Entfernen des ausgetauschten Knotens mit den beiden oberen Schritten erfolgen kann.
Das Suchen in binären Suchbäumen wird später (auf Seite 9.16f) behandelt.
¤
Informatik II – c Guido Rößling
Bäume – Binärer Suchbaum : Löschen
5.36
Beispiel zum Löschen im binären Suchbaum
Fall 1:
x ist Blatt und kann einfach gelöscht werden.
y
y
Fall 3:
x hat zwei Unterbäume.
Ersetze x durch das größte Element links
oder das kleinste Element rechts.
x
x
z
z
y
z
Fall 2:
x hat genau einen Unterbaum.
Dieser wird zur Wurzel des Teilbaums.
x
gl
kr
z
oder
z
y
B1
B1
z
y
z
B2
B2
Abbildung 36: Beispiel zum Löschen im binären Suchbaum
¤
Informatik II – c Guido Rößling
Bäume – Binärer Suchbaum : Löschen
5.37
Vor- und Nachteile
Vorteile:
❑ Alle Vorteile des Binären Baums
❑ Einfache Suche
❑ Auch in einem Array darstellbar (bei Größenbeschränkung)
Nachteile:
❑ Effizienz und Aufbau von der Einfügereihenfolge abhängig: Zugriffe von Ð9ÑRÒÔÓÕÚÖ%×‘Ø bis
Ð4Ñ×‘Ø möglich.
¤
Informatik II – c Guido Rößling
Bäume – Binärer Suchbaum : Vor- und Nachteile
5.38
Höhenbalanzierter Baum
❑ Alle Operationen auf Binärbäumen arbeiten am besten, wenn der Baum vollständig oder
fast vollständig ist.
☞ (Fast) alle Blätter sind auf der gleichen Stufe, mit einer maximalen Schwankung von 1.
☞ Es sind stets maximal ÒÃÓÕ Ö × Schritte zum Erreichen eines beliebigen Knotens
von der Wurzel ab notwendig
❑ In dem Spezialfall eines Binären Suchbaums hängt der Aufbau des Baums aber – wie
schon gezeigt – stark von der Einfügereihenfolge ab.
❑ Höhenbalanzierte Bäume versuchen, bei Einfüge- und Löschoperationen dafür zu sorgen,
daß für jeden Knoten des Baum die Differenz zwischen der Höhe der Unterbäume nur
gering schwanken darf.
❑ Dabei wird kein Wert auf die Einhaltung des Kriteriums fast vollständig“ gelegt; es
”
dürfen also ruhig auch Lücken“ auftreten.
”
¤
Informatik II – c Guido Rößling
Bäume – AVL-Baum
5.39
AVL-Baum
❑ Der wichtigste Vertreter dieser Klasse ist der AVL-Baum, benannt nach seinen Erfinden
Adelson-Velskii und Landis, die den Algorithmus zum Einfügen und Löschen bereits 1962
publizierten.
❑ Zunächst wird für alle Knoten der Balanzierungsfaktor ÛAÜÝÑuÞßØ eines Knotens Þ
net
☞ ÛFÜÝÑRÞàØâáäãåÑRÞ4æ„Ø‘çµãÉÑuÞÝè7Ø
berech-
❑ Dabei sind Þ æué Þ è die Wurzeln des linken bzw. rechten Unterbaums von Þ und ãåÑRÞßØ die
Höhe des Baums mit Wurzel Þ
☞ ÛFÜÝÑRÞàØ gibt also den Höhenunterschied zwischen dem linken und dem rechten
Unterbaum des Knotens Þ an
❑ Ein AVL-Baum ist dann ein binärer Suchbaum, bei dem der Balanzierungsfaktor an jedem
Knoten betragsmäßig kleiner oder gleich 1 ist.
BF(K)
Balancierungsfaktor des Knotens
Wert
Wert des Knotens
Abbildung 37: Beispiel für einen Knoten eines AVL-Baums
¤
Informatik II – c Guido Rößling
Bäume – AVL-Baum
5.40
Einfügen in AVL-Bäumen
❑ Beim Einfügen in AVL-Bäumen kann das Balanzierungskriterium
ê
ÛFÜÝÑRÞàØ
êÇë
ì
für alle Knoten Þ
verletzt wird.
☞ In diesem Fall muß eine Rebalanzierung erfolgen
☞ andernfalls wird wie im binären Suchbaum eingefügt
❑ Bei der Rebalanzierung wird der dem eingefügten Knoten näheste Vater í
ÛFÜÝÑîíïØáäðòñ bestimmt.
mit
❑ Der Pfad zum eingefügten Knoten hat dann einen von vier Typen: LL, LR, RL oder
RR.
❑ Die Fälle LL und RR sind am einfachsten zu lösen.
❑ Tabelle 12 auf Seite 5.42 gibt die auszuführenden Aktionen an, wenn ó
Knoten und ô der betroffene Vater mit ÛFÜÝÑuôAØáõðòñ ist.
der eingefügte
❑ Die Operationen werden in Abbildung 40 - 43 illustriert.
¤
Informatik II – c Guido Rößling
Bäume – AVL-Baum : Einfügen
5.41
Rotationstypen
Typ Rotationsname Rebalanzierungsaktion
LL Rechtsrotation ö wird im linken Unterbaum des linken Unterbaums von ÷ eingefügt. ÷
wandert in den rechten Unterbaum.
ö wird im rechten Unterbaum des rechten Unterbaums von ÷ eingefügt.
RR Linksrotation
÷ wandert in den linken Unterbaum.
ö
wird im rechten Unterbaum des linken Unterbaums von ÷ eingefügt.
÷ wird zur Wurzel des rechten Unterbaums von ÷ ; die neue Wurzel ist
der Vater von ö .
ö wird im linken Unterbaum des rechten Unterbaums von ÷ eingefügt.
÷ wird zur Wurzel des linken Unterbaums von ÷ ; die neue Wurzel ist der
Vater von ö .
LR Doppelrotation
RL Doppelrotation
Tabelle 12: Rotationsformen in AVL-Bäumen
¤
Informatik II – c Guido Rößling
Bäume – AVL-Baum : Rotationstypen
5.42
Schema zu den einfachen Rotationstypen
balanciert
nach Einfügung
1
2
h+2
x4
0
x2
h
x2
B5
h+2
x2
LL
1
h
0
h+3
x4
L
Rebalancierter Unterbaum
0
h+1
B5
x4
B1
L
h
h
B1
h+2
h+1
h
B1
B3
-1
h+2
x2
h
h
B3
B3
-2
0
x2
x4
B5
h+2
R
0
h
B1
x4
RR
-1
h
B1
0
h+1
x2
x4
B5
R
h
h
B3
B5
h
h+1
B3
h
B5
h
B1
B3
Abbildung 38: Schematische Darstellung der Einfachrotationen in AVL-Bäumen
¤
Informatik II – c Guido Rößling
Bäume – AVL-Baum : Rotationstypen
5.43
Schema zu den Doppelrotationstypen
balanciert
1
nach Einfügung
2
h+2
x4
1
h
B5
x2
0
h
x3
B1
h-1
h-1
B3l
B5
R
0
h
LR(a)
1
h
B3r
B3r
B3l
2
-1
h+1
x3
h
x3
B1
h+2
x3
-1
h
0
x4
L
x2
Rebalancierter Unterbaum
h+3
h
B1
h+1
x4
B3r
B3l
h-1
B5
h
h-1
0
h+3
x4
h+2
x3
L
-1
x2
h
B5
R
-1
h-1
B3l
h
h-1
B1
0
h+1
x2
LR(b)
h
x3
B1
1
h
B3l
x4
h
B3r
h+1
B5
h
B3r
Abbildung 39: Schematische Darstellung der Doppelrotationen in AVL-Bäumen
¤
Informatik II – c Guido Rößling
Bäume – AVL-Baum : Rotationstypen
5.44
Beispiel zum Einfügen in AVL-Bäumen: LL
Einfügereihenfolge: 3 2 1 8 9 5 4 7 6
Wert
nach Rebalancierung
Baum nach Einfügen
0
3
3
1
2
3
0
2
0
2
1
3
LL
2
L
1
0
0
2
1
3
L
0
1
Abbildung 40: Beispiel zum Rebalanzieren in AVL-Bäumen: LL
¤
Informatik II – c Guido Rößling
Bäume – AVL-Baum : Beispiel zum Einfügen
5.45
Beispiel zum Einfügen in AVL-Bäumen: RR
Einfügereihenfolge: (3 2 1) 8 9 5 4 7 6
nach Rebalancierung:
-1
8
9
2
-2
-1
2
2
RR
0
-1
0
-2
1
3
1
3
0
0
1
8
R
0
-1
0
0
8
8
3
9
R
0
9
Abbildung 41: Beispiel zum Rebalanzieren in AVL-Bäumen: RR
¤
Informatik II – c Guido Rößling
Bäume – AVL-Baum : Beispiel zum Einfügen
5.46
Beispiel zum Einfügen in AVL-Bäumen: RL
Einfügereihenfolge: (3 2 1 8 9) 5 4 7 6
Wert
nach Rebalancierung
Baum nach Einfügen
5
-2
0
2
3
-1
4, 7
3
R
0
-1
1
8
RL
1
0
1
1
2
8
2
8
L
-1
0
0
0
0
0
0
0
3
9
1
5
9
1
5
9
0
0
0
5
4
7
Abbildung 42: Beispiel zum Rebalanzieren in AVL-Bäumen: RL
¤
Informatik II – c Guido Rößling
Bäume – AVL-Baum : Beispiel zum Einfügen
5.47
Beispiel zum Einfügen in AVL-Bäumen: LR
Einfügereihenfolge: (3 2 1 8 9 5 4 7) 6
nach Rebalancierung
6
-1
-1
3
3
1
2
2
8
0
1
2
LR
L
7
L
0
-1
0
0
-1
-1
1
5
9
1
5
8
0
1
0
0
0
4
7
4
6
9
0
6
Abbildung 43: Beispiel zum Rebalanzieren in AVL-Bäumen: LR
¤
Informatik II – c Guido Rößling
Bäume – AVL-Baum : Beispiel zum Einfügen
5.48
Löschen in AVL-Bäumen
❑ Das Löschen in AVL-Bäumen ist erheblich aufwendiger als das Einfügen.
❑ Wie bei den binären Suchbäumen kann das Löschen auch beim AVL-Baum auf das Umorganisieren von Randknoten (Knoten mit maximal einem Nachfolger) reduziert werden.
❑ Unter Umständen sind dabei Rebalanzierungen entlang des Pfads des Randknotens bis
hin zur Wurzel notwendig.
Die Rebalanzierung endet dabei wenn
☞ ab dem Vater des umgehängten Knotens die Wurzel erreicht wurde
☞ oder ein Knoten mit BF(K)=0 vor der Umorganisation angetroffen wird.
❑ Die Details zum Thema Löschen in AVL-Bäumen“ findet man bei Interesse in diversen
”
Informatik-Büchern.
¤
Informatik II – c Guido Rößling
Bäume – AVL-Baum : Löschen
5.49
Vor- und Nachteile
Vorteile:
❑ Alle allgemeinen Vorteile von Binären Bäumen
❑ Höhenbalanzierung garantiert Zugriffe von ø4ùRúÃûüÆýÇþ‘ÿ auch im worst case
❑ Einfache Suche nach Elementen
❑ Elemente sind sortiert
Nachteile:
❑ Aufwendiges Einfügen und Löschen durch Ausgleichsoperationen
¤
Informatik II – c Guido Rößling
Bäume – AVL-Baum : Vor- und Nachteile
5.50
B-Baum
❑ Der B-Baum ist eine sehr nützliche Baumstruktur, der nicht ein Binärbaum zugrundeliegt.
❑ Erstmals 1970 von R. Bayer und E. McCreight vorgestellt.
❑ Aufgrund der vielfältigen Anwendung, insbesondere in Datei- und Datenbanksystemen,
auch als The Ubiquitious B-Tree“ ( Der überall anzutreffende B-Baum“) bezeichnet
”
”
❑ Besonderes Kennzeichen: als Indexstrukturen sehr breite Bäume mit geringer Höhe und
daher günstigem Zugriff bieten
☞ Effizienz ist weitgehend unabhängig von der tatsächlichen Anzahl Elemente:
geeignet sowohl für 10 als auch für oder mehr Elemente.
❑ Verwendung von zwei Kenngrößen
☞ : Anzahl Einträge in einem Knoten
☞ : aktuelle Höhe des Baums
Im folgenden wird stets nur betrachtet.
¤
Informatik II – c Guido Rößling
Bäume – B-Baum
5.51
Eigenschaften von B-Bäumen
❑ Jeder Pfad von der Wurzel zu einem Blatt hat die gleiche Länge.
☞ Alle Blätter sind auf der gleichen Stufe
❑ Jeder Knoten außer der Wurzel und den Blättern hat mindestens Söhne.
☞ Die Wurzel ist entweder ein Blatt oder hat mindestens 2 Söhne
❑ Jeder Knoten hat höchstens Söhne.
❑ Jeder Knoten außer der Wurzel als Blatt hat mindestens und höchstens Einträge.
❑ Jeder Eintrag besteht aus einem Paar von Schlüsselwert und Daten
❑ Die Daten können in die Seite eingebettet oder nur als Zeiger vorhanden sein.
❑ Jeder Knoten ( Seite“) besteht aus Schlüsseleinträgen sowie immer einem Zeiger
”
zu Unterbäumen mehr als Schlüsseleinträge
❑ Der Zeiger vor einem Schlüssel verweist immer auf eine Seite, in der alle Elemente kleiner
als der Schlüssel sind
❑ Der Zeiger hinter einem Schlüssel auf eine Seite verweist, in der alle Einträge größer als
der Schlüssel sind (analog zum binären Suchbaum).
Informatik II – c Guido Rößling
Bäume – B-Baum : Eigenschaften
5.52
Schematischer Aufbau eines Knotens
&
' (
' (
' $ (
' (
' (
' (
' && (
' ('
(
) *
*
) *
) *
) *
) *
) *
) *
) ,+, *)
%$%$
&
+
L Byte
--.
" " %$% D1
K2 D2! ... Kb Db freier Platz
b## K1
P0
P1
P2
Pb
Abbildung 44: Schematischer Aufbau eines Knotens in B-Bäumen
❑ b gibt an, wieviele Schlüssel /0 und Daten 120 in dem jeweiligen Knoten enthalten sind.
❑ 340 verweist jeweils auf einen Unterbaum, dessen größter Schlüssel kleiner als Schlüssel
/06587 ù9;:=<>=?5ÿ und größer als Schlüssel /0îù@:A<B:C?5ÿ ist.
❑ Im folgenden werden nur die Zeiger auf Nachfolger sowie die Schlüsselwerte /
tet.
Informatik II – c Guido Rößling
Bäume – B-Baum : Aufbau eines Knotens
betrach-
5.53
Einfügen in B-Bäumen
❑ Die meisten Baumtypen wachsen beim Einfügen von der Wurzel zu den Blättern
❑ B-Bäume wachsen von den Blättern zur Wurzel.
❑ Im ersten Schritt wird ein leerer Knoten als Wurzel angelegt.
❑ Die ersten Schlüssel werden sortiert in der Wurzel eingefügt.
❑ Beim Einfügen des nächsten Schlüssels läuft die Wurzel über, da sie nur maximal ;D
Einträge haben darf.
❑ Zur Verarbeitung des Überlaufs wird ein Split durchgeführt.
☞ Auf der nächsten Folie wird ein Algorithmus für Split vorgestellt.
☞ Im Extremfall führt das Einfügen eines neuen Schlüssels zu einem Split bis
einschließlich der Wurzel und damit einer Erhöhung der Baumhöhe um eins
Informatik II – c Guido Rößling
Bäume – B-Baum : Einfügen
5.54
Split von B-Baumknoten
1. Füge den ùEFÿ -ten Schlüssel sortiert nach seinem Wert in die G Schlüssel
ein.
2. Fordere eine neue Seite in der Speicherverwaltung an
3. Teile die sortierten HIJ
Schlüssel in drei Teile auf: die kleinsten Schlüssel,
den Median und die größten Schlüssel.
4. Kopiere die größten Schlüssel in die neue Seite und entferne sie aus der alten
Seite
5. Entferne den Median aus der bisherigen Seite, die nun nur noch die kleinsten
Schlüssel beinhaltet
6. Füge den Median im Vaterknoten ein, falls dieser existiert. Gegebenenfalls sorgt
dies wiederum für einen Überlauf, so daß der Prozeß ab Schritt 3 wiederholt wird.
War die aktuelle Seite die Wurzel, fordere eine neue Seite an und trage den Median
als einzigen Schlüssel in der neuen Seite ein, die die neue Wurzel wird.
Informatik II – c Guido Rößling
Bäume – B-Baum : Einfügen
5.55
Schema des Splits in einem B-Baum
4
12
48
69
77
33
48 Median der Werte wird Wurzel
2
12
33
2
2
12
2
69
77
2
69
77
48
33
Abbildung 45: Schematische Darstellung des Splits in B-Bäumen
Informatik II – c Guido Rößling
Bäume – B-Baum : Einfügen
5.56
Beispiel zum Einfügen in einen B-Baum
Einfügereihenfolge:
77, 12, 48, 69, 33, 89, 97, 91, 37, 45, 83, 2, 5, 57, 90, 95, 99, 50
77, 12, 48, 69
4
12
33, 89, 97
1
48
2
12
33
4
69
77
89
91, 37, 45, 83
4
33
37
45
3
69
77
3
2
5
12
2
37
45
48
83
77
89
91
2
2
2, 5, 57, 90, 95
69
97
2
12
48
33
48
4
97
89
57
69
77
83
4
90
91
95
97
Abbildung 46: Beispiel zum Einfügen in B-Bäumen
Informatik II – c Guido Rößling
Bäume – B-Baum : Einfügen
5.57
Beispiel zum Einfügen in einen B-Baum, Teil 2
Einfügereihenfolge:
(77, 12, 48, 69, 33, 89, 97, 91, 37, 45, 83, 2, 5, 57, 90, 95), 99, 50
2
2
3
5
12
2
37
45
99
2
5
12
2
37
2
3
5
33
89
57
48
4
1
2
33
45
50
48
4
2
3
33
69
89
57
77
83
4
90
91
77
83
2
90
91
69
37
45
2
97
99
2
90
91
69
2
2
97
95
48
12
95
2
50
57
2
77
83
89
95
2
97
99
Abbildung 47: Beispiel zum Einfügen in B-Bäumen, Teil 2
Informatik II – c Guido Rößling
Bäume – B-Baum : Einfügen
5.58
Löschen in B-Bäumen
❑ Das Löschen in einem B-Baum ist relativ einfach.
❑ Zunächst wird die den Schlüssel enthaltende Seite bestimmt und der Schlüssel aus der
Seite entfernt.
❑ Für das Löschen in Blättern sind drei Fälle zu unterscheiden, die auf der nächsten Folie
angegeben werden.
❑ Beim Löschen in inneren Knoten gilt: der zu löschende Schlüssel wird durch den größten
Schlüssel im linken Unterbaum bzw. den kleinsten Schlüssel im rechten Unterbaum ersetzt.
❑ Nach Entfernen des gewählten Knotens muß die auf der nächsten Folie angegebene Prozedur auf die Seite angewendet werden, aus der der Knoten stammt.
Informatik II – c Guido Rößling
Bäume – B-Baum : Löschen
5.59
Fälle beim Löschen in B-Bäumen
❑ Nach dem Entfernen des Schlüssels verbleiben dort mindestens Schlüssel; die Seite
bleibt also gültig.
☞ In diesem Fall ist der Löschvorgang abgeschlossen
❑ Nach dem Entfernen hat die Seite Schlüssel, der direkte Nachbar der Seite besitzt aber
mehr als Schlüssel.
☞ In diesem Fall wandert der größte (linker Nachbar) bzw. kleinste (rechter Nachbar)
Schlüssel des Nachbarn in die Wurzel; der Wurzeleintrag wird als erster bzw. letzter
Schlüssel in die Seite eingefügt, aus der gelöscht wurde.
☞ Anschließend ist also eine neue Wurzel im Vater, und die aktuelle Seite besitzt , der
Nachbar mindestens Schlüssel.
☞ Dieser Ausgleichsvorgang setzt sich daher nicht im Baum fort.
❑ Nach dem Entfernen besitzt die Seite 2K= und eine Nachbarseite Schlüssel.
☞ Kopiere die KL Elemente der Seite in den Nachbarn und füge den Wurzeleintrag in der Mitte ein ☞ neue Seite mit MN2K
= Schlüsseln
☞ Die ursprüngliche, nun leere Seite kann freigegeben werden.
Informatik II – c Guido Rößling
Bäume – B-Baum : Löschen
5.60
Beispiel zum Löschen in einen B-Baum
1
12
2
91
48
33
Entfernen von 33:
2
48
69
77
89
2
93
97
3
69
77
89
2
93
97
2
77
89
2
93
97
2
93
97
91
12
1
3
unvollständiges Blatt!
Ausgleich über den Vaterknoten:
2
2
12
12
91
48
Entfernen von 77:
2
69
69
2
91
1 89
unvollständiges Blatt!
48
Mischen der beiden Knoten:
91
1
4
12
48
69
89
2
93
97
gelöschter Knoten
0
Abbildung 48: Beispiel zum Löschen in B-Bäumen
Informatik II – c Guido Rößling
Bäume – B-Baum : Löschen
5.61
Vor- und Nachteile
Vorteile:
❑ sehr effiziente Struktur für Suche
❑ Abspeicherung von Dateneinträgen direkt im Knoten bzw. Blatt möglich
❑ üblicherweise eine breite, aber flache Struktur
❑ sehr gut einsetzbar in Datenbanksystemen als Indexstruktur
❑ in der Regel Zuweisung einer Speicherseite zu einem Knoten ☞ effiziente Verwaltung
im Speicher
❑ einfache Navigation über die Elemente
❑ Relativ einfache Einfüge- und Löschoperationen
Nachteile:
❑ Möglicherweise große Speicherverschwendung durch freibleibende Zellen
❑ Navigation von einem Blatt zum nächsten problematisch (nur über Vater)
Informatik II – c Guido Rößling
Bäume – B-Baum : Vor- und Nachteile
5.62
Weitere Baumstrukturen
Neben den bereits vorgestellten Baumstrukturen gibt es noch die folgenden, die hier nicht
weiter betrachtet werden:
❑ 2-3-4 Bäume, bei denen jeder Knoten 1, 2 oder 3 Schlüssel enthält und entsprechend 2, 3,
4 Nachfahren besitzt.
❑ Rot-Schwarz-Bäume, die eine Umsetzung der 2-3-4 Bäume auf Binärbäume darstellen,
❑ Digitale Suchbäume, in denen die Einträge gemäß ihres alphanumerischen Werts gespeichert sind, d.h. die Einfügefolge durch den Bitcode bestimmt ist (0 = links, 1 = rechts),
❑ sowie weitere Sonderformen für spezifische Anwendungen.
Informatik II – c Guido Rößling
Bäume – Weitere Baumstrukturen
5.63
Informatik II – c Guido Rößling
Kryptologie
Graphentheorie
Graphenalgorithmen
Suchalgorithmen
Suche in Zeichenfolgen
Sortieralgorithmen
Hashing
Kompressionsverfahren
Primitive Datentypen
Listenstrukturen
Bäume
Sonstige Datentypen
Einleitung
Zahlendarstellung
Wo sind wir OPOQO ?
Bäume
5.64
Set
Die Datenstruktur Set repräsentiert eine Menge von Elementen.
Charakteristisch für eine Menge sind folgende Eigenschaften:
❑ Es lassen sich Durchschnitt R , Vereinigung S und Differenz T von Mengen bilden.
☞ Das Ergebnis ist wiederum eine Menge.
❑ Es kann ein Element in die Menge eingefügt werden sowie abgefragt werden, ob sich ein
bestimmtes Element der Menge befindet.
Das wiederholte Einfügen eines bereits enthaltenen Elements hat dabei keine Auswirkung:
jedes Element kann nur maximal einmal in einer Menge enthalten sein.
❑ Die Kardinalität der Menge ist die Anzahl der Elemente der Menge und kann abgefragt
werden.
❑ Es kann getestet werden, ob eine Menge Teilmenge einer anderen Menge ist.
❑ Die Einfügereihenfolge der Elemente ist unwesentlich.
Informatik II – c Guido Rößling
Sonstige Datentypen – Set
6.1
Implementierung von Sets
Mengen können auf die folgenden Arten implementiert werden:
❑ als (doppelt) verkettete Liste (zweckmäßigerweise sortiert)
In diesem Fall sind alle angeführten Operationen relativ aufwendig.
❑ in einer geeigneten Baumstruktur, etwa einem binären Suchbaum oder einem B-Baum.
Der Zugriff auf die Elemente sowie Einfügen und Löschen sind relativ einfach; die Realisierung der Mengenoperationen SUR und T bereitet einigen Aufwand.
❑ in einem boole’schen Array
Dies ist nur dann möglich, wenn Anzahl und Werte der möglichen Mengenelemente von
vorneherein feststehen (vgl. die Verwendung von Sets in PASCAL!).
In diesem Fall markiert true an Position < , daß Element < in der Menge enthalten ist. Die
Zuordnung des Element zu einem Arrayindex muß injektiv sein und vom Programmierer
vorgenommen werden.
Die Ausführung aller Operationen ist dann mit sehr geringem Aufwand realisierbar.
Informatik II – c Guido Rößling
Sonstige Datentypen – Set : Implementierung
6.2
Implementierung von Sets
❑ Mittels eines Dictionary ( Wörterbuch“).
”
In dem Dictionary besteht jedes Element aus einem Paar von Schlüssel und Objekt.
☞ Als Struktur für das Dictionary bieten sich wiederum Listen oder B-Bäume an
Der Aufwand bei Verwendung des Dictionary hängt stark davon ab, wie effizient das
Auffinden eines gegebenen Schlüssels ist.
Näheres dazu im Abschnitt Hashing“ ab Folie 12.1.
”
V
Informatik II – c Guido Rößling
Sonstige Datentypen – Set : Implementierung
6.3
Anmerkungen
❑ Aufgrund der vergleichsweise aufwendigen Implementierung der Mengenoperationen sollte der Einsatz von Sets sorgfältig überdacht werden.
❑ Falls die maximale Kardinalität WXZY\[ von vorneherein bekannt ist und jedem Element eine
Zahl im Intervall ]^P^Q^_a`b_dcCWXeY@[Pf injektiv zugeordnet werden kann, ist die Implementierung über ein Array sinnvoll.
❑ In allen anderen Fällen ist der Aufwand der Implementierung zu hoch, um die Verwendung eines Sets attraktiv zu machen.
V
Informatik II – c Guido Rößling
Sonstige Datentypen – Set : Anmerkungen
6.4
Bag
❑ Die Datenstruktur Bag (engl., Sack“) ist eine Erweiterung des Set.
”
❑ Während ein Set jedes Element aber nur maximal einmal enthalten kann, können Elemente in einer Bag auch mehrfach auftreten.
❑ Der Name stammt von einem Sack, in dem einfach der Reihe nach Elemente eingeräumt
werden und der anschließend alle eingefügten Elemente enthalten muß, inklusive mehrfacher Objekte.
❑ Die Implementierung einer Bag kann analog zu der des Set erfolgen, indem jedem Element noch ein Zähler über die Anzahl des Auftretens mitgegeben wird.
☞ Zweckmäßigerweise wird man bei der Array-Codierung statt einem BooleanArray nun also ein Integer-Array verwenden
❑ Bei der Bag ist nicht spezifiziert, welches von mehreren Elementen man bei dem Entfernen aus der Menge löscht.
❑ Bags teilen alle Vor- und Nachteile des Sets (siehe Folie 6.4).
V
Informatik II – c Guido Rößling
Sonstige Datentypen – Bag
6.5
Dateien (Files)
❑ Files (engl. Dateien“) stellen den Zugriff auf Dateien dar.
”
❑ Üblicherweise sind wenigstens die folgenden Operationen möglich:
☞ Öffnen einer Datei, wahlweise mit Lese- oder Schreibzugriff
☞ Lesen aus der Datei
☞ Schreiben in die Datei
☞ Schließen der Datei
❑ Erst durch das Schließen der Datei wird dabei in vielen Betriebssystemen der Inhalt der
Datei zugreifbar.
☞ Das vergessene Schließen einer Datei ist einer der häufigsten Fehler beim
Umgang mit Dateien
V
Informatik II – c Guido Rößling
Sonstige Datentypen – File
6.6
Zugriffsmöglichkeiten
❑ Optional kann auch ein gemischter Zugriff angeboten werden, in dem sowohl Lesen als
auch Schreiben möglich ist.
❑ Weitere Möglichkeiten sind das Öffnen zum Anhängen am Dateiende sowie das Positionieren innerhalb der Datei.
☞ Der Umfang der angebotenen Leistungen hängt von der jeweiligen Programmiersprache ab!
❑ In vielen Programmiersprachen sind die Befehle zum Lesen und Schreiben in eine Datei
vom Namen identisch zur Eingabe von Tastatur bzw. Ausgabe auf dem Bildschirm.
❑ So lauten etwa in Java die Befehl zum Schreiben auf den Bildschirm System.out.print
bzw. System.out.println; die entsprechenden Befehle für Dateien sind u.a. pw.print
und pw.println
☞ pw sei dabei ein Objekt vom Typ PrintWriter
.
V
Informatik II – c Guido Rößling
Sonstige Datentypen – File : Zugriff
6.7
Verarbeitung von Dateien beim Lesen
❑ Beim Lesen besteht in der Regel die Wahlmöglichkeiten zwischen dem Lesen der Einzelzeichen (characters) oder größerer Einheiten (elementare Datentypen oder Blöcke bestimmter Größe).
❑ In jedem Fall hat aber der Programmierer dafür Sorge zu tragen, daß
☞ die Reihenfolge der Lesebefehle zu dem Format der Datei paßt
☞ und bei Auftreten eines Fehlers mindestens die Datei geschlossen wird.
☞ Nach Möglichkeit sollte eine entsprechende Fehlermeldung ausgegeben werden und das Programm die Arbeit entweder fortsetzen oder sich in einem geordneten Zustand beenden.
❑ Zur Verarbeitung von Dateien sind Hilfsprogramme bzw. -routinen oder -klassen hilfreich,
die in der Regel als lexikalische Analysatoren oder Tokenizer bezeichnet werden.
V
Informatik II – c Guido Rößling
Sonstige Datentypen – File : Dateiverarbeitung
6.8
Verarbeitung von Dateien beim Lesen
❑ Die Aufgabe von Tokenizern ist es, die Menge Einzelzeichen in inhaltliche Symbole bestimmter Typen zu zerlegen
☞ etwa Zahl“, Wort“ oder Sonderzeichen“
”
”
”
❑ Diese Symbole werden dem Programmierer dann entsprechend gemeldet, so daß er nicht
mehr die Einzelzeichen verarbeiten muß.
❑ Die Aufgabe des Programmierers ist dann, das nächste Symbol anzufordern, zu überprüfen und dessen Wert zu bestimmen, um etwa aus Zahl“ zur tatsächlichen gelesenen
”
Zahl zu gelangen.
V
Informatik II – c Guido Rößling
Sonstige Datentypen – File : Dateiverarbeitung
6.9
V
Informatik II – c Guido Rößling
Kryptologie
Graphentheorie
Graphenalgorithmen
Suchalgorithmen
Suche in Zeichenfolgen
Sortieralgorithmen
Hashing
Kompressionsverfahren
Primitive Datentypen
Listenstrukturen
Bäume
Sonstige Datentypen
Einleitung
Zahlendarstellung
Wo sind wir ^P^Q^ ?
Sonstige Datentypen
6.10
Graphentheorie
❑ Bisher wurden Bäume als eine spezielle Form von Graphen eingeführt.
❑ Bäume wurden definiert als eine Menge von durch Kanten miteinander verbundenen Knoten, wobei die Kanten gerichtet von der Wurzel zu den Blättern verlaufen.
Zusätzlich durfte jeder Knoten nur maximal einen Vorgängerknoten besitzen.
❑ Bei Graphen entfallen diese Einschränkungen: ein Graph besteht aus Knoten, die durch
Kanten verbunden sind.
Die Kanten können dabei entweder gerichtet (☞ gerichteter Graph) oder ungerichtet sein
(☞ ungerichteter Graph).
❑ Im folgenden wird die Datenstruktur Graph formal definiert, Repräsentierungsmöglichkeiten von Graphen gezeigt und einige Standardalgorithmen für Graphen präsentiert.
V
Informatik II – c Guido Rößling
Graphentheorie
7.1
Definition von Graphen
Ein Graph G = ( gihkj ) ist eine Datenstruktur mit folgenden Eigenschaften:
l n ist eine endliche, nichtleere Menge, die Knotenmenge“.
❑ g m=
”
Die Elemente oqprg werden als Knoten bezeichnet.
g steht für vertices (Singular vertex), englisch für Eckpunkt, Knoten“.
”
❑ j s g tug ist eine Menge von Knotenpaaren, die Kantenmenge“.
”
Die Elemente `wvxhyozfUprj werden als Kante bezeichnet; Elemente `wo{hyo|f}prj
oder (direkter) Zyklus.
j steht für edges, also Kanten“.
”
als Schlinge
Ein Graph ohne Schlingen wird als schlingenlos bezeichnet. Besitzt er zusätzlich keine
(direkten oder indirekten) Zyklen, wird er azyklisch genannt.
V
Informatik II – c Guido Rößling
Graphentheorie – Definition
7.2
Gerichteter und ungerichteter Graph
❑ In einem ungerichteten Graphen ist die Anordnung der Knoten innerhalb eines Knotenpaars irrelevant: `wvxh~ozf m `oahyvaf . Beim ungerichteten Graph gelten Knoten v€ho als benachbart, wenn `wvxhyozfp‚j„ƒL`oahyvafp…j gilt.
❑ In einem gerichteten Graph hingegen gibt `v€hyozf an, daß eine Kante von v nach o existiert.
v wird dann als die Quelle oder Startknoten, o als Endknoten der Kante `wvxh~ozf bezeichnet
und auch als v‡† o notiert.
❑ In Abbildung 49 wird die Visualisierung von zwei Graphen angegeben.
Dabei werden die Graphen im linken Teil als ungerichtete, im rechts als gerichtete Graphen interpretiert.
❑ Wie zu erkennen ist, kann man die Knoten beliebig anordnen und hat auch große Freiheiten bei der Darstellung der Kanten.
V
Informatik II – c Guido Rößling
Graphentheorie – Definition : Gerichteter und ungerichteter Graph
7.3
Darstellung von Graphen
G = (V, E) mit V G = {1, 2, 3, 4}, EG = {(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)}
H = (V, E) mit V H= {A, B, C, D}, E H= {(A, B), (B, C), (C, D), (A, D), (A, C), (B, D)}
ˆ‰b‹Œ Ž”‰Œ‘“’@‘“‰Œ—–b—‹ ˜@Ž¡–Œ™ šI¢”Ž@›”‰Œ‘•‹ Œž”‰Œ—‰IŸP‘“–Œ’@ž”‰ŒŽ@ 1
4
1
4
ˆŠ‰Œ‹Œ Ž@‰Œ‘“’”‘•‰Œ—–Œ‹ ˜”Ž–Œ™ šœ›@‰Œ‘“‹ Œž@—‰Œ‰œŸQ‘“–Œ’”ž@‰ŒŽ@ 1
B
4
1
4
B
A
2
3
2
C
A
3
D
2
Darstellung von H
Darstellungen von G
3
2
3
Darstellungen von G
C
D
Darstellung von H
Abbildung 49: Darstellung von ungerichteten und gerichteten Graphen
V
Informatik II – c Guido Rößling
Graphentheorie – Definition : Darstellung
7.4
Teilgraphen und Isomorphie
❑ Ein Graph £ heißt Teilgraph eines Graphen ¤ , wenn alle Knoten oqprg¦¥ auch im Graph
¤ enthalten sind und zusätzlich alle Kanten §Jp‚j¥ in ¤ enthalten sind.
Man schreibt dann £ ¨©¤ “ bzw. £ m ¤ , falls die beiden Graphen identisch sind.
”
Formal:
£
¨©¤
ª
`«g¦¥Fs
g¦¬®­¯j¥°sCj¬{f
❑ £ wird als vollständiger Teilgraph von ¤ bezeichnet, wenn £ Teilgraph von ¤ ist und
jede Kante `wvxhyozfp…j¬ auch in j¥ enthalten ist, falls v€hodprg¦¥ .
Formal:
£
vollst. Teilgr. v. ¤
ª
`E£
¨©¤C­²±M`wvxhyozfB³´j¬4^P`\`wvµpLg¦¥µ­¶oqpLg8¥ifM†
`wvxhyozfp‚j¥Mf\f
❑ Zwei Graphen ¤·h£ gelten als isomorph, wenn sie nach ggf. Umbennenung von Knoten
in £ identisch sind, d.h. anschließend ¤ m £ gilt.
Die Isomorphie wird oft als ¤ ¸m £ geschrieben. In Abbildung 49 gilt ¤ ¸m £ .
❑ Der Isomorphiebegriff überträgt sich entsprechend auch auf Teilgraphen und vollständige
Teilgraphen.
V
Informatik II – c Guido Rößling
Graphentheorie – Definition : Teilgraphen und Isomorphie
7.5
Kantenfolge, Kantenzug und Weg
Sei ¤
m
¾ÁÀ8»
eine Folge von ÂÄÃÅ Knoten von ¤ .
`bgihkj2f Graph und _ m©¹ o´ºhyo¼»yhQ^½^Q^½h~o¾´¿;prg
❑ _ heißt Kantenfolge der Länge  von o´º nach oœ¾ , wenn für ];ÆAÇBÆ=²ÈFÅ gilt: `woœÉŒh~oÉ6À8»”fBp
j .
Falls ¤ gerichtet ist, ist o º der Startknoten und o ¾ der Endknoten, andernfalls sind beide
Endknoten der Kantenfolge _ .
oD»~hP^P^P^Phyo¾Ëʦ» sind die inneren Knoten von _ .
Für o´º m o¾ ist die Kantenfolge geschlossen.
❑ _ ist ein Kantenzug der Länge  von o º nach o ¾ , falls _ eine Kantenfolge der Länge  von
oIº nach o¾ ist und für ]JÆ=ÇkhÍÌÎÆ=ÂÏÈ=ÅhyÇm l Ì gilt: `woÉ«hoœÉ6À8»”fm l `woQнhyoËÐ\ÀÑ»”f .
Jede Kante darf in einem Kantenzug also maximal einmal auftreten.
❑ _ ist ein Weg der Länge  von oIº nach oœ¾ , wenn _ eine Kantenfolge der Länge  von oIº
nach oœ¾ ist und für ];Æ=ÇkhÍÌÎÆ=ÂihyÇm l Ì gilt oÉÒm l oËÐ .
In einem Weg darf jeder Knoten also nur maximal einmal auftreten.
❑ Ein Graph ist zusammenhängend, wenn es für jedes Paar Çh«ÌqpLg einen Weg von Ç nach
Ì gibt.
V
Informatik II – c Guido Rößling
Graphentheorie – Definition : Kantenfolge, -zug, Weg
7.6
Zyklus, Länge und Beispiel
❑ _ heißt Zyklus der Länge  , wenn _ eine geschlossene Kantenfolge der Länge  von oIº
nach o ¾ ist (d. h. o º m o ¾ f und _Ó m `o º hP^Q^½^Qho ¾Qʦ» f ein Weg ist.
Graphen ohne Zyklen heißen azyklisch.
❑ ԓ_eÔ gibt die Länge von _ an.
❑ Ist _ eine Kantenfolge von o nach Õ , so gibt es immer auch einen Weg von o nach Õ .
5
1
4
2
3
(1, 2, 3, 4, 5, 2, 3) ist Kantenfolge der Länge 6 von 1 nach 3
(1, 2, 5, 4, 2, 3) ist Kantenzug der Länge 5 von 1 nach 3
(1, 2, 5, 4, 3) ist Weg der Länge 4 von 1 nach 3
(2, 3, 4, 5, 2) ist Zyklus der Länge 4
Abbildung 50: Kantenfolge, Kantenzug, Weg und Zyklus
Ö
Informatik II – c Guido Rößling
Graphentheorie – Definition : Zyklus und Länge
7.7
Speicherung von Graphen
Ein Graph ¤
chert:
m
`«gihj2f mit ԓgdÔ m
 wird üblicherweise auf eine der folgenden Arten gespei-
❑ Speicherung in einer Adjazenzmatrix
❑ Speicherung in einer Adjazenzliste
❑ Speicherung in einer doppelt verketteten Kantenliste
Ö
Informatik II – c Guido Rößling
Graphentheorie – Speicherung
7.8
Speicherung in einer Adjazenzmatrix
❑ Die Matrix hat die Größe °t…Â . Der Eintrag an Position סÉØÐ ist dabei genau dann true
bzw. 1, wenn die Kante ÙwÇkh«ÌzÚ in j enthalten ist.
❑ Der Speicherplatzbedarf einer Adjazenzmatrix hängt nur von der Anzahl Knoten ab, nicht
von der Anzahl Kanten.
❑ Es ergibt sich immer ein Platzbedarf von ÂeÛ .
❑ Bei ungerichteten Graphen ist die Matrix symmetrisch, d.h. die Werte an Position ÙÇh«ÌzÚ
und Ù6Ìh~Ç\Ú sind identisch.
☞ Statt einer quadratischen Matrix könnte also auch eine (untere) Dreiecksmatrix verwendet werden mit ÂeÛÜœÝ Einträgen.
Ö
Informatik II – c Guido Rößling
Graphentheorie – Speicherung : Adjazenzmatrix
7.9
Speicherung in einer Adjazenzliste
❑ Bei Adjazenzlisten wird für jeden Knoten eine verkettete Liste angelegt, die die von dem
Knoten erreichbaren Kanten speichert. Die Reihenfolge der Einträge ist dabei üblicherweise aufsteigend sortiert.
❑ Bei Þà߶޴áâ Kanten im Graph benötigt die Adjazenzliste einen Speicherbedarf von ãUäåâ
Elementen. Die Startknoten“ werden dabei in einem Feld der Größe ã gespeichert.
”
❑ Adjazenzlisten sind eine einfache Repräsentation des Graphen.
Hinzufügen und Verfolgung von Kanten werden gut unterstützt; Entfernen oder Einfügen
von Knoten ist dagegen aufwendig.
❑ Der Test, ob eine Kante existiert, ist nicht so schnell wie bei einer Adjazenzmatrix.
æ
Informatik II – c Guido Rößling
Graphentheorie – Speicherung : Adjazenzliste
7.10
Speicherung in einer doppelt verketteten Adjazenzliste
❑ Hierbei werden sowohl die Knoten selbst als auch die Kantenlisten in doppelt verketteten
Listen gehalten.
❑ Jeder Eintrag der Kantenliste hat dabei drei Zeiger: Vorgänger und Nachfolger sowie
Zeiger auf die Kantenliste des Knotens.
❑ In der Knotenliste verweist jeder Knoten auf den vorherigen und nachfolgenden Knoten
sowie den Beginn seiner Kantenliste.
❑ Durch die doppelt verkettete Kantenliste (doubly connected arc list, DCAL“) werden die
”
Nachteile der Adjazenzliste vermieden.
æ
Informatik II – c Guido Rößling
Graphentheorie – Speicherung : doppelt verkettete Adjazenzliste
7.11
Beispiel zur Speicherung
Adjazenzliste von G
1
2
3
4
2
3
3
2
5
doppelt verkettete Adjazenzliste von G
6
1
2
3
4
5
6
1 2 3 4 5 6
4
6
1
2
3
Graph G
5
1
2
3
4
5
6
0
0
0
0
0
0
1
0
0
1
0
0
1
1
1
0
0
0
1
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
5
3
4
Adjazenzmatrix von G
Abbildung 51: Adjazenzmatrix, -liste und doppelte Liste
æ
Informatik II – c Guido Rößling
Graphentheorie – Speicherung : Beispiel
7.12
Gewichtung von Kanten
Bislang war die Anordnung der Knoten beliebig wählbar. In einigen Fällen ist dies aber nicht
zulässig, z.B. in den folgenden Fällen:
❑ Modellierung von geometrischen Punkten als Koordinaten
Hier wird jedem Punkt eine feste Koordinate zugeordnet; die Anordnung der Knoten ist
damit fest vorgegeben; es kann höchstens eine Skalierung der Knoten vorgenommen werden.
Beispiel: Darstellung von CAD-Zeichnungen als Graph.
❑ Gewichtete Kanten
Hierbei geht es nicht nur um die Frage existiert eine Kante“, sondern um das Gewicht
”
der Kante (in der Regel ç=è ).
Beispiel: Kostenfunktionen für die Verfolgung einer Kante; Verzögerungszeiten
æ
Informatik II – c Guido Rößling
Graphentheorie – Gewichtung von Kanten
7.13
Feste Anordnung mit Abstandsfunktion
❑ Der Fall feste Anordnung mit Abstandsfunktion“ stellt eine Kombination der beiden er”
sten Ansätze dar. Dabei sind die Punktkoordinaten vorgegeben und die Kanten gewichtet.
❑ Als Abstandsfunktion kann z.B. der euklidische Abstand (
vorgegebene Gewichtung.
é êÛ äëé ìÛ ) dienen oder eine
❑ Beispiel: Straßennetz mit Stadtkoordinaten und Straßenlängen
Generell kann die Gewichtung in einer Adjazenzmatrix anstelle der 1 bzw. von true direkt
eingetragen werden; bei Adjazenzlisten muß ein gesonderter Eintrag vorgesehen werden.
æ
Informatik II – c Guido Rößling
Graphentheorie – Gewichtung von Kanten
7.14
Gewichtung der Kanten, Adjazenzmatrix
Entfernung
Berlin (B)
Braunschweig (BR)
Dortmund (DO)
Düsseldorf (D)
Frankfurt am Main (F)
Hamburg (HH)
Heidelberg (HD)
Karlsruhe (KA)
Koblenz (KO)
Köln (K)
Mannheim (MA)
München (M)
Stuttgart (S)
Wiesbaden (WI)
B
—
230
490
570
560
290
640
690
610
570
630
580
630
580
BR
230
—
270
350
340
200
420
470
460
350
410
630
540
360
DO
490
270
—
610
270
350
330
390
190
90
330
650
450
240
D
570
350
610
—
230
420
300
350
160
50
290
630
420
210
F
560
340
270
230
—
500
90
140
120
190
90
400
210
30
HH
290
200
350
420
500
—
580
630
530
420
580
780
700
520
HD
640
420
330
300
90
580
—
60
280
260
20
340
130
100
KA
690
470
390
350
140
630
60
—
240
310
70
290
80
150
KO
610
460
190
160
120
530
280
240
—
120
180
510
320
100
K
570
350
90
50
190
420
260
310
120
—
250
580
380
170
MA
630
410
330
290
90
580
20
70
180
250
—
350
140
90
M
580
630
650
630
400
780
340
290
510
580
350
—
220
430
S
630
540
450
420
210
700
130
80
320
380
140
220
—
230
WI
580
360
240
210
30
520
100
150
100
170
90
430
230
—
Tabelle 13: Entfernungsnetz in Deutschland (Autobahnkilometer, gerundet)
Informatik II –
æc
☞ Geben diese Informationen eine eindeutige Knotenanordnung vor?
Guido Rößling
Graphentheorie – Gewichtung von Kanten
7.15
Durchlaufen von Graphen
Ähnlich zur Traversierung von Bäumen müssen auch Graphen für viele Probleme durchlaufen werden. Die beiden häufigsten Verfahren dazu sind die Tiefensuche und die Breitensuche.
Die Tiefensuche ist die Verallgemeinerung des Pre-Order Durchlaufs bei Bäumen und läuft
wie folgt ab:
1. Markiere alle Knoten als nicht besucht“ (z.B. mittels eines boole’schen Feldes)
”
2. Wähle einen nicht besuchten Knoten íëîFï als Startknoten, z.B. den Knoten mit
kleinstem Index
3. Markiere den Startknoten als besucht“
”
4. Falls es eine Kante vom Startknoten zu einem nicht besuchten Knoten ð gibt, setze
ð als Startknoten und fahre mit Schritt 3 fort.
Andernfalls fahre fort mit Schritt 2, bis alle Knoten besucht sind.
Das Grundschema ist also das in die Tiefe gehen“, d.h. einen Nachfolgerknoten ð des aktu”
ellen Knotens zu suchen und dann von ð aus weiterzusuchen.
æ
Informatik II – c Guido Rößling
Graphentheorie – Durchlaufen : Tiefensuche
7.16
Algorithmus für Tiefensuche
/ ñzñ
ñ S t a r t e Tiefensuche ab Knoten Nummer i n d e x
ñ /
public void t i e f e n s u c h e ( i n t [ ] [ ] a , i n t i n d e x )
ò
int i , n = a . length ;
/ / Aktionen a u f dem Knoten óó
hier leergelassen
/ / m arkieren a l s besucht
v i s i t e d [ index ] = true ;
õ
/ / Besuche r e k u r s i v a l l e N a c h f o l g e r
f o r ( i = 0 ; i ô n ; i ++)
i f ( a [ i n d e x ] [ i ] ! = 0 & & ! v i s i t e d [ i ] ) / / Kante zu unbesucht ?
tiefensuche (a , i ) ;
/ / dann mache Rekursion i n d i e T i e f e
Listing 6: Tiefensuche
æ
Informatik II – c Guido Rößling
Graphentheorie – Durchlaufen : Tiefensuche
7.17
Initialisierung des Pseudo-Algorithmus für Tiefensuche
/ ñzñ
ñ I n i t i a l i s i e r e A l g o r i t h m u s f u e r Tiefensuche
ñ /
public void s t a r t e T i e f e n s u c h e ( i n t [ ] [ ] a )
ò
int i , n = a . length ;
v i s i t e d = new boolean [ n ] ;
// Initialisierung
f o r ( i = 0 ; i ô n ; i ++)
v i s i t e d [ i ] = false ;
/ / A l l e Knoten noch n i c h t besucht
õ
/ / Durchfuehren der Tiefensuche
f o r ( i = 0 ; i ô n ; i ++)
i f ( ! v i s i t e d [ i ] ) / / Knoten noch n i c h t besucht ? == ö
tiefensuche (a , i ) ;
besuchen !
Listing 7: Initialisierung der Tiefensuche
æ
Informatik II – c Guido Rößling
Graphentheorie – Durchlaufen : Tiefensuche
7.18
Beispiel für Tiefensuche
unbesucht
6
1
6
4
1
5
2
6
1
4
3
1
2
4
2
1
4
3
1
2
4
2
1
4
3
1
2
4
2
3
6
1
5
3
4
5
6
5
3
6
5
6
5
3
6
5
6
5
2
4
2
aktuell
6
5
3
1
besucht
4
5
3
2
3
Alle Knoten wurden besucht -- Ende der Tiefensuche.
Abbildung 52: Beispiel zur Tiefensuche
æ
Informatik II – c Guido Rößling
Graphentheorie – Durchlaufen : Tiefensuche
7.19
Breitensuche
Bei der Breitensuche wird in die Breite“ gegangen, d.h. es werden direkt alle Söhne eines
”
Knotens betrachtet, bevor der erste Enkel betrachtet wird.
1. Markiere alle Knoten als nicht besucht“ (z.B. mittels eines boole’schen Feldes)
”
2. Wähle einen nicht besuchten Knoten íëîFï als Startknoten, z.B. den Knoten mit
kleinstem Index
3. Markiere den Startknoten als besucht“ und stelle ihn in eine Queue
”
4. Markiere alle noch nicht besuchten Söhne des Startknotens als besucht und stelle
sie gleichzeitig in eine Warteschlange.
Bereits besuchte Söhne werden ignoriert.
5. Hole den ersten Knoten der Queue als neuen Startknoten und fahre fort mit 4.
Ist die Queue leer, so sind alle von dem ursprünglichen Knoten aus erreichbaren
Knoten bereits besucht. Fahre in diesem Fall fort mit Schritt 2, bis alle Knoten
besucht wurden.
Als Datenstruktur für dieses Vorgehen bietet sich eine Queue an.
æ
Informatik II – c Guido Rößling
Graphentheorie – Durchlaufen : Breitensuche
7.20
Implementierung der Breitensuche
/ ÷P÷
÷ S t a r t e B r e i t e n s u c h e ab Knoten Nummer i ndex
÷ /
public void b r e i t e n s u c h e ( i n t [ ] [ ] a , i n t i ndex ) ø / / S t a r t e b e i ’ i ndex ’
i n t thisNode , i , n = a . l e n g t h ;
Queue queue = new Queue ( ) ;
/ / Einfuegen i n d i e L i s t e
queue . enqueue (new I n t e g e r ( i ndex ) ) ;
v i s i t e d [ i ndex ] = t r ue ;
while ( ! queue . isEmpty ( ) ) ø
/ / Ausfuehren , solange Queue n i c h t l e e r
try ø
thisNode = ( ( I n t e g e r ) queue . dequeue ( ) ) . i n t V a l u e ( ) ; / / Hole Knoten
/ / ggf . A k ti onen auf dem Knoten
for ( i =0; i ù n ; i ++)
/ / Besuche a l l e N a c h f o l g e r
i f ( a [ thisNode ] [ i ] ! = 0 & & ! v i s i t e d [ i ] ) ø / / ’ neue ’ Kante?
/ / m ar k i er e a l s ’ besucht ’
queue . enqueue (new I n t e g e r ( i ) ) ;
t
r
ue
;
/
/
und
m
ar
k
i
er
e
a
l s besucht
v
i
s
i
t
e
d
[
i
]
=
ú
ú
ú
ú
catch ( S t r u c t u r e I s E m p t y E x c e p t i o n e )
ø
ú
Listing 8: Breitensuche
æ
Informatik II – c Guido Rößling
Graphentheorie – Durchlaufen : Breitensuche
7.21
Initialisierung des Pseudo-Algorithmus für Breitensuche
/ ñzñ
ñ I n i t i a l i s i e r e Algorithmus fuer Breitensuche
ñ /
public void s t a r t e B r e i t e n s u c h e ( i n t [ ] [ ] a )
ò
int i , n = a . length ;
v i s i t e d = new boolean [ n ] ;
// Initialisierung
f o r ( i = 0 ; i ô n ; i ++)
v i s i t e d [ i ] = false ;
õ
/ / Knoten noch n i c h t besucht
/ / Durchfuehren der B r e i t e n s u c h e
f o r ( i = 0 ; i ô n ; i ++)
i f ( ! v i s i t e d [ i ] ) / / Knoten noch n i c h t besucht ? == ö
breitensuche ( a , i ) ;
Besuchen
Listing 9: Initialisierung der Breitensuche
û
Informatik II – c Guido Rößling
Graphentheorie – Durchlaufen : Breitensuche
7.22
Beispiel Breitensuche
unbesucht
6
6
1
4
2
4
1
3
2
3
1
5
3
4 5 6
4
3
5 6
2
4
2
1
3
2
1
6
4
1
5
3
2
6 3
3
2 4 5 6
6
4
4
5
2 4 5
5
2
6
5
6
1
5
1
2 4
6
4
4
2
2
1
6
5
2
6
head
Queue
tail
1
5
3
aktuell
6
1
5
head
Queue
tail
besucht
4
5
3
2
3
3
Alle Knoten wurden besucht -- Ende der Breitensuche.
Abbildung 53: Beispiel zur Breitensuche
û
Informatik II – c Guido Rößling
Graphentheorie – Durchlaufen : Breitensuche
7.23
û
Informatik II – c Guido Rößling
Graphentheorie
Kryptologie
Graphentheorie
Graphenalgorithmen
Suchalgorithmen
Suche in Zeichenfolgen
Sortieralgorithmen
Hashing
Kompressionsverfahren
Primitive Datentypen
Listenstrukturen
Bäume
Sonstige Datentypen
Einleitung
Zahlendarstellung
Wo sind wir üPüQü ?
7.24
Minimaler spannender Baum
❑ Ein minimaler spannender Baum eines gewichteten Graphen ist eine Menge von Kanten,
die alle Knoten miteinander so verbindet, daß die Summe der Kantengewichte minimal
ist.
❑ Der minimale spannende Baum muß nicht eindeutig sein; zu jedem gewichteten Graph
gibt es aber mindestens einen minimalen spannenden Baum.
❑ Minimale spannende Bäume sind z.B. für folgende Fragestellung interessant: Finde die
”
billigste Möglichkeit, alle Punkte zu verbinden“. Diese Frage stellt sich z.B. für elektrische Schaltungen, Flugrouten und Autostrecken.
❑ Das einfachste Verfahren zur Erzeugung eines minimalen spannenden Baums stammt von
Prim aus dem Jahr 1952. In diesem Verfahren wird zu dem bereits vorhandenen Teilgraph
immer die billigste Kante hinzugefügt, die den Teilgraph mit einem bisher noch nicht
besuchten Knoten verbindet.
û
Informatik II – c Guido Rößling
Graphenalgorithmen – Minimaler spannender Baum
8.1
Vorgehen Algorithmus von Prim
1. Markiere alle Knoten als nicht besucht
2. Erstelle eine neue Adjazenzmatrix mst, in der die tatsächlich verwendeten Kanten
eingetragen werden (anfangs alle Elemente 0)
3. Wähle einen beliebigen Knoten als Startknoten aus.
4. Markiere den gewählten Knoten als besucht.
5. Wähle die billigste Kante, die von einem bereits besuchten Knoten aus zu einem
anderen, noch nicht besuchten Knoten führt, und trage sie in mst ein.
6. Wiederhole Schritt 4 und 5, bis alle Knoten besucht sind.
Das Auffinden der billigsten Kante kann z.B. durch Eintragen der Gewichte mit Angabe von
Start- und Endknoten in einer Priority Queue erfolgen oder durch Durchlaufen der Adjazenzmatrix a mit Vermerken der Position des bisherigen Minimums, da die Reihenfolge der
Kanteneinfügung irrelevant ist.
Die Komplexität des Algorithmus ist ýÄþ~ÿÎÿ .
Informatik II – c Guido Rößling
Graphenalgorithmen – Minimaler spannender Baum : Alg. von Prim
8.2
Beispiel zum Algorithmus von Prim
Was ergibt der Algorithmus von Prim für den folgenden Graphen?
2
c
a
4
1
3
5
6
d
2
e
b
5
1
4
f
Abbildung 54: Aufgabenstellung zum minimalen spannenden Baum nach Prim
Informatik II – c Guido Rößling
Graphenalgorithmen – Minimaler spannender Baum : Beispiel
8.3
Beispiel zum Algorithmus von Prim
2
c
4
1
2
c
2
c
1
d
2
c
b
5
6
d
2
5
1
3
b
d
2
5
1
4
f
c
1
5
2
5
1
f
4
3
a
b
5
6
d
2
1
b
d
e
4
f
3
6
4
5
4
a
2
5
6
2
1
f
4
a
c
d
e
2
b
5
6
4
1
f
3
a
2
1
3
e
e
5
4
a
4
b
5
6
e
4
1
3
a
e
5
1
4
f
Abbildung 55: Beispiel zum minimalen spannenden Baum nach Prim
Informatik II – c Guido Rößling
Graphenalgorithmen – Minimaler spannender Baum : Beispiel
8.4
Algorithmus von Kruskal
Etwas effizienter als der Algorithmus von Prim ist der Algorithmus von Kruskal:
1. Markiere alle Knoten als nicht besucht
2. Erstelle eine neue Adjazenzmatrix mst, in der die tatsächlich verwendeten Kanten
eingetragen werden (anfangs alle Elemente 0)
3. Bestimme die erste billigste Kante von einem Knoten zu , die entweder zwei
nicht erreichte Knoten verbindet, einen nicht erreichten mit einem erreichten Knoten oder zwei bisher unverknüpfte Teilgraphen verbindet.
Falls beide Knoten bereits erreicht wurden, kann diese Kante ignoriert werden, da
durch sie ein Zyklus entstehen würde.
4. Markiere und als erreicht und setze mst[i][j] = g, wobei g das Gewicht
der Kante þ
sei.
5. Fahre mit Schritt 3 fort, bis alle Knoten erreicht sind.
Der Algorithmus hat eine Komplexität von ý²þ~ÿ¶ÿ
Informatik II – c Guido Rößling
ÿÏÿ .
Graphenalgorithmen – Minimaler spannender Baum : Algorithmus von Kruskal
8.5
Beispiel zum Algorithmus von Kruskal
2
c
4
1
2
c
2
c
1
6
d
e
1
b
d
e
5
1
3
b
5
d
2
1
4
4
c
f
4
3
b
5
6
d
e
5
1
f
4
3
a
4
5
1
2
1
f
d
a
2
5
6
6
e
1
f
4
a
c
b
5
2
2
5
6
4
1
f
3
2
e
c
3
a
2
5
4
a
4
b
5
2
4
1
3
a
b
5
6
5
d
2
e
1
4
f
Abbildung 56: Beispiel zum minimalen spannenden Baum nach Kruskal
Informatik II – c Guido Rößling
Graphenalgorithmen – Minimaler spannender Baum : Algorithmus von Kruskal
8.6
Transitive Hülle
❑ Ein weiteres häufiges Problem ist die Frage Welche Knoten sind von einem gegebenen
”
Knoten aus erreichbar?“.
❑ In der Verallgemeinerung dieser Frage kann gefragt werden, welche Knoten von einem
Knoten erreichbar sind für ein beliebiges .
❑ Zur Lösung dieses Problems dient die Berechnung der transitiven Hülle. Die transitive
Hülle fügt in die Adjazenzmatrix an Position þ
einen Eintrag ein, wenn es einen Weg
von nach gibt – also nicht nur eine direkte Kante.
❑ Generell gilt: Falls ein Weg von nach
auch einen Weg von nach .
existiert sowie ein Weg von
nach , gibt es
❑ Die Aussage kann noch verschärft werden: Falls es einen Weg von nach gibt, der nur
Knoten mit Index verwendet, und einen Weg von nach , der ebenfalls nur Knoten
mit Index verwendet, gibt es auch einen Weg von nach , der nur Knoten mit Index
verwendet.
Informatik II – c Guido Rößling
Graphenalgorithmen – Transitive Hülle
8.7
Algorithmus von Warschall
/ Berechne d i e t r a n s i t i v e H u e l l e der A dj az enz m atr i x a i n O ( V ˆ 3 )
/
public
int [ ] [ ] trans itiveHull ( int [ ] [ ] a)
i f ( a = = n u l l a . l e n g t h = = 0 ) r et ur n n u l l ; / / M a t r i x l e e r "! Ende !
int i , j , x , n = a . length ;
i n t [ ] [ ] h u l l = new i n t [ a . l e n g t h ] [ a . l e n g t h ] ;
/ / Speicher holen
#
f o r ( i = 0 ; i ù a . l e n g t h ; i ++)
f o r ( j = 0 ; j ù a . l e n g t h ; j ++)
hull [ i ] [ j ] = a[ i ] [ j ] ;
f o r ( x = 0 ; x ù n ; x ++)
f o r ( i = 0 ; i ù n ; i ++)
i f ( h u l l [ i ] [ x ] ! = NO EDGE )
f o r ( j = 0 ; j ù n ; j ++)
i f ( h u l l [ x ] [ j ] ! = NO EDGE )
hull [ i ] [ j ] = 1;
r et ur n h u l l ;
/ / a l t e Werte k o p i e r e n
/ / G i b t es Weg von i nach x?
/ / . . . und Weg von x nach j ?
/ / Ja == ! t r a g e den Weg e i n
/ / Ergebnis zurueckgeben
Listing 10: Algorithmus von Warschall
Informatik II – c Guido Rößling
Graphenalgorithmen – Transitive Hülle : Alg. von Warschall
8.8
Beispiel zum Algorithmus von Warschall
6
5
6
5
0
1
3
4
6
5
0
1
3
4
4
5
0
1
4
5
21
2
3
2
3
21
0
1
3
4
0
1
x=4
3
4
4
5
2
3
21
2
3
6
5
4
5
2
3
3
4
x=2
6
5
4
5
x=3
2
3
x=1
6
5
3
4
0
1
4
5
21
x=0
21
3
4
4
5
21
0
1
6
5
2
3
21
x=5
Abbildung 57: Beispiel zur transitiven Hülle nach Warschall
Informatik II – c Guido Rößling
Graphenalgorithmen – Transitive Hülle : Alg. von Warschall
8.9
Topologische Sortierung
❑ Bei gerichteten Graphen können oft Zyklen auftreten. Eine häufige Problemstellung ist die
Frage, ob der Graph einen Zyklus enthält.
❑ Insbesondere bei Modellierung von Abläufen ist diese Frage entscheidend. Hier gibt eine
Kante þ
z.B. an, daß Tätigkeit vor Tätigkeit ausgeführt werden muß.
Existiert ein Zyklus, so muß z.B. ein Arbeitsvorgang $ vor ausgeführt werden, kann aber
erst nach Fertigstellung von begonnen werden.
❑ Von Interesse sind in so Fällen nur gerichtete Graphen ohne gerichtete Zyklen, die ge”
richteten azyklischen Graphen“ (directed acyclic graphs, dags).
❑ Eine topologische Sortierung eines gerichteten Graphen ordnet die Knoten so an, daß kein
Knoten vor einem auf ihn zeigenden Knoten verarbeitet wird. Im Beispiel der Ablaufsmodellierung treten also Aktivitäten , die eine Voraussetzung für Tätigkeit sind, in der
topologischen Sortierung vor auf.
Informatik II – c Guido Rößling
Graphenalgorithmen – Topologische Sortierung
8.10
Eigenschaften der topologischen Sortierung
❑ Alle Knoten mit Kante in Richtung treten in der topologischen Sortierung vor auf.
❑ Die Reihenfolge der topologisch sortierten Knoten ist nicht zwangsläufig eindeutig, da
sie nur mehrere partielle Ordnungen zu einer totalen Ordnung zusammenfügt.
❑ Genau für jeden dag gibt es eine entsprechende topologische Sortierung.
❑ Existiert keine topologische Sortierung für einen gerichteten Graphen % , so hat % mindestens einen gerichteten Zyklus.
Informatik II – c Guido Rößling
Graphenalgorithmen – Topologische Sortierung : Eigenschaften
8.11
Algorithmus zur topologischen Sortierung
1. Finde einen Knoten ohne Nachfolger.
Gibt es keinen solchen Knoten, enthält der Graph Zyklen (oder ist leer).
2. Entferne diesen Knoten und setze ihn an den Anfang der bisher erstellten topologisch
sortierten Liste.
3. Wiederhole Schritt 1, bis der Graph leer ist.
Alternativer Ansatz:
1. Finde einen Knoten ohne Vorfahren.
Gibt es keinen solchen Knoten, enthält der Graph Zyklen oder ist leer.
2. Entferne diesen Knoten und setze ihn an das Ende der bisher ertellten topologisch sortierten Liste.
3. Wiederhole Schritt 1, bis der Graph leer ist.
Informatik II – c Guido Rößling
Graphenalgorithmen – Topologische Sortierung : Algorithmus
8.12
Beispiel zur topologischen Sortierung
A
F
B
C
D
E
H
I
J
K
L
M
G
Abbildung 58: Beispiel zur topologischen Sortierung
Mögliche topologische Sortierungen dieses Graphen sind beispielsweise:
❑ABJLGCFEDKMHI
❑AJLGCFEDHIMKB
❑JKLMAGCFEDHIB
Informatik II – c Guido Rößling
Graphenalgorithmen – Topologische Sortierung : Beispiel
8.13
Kürzeste Verbindung von einem Knoten zu allen
❑ Eine oft gestellte Frage ist Was ist die kürzeste Verbindung vom Startknoten zu allen
”
anderen Knoten?“
Der Algorithmus von Dijkstra aus dem Jahr 1959 löst dieses Problem.
❑ Ausgehend vom Startknoten werden zunächst für alle Knoten die direkten Kosten eingetragen.
Nun wird der billigste noch nicht besuchte Knoten gewählt und getestet, ob von diesem
aus andere Knoten günstiger erreichbar sind. Die Änderungen werden gespeichert und der
Knoten als besucht markiert.
Das Vorgehen wird solange wiederholt, bis alle Knoten besucht wurden.
❑ Der Nachteil dieses Verfahrens ist, daß alle Kantengewichte &
endlose Zyklen als immer günstigere Lösung bestimmt würden.
'
sein müssen, da sonst
❑ Die Komplexität des Verfahrens von Dijkstra beträgt ý²þ~ÿÎÿ .
Informatik II – c Guido Rößling
Graphenalgorithmen – Kürzeste Pfade - Algorithmus von Dijkstra
8.14
Implementierung des Algorithmus von Dijkstra
/ Berechne den k uer z es ten Weg von Knoten m i t Index s t a r t zu a l l e n
anderen Knoten anhand der A dj az enz m atr i x gemaess D i j k s t r a .
Aufwand : O ( V ˆ 2 )
Ergebnis : Die Kosten zum E r r e i c h e n der e i n z e l n e n Knoten
/
public
int [ ] dijk str a ( int [ ] [ ] a , int start )
i f ( a == null
r et ur n n u l l ;
a . length == 0)
/ / Matrix leer . . .
boolean v i s i t e d [ ] = new boolean [ a . l e n g t h ] ;
i n t [ ] c o s t s = new i n t [ a . l e n g t h ] ;
i n t i , w= 0 , j , cheapestCost , n = a . l e n g t h ;
/ / Knoten besucht ?
/ / Kosten s t a r t (! i
v i s i t e d [ s t a r t ] = t r ue ;
/ / s t a r t besucht
for ( i =0; i ù n ; i ++)
/ / Kosten setzen
c o s t s [ i ] = ( a [ s t a r t ] [ i ] ! 0 ) ? a [ s t a r t ] [ i ] : NO EDGE ; / / I n i t
costs [ s t a r t ] = 0 ;
/ / S t ar t ” kostenlos ”
Listing 11: Algorithmus von Dijkstra, Teil 1
Informatik II – c Guido Rößling
Graphenalgorithmen – Kürzeste Pfade - Algorithmus von Dijkstra : Implementierung
8.15
Implementierung des Algorithmus von Dijkstra
f o r ( i = 0 ; i ) n ; i ++)
*
/ / suche n i c h t + besuchten Knoten w m i t c o s t s [ w ] m inim al
/ / maximale Kosten
cheapestCost = NO EDGE ;
f o r ( j = 0 ; j ) n ; j ++)
i f ( ! v i s i t e d [ j ] & & c o s t s [ j ] ) cheapestCost )
*
/ / f r e i und b i l l i g e r
w = j;
/ / merken
cheapestCost = c o s t s [w ] ;
/ / Kosten merken
,
,
,
v i s i t e d [w] = true ;
/ / m a r k i e r e w a l s besucht
f o r ( j = 0 ; j ) n ; j ++)
c o s t s [ j ] = min ( c o s t s [ j ] , c o s t s [ w ] + a [w ] [ j ] ) ;
return costs ;
/ / a l s Ergebnis l i e f e r n
Listing 12: Algorithmus von Dijkstra, Teil 2
Informatik II – c Guido Rößling
Graphenalgorithmen – Kürzeste Pfade - Algorithmus von Dijkstra : Implementierung
8.16
Beispiel zum Algorithmus von Dijkstra
A B
3
3 2 6 5
4 5
A
B
C
D
E
F
C D
2 6
5
-
E
4
5
-
1
2
1
-
-
-
-
F
1
2
-
4
-
1
4
-
Schritt
Init
1
2
3
4
B
3
3
3
3
3
Kosten
C D E
2 6 4
2 6 3
2 6 3
2 5 3
2 5 3
F Besucht
C
B
8
E
7
D
6
F
-
Tabelle 14: Beispiel zum Algorithmus von Dijkstra für start = A
2
c
4
1
3
a
2
5
6
d
2
e
b
5
1
4
f
c
4
1
3
a
6
d
2
e
b
5
5
1
4
f
Abbildung 59: Ergebnis des Algorithmus von Dijkstra
Informatik II – c Guido Rößling
Graphenalgorithmen – Kürzeste Pfade - Algorithmus von Dijkstra : Beispiel
8.17
Kürzeste Verbindung aller Knoten zueinander
Der Algorithmus von Dijkstra hat zwei Nachteile:
❑ Es werden nur die kürzesten Verbindungen von einem ausgezeichneten Startknoten zu
allen anderen Knoten bestimmt
❑ Die Gewichte aller Kanten müssen positiv sein.
Der Algorithmus von Floyd ist eine Verallgemeinerung des Algorithmus von Dijkstra. Er
berechnet die kürzeste Verbindung von allen Knoten zu allen Knoten.
Die zugrundeliegende Idee ist folgende:
❑ Zunächst werden alle direkten Verbindungen zweier Knoten als die billigste Verbindung
der beiden Knoten verwendet.
❑ Die billigste Verbindung zwischen zwei Knoten ist entweder die direkte Verbindung oder
aber zwei Wege über einen Mittelknoten.
Informatik II – c Guido Rößling
Graphenalgorithmen – Kürzeste Pfade - Algorithmus von Floyd
8.18
Anmerkungen zum Algorithmus
❑ Der Algorithmus von Floyd verwendet denselben Trick“ wie der Algorithmus zur Be”
rechnung der transitiven Hülle von Warschall (auf Seite 8.7 – 8.9).
❑ Es werden in jedem Schritt die bisher günstigen Pfade zum Erreichen aller Knoten errechnet, wobei in Schritt . nur direkte Verbindungen oder Kanten verwendet werden dürfen,
die nur Knoten mit Index kleiner oder gleich . benutzen.
☞ Erst im letzten Schritt erhält man das tatsächliche Ergebnis für alle Knoten.
❑ Alternativ könnte auch der Algorithmus von Dijkstra / -mal verwendet werden, indem
immer ein anderer Startknoten verwendet wird. Dies wäre aber extrem ineffizient.
❑ Der Algorithmus von Floyd arbeitet in 0214356387:9 , wie aus den drei geschachtelten Schleifen
des Algorithmus (auf Seite 8.20) leicht erkennbar ist.
Informatik II – c Guido Rößling
Graphenalgorithmen – Kürzeste Pfade - Algorithmus von Floyd : Anmerkungen
8.19
Implementierung des Algorithmus von Floyd
/ ;;
;
;
;
;
Berechne d i e k u e r z e s t e Verbindung von a l l e n Knoten zu a l l e n
Knoten nach dem A l g o r i t h m u s von Floyd i n O ( < V < ˆ 3 ) .
Parameter a : A dj az enz m atr i x des Graphen
Ergebnis : Die neue A dj az enz m at r i x m i t den b i l l i g s t e n Kosten
; /
public
int [ ] [ ] floyd ( int [ ] [ ] a)
=
i f ( a = = n u l l << a . l e n g t h = = 0 ) r et ur n n u l l ;
/ / Matrix leer / n u l l !
int i , j , x ;
/ / i = S t a r t > , j = End > , x = Zwischenknoten
i n t n = a . l e n g t h ; / / Groesse des Feldes
/ / Lege ei ne neue A dj az enz m atr i x an
i n t [ ] [ ] c = new i n t [ n ] [ n ] ;
/ / Kopiere a l l e Werte aus der M a t r i x : anfangs i s t d i e d i r e k t e
/ / Verbindung d i e e i n z i g e , und daher auch d i e b i l l i g s t e
f o r ( i = 0 ; i ? n ; i ++)
f o r ( j = 0 ; j ? n ; j ++)
c[ i ][ j ] = a[ i ][ j ];
/ / d i r e k t e Kanten k o p i e r e n
Listing 13: Initialisierung zum Algorithmus von Floyd
Informatik II – c Guido Rößling
Graphenalgorithmen – Kürzeste Pfade - Algorithmus von Floyd : Implementierung
8.20
Implementierung des Algorithmus von Floyd
/ / Suche f u e r Knoten x nach Wegen ueber x , d . h . i @BA x , x@CA j
for ( x = 0 ; x D n ; x ++)
/ / S c h l e i f e Zwischenknoten
f o r ( i = 0 ; i D n ; i ++)
i f ( c [ i ] [ x ] ! = NO EDGE )
/ / g i b t es einen Weg i @CA x?
f o r ( j = 0 ; j D n ; j ++)
i f ( c [ x ] [ j ] ! = NO EDGE )
/ / g i b t es einen Weg x@CA j ?
i f ( c [ i ] [ j ] = = NO EDGE / / noch k e i n Weg i @BA j ?
EE
( c[ i ][x] + c[x][ j ] D c[ i ][ j ])) // billiger?
c[ i ][ j ] = c[ i ][x] + c[x][ j ];
/ / = = A aufnehmen !
F
return c ;
/ / Ergebnis l i e f e r n
Listing 14: Algorithmus von Floyd
Informatik II – c Guido Rößling
Graphenalgorithmen – Kürzeste Pfade - Algorithmus von Floyd : Implementierung
8.21
Beispiel zum Algorithmus von Floyd
Ausgangsadjazenzmatrix
A
B
3
G
A
B
C
D
E
F
3
2
6
4
G
G
G
G
C
2
G
1
G
2
1
F
A
G
G
1
2
G
4
G
1
4
G
G
A
B
C
D
E
F
5
G
5
5
E
4
G
G
G
D
6
5
Ergebnis nach x=A
3
2
6
4
G
A B C D
4 3 2 6
3 6 5 5
2 5 4 8
6 5 8 10
3 6 1 2
7 5 9 1
G
C
2
5
4
8
1
D
6
5
8
12
2
1
E
4
7
1
2
8
4
F
G
5
G
1
4
G
A
B
C
D
E
F
Ergebnis nach x=E
Ergebnis nach x=D
A
B
C
D
E
F
B
3
6
5
5
7
5
Ergebnis nach x=B
E F
3 7
6 5
1 9
2 1
2 3
3 2
A
B
C
D
E
F
A
4
3
2
5
3
6
B C D
3 2 5
6 5 5
5 2 3
5 3 4
6 1 2
5 4 1
A B C D
6 3 2 6
3 6 5 5
2 5 4 8
6 5 8 10
4 7 1 2
8 5 10 1
Ergebnis nach x=C
E F
4 8
7 5
1 10
2 1
8 4
4 10
Ergebnis nach x=F
E F
3 6
6 5
1 4
2 1
2 3
3 2
A
B
C
D
E
F
A
4
3
2
5
3
6
B C D
3 2 5
6 5 5
5 2 3
5 3 2
6 1 2
5 4 1
E F
3 6
6 5
1 4
2 1
2 3
3 2
A B C
4 3 2
3 6 5
2 5 4
6 5 8
3 6 1
8 5 10
A
B
C
D
E
F
D E F
6 3 8
5 6 5
8 1 10
10 2 1
2 2 4
1 4 10
Endergebnis
A
B
C
D
E
F
A
4
3
2
5
3
6
B C D
3 2 5
6 5 5
5 2 3
5 3 2
6 1 2
5 4 1
E F
3 6
6 5
1 4
2 1
2 3
3 2
Tabelle 15: Algorithmus von Floyd
Informatik II – c Guido Rößling
Graphenalgorithmen – Kürzeste Pfade - Algorithmus von Floyd : Beispiel
8.22
I
Informatik II – c Guido Rößling
Graphenalgorithmen
Kryptologie
Graphentheorie
Graphenalgorithmen
Suchalgorithmen
Suche in Zeichenfolgen
Sortieralgorithmen
Hashing
Kompressionsverfahren
Primitive Datentypen
Listenstrukturen
Bäume
Sonstige Datentypen
Einleitung
Zahlendarstellung
Wo sind wir HHH ?
8.23
Typische Algorithmengebiete
❑ Eines der Hauptprobleme der Informatik die Entwicklung präziser, formalisierter Verfahren zur Lösung von Problemen.
❑ Die so gewonnenen Algorithmen dienen dann nicht nur zur Lösung eines konkreten Problems, sondern (fast) aller Probleme dieser Art.
Die häufigsten Algorithmengebiete sind:
☞ Suchverfahren,
☞ Sortierverfahren,
☞ Hashing,
☞ Kompressionsverfahren und
☞ Kryptologie.
❑ Im folgenden werden Vertreter der ersten drei Klassen vorgestellt.
I
Informatik II – c Guido Rößling
Elementare Suchalgorithmen
9.1
Suchalgorithmen
Die erste Hauptklasse von Algorithmen beschäftigt sich mit der Suche nach Elementen. Bei
den Elementen kann es sich um Zahlen, Zeichen, Zeichenfolgen oder Objekte handeln, die in
einer Datenstruktur abgelegt sind.
Prinzipiell können dabei die folgenden Fälle eintreten:
❑ Das Element ist nicht in der Datenstruktur enthalten.
Es ist darauf zu achten, daß keine Zugriffe außerhalb der Datenstruktur erfolgen, die zu
Fehlern führen können.
❑ Das Element ist genau einmal in der Datenstruktur gespeichert.
In diesem Fall soll das Ergebnis – je nach Anwendung – true, der Wert des Elements
oder seine Position / Adresse sein.
❑ Das Element ist mehr als einmal gespeichert.
In einigen Datenstrukturen ist dies nicht zulässig. In den anderen muß definiert werden,
welches Element das Ergebnis sein soll.
Neben direkten Elementen kann dabei auch nach Elementen gesucht werden, die eine bestimmte Bedingung erfüllen, für die also z.B. eine boole’sche Funktion true liefert.
I
Informatik II – c Guido Rößling
Elementare Suchalgorithmen
9.2
Anmerkungen zum weiteren Vorgehen
Die folgenden Algorithmen dienen zur Suche nach allen Objekttypen, bei denen die Vergleiche etwa über die Objektidentität ausgeführt werden kann.
An konkrete Anforderungen sind die Algorithmen daher wie folgt anzupassen:
❑ Anpassen des Typs der Variablen und des Feldes
❑ Ersetzen des Vergleichs mittels equals der Klasse Object durch andere Vergleiche.
Bei einfachen Datentypen wie int ist == zu verwenden; bei anderen Objekten ein Vergleich auf das für die Suche relevante Attribut, z.B. für ein String-Attribut name“:
”
(person.getName()).equals(suchperson.getName())
❑ Ggf. Implementieren der Methoden lessThan, lessOrEqual und equals der
Schnittstelle Comparable, falls nicht anhand des Suchattributs verglichen werden kann.
Bei einfachen Datentypen ist für den Vergleich <, == ausreichend.
Zur einfacheren Darstellung wird in den Beispielen der einfache Datentyp int verwendet.
I
Informatik II – c Guido Rößling
Elementare Suchalgorithmen
9.3
Sequentielle Suche
❑ Die einfachste und allgemeinste Methode der Suche von Elementen ist die sequentielle
Suche, bei der einfach alle Elemente der Reihe nach überprüft werden.
Aufgrund des überaus einfachen Vorgehens wird sie auch als brute force search ( Suche
”
mit brutaler Gewalt“) bezeichnet.
❑ Die sequentielle Suche kann auf allen Datenstrukturen einfach durch eine Schleife (Array,
Listen) oder Tiefensuche (Bäume, Graphen) implementiert werden.
❑ Gleichzeitig ist aber auch die Komplexität mit JLKMON sehr ungünstig.
❑ Dennoch ist das Verfahren bei unsortierten Daten notwendig; hier rechnet man mit einem
durchschnittlichen Aufwand von MOPRQ .
I
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Sequentielle Suche
9.4
Algorithmus zur sequentiellen Suche
/ SS
S
S
S e q u e n t i e l l e Suche nach Element x i n Feld a , K o m p l e x i t a e t O( n ) .
@return Index des Elements oder T 1 ( Feld n u l l / l e e r / x n . enth . )
/
public i n t bruteForceSearch ( Comparable [ ] a , Comparable x )
S
U
int i ;
i f ( a== n u l l
VV
a . length ==0) return
T
1 ; / / Feld n u l l o . l e e r
/ / Laufe durch Feld b i s Ende des Feldes oder a [ i ] = = x
f o r ( i = 0 ; i W a . l e n g t h & & ! a [ i ] . equals ( x ) ; i + + ) ;
X
i f ( i W a . length )
return i ;
else
return T 1 ;
/ / gefunden an Pos . i
/ / nicht enthalten
Listing 15: Sequentielle Suche
Y
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Sequentielle Suche : Algorithmus
9.5
Erweiterung der sequentiellen Suche
❑ Eine Alternative zum Schleifenabbruch wie oben ist die Sentinel-Methode.
Hierbei wird das gesuchte Element an die letzte Position eingefügt und anschließend gesucht. Spätestens an der letzten Position wird dann das Element gefunden.
❑ Wird bei der Suche die letzte Position erreicht, so war die Suche erfolglos, andernfalls
hatte sie Erfolg.
❑ Durch die Verwendung der Sentinel-Methode läßt sich die Abfrage auf Erreichen des
Array- bzw. Listenendes einsparen.
Y
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Sequentielle Suche : Erweiterung
9.6
Sequentielle Suche auf sortierten Daten
❑ Sind die Daten sortiert, so kann die sequentielle Suche abgebrochen werden, sobald das
aktuelle Element größer als das gesuchte Element ist.
❑ Diese Möglichkeit setzt voraus, daß die Elemente sich nach einem gegebenen Kriterium
(bzw. einer gegebenen Funktion) in eine Ordnung bringen lassen. Bei Objekten ist dies im
allgemeinen nicht möglich.
❑ Die Komplexitätsabschätzung der sequentiellen Suche bleibt aber auch bei sortierten Daten bei J2KZMON .
❑ Für die nachfolgenden Suchverfahren wird immer unterstellt, daß die Daten sortiert vorliegen.
Y
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Sequentielle Suche : Erweiterung
9.7
Binäre Suche
❑ Die binäre Suche ist ein sehr einfaches, gleichzeitig aber auch sehr effizientes Verfahren,
das in der Praxis oft eingesetzt wird.
❑ Die binäre Suche vergleicht in jedem Schritt das gesuchte Element mit dem mittleren
Element des Suchraums.
Sind die beiden Elemente identisch, so bricht die Suche mit Erfolg ab. Ist das mittlere
Element kleiner als das gesuchte Element, so wird die Suche in der rechten Hälfte des
Suchraums fortgesetzt, andernfalls in der linken Hälfte.
❑ Damit unterteilt das Verfahren in jedem Schritt den Suchraum in zwei Hälften und untersucht nur eine der beiden Hälften weiter, bis das Element gefunden wurde oder das
gleiche Element zweimal aufgesucht wird (dann ist das Element nicht enthalten).
❑ Die Komplexität der binären Suche ist für erfolglose wie auch für erfolgreiche Suche
JLK\[]^`_MaN .
Y
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Binäre Suche
9.8
Implementierung der Binären Suche
/ bb
Binaere Suche nach Element x im Feld a , K o m p l e x i t a e t : O( l o g n ) .
@return Index des Elements oder c 1 ( Feld n u l l / l e e r / x n i c h t enth . )
b
b
b /
public
i n t b i n S e a r c h I t e r a t i v ( Comparable [ ] a , Comparable x )
d
i f ( a == null
ee
a . l e n g t h = = 0 ) r et ur n
c
1;
/ / Feld n u l l / l e e r
/ / Grenzen und m i t t l e r e s Element
i n t l = 0 , r = a . l e n g t h , midElem = ( l + r ) / 2 ;
g
/ / Solange Grenzen v er s c hi eden und n i c hd t gefunden
while ( r f l & & ! a [ midElem ] . equals ( x ) )
i f ( x . isLessThan ( a [ midElem ] ) ) r = midElem c 1 ;
else
l = midElem + 1 ;
midElem
=
(
l
+
r
)
/
2
;
g
, suchen
i f ( a [ midElem ] . equals ( x ) ) r et ur n midElem ;
else
r et ur n c 1 ;
/ / gefunden : midElem
/ / n i c h t gefunden
/ / zu k l e i n = f l i n k s
/ / zu gross = f r e c h t s
/ / Berechne M i t t e
Listing 16: Binäre Suche
Y
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Binäre Suche : Implementierung
9.9
Rekursive Implementierung zur Binären Suche
/ SS
S
S
Binaere Suche n . Element x im Feld a , K o m p l e x i t a e t : O( l o g n ) .
@return Index des Elements oder T 1 ( Feld n u l l / l e e r / x n . enth . )
/
public i n t binSearch ( Comparable [ ] a , Comparable x , i n t l , i n t r )
S
U
X
i n t midElem = ( l + r ) / 2 ;
//
i f ( a = = n u l l VV a . l e n g t h = = 0 VV r W l )
return T 1 ;
//
i f ( a [ midElem ] . equals ( x ) )
r e t u r n midElem ;
//
else
i f ( x . isLessThan ( a [ midElem ] ) )
r e t u r n binSearch ( a , x , l , midElem T 1 ) ;
else
r e t u r n binSearch ( a , x , midElem + 1 , r ) ;
Element i n M i t t e
Feld n u l l / l e e r
Element gefunden
//
Tih
links weiter
//
Tih
rechts weiter
Listing 17: Binäre Suche, rekursiv
Y
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Binäre Suche : Implementierung
9.10
Beispiel zur Binären Suche
Gegeben sei int c[17] wie folgt:
0
5
10
15 16
1 1 1 2 3 3 3 3 4 4 5 6 7 8 9 9 9
binsearch(c, 6):
l r midElem
0
5
10
15 16
0 16
8
1 1 1 2 3 3 3 3 4 4 5 6 7 8 9 9 9
4<6
rechts weitersuchen
9 16
12
0
5
10
15 16
1 1 1 2 3 3 3 3 4 4 5 6 7 8 9 9 9
7>6
links weitersuchen
9 11
10
0
5
15 16
1 1 1 2 3 3 3 3 4 4 5 6 7 8 9 9 9
5<6
rechts weitersuchen
11 11
11
0
5
15 16
10
1 1 1 2 3 3 3 3 4 4 5 6 7 8 9 9 9
6 == 6
gefunden; Ergebnis ist 11
Abbildung 60: Beispiel zur Binären Suche
Y
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Binäre Suche : Beispiel
9.11
Interpolationssuche
❑ Das Ziel ist es, die binäre Suche so zu verbessern, daß der Teilungsindex abhängig vom
gesuchten Wert und den Werten an den Intervallgrenzen gewählt wird.
❑ Die Interpolationssuche entspricht dabei der Suche im Telefonbuch: Man schlägt eine
mögliche“ Stelle auf und schaut, wo man sich befindet. Je nachdem, wie weit der aktuel”
le Eintrag von dem gewünschten ist, wird man nun entsprechend weit vor- oder zurückblättern.
❑ Die Interpolationssuche arbeitet am besten, wenn die Einträge etwa gleichverteilt sind.
❑ Bei der binären Suche wurde der Suchindex wie folgt berechnet:
jlknmporqtsj
uvqxw
y
K{}|
q
N
Qrz
Bei der Interpolationssuche wird der neue Suchindex folgendermaßen bestimmt:
jlk~morq\sj
uvqxw
qZ„
K€2|‚"ƒ
…ƒ†{
„
N
KZ{}|
q
N
z
qZ„
|
‚
"ƒ
❑ Der Rest des Algorithmus kann unverändert übernommen werden und wird daher nicht
erneut angegeben.
Y
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Interpolationssuche
9.12
Beispiel zur Interpolationssuche
Gegeben sei int c[17] wie folgt:
0
5
10
15 16
1 1 1 2 3 3 3 3 4 4 5 6 7 8 9 9 9
interpolsearch(6, c):
midElem = 0 + ((6 - 1) * (16-0))/(9-1) = 10
l = 0,
0
5
15 16
r = 16,
1 1 1 2 3 3 3 3 4 4 5 6 7 8 9 9 9
midElem=10
5<6
l = midElem + 1 = 11
6 == 6
Ergebnis ist 11
midElem = 11 + ((6 - 6) * (16 - 11)) / (9 - 6) = 11
l = 11,
0
5
15 16
10
r = 16
1
1
1
2
3
3
3
3
4
4
5
6
7
8
9
9 9
midElem=11
Abbildung 61: Beispiel zur Interpolationssuche
‡
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Interpolationssuche : Beispiel
9.13
Anmerkungen
❑ Die Interpolationssuche benötigt bei zufälliger Verteilung ˆŠ‰‹pŒˆ‰‹`Œ
Beweis ist schwierig).
Diese Funktion wächst extrem langsam mit größer werdendem  .
Beispiel: ˆ‰‹ Œ ˆ‰‹ Œ yŽ(’‘ ˆ‰‹ Œ”“•p–—•˜(™š™ ‘œ› –• Ž “
w
y
Vergleiche (der
❑ Für (sehr) große, sortierte Felder mit annähernd gleichverteilten Werten ist die Interpolationssuche daher sehr gut geeignet.
❑ Gegenüber der binären Suche ist lediglich die Berechnung des neuen mittleren Elements
aufwendiger.
Aufgrund der Integer-Arithmetik ist dabei darauf zu achten, daß die Multiplikation vor
der Division durchgeführt wird.
‡
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Interpolationssuche : Anmerkungen
9.14
Selbstanordnende Listen
Falls die Suchzugriffe auf Elemente deutlich von der Gleichverteilung abweichen, kann es
sich lohnen, die am häufigsten gesuchten Elemente weit vorne in der Liste anzuordnen und
als Suchstrategie sequentielle Suche zu verwenden.
Hierzu gibt es drei Vorgehensweisen:
❑ MF-Regel (Move to Front)
Das zuletzt gesuchte Element wird zum Kopf der Liste. Der Rest der Liste bleibt unverändert.
❑ T-Regel (Transpose)
Vertausche das gesuchte Element mit dem unmittelbar vorhergehenden.
❑ FC-Regel (Frequency Count)
Führe für jedes Element einen Zähler der Zugriffe. Jeder Zugriff erhöht den Elementzähler
um 1. Ordne nach dem Zugriff auf ein Element dieses so ein, daß die Zählerwerte absteigend sortiert in der Liste auftreten.
Vorsicht: Erfolgen die Zugriffe dennoch annähernd gleichverteilt, ist dieses Vorgehen durch
die Reorganisation noch ineffizienter als einfache sequentielle Suche!
‡
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Selbstanordnende Listen
9.15
Suchen im binären Suchbaum
Wie bei den Datenstrukturen definiert (auf Seite 5.32f), sind die Elemente eines binären Suchbaums geordnet: alle Elemente des linken Teilbaums eines Knotens sind kleiner als der Wert
der Wurzel; alle Elemente des rechten Teilbaums hingegen sind größer als der Wert der Wurzel. Daher kann man im binären Suchbaum wie folgt suchen:
❑ Betrachte zunächst die Wurzel des gesamten Baums als aktuelle Wurzel.
❑ Vergleiche die aktuelle Wurzel mit dem gesuchten Element:
☞ Falls die Elemente gleich sind, ist die Suche beendet.
☞ Falls das gesuchte Element kleiner als die aktuelle Wurzel ist, mache den Wurzelknoten des linken Teilbaums zur aktuellen Wurzel.
☞ Falls das gesuchte Element größer als die aktuelle Wurzel ist, mache den Wurzelknoten des rechten Teilbaums zur aktuellen Wurzel.
Falls nach Unterpunkt 2 oder 3 die aktuelle Wurzel null ist, also kein entsprechender Teilbaum existiert, ist die Suche erfolglos beendet.
‡
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Binärer Suchbaum
9.16
Algorithmus zur Suche im binären Suchbaum
/ žž
ž
ž
ž
Suche Wert i n einem Binaeren Suchbaum .
Ergebnis : Der Knoten , der das Element e n t h a e l t oder n u l l , f a l l s
das Element n i c h t e n t h a l t e n i s t .
ž /
public
B i nar y Tr ee tr eeS ear c h ( Comparable x )
Ÿ
/ / f a l l s das der r i c h t i g e Knoten i s t , zurueckgeben !
i f ( v al ue . equals ( x ) )
r et ur n t h i s ;
/ / s ons t wei ter s uc hen : l i n k s , f a l l s x v al ue ; s ons t r e c h t s .
i f ( x . lessThan ( v al ue ) & & l e f t ! = n u l l )
r et ur n l e f t . tr eeS ear c h ( x ) ;
i f ( v al ue . lessThan ( x ) & & r i g h t ! = n u l l )
r et ur n r i g h t . tr eeS ear c h ( x ) ;
¡
/ / wenn w i r h i e r anlangen , i s t der Wert n i c h t im Baum e n t h a l t e n !
r et ur n n u l l ;
Listing 18: Suche im binären Suchbaum
‡
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Binärer Suchbaum : Algorithmus
9.17
Einfügen im binären Suchbaum
❑ Der Algorithmus zum Suchen im binären Suchbaum kann so modifiziert werden, daß er
auch zum (sortierten) Einfügen von neuen Elementen benutzt werden kann.
❑ Dazu wird zunächst nach dem Element gesucht. Falls dabei der zu verfolgende Teilbaum
null ist, wird das Element als neuer Knoten eingefügt; andernfalls wird im Teilbaum
weitergesucht.
❑ Hierzu sind nur die Abfragen auf
¢
und
£
anzupassen:
i f ( x . lessThan ( v a l u e ) )
i f ( l e f t == null )
l e f t = new BinaryTree ( x ) ;
/ / einfuegen
else
l e f t . treeSearch ( x ) ;
Listing 19: Einfügen im binären Suchbaum
❑ Zusätzlich wird Rückgabetyp BinaryTree durch void ersetzt.
❑ Wichtig: wurde der neu einzufügende Knoten gefunden, wird er nicht erneut eingefügt,
da in einem binären Suchbaum jeder Schlüssel nur einmal vorkommen darf.
‡
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Binärer Suchbaum : Einfügen
9.18
Beispiel zum binären Suchbaum
aktueller Knoten
gefundener Zielknoten
Suche nach Eintrag 3:
2
2
5
1
2
5
1
3
3
7
6
5
1
3
7
6
8
7
6
8
8
Suche nach Eintrag 4:
2
2
5
1
2
5
1
3
3
7
6
3
7
6
8
5
1
7
6
8
8
3 < 4,
leer
¤¥ ¦aber
§ ¨ ©8ª«¦rechter
¥ ¬­§ª®8¯ °Teilbaum
¦±®8¦²
Abbildung 62: Beispiel zum Suchen im binären Suchbaum
‡
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – Binärer Suchbaum : Beispiel
9.19
Anmerkungen
Die Suche im binären Suchbaum erfordert durchschnittlich ungefähr “´³ ˆŠ‰‹µŒ Vergleiche bei
Knoten. Generell ist die Anzahl der benötigten Vergleiche identisch zur Länge des Pfads

der Wurzel zu dem jeweiligen Knoten.
Bei vollständigen Bäumen sind für jeden Knoten maximal ˆ‰‹ Œ  Vergleiche durchzuführen.
Ist der Baum hingegen zu einer Liste entartet, so fallen im schlimmsten Fall  Vergleiche an.
ergibt sich durch
Berechnen
der mittleren
inneren
Pfadlänge (auf Seite 5.8)
Die
Größe
“³ ˆŠ‰‹ Œ 
¶’·¹¸
¸
¶
¶Ç·
·º
·º
ÂÅƺ ¾
ÅÂÉÈ
¼»v½¿¾
³ innere Pfadlänge
³
À
·ÄÃ
ºÁÂÁ
Die Formel ergibt sich aus der Überlegung, daß
❑
❑
¶’·
die mittlere innere Pfadlänge eines binären Suchbaums mit  Knoten ist (
¶
º
¸
½
),
Vergleiche durch die Wurzel zu den inneren ¼»Ë½ Knoten hinzugefügt werden,
¼»Ê½
❑ und die Wurzel mit gleicher Wahrscheinlichkeit der k-größte Schlüssel des Baums ist und
damit Unterbäume der Größe Ìͻʽ und ¼»ÎÌ besitzt.
Die Auflösung der Formel ist kompliziert; es ergibt sich
Ñ
Informatik II – c Guido Rößling
¶
·
‘
“ϳ ˆŠ‰(‹`Œ
Elementare Suchalgorithmen – Binärer Suchbaum : Anmerkungen
‘
½
–™—Ðϳ ˆ‰‹`Œ
.
9.20
Suche in AVL-Bäumen
Da der AVL-Baum höhenbalanziert ist, besitzt er nur geringe Schwankungen in den Pfadlängen.
Der Fall der Entartung zu einer Liste kann bei einem AVL-Baum nicht auftreten.
AVL-Bäume sind spezielle binäre Suchbäume; der Algorithmus für die Suche in (allgemeinen) binären Suchbaum kann unverändert übernommen werden.
Es läßt sich formal zeigen, daß die Suche in AVL-Bäumen in Ò
Ñ
Informatik II – c Guido Rößling
à ˆ‰‹`Œ
Elementare Suchalgorithmen – AVL-Baum
È
liegt.
9.21
Suche in B-Bäumen
Auch der B-Baum ist ein Suchbaum – allerdings kein binärer mehr.
Die Suche geschieht wie folgt:
1. Erkläre die Wurzel des B-Baum zum aktuellen Knoten
2. Suche im aktuellen Knoten nach dem ersten Eintrag, der größer oder gleich dem gesuchten Schlüssel ist. Dies sei ÓÕÔ .
¸
Ö
3. Falls ÓÕÔ
, ist die Suche beendet. Das Ergebnis – die mit ÓÕÔ verknüpften Daten ×rÔ –
stehen im Blattknoten und können direkt zurückgegeben werden.
Andernfalls folge dem Zeiger ØOÔ Åƺ zu einem neuen Knoten und erkläre diesen zum aktuellen Knoten. Fahre fort in Schritt 2, falls der Knoten nicht leer ist, sonst ist die Suche
erfolglos beendet.
Ein B-Baum mit Grad k und  Schlüsseln hat maximal die Höhe ˆ‰‹ÆÙÚ Ã l¾Ë½ È . Da die Suche
pro Ebene nur maximal einen Knoten berührt, liegt sie also in Ò Ã ˆ‰‹ ÙÚ Ã 2¾Û½ È~È .
Ñ
Informatik II – c Guido Rößling
Elementare Suchalgorithmen – B-Baum
9.22
Ñ
Informatik II – c Guido Rößling
Elementare Suchalgorithmen
Kryptologie
Graphentheorie
Graphenalgorithmen
Suchalgorithmen
Suche in Zeichenfolgen
Sortieralgorithmen
Hashing
Kompressionsverfahren
Primitive Datentypen
Listenstrukturen
Bäume
Sonstige Datentypen
Einleitung
Zahlendarstellung
Wo sind wir ––– ?
9.23
Suche in Zeichenfolgen
❑ Bisher wurden nur Elemente innerhalb einer Datenstruktur gesucht. Eine sehr häufige
Anwendung in der Praxis ist aber die Suche in Zeichenfolgen, etwa bei der Volltextsuche
in Textdateien.
❑ Insbesondere zur effizienten Unterstützung von Suchoperationen bei der Bearbeitung von
Texten sind gute Algorithmen notwendig, da nicht – wie bei Textdatenbanken – erst ein
Index der Elemente aufgebaut werden kann.
Die formale Problemstellung lautet also:
☞ Gegeben ein beliebiger Text, über dessen Struktur nichts bekannt ist. Finde eine
beliebige Zeichenfolge in möglichst kurzer Zeit.
❑ Im folgenden wird neben der offensichtlichen“ Lösung eine sehr gute zweite Implemen”
tierung präsentiert.
❑ Der offensichtliche“ Ansatz ist, den Text zeichenweise solange mit den ersten Ü Buch”
staben des Suchwortes zu vergleichen, bis entweder das Wort komplett ist oder eine Abweichung auftritt; im letztem Fall wird mit dem nächsten Eingabezeichen fortgefahren.
Ý
Informatik II – c Guido Rößling
Suche in Zeichenfolgen
10.1
Brute Force-Suche in Zeichenfolgen
/ ÞÞ
Suche Z e i c h e n f o l g e p im Text t e x t .
@return Pos . oder ß 1 ( n i c h t e n t h a l t e n )
Þ
Þ
/
i n t b r u t e F o r c e ( char [ ] p , char [ ] t e x t ) à
int i , j , m = p . length , n = text . length ;
Þ
/ / Ausfuehren b i s Textende ( i =n ) oder Wort f e r t i g ( j =m)
f o r ( i = 0 , j = 0 ; j á m & & i á n ; i + + , j ++)
while ( t e x t [ i ] ! = p [ j ] ) à
/ / F e h l e r an Pos . i , Wortpos . j
i = i ß j + 1;
/ / zum z w e i t e n Zeichen zurueck
j = 0;
/ / und fange neu an m i t p
â
â
i f ( j ==m)
else
r e t u r n i ß m;
return ß 1 ;
/ / E r f o l g ; Wort b e g i n n t b e i i ß m
/ / n i c h t gefunden
Listing 20: Brute-Force Suche in Zeichenfolgen
Ý
Informatik II – c Guido Rößling
Suche in Zeichenfolgen – Brute Force : Algorithmus
10.2
Analyse des Verfahrens
❑ Die letzte Stelle, an der der gesuchte Text beginnen kann, ist ãåäÛæ¼çèÜ
éÎê
.
❑ Im schlimmsten Fall sind maximal ãµënÜ Vergleiche durchzuführen, wenn das Muster fast
”
überall fast ganz“ passt
☞ Beispiel: Suche ab“ in einer Datei, die nur aus æ a“s besteht
”
”
❑ Maximal sind damit ã"ëÜ äÛÜ ëµìæ¼çèÜ éÎêîíïävð2ìæ¼ëÜñí Vergleiche durchzuführen.
❑ Vorteil des Verfahrens:
☞ sehr leicht zu implementieren (daher auch oft als naive Suche bezeichnet)
❑ Zusätzlich ist das Verfahren durch eine Reihe von Implementierungstricks verbesserbar
❑ Im allgemeinen Fall, und insbesondere bei Binärdateien, ist aber mit ð2ìZæòëÜóí zu rechnen,
was sehr ungünstig ist.
Ý
Informatik II – c Guido Rößling
Suche in Zeichenfolgen – Brute Force : Analyse
10.3
Beispiel zum Brute Force-Algorithmus
korrekte ("passende") Zeichen
Fehler
100111010010100010100111000111
10100111
10100111
10100111
10100111
10100111
10100111
10100111
10100111
10100111
10100111
10100111
10100111
10100111
10100111
10100111
10100111
100111010010100010100111000111
Abbildung 63: Brute Force Suche in Zeichenfolgen
Ý
Informatik II – c Guido Rößling
Suche in Zeichenfolgen – Brute Force : Beispiel
10.4
Algorithmus KMP von Knuth, Morris und Pratt
❑ Das große Manko des Brute Force-Ansatzes ist, daß er ohne Gedächtnis arbeitet.
☞ Wird beispielsweise an der 7. Stelle ein Unterschied festgestellt, so werden die
bereits gelesenen Stellen vergessen“ und an der – bereits bekannten! – zweiten
”
Stelle im Text fortgefahren
❑ Der Ansatz von Knuth, Morris und Pratt greift genau an dieser Stelle
☞ aus den bereits gelesenen Zeichen kann eindeutig bestimmt werden, ob das
tatsächliche Wort innerhalb der bereits gelesenen Zeichen beginnen kann oder
nicht
❑ Generell soll also unter Ausnutzung des Wissens über die gelesenen Zeichen aus der Musterstruktur eine möglichst weitgehende Verschiebung des Musters nach rechts im Text
erfolgen.
❑ Ein völliges Überspringen der Zeichen ist nicht möglich, da sich in den Zeichen bereits
der Anfang des Wortes befinden kann.
☞ Es können aber alle Zeichen, die definitiv nicht zum Wortanfang gehören, gefahrlos übersprungen werden.
Ý
Informatik II – c Guido Rößling
Suche in Zeichenfolgen – KMP
10.5
Vorgehen zur Verbesserung
Um die Verschiebepositionen festzustellen, kann man wie folgt vorgehen:
1. Setze ô = 1
2. Lege eine Kopie der ersten j Zeichen des Musters unter das Muster, um eine Stelle nach rechts
verschoben.
3. Verschiebe die untere Kopie soweit nach rechts, daß eine der beiden folgenden Bedingungen gilt:
❑ alle überlappenden Zeichen der Muster stimmen überein,
❑ oder es überlappen sich keine Zeichen mehr.
Die übereinanderliegenden Zeichen bestimmen die erste mögliche Stelle, an der das Muster passen
könnte, falls eine Abweichung an p[j] festgestellt wurde.
4. Trage die Anzahl übereinanderliegender Zeichen in next[j] ein. Sie ist gleichzeitig die Entfernung, wie weit im Muster zurückzugehen ist.
5. Wiederhole Schritt 2 für ôöõL÷ , bis der Wert øùß2÷ erreicht wurde.
Das Ergebnis sind die Einträge
Ý
Informatik II – c Guido Rößling
÷úûúûútøùß6÷
des Arrays next.
Suche in Zeichenfolgen – KMP : Vorgehensweise
10.6
Beispiel zur Bestimmung von next
j Muster
1
1
1
1 0
2
1
1 0 1
3
1
1 0 1
4
1
1 0 1
5
6
7
next[j]
0
0
0 1
0
0 1 0
0 0
1 0 1 0 0
1 0 1 0 0 1
1 0 1 0 0 1
1 0 1 0 0 1 1
1 0 1 0 0 1 1
0
1
2
0
1
1
Tabelle 16: Bestimmung von next bei KMP für p = 10100111
Ý
Informatik II – c Guido Rößling
Suche in Zeichenfolgen – KMP : Bsp. Bestimmung next
10.7
Algorithmus von KMP
Der Algorithmus geht nun wie folgt vor:
1. Beginne mit üÄäþý (Textposition) und ÿÕäþý (Musterposition)
2. Solange es einen Unterschied zwischen a[i] und p[j] gibt und ÿ ý gilt, setze
auf next[j], d.h. suche die nächste Stelle, an der das Muster passen“ würde.
ÿ
”
3. Wiederhole Schritt 2 in einer Schleife, in der sowohl i als auch j in jedem Schritt
hochgezählt werden, bis entweder
☞ das Musterende erreicht wurde ( gefunden)
☞ oder das Textende erreicht wurde ( nicht gefunden)
ý “ liegt in einem Trick zum Ausschalten einer
❑ Die Begründung für die Bedingung ÿ
”
Fallunterscheidung:
☞ Liegt der Fehler am ersten Zeichen (ÿ ä ý ), so muß ü direkt inkrementiert
werden, um im Text weiterzulaufen
☞ Das wird durch Setzen von next[0] = -1 und abbrechen der inneren
Schleife bei ÿ vý erreicht
Ý
Informatik II – c Guido Rößling
Suche in Zeichenfolgen – KMP : Algorithmus
10.8
Implementierung von KMP
/ ÞÞ
Þ
Suche Z e i c h e n f o l g e p im Text t e x t .
Ergebnis : Pos . oder ß 1 ( n i c h t e n t h a l t e n )
Þ
Þ /
i n t kmpSearch ( char [ ] p , char [ ] t e x t )
à
i n t i = 0 , j = 0 , m = p . length , n = t e x t . length ; / / Zaehler
i n t [ ] next = i n i t N e x t ( p ) ;
/ / I n i t ” n e x t ” ß Daten
f o r ( ; j á m & & i á n ; i + + , j + + ) / / B i s Muster ß / Textende
while ( ( j
= 0 ) & & ( t e x t [ i ] ! = p [ j ] ) ) / / F e h l e r Pos . i / j ?
j = next [ j ] ;
/ / Verschiebe Muster
â
i f ( j = = m) r e t u r n i ß m;
else
return ß 1 ;
/ / gefunden !
/ / n i c h t gefunden .
Listing 21: Implementierung von KMP
Ý
Informatik II – c Guido Rößling
Suche in Zeichenfolgen – KMP : Implementierung
10.9
Algorithmus für initNext
❑ Das Vorgehen zum Initialisieren des Arrays next ist denkbar einfach: im wesentlichen
wird einfach der Algorithmus kmpSearch auf das Muster angesetzt.
❑ Dabei ist der Wert next[i] genau dann bestimmt, wenn einer der beiden folgenden
Fälle eintritt:
☞ p[i] != p[j], d.h. das i-te Zeichen des Musters passt nicht zum j-ten Zeichen,
☞ oder j
0, d.h. es muß zur nächsten Position gegangen werden: die Muster passen
nicht zusammen.
❑ Folgende kleine Modifikation verbessert den Algorithmus nochmals:
☞ Gilt nach einer Nichtübereinstimmung p[i] == p[j], liegt auch hier eine
Nichtübereinstimmung vor.
☞ Statt nun next[i] = j zu setzen und diese Stelle nochmals
zu überprüfen, wird in diesem Fall next[i] = next[j] gesetzt, um Mehrfachtests zu sparen
Informatik II – c Guido Rößling
Suche in Zeichenfolgen – KMP : Algorithmus f. initNext
10.10
Auswirkung der Modifikation
Verglichen mit den auf Folie 10.7 berechneten Werten ergibt sich:
j next[j] normal“ next[j] modifiziert“
”
”
0
-1
-1
1
0
0
2
0
-1
3
1
0
4
5
6
7
2
0
1
1
2
-1
1
1
Anmerkung
automatisch weitergehen
Zeichen 0 passt
p[0]==p[2]; wenn p[2] nicht
stimmt, stimmt auch p[0] nicht
weitergehen
p[3]==p[1]; wenn p[3] nicht
stimmt, stimmt auch p[1] nicht
mit
Zeichen 0 fortfahren
identisch
siehe j=2
(Nur) Zeichen 0 und 1 passen
(Nur) Zeichen 0 und 1 passen
Tabelle 17: Auswirkung der Modifikation von initNext
Informatik II – c Guido Rößling
Suche in Zeichenfolgen – KMP : Ausw. der Modifikation
10.11
Implementierung von initNext
/
/
I n i t i a l i s i e r e n e x t durch V e r g l e i c h des Musters m i t s i c h
public i n t [ ] i n i t N e x t ( char [ ] p )
int i = 0 , j =
1 , m = p . length ; / / Zaehler
i n t [ ] n e x t = new i n t [m ] ;
/ / next Array d e k l a r i e r e n
1;
/ / durch ” j ++ ” ausgeglichen
next [ 0 ] =
/ / Bestimme n e x t [ i ] .
/ / F a l l s V e r g l e i c h redundant waere , gehe d i r e k t w e i t e r
for ( ; i m 1; i ++, j ++, next [ i ] = ( p [ i ] = = p [ j ] ) ? next [ j ] : j )
while ( ( j
= 0) && (p [ i ] ! = p [ j ] ) )
/ / f a l l s Fehler ,
j = next [ j ] ;
/ / s e t z e j zurueck
return next ;
/ / A r r a y zurueckgeben
Listing 22: Initialisierung von next bei KMP
Informatik II – c Guido Rößling
Suche in Zeichenfolgen – KMP : Implementierung initNext
10.12
Beispiel zum KMP
korrekte ("passende") Zeichen
Fehler
100111010010100010100111000111
10100111
10100111
10100111
10100111
10100111
100111010010100010100111000111
Abbildung 64: Beispiel zum Algorithmus von Knuth, Morris und Pratt
Informatik II – c Guido Rößling
Suche in Zeichenfolgen – KMP : Beispiel
10.13
Anmerkungen zum KMP
❑ Bei der Suche in Zeichenfolgen mit KMP sind niemals mehr als
Zeichenvergleiche
erforderlich.
☞ Gegenüber einer Komplexität von
bei dem Brute Force-Algorithmus
ist dies eine beträchtliche Steigerung!
❑ Die Vorteile gegenüber Brute Force kann KMP allerdings vor allem bei der Suche nach
Mustern mit vielen Selbstwiederholungen in einem Text mit vielen Selbstwiederholungen
ausspielen.
❑ Kommt z.B. jeder Buchstabe nur einmal im Muster vor, hilft auch die Berechnung der
next-Matrix nichts.
❑ Der große Vorteil des Verfahrens ist, daß es die Eingabe sequentiell durchläuft und niemals zu einem bereits gelesenen Zeichen zurückgeht.
☞ Die sonst nötige Pufferung der Eingabe kann damit entfallen
❑ Insbesondere bei Daten, die von Hardware-Geräten oder Systemkomponenten gesendet
werden, sowie dem direkten Lesen aus Dateien ist das Zurücksetzen nicht möglich, und
eine Pufferung unter Umständen kompliziert.
Informatik II – c Guido Rößling
Suche in Zeichenfolgen – KMP : Anmerkungen
10.14
Weitere Suchalgorithmen
Nicht betrachtet wurden in diesem Kapitel:
❑ Digitale Suchbäume
❑ zusätzliche Algorithmen für Suche in Zeichenfolgen:
☞ Boyer-Moore, das das Suchmuster von rechts nach links durchläuft mit durchschnittlifür hinreichend große Alphabete und kurze Muster (im schlimmchen Aufwand
sten Fall
).
Durch die Vergleichsrichtung wird hier oft das Muster komplett um Zeichen verschoben.
Schritten (im schlimm☞ Rabin-Karp, das Hashwerte benutzt mit durchschnittlich
sten Fall aber
)
!"
#$
%&'(
❑ spezielle Suchverfahren (Local-Search, nearest neighbour)
Informatik II – c Guido Rößling
Suche in Zeichenfolgen – Weitere Suchalgorithmen
10.15
Informatik II – c Guido Rößling
Suche in Zeichenfolgen
Kryptologie
)()*) ?
Graphentheorie
Graphenalgorithmen
Suchalgorithmen
Suche in Zeichenfolgen
Sortieralgorithmen
Hashing
Kompressionsverfahren
Primitive Datentypen
Listenstrukturen
Bäume
Sonstige Datentypen
Einleitung
Zahlendarstellung
Wo sind wir
10.16
Problemstellung bei Sortieralgorithmen
Generell geht es bei Sortieralgorithmen darum,
Fragen sind dazu zunächst zu beantworten:
gegebene Elemente zu sortieren. Folgende
❑ der Typ der Daten: kann direkt sortiert werden (primitive Datentypen wie Integer),
oder muß gemäß eines Attributs, etwa key oder value, sortiert werden?
+
,-,
ausgenutzt werden, oder müssen spezielle Ver❑ Können die Standardvergleiche und
gleichsfunktionen benutzt und ggf. erst programmiert werden?
❑ Soll aufsteigend oder absteigend sortiert werden?
❑ Geschieht das Sortieren ohne zusätzlichen Speicherbedarf ( in place“), oder auf einer
”
Kopie der Datensätze?
❑ Haben alle Datensätze gleichzeitig Platz im Speicher ( Internes Sortieren“), oder müssen
”
externe Speicher einbezogen werden ( Externes Sortieren“)?
”
❑ Bleibt die relative Anordnung von gleichen Schlüsseln erhalten ( Stabilität“)?
”
❑ Welche Komplexität hat das gewählte Verfahren?
Informatik II – c Guido Rößling
Sortieralgorithmen – Problemstellung
11.1
Konventionen
Im folgenden wird nur die Sortierung von Characters betrachtet.
☞ Um die Verfahren an die Sortierung von anderen Datentypen anzupassen, ist
nur der Zugriff auf die Variable sowie ggf. die Vergleiche umzudefinieren, wie
dies bereits bei der Suche (auf Seite 9.3) beschrieben ist.
Die folgenden Algorithmen sind jeweils nur eine (oder mehrere) Funktion; der Programmierer muß für eine entsprechende Einbettung in ein Programm bzw. eine Klasse sorgen, in der
die zu sortierenden Daten in der geeigneten Datenstruktur abgelegt werden (in der Regel ein
Array). Zusätzlich ist der Sortieralgorithmus mit den korrekten Parametern an einer beliebigen Stelle im Programm aufzurufen.
Gemessen werden bei Sortieralgorithmen
❑ die Anzahl Vergleiche (C) sowie
❑ die Anzahl Bewegungen von Datensätzen (M)
Von Interesse sind dabei der beste, durchschnittliche und schlechteste Fall.
Informatik II – c Guido Rößling
Sortieralgorithmen – Konventionen
11.2
Hilfsroutine swap
Die folgende Routine swap zum Vertauschen von zwei Feldelementen wird häufig verwendet.
/
/
.(.
. Vertausche
./
a [ i ] und a [ j ] m i t e i n a n d e r
public void swap ( O bj ec t [ ] a , i n t i , i n t j )
O bj ec t t ;
/ / E x i s t i e r t Feld und i s t der Z u g r i f f moeglich?
i f ( a ! = null
/ / e x i s t i e r t das Feld ?
/ / i s t Index i g u e l t i g ?
&& i =0 && a . l e n g t h i
/ / i s t Index j g u e l t i g ?
&& j =0 && a . l e n g t h j )
0
/
0
1
1
0
0
/ / Dr ei ec k s tau s c h ueber V a r i a b l e t
t = a[ i ];
/ / Speichere P o s i t i o n i
a[ i ] = a[ j ] ;
/ / Kopiere a [ j ] an Pos . i
a[ j ] = t ;
/ / Kopiere a l t e s a [ i ] an j
2
Informatik II – c Guido Rößling
Listing 23: Routine swap
Sortieralgorithmen – Hilfsroutine swap
11.3
Sortieren durch Auswahl
Das naheliegendeste Verfahren zur Sortierung ist Sortieren durch Auswahl, auch als Selection
Sort bezeichnet.
Das Vorgehen ist denkbar einfach:
1. Setze
3#465
3
2. Suche ab Position das kleinste Element im Feld.
3
3. Vertausche das kleinste Element mit dem Element an Position .
4. Setze
3#47398;:
und fahre bei Schritt 2 fort bis
2
Informatik II – c Guido Rößling
3#47<
.
Sortieralgorithmen – Sortieren durch Auswahl
11.4
Implementierung des Algorithmus
/
?
=
=
= Sortieren
= kleinstem
=/
>
durch Auswahl : tausche im S c h r i t t i a [ i ] m i t dem i t
Element . K o m p l e x i t a e t : O( n ˆ 2 )
public void s e l e c t i o n S o r t ( Comparable [ ] a )
i n t i , j , minIndex ;
for ( i =0; i a . length
@
?
>
1; i ++)
>
/ / Suche i t k l e i n s t e s Element
minIndex = i ;
/ / b i s h e r i g e s Minimum
f o r ( j = i + 1 ; j a . l e n g t h ; j + + ) / / Suche Rest ab
i f ( a [ j ] . isLessThan ( a [ minIndex ] ) )
minIndex = j ;
/ / neues Minimum
@
A
A
swap ( a , i , minIndex ) ;
2
Informatik II – c Guido Rößling
/ / tausche a [ i ] u . a [ minIndex ]
Listing 24: Sortieren durch Auswahl
Sortieralgorithmen – Sortieren durch Auswahl : Implementierung
11.5
Beispiel
ausgeführte Vertauschung
bereits sortierte Elemente
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
A A O R T I N G E X S M P L E
A A E R T I N GO X S M P L E
A A E E T I N GO X S M P L R
A A E E G I N T O X S M P L R
A A E E G I N T O X S M P L R
A A E E G I L T O X S M P N R
A A E E G I L M O X S T P N R
A A E E G I L M N X S T P O R
A A E E G I L M N O S T P X R
A A E E G I L M N O P T S X R
A A E E G I L M N O P R S X T
A A E E G I L M N O P R S X T
A A E E G I L M N O P R S T X
Abbildung 65: Beispiel Sortieren durch Auswahl“
”
2
Informatik II – c Guido Rößling
Sortieralgorithmen – Sortieren durch Auswahl : Beispiel
11.6
Komplexität
3CB
❑ Das Verfahren führt für das Element jeweils genau
ist kein Vergleich notwendig).
<'DE3
Vergleiche aus (für
3F4G<'DH:
N*f`g P
P <bDpa R
b
<
l
D
m
:
o
R
n
IKJMLONQP <"RS4 IUTWVYXP <R#4 IKJZT\[]P <RS4;<^D_:`8%<^DbaM8%<^DbcM8dB(B(BW8:e4
Lihkj #3 4
a
❑ Als Anzahl Vergleiche im best, average und worst case ergibt sich
❑ Diese Kosten gelten unabhängig von einer eventuellen Vorsortierung.
❑ Pro Position (mit Ausnahme der letzten) wird ein Swap durchgeführt, was zu folgenden
Datensatzbewegungen führt:
q ZJ LON P < RS4 q WT VWX P < RS4 q J"T\[ P <R#46crn P <Dl:mR
N f`gutw v N*fkwYt
w
P
P
s 8xc$n <bDl:mRzy_{ < R .
❑ Als Komplexität ergibt sich damit für alle Fälle s
☞ Die Anzahl Vergleiche ist sehr hoch, die Anzahl Datensatzbewegungen hingegen gering. Falls die Datensätze sehr groß sind und die Schlüssel sehr klein,
d.h. Vergleiche sehr billig sind, kann Sortieren durch Auswahl sehr gut sein.
❑ Ansonsten wird das Verfahren durch die meisten anderen Verfahren klar übertroffen.
2
Informatik II – c Guido Rößling
Sortieralgorithmen – Sortieren durch Auswahl : Komplexität
11.7
Sortieren durch Einfügen
❑ Sortieren durch Einfügen, auch als Insertion Sort bezeichnet, fügt der Reihe nach Elemente in eine bereits sortierte (Teil-)Liste ein, die anfangs leer ist.
❑ Damit ist das Vorgehen dem Sortieren von Spielkarten ähnlich: in jedem Schritt wird eine
neue Spielkarte zwischen die bereits sortierten Karten eingefügt.
❑ Das Vorgehen ist auch hier wieder sehr einfach:
3S4 :
1. Setze
2. Speichere
in einer Variablen und setze
3. Solange
und kleiner als
ist, kopiere
an Position
setze
.
4. Füge Element an die Position ein.
5. Falls kleiner als ist, erhöhe um eins und fahre fort mit Schritt 2.
~| }3€
ƒ†… 5
ƒ‡4xƒŠDl:
3
‚
‚
‚
<
2
Informatik II – c Guido Rößling
3
ƒ„473
|~} ƒ‡DH:C€
|9} ƒ‡DH:ˆ€
|~} ƒ‰€
und
ƒ
Sortieralgorithmen – Sortieren durch Einfügen
11.8
Implementierung
/
?
=
=
= S o r t i e r e n durch Einfuegen .
= Grundidee : Fuege im i > t e n S c h r i t t
= K o m p l e x i t a e t : O( n ˆ 2 )
=/
Element i s o r t i e r t e i n .
public void i n s e r t i o n S o r t ( Comparable [ ] a )
int i , j ;
/ / Zaehler
Comparable v ;
/ / b e i n h a l t e t e i n Element
f o r ( i = 1 ; i a . l e n g t h ; i ++)
@
?
v = a[ i ] ;
/ / Speichern einzufuegendes E l .
f o r ( j = i ; j 0 && v . isLessThan ( a [ j 1 ] ) ; j
)
a [ j ] = a [ j 1];
/ / Verschiebe E l . nach r e c h t s
a[ j ] = v ;
/ / Einfuegen i n s o r t i e r t e s Feld
‹
A
A
2
Informatik II – c Guido Rößling
>
>
>S>
Listing 25: Sortieren durch Einfügen
Sortieralgorithmen – Sortieren durch Einfügen : Implementierung
11.9
Beispiel
ausgeführte Bewegungen
unveränderte, bereits sortierte Elemente
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
A O S R T I N G E X A M P L E
A O R S T I N G E X A M P L E
A O R S T I N G E X A M P L E
A I O R S T N G E X A M P L E
A I N O R S T G E X A M P L E
A G I N O R S T E X A M P L E
A E G I N O R S T X A M P L E
A E G I N O R S T X A M P L E
A A E G I N O R S T X M P L E
A A E G I M N O R S T X P L E
A A E G I M N O P R S T X L E
A A E G I L M N O P R S T X E
A A E E G I L M N O P R S T X
Abbildung 66: Beispiel zu Sortieren durch Einfügen“
”
Œ
Informatik II – c Guido Rößling
Sortieralgorithmen – Sortieren durch Einfügen : Beispiel
11.10
Komplexität
❑ Es werden für
3#4 : ŽB*B(B(<bDl:
3
minimal 1, maximal stets Vergleiche ausgeführt.
3
❑ Im durchschnittlichen Fall ist die Hälfte der sortierten Elemente größer als das einzufügende Element, was zu
Vergleichen führt. Es gilt daher
3‘]a
N
N
I JZLON P <RS47<F I J"T\[ P <"RS4
I TYVWX P <Ro4 : n 3
3
C

Lih’g
a Lih“g
❑ Für das 3 -te Element werden zwischen 2 und 3”8 : Bewegungen von Datensätzen ausgeführt. Damit folgt
N˜ f`g
q•JZLONQP <RS46arn P <D–:mRC q•JZT\[—P <RS4 Lih“g P 3~87:mRC q•TWVWX™P <"RS4 wg n q•JZT\[—P <R
❑ Insgesamt
und schlimmsten Fall eine Komplexität
w ergibt sich damit im durchschnittlichen
P
P
von { < R , im besten Fall hingegen { <"R .
❑ Wichtig:Sortieren durch Einfügen für bereits sortierte Eingaben linear ist.
❑ Auch bei größtenteils vorsortierten Folgen verhält sich Sortieren durch Einfügen gut.
Œ
Informatik II – c Guido Rößling
Sortieralgorithmen – Sortieren durch Einfügen : Komplexität
11.11
Bubble Sort
❑ Bubble Sort ist ein elementares Suchverfahren, das in vielen Informatikveranstaltungen
gelehrt wird (so auch hier).
❑ Die Grundidee des Verfahrens ist es, benachbarte Elemente so zu vertauschen, daß sie
sortiert sind.
❑ Der Algorithmus sieht wie folgt aus:
S3 4;<
ƒš4 :
1. Setze
2. Setze
und eine boole’sche Variable swapPerformed auf false
und
, falls
ist
3. Vertausche in einer Schleife die Elemente
und setze swapPerformed auf true.
4. Zähle um eins hoch, bis
gilt.
oder ist swapPerformed false, so
5. Zähle um eins herunter. Gilt
beende das Programm; andernfalls fahre fort bei Schritt 2.
ƒ
|9} ƒrD›:ˆ€
|~} ƒ‰€
|~} ƒrDE:ˆ€Z…l|9} ƒ‰€
ƒ‡4-4;3
3œ4-4 DŠ:
3
Œ
Informatik II – c Guido Rößling
Sortieralgorithmen – Bubble Sort : Algorithmus
11.12
Implementierung Bubble Sort“
”
/
ž
(
 Bubble S o r t v e r t a u s c h t f d i r e k t e Nachbarn , f a l l s n i c h t s o r t i e r t
 und l a e u f t dazu max . n mal ueber d i e L i s t e , um v o l l s t a e n d i g zu
 s o r t i e r e n . K o m p l e x i t a e t : O( n ˆ 2 )
/
public void b u b b l e S o r t ( Comparable [ ] a )
int i , j ;
boolean swapPerformed = t r ue ;
f
/ / Schleifenzaehler
/ / wurde g e t a u s c h t ?
Ÿf
f
f
/ / Laufe n mal durch , oder b i s k ei ne Vertauschung mehr s t a t t f a n d
f o r ( i =a . l e n g t h ; swapPerformed & & i
1; i
)
f o r ( j =1, swapPerformed = f a l s e ; j i ; j + + ) / / Teste a l l e Elemente
i f ( a [ j 1]. i s G r eater Than ( a [ j ] ) )
/ / f a l s c h angeordnet ?
ž
f
¡
¡
f
Ÿ
swap ( a , j 1, j ) ;
swapPerformed = t r ue ;
// ==
dann v er taus c he !
/ / und merke den Tausch
Listing 26: Bubble Sort
Œ
Informatik II – c Guido Rößling
Sortieralgorithmen – Bubble Sort : Implementierung
11.13
Beispiel
ausgeführte Bewegungen
sortierte Elemente
A S O R T I N G E X A M P L E
A O R S I N G E T A M P L E X
A O R I N G E S A M P L E T X
A O I N G E R A M P L E S T X
A I N G E O A M P L E R S T X
A I G E N A M O L E P R S T X
A G E I A M N L E O P R S T X
A E G A I M L E N O P R S T X
A E A G I L E M N O P R S T X
A A E G I E L M N O P R S T X
A A E G E I L M N O P R S T X
A A E E G I L M N O P R S T X
A A E E G I L M N O P R S T X
Abbruch: keine Vertauschung duchgeführt
Abbildung 67: Beispiel zu Bubble Sort“
”
Œ
Informatik II – c Guido Rößling
Sortieralgorithmen – Bubble Sort : Beispiel
11.14
Komplexität
❑ Im günstigen Fall wird bereits im ersten Durchlauf keine Vertauschung ausgeführt:
¢K£Z¤O¥‰¦&§¨o©;§bªl« ¬d­£Z¤O¥Q¦§¨#©6®
❑ Im schlimmsten Fall liegt eine absteigend sortierte Folge vor. In diesem Fall wandert in
jedem Schritt genau ein Element an seine korrekte Position (am Ende des Feldes).
☞ Für Schritt ergibt sich damit
K¢ £Z°\±]¦&§¨S© ¦&§bª ¯ ¨C¬­£"°\±—¦§¨#©G²$³Q¦&§ª ¯ ¨
❑ Daher sind sowohl ¢K£"°\±]¦&§"¨ als auch ­•£"°W±—¦&§¨ quadratisch.
❑ Auch im durchschnittlichen Fall ergibt sich ¢ °W´Wµ ¦&§"¨C¬­ °Y´Wµ ¦&§¨z¶_·%¦&§"¸¹¨ .
¯
º
Informatik II – c Guido Rößling
Sortieralgorithmen – Bubble Sort : Komplexität
11.15
Anmerkungen
¯ª
❑ Bei Bubble Sort wandert durch die Vergleiche mit dem Nachbarn in einem Schritt immer
das t größte Element an die korrekte Position
☞ der Rest der Elemente wird nur vorsortiert“.
”
❑ Bubble Sort ist daher vor allem dann geeignet, wenn die Folge bereits vollständig oder
fast vollständig sortiert vorliegt, da es dann linear ist.
❑ Bereits im durchschnittlichen Fall aber ist das Verhalten von Bubble Sort nicht mehr
günstig.
❑ Im allgemeinen Fall ist Bubble Sort – trotz seiner großen Beliebtheit in der Lehre und der
Industrie– daher keine gute Wahl für die meisten Sortieranforderungen.
º
Informatik II – c Guido Rößling
Sortieralgorithmen – Bubble Sort : Anmerkungen
11.16
Shellsort
❑ Das Verfahren Sortieren durch Einfügen ist langsam, weil es Elemente immer nur um eine
Position nach rechts verschiebt.
❑ Shellsort versucht, Elemente durch größere Sprünge schneller an die Zielposition zu bringen.
Dabei werden die Daten in jedem Schritt h-sortiert. Eine Datenfolge ist dabei h-sortiert,
wenn man bei Entnahme jedes h-ten Elements ab einem beliebigen Startelement immer
eine sortierte Folge erhält.
❑ Eine h-sortierte Datenfolge besteht daher aus
einander überlagern.
»
unabhängig sortierten Datenfolgen, die
❑ Das Vorgehen von Shellsort ist dabei, daß die Datenfolge sortiert wird, indem mit abnehmenden mehrere h-Sortierungen ausgeführt werden, wobei am Schluß eine Sortierung
erfolgt.
mit
»
¼
©
«
»
❑ Die Folge zu verwendender Werte für
º
Informatik II – c Guido Rößling
»
wird dabei als Inkrementfolge bezeichnet.
Sortieralgorithmen – Shellsort
11.17
Algorithmus zu Shellsort
­
1. Bestimme eine -elementige Inkrementfolge
in einem Array h
» ½ = » £#¾`¿À¬*ÁŽÁ*ÁŽ¬ »ÃÂ
und speichere sie
© ­ ªl«
Ä 7
3. Setze ¯ © »ÅÆÄQÇ
2. Setze
È~ůÇ in einer Variablen É , und speichere ¯ in einer Variablen Ê
5. Solange ÊËH»ÅÆÄQÇ ist und È9Å Ê ª »ÌÅÍÄÎÇÏÇZË;É , setze È~Å Ê‰Ç © È9Å Ê ª »ÅÆÄÎÇÏÇ und Ê © Ê ª »
6. Setze È9Å Ê‰Ç © É
7. Zähle ¯ um eins hoch. Falls ¯ÑÐ § , fahre fort mit Schritt 4.
8. Zähle Ä um eins hoch. Falls ÄË ªÒ« , fahre fort mit Schritt 3.
4. Speichere Element
º
Informatik II – c Guido Rößling
Sortieralgorithmen – Shellsort : Algorithmus
11.18
Verbesserter Algorithmus
»ÌůZÓ « Ç © Ô² ³ » ůÕÇkÓ «
Es hat sich gezeigt, daß die Folge
läßt sich der Algorithmus wie folgt anpassen:
günstige Eigenschaften hat. Mit ihr
»'Ð ©7§ÌÖ]× , setze » ©6²r³ »ÒÓ « .
2. Setze ¯ © »
3. Speichere Element È~ůÇ in einer Variablen É , und speichere ¯ in einer Variablen Ê
4. Solange ÊËH» ist und È9Å Ê ª »kÇZË;É , setze È~Å Ê‰Ç © È~Å Ê ª »kÇ und Ê © Ê ª »
5. Setze È9Å Ê‰Ç © É
6. Zähle ¯ um eins hoch. Falls ¯ÑÐ § , fahre fort mit Schritt 3.
7. Setze » © » Ö]² (Integer-Division!). Falls »bË ® , fahre fort mit Schritt 2.
1. Solange
º
Informatik II – c Guido Rößling
Sortieralgorithmen – Shellsort : Verbesserter Algorithmus
11.19
Implementierung
/
Ù
Ø(Ø
Ø Sortieren m i ttel s Shellsort ( Sortiere Teilfolgen
Ø K o m p l e x i t a e t : O( n ( l o g n ) ˆ 2 ) oder O( n ˆ 1 . 2 5 )
Ø/
m i t Abstand h ) .
public void s h e l l s o r t ( Comparable [ ] a )
int i , j , h ;
Comparable v ;
Û
Ú
/ / Zaehl er und D i s t a n z
/ / Hilfselement
Ø
¾
for ( h =1; h a . length / 9 ; h = 3 h + 1 ) ;
for ( ; h 0; h / = 3 )
f o r ( i =h ; i a . l e n g t h ; i ++)
Ù
Ú
Û ¾
¾
v = a[ i ] ; j = i ;
while ( j =h & & v . isLessThan ( a [ j h ] ) )
= h;
a[ j ] = a[ j h ]; j
Ü
Ü
Ü
¾
/ / S t ar t Inkrementfolge
/ / Herstellen h Sortierung
Ù
a[ j ] = v ;
/ / Speichern
/ / Tausch dur c hz ufuehr en ?
/ / Tauschen
/ / Letztes einkopieren
Listing 27: Shellsort
º
Informatik II – c Guido Rößling
Sortieralgorithmen – Shellsort : Implementierung
11.20
Beispiel
» © «
» ©¼«Ý² » ©ßÞ
» ½ © «Ý²Î¬‘Þ
¬Ž«
❑ Das folgende Beispiel verwendet zur Illustration die Inkrementfolge
. Shellarbeiten. Der Ablauf von Shellsort wird dabei so darsort selbst würde direkt mit
gestellt, daß die einzelnen erfolgten h-Sortierungsschritte sichtbar sind. Im Algorithmus
ist die Berechnung für
und
jeweils ein Schritt.
Anfang
A S O R T I N G E X A M P L E
h=13
A S O R T I N G E X A M P L E
verglichene Elemente
A E O R T I N G E X A M P L S
Austauschungen
h=4
A E O R E I N G P X A M T L S
A E O R E I N G P L A M T X S
A E A R E I N G P L O M T X S
A E A G E I N M P L O R T X S
h=1
º
A A E E G I L M N O P R S T X
Informatik II – c Guido Rößling
Abbildung 68: Beispiel Shellsort“
”
Sortieralgorithmen – Shellsort : Beispiel
11.21
Komplexität
❑ Die Komplexitätsbestimmung für Shellsort ist extrem schwierig. Sie hängt von der Inkrementfolge ab, aber nicht sonderlich von der Ordnung der Daten.
»½
¿ãâä
®
©
«
¬
«
©
á
²
³
«
§
❑ Für die angegebene Folge »Å Ç
»Åà¯ZÓ Ç
»ÌůÇ
Ó gilt, daß niemals mehr als
Vergleiche ausführt. Die Vermutungen
¿ãâ ¸ ä ¨ für die Komplexität des angegebenen Programms
¸
·
&
¦
b
§
Q
³
æ
¦
O
å
*
ç
è
§
¨
¨
%
·
&
¦
§
lauten
.
¸ und
»Å ® Ç © « ¬ » Åà¯ÌÓ « Ç © Òé ³ Ì» ůÇ
❑ Bei der Wahl der Inkrementfolge ist aber Vorsicht geboten: etwa die naheliegende Folge
führt zu einem sehr schlechten Verhalten, da erst im letzten
Schritt Elemente an ungeraden Positionen mit denen an geraden Positionen verglichen
werden.
❑ Für viele Sortieranwendungen gehört Shellsort zu den bevorzugten Methoden, da es selbst
für relativ große Datenmengen (z.B. 5000 Elemente) akzeptable Laufzeit aufweist und
zusätzlich eine sehr einfache Implementierung aufweist.
º
Informatik II – c Guido Rößling
Sortieralgorithmen – Shellsort : Komplexität
11.22
Quicksort
Quicksort ist eines der populärsten, wenn nicht das populärste, Sortieralgorithmen.
Die Grundidee dieses bereits 1960 von C. A. R. Hoare entwickelten Sortieralgorithmus ist
dabei sehr einfach:
❑ Seien
ê ©G®Î¬Àë^©;§bªl«
die linke bzw. rechte Folgengrenze
¯
❑ Bestimme ein Element der Folge als Pivotelement
È9ÅìêíÇ ÁŽÁ*Á È~Å ë Ç
¯
derart um, daß alle Elemente mit Index
❑ Sortiere die Folgenelemente
kleiner als (für ein beliebiges ) kleiner oder gleich dem Pivotelement sind, und
alle Elemente mit Index größer i größer als das Pivotelement sind.
¯
¯
❑ Füge das Pivotelement an Position ein.
¯9Ó « ¬(Á(Á(Á(¬ë
ê ¬*ÁŽÁ*Á(¬ ¯ ª ë «
ê
❑ Beginne erneut mit Schritt 2 für die Folge
sowie anschließend die
. Dabei werden die Werte von und entsprechend angepaßt.
Folge
º
Informatik II – c Guido Rößling
Sortieralgorithmen – Quicksort
11.23
Schematische Implementierung von Quicksort
Schematisch sieht die Implementierung von Quicksort wie folgt aus:
/
ï
î
î
î Schematische
î/
Im plem entierung von Q u i c k s o r t
public void quicksortSchema ( Comparable [ ] a , i n t l , i n t r )
int i ;
/ / G i b t es noch zu s o r t i e r e n d e Elemente?
if ( r l )
ð
ï
i = partition (a , l , r ) ;
ò
ò
ñ
//
//
//
//
quicksort (a , l , i 1);
quicksort (a , i +1, r ) ;
P a r t i t i o n i e r e Feld a [ l ] . . . a [ r ]
und k o p i e r e P i v o t e l e m e n t an a [ i ]
linken Teil sortieren
rechten T e i l s o r t i e r e n
º
Listing 28: Schematische Implementierung von Quicksort
Informatik II – c Guido Rößling
Sortieralgorithmen – Quicksort : Schematische Implementierung
11.24
Ablauf von partition
Entscheidend für den Ablauf von Quicksort ist die Funktion partition, die das Feld so
sortieren muß, daß die folgenden Bedingungen erfüllt sind:
ó
❑ Für das von der Funktion gewählte muß sich das Element
Position befinden, muß also das
kleinste Element sein.
ist gleichzeitig das Pivotelement.
ó÷›ø
ô9õàóö
ô9õàóö
an seiner endgültigen
ô~õùêöú(û(û(û*úÀô~õóÌ÷lüˆö (falls nicht leer) sind kleiner oder gleich ô~õóö .
❑ Alle Element in ô~õó9ý;üˆöú(û*ûŽû*úÀô~õ ë ö (falls nicht leer) sind größer ô9õàóö .
1. Wähle ein Element als Pivotelement, z.B. þ`óã
ÿ øGô~õ ë ö
2. Suche ab ó ê ein Element ô9õàóö ;þ“óãÿ ™ø ; suche ab ë ÷ ü ein Element ô9õ ö
þ`óãÿ ø .
3. Vertausche ô~õóö und ô~õ ‰ö und fahre fort mit Schritt 2, bis sich die Bereiche überlappen (
ó )
4. Falls þ`óãÿølô~õóö , vertausche Pivotelement ô9õ ë ö und das Element ô~õóö .
❑ Alle Element in
Informatik II – c Guido Rößling
Sortieralgorithmen – Quicksort : Ablauf von partition
11.25
Implementierung
/ Q u i c k s o r t : S o r t i e r e m i t t e l s P i v o t e l e m e n t i n Teilmenge ” k l e i n e r /
gr oes s er a l s P i v o t ” . K o m p l e x i t a e t : O( n l o g n ) bzw . O( n ˆ 2 )
/
public
void q u i c k s o r t ( Comparable [ ] a , i n t l , i n t r )
int i , j ;
/ / Schleifenzaehler
Comparable p i v o t ;
/ / P i v o t Element
if ( r l )
/ / G i b t es zu s o r t i e r e n d e Elemente?
pivot = a[ r ] ;
/
/ I n i t i a l i s i e r e n Pivotelement
f o r ( i = l , j = r 1; i j ; )
while ( a [ i ] . isLessOrEqual ( p i v o t ) & & i j ) i + + ; / / Suche zu grosses
while ( p i v o t . isLessThan ( a [ j ] ) & & j i ) j ; / / Suche zu k l e i n e s
/ / Vertausche Elemente
i f ( i j ) swap ( a , i , j ) ;
i f ( p i v o t . isLessThan ( a [ i ] ) ) swap ( a , i , r ) ; / / Einfuegen P i v o t Pos . i
else i = r ;
/ / P i v o t n i c h t geaendert s o r t i e r e a l l e s v or P i v o t !
/ / linken Teil sortieren
quicksort ( a , l , i 1);
quicksort (a , i +1, r ) ;
/ / rechten T e i l s o r t i e r e n
Listing 29: Quicksort
Informatik II – c Guido Rößling
Sortieralgorithmen – Quicksort : Implementierung
11.26
Beispiel
r
i
Pivotelement
Vertauschungen
sortierte Elemente
0 1 2 3 4 5 6 7 8 9 10 1112 13 14
A A E E T I N G OX SM P L R
l
0 14 3
A A E E T I N G OX SM P L R
A S O R T I N G E X A M P L E
0 2 2
A A E E T I N G OX SM P L R
A A E E L I G M O P NR X T S
0 1 1
4 10 7
A A E E G I L M O P NR X T S
4 14 11 A A E E L I N G O P M R X T S
4 6 4
A A E E G I L M O P NR X T S
A A E E G I L M O P NR X T S
4 6 6
4 5 5
A A E E G I L M N PO R X T S
A A E E G I L M O P NR X T S
8 10 8
A A E E G I L M N OP R X T S
4 4 4
9 10 9
12 14 12 A A E E G I L M N O P R S T X
13 14 14 A A E E G I L M N O P R S T X
A A E E G I L M N OP R S T X
Abbildung 69: Beispiel zu Quicksort“
”
Informatik II – c Guido Rößling
Sortieralgorithmen – Quicksort : Beispiel
11.27
Komplexität
❑ Im schlimmsten Fall wird jedes Folgenelement einmal als Pivotelement ausgewählt. Dies
passiert z.B. bei einer sortierten Folge. Es werden dann
!#"$ %
&('*)
ó+-,
."/0$
Vergleiche benötigt sowie , #" / $ Bewegungen.
☞ Im schlimmsten Fall gilt also Quicksort 12, ." / $
❑ Im günstigsten Fall wird die Teilfolge in jedem Schritt genau halbiert. Damit hat der Baum
der rekursiven Aufrufe minimale Höhe, nämlich ungefähr 35476 / " .
☞ In diesem Fall gilt dann Quicksort 18, #":9 35476 / ";$
❑ Für den durchschnittlichen Fall wird angenommen, daß alle "< Anordnungen gleich wahrscheinlich sind. Mit einigem Rechengeschick ergibt sich auch dann
Quicksort 18, #":9 35476 / ";$
Informatik II – c Guido Rößling
Sortieralgorithmen – Quicksort : Komplexität
11.28
Anmerkungen zu Quicksort
❑ Quicksort hat eine sehr einfache Implementierung, ist aber dennoch sehr effizient
❑ wenig Ressourcen nötig: nur ein kleiner Stack für die Rekursion
❑ störanfällig bei Implementierungen, besonders bei mehreren gleichen Schlüsseln
❑ Im besten und durchschnittlichen Fall sehr effizient: , #":9 3=476 / ";$
❑ Bei sortierten Eingaben sehr schlecht: , #" / $ . Dies hängt von der Wahl des Pivotelements
ab.
Informatik II – c Guido Rößling
Sortieralgorithmen – Quicksort : Anmerkungen
11.29
Alternative Pivotwahl
Wie gesehen, führt die Wahl von >?A@CB als Pivotelement zum Eintreten des worst case bei
sortierten Eingaben.
Durch andere Pivotwahl kann versucht werden, dies zu verhindern:
❑ Zufällige Auswahl eines Elements aus DFEGE7EH@
☞ Wähle mittels Zufallszahlgenerator ein Element aus und vertausche es mit >?A@CB
vor der Ausführung von partition
Der worst case tritt nur noch mit sehr geringer Wahrscheinlichkeit auf; alle Eingaben
werden (annähernd) gleich behandelt.
❑ Wahl des mittleren von drei Elementen ( 3-Median-Strategie“)
”
☞ Sortiere >?ID.BKJL>?A@CBKJM>? DONP@ $RQ!S B auf ihren Plätzen. Wähle dann >T? DONP@ $QUS B als
Median und sortiere nur noch die Teilfolgen ab DVNXW und bis @ZY-W
Die Laufzeit verbessert sich dadurch um circa 5%; die Wahl des Pivots macht die Aufteilung in ungefähr gleich große Teile wahrscheinlich.
Informatik II – c Guido Rößling
Sortieralgorithmen – Quicksort : Alternative Pivotwahl
11.30
Ausnutzung der Datenstruktur
Für einige Datenstrukturen existieren triviale Sortierungsverfahren.
In einem binären Suchbaum oder AVL-Baum kann eine Sortierung der Elemente einfach durch
einen In-Order Durchlauf gewonnen werden, da die Elemente in diesen Datenstrukturen bereits sortiert vorliegen.
Bei B-Bäumen muß der In-Order Durchlauf so angepaßt werden, daß die Besuchsreihenfolge
in einem Knoten wie folgt aufgebaut ist:
1. Setze [+\
W
2. Folge ] & ) in die Tiefe
3. Falls [_^`\-a , gib Element b & bzw. dessen Daten c & aus.
4. Setze [d\
Tiefe.
h
[+NeW und fahre mit Schritt 2 fort, bis [f\\
Informatik II – c Guido Rößling
a . In diesem Fall folge ]Og in die
Sortieralgorithmen – Binärer Suchbaum, AVL- und B-Baum
11.31
Heapsort
❑ Ab Seite 5.21 wurde bereits der Heap als Datenstruktur sowie als Modellierung einer
Prioritätswarteschlange präsentiert.
Zugleich eignet sich der Heap aber auch sehr gut zum Sortieren in einem speziellen Verfahren: Heapsort.
❑ Zur Erinnerung: Ein Heap ist ein fast vollständiger binärer Baum, in dem der Wert jeder
(Teil-)Wurzel größer als der ihrer beiden Söhne ist und jeder nicht-leere Sohn die Wurzel
eines Heaps ist.
❑ Im Heap steht entsprechend das größte Element immer an der Wurzel.
❑ Heaps können effizient in einem Array gespeichert werden: siehe auf Seite 5.21 und auf
Seite 5.12f.
h
Informatik II – c Guido Rößling
Sortieralgorithmen – Heapsort
11.32
Algorithmus
Das Vorgehen bei Heapsort ist wie folgt:
1. Konstruiere einen Heap aus den zu sortierenden Elementen.
Dies geht in , 35476 / ";$ .
2. Solange der Heap nicht leer ist, entferne die Wurzel und stelle die HeapEigenschaft wieder her.
Üblicherweise wird die Wurzel bei Speicherung in einem Array in Schritt [ an Position " Yi[
geschrieben, so daß am Ende ein sortiertes Feld vorliegt.
Anstatt ein Element zu entfernen, wird die Wurzel einfach mit dem Element an Position " Yj[
vertauscht und die Heap-Eigenschaft wieder hergestellt.
h
Informatik II – c Guido Rößling
Sortieralgorithmen – Heapsort : Algorithmus
11.33
Implementierung
Sei downheap(a, l, r) eine Routine zum Herstellen der Heap-Eigenschaft für den
Heap mit Knoten DRJEEEJM@ , der im Feld > gespeichert ist (beschrieben auf Seite 5.24).
/ kk
k
k
Heapsort s o r t i e r t ueber Heap ( e i n e s p e z i e l l e Baum struktur )
K o m p l e x i t a e t : O( n l o g n )
k
/
public void heapsort ( Comparable [ ] a )
l
i n t k , t , n=a . l e n g t h m 1;
f o r ( k=n / 2 ; k n =0; k mom ) downheap ( a , k , n ) ;
while ( n n 0)
/ / Noch Elemente da?
l
q
q
swap ( a , n , 0 ) ;
n mpm ;
downheap ( a , 1 , n ) ;
/ / ” E n t f e r n e ” Wurzel
/ / merke g e r i n g e r e Groesse
/ / s t e l l e Heap wieder her
Listing 30: Heapsort
h
Informatik II – c Guido Rößling
Sortieralgorithmen – Heapsort : Implementierung
11.34
Beispiel
bewegter Knoten
ausgetauschte Wurzel
sortierte Elemente
X
T
T
R
S
P
S
O
N
G E A A M I
L E
P
E
R
L X
E
M
G E A A R S T
I
N
X
G E A
I
N
T
E
M
P R S T
A
I
X
G E O
N
X
G E A A M S T
X
M
E
O
M
L
N
E
O
G E A A M I
P
L
N
L
O
E
L
N
O
L
I
P
R
O
G E A A M I
P
R
S
A
P R S T
L
A
I
X
G N O
E
E
A
P R S T
A
X
Abbildung 70: Beispiel zu Heapsort“, Teil 1
”
h
Informatik II – c Guido Rößling
Sortieralgorithmen – Heapsort : Beispiel
11.35
Beispiel
bewegter Knoten
ausgetauschte Wurzel
sortierte Elemente
L
I
I
E
G
E
M N O
G
A
A
P R S T
E
A
E
X M N O
E
M N O
A
G
A
L
P R S
I
T
A
X
E
I
A
M N O
P R S T
E
X
M N O
E
G
A
L
P R S T
E
A
X
G
M N O
I
I
P R S T
E
X
M N O
E
G
X
A
A
L
L
P R S T
A
A
L
E
E
A
A
E
G
I
P R
A
L
S T
E
X
M N O
E
G
I
P R S T
L
X
Abbildung 71: Beispiel zu Heapsort“, Teil 2
”
h
Informatik II – c Guido Rößling
Sortieralgorithmen – Heapsort : Beispiel
11.36
Komplexität
❑ Unabhängig von den Eingabedaten garantiert Heapsort eine Sortierung der r Elemente
in sut#rwv!x=y7z|{r;} . Der für das Sortieren notwendige Aufbau des Heaps erfolgt ebenfalls in
s~t#rv€x5y7z{r} , so daß das Verfahren insgesamt in s~t#rfx=y7z|{‚r;} arbeitet.
❑ Im Gegensatz zu praktisch allen anderen Sortieralgorithmen gibt es für Heapsort keinen
worst case“, da die Sortierung immer in sut#rv€x5y7z|{‚r;} erfolgt.
”
❑ Zusätzlich benötigt Heapsort keinen zusätzlichen Speicher.
❑ Im Durchschnitt ist Quicksort schneller als Heapsort, benötigt allerdings zusätzlichen
Speicher.
ƒ
Informatik II – c Guido Rößling
Sortieralgorithmen – Heapsort : Komplexität
11.37
Mergesort
Mergesort benutzt als Grundlage das Konzept des Mischens, das heißt Zusammenfügen zweier
sortierter Folgen zu einer sortierten Gesamtfolge.
Ähnlich wie Heapsort garantiert auch Mergesort eine Komplexität von s~t#r„vx5y7z|{r} , allerdings auf Kosten von zusätzlichem Speicherbedarf.
Der grundlegende Algorithmus sieht wie folgt aus:
1. Teile die Teilfolge in zwei Hälften
2. Sortiere die beiden Hälften rekursiv durch Beginnen bei Schritt 1 für beide Teilfolgen
3. Mische die beiden Hälften zu einer sortierten Datenfolge
ƒ
Informatik II – c Guido Rößling
Sortieralgorithmen – Mergesort
11.38
Implementierung
/ ……
…
…
Mergesort s o r t i e r t durch Mischen s o r t i e r t e r Folgen o . D ateien .
K o m p l e x i t a e t O( n )
…
/
void mergesort ( Comparable [ ] a , i n t l , i n t r )
l
i n t i , j , k , m;
Comparable [ ] b = new Comparable [ a . l e n g t h ] ;
l
i f ( rn l )
m = ( l +r ) / 2 ;
/ / M i t t e bestimmen
mergesort ( a , l , m ) ;
/ / S o r t i e r e und Mische l i n k s
mergesort ( a , m+ 1 , r ) ;
/ / S o r t i e r e und Mische r e c h t s
f o r ( i = l ; i † =m & & i † a . l e n g t h ; i + + ) b [ i ] = a [ i ] ; / / Kopiere l .
f o r ( j =m+ 1 ; j † =r ; j + + ) b [ r +m+1 m r ] = a [ j ] ;
/ / Kopiere r .
f o r ( k= l , i = l , j = r ; k † =r & & k † a . l e n g t h ; k + + )
/ / Merge
a [ k ] = ( b [ i ] . isLessThan ( b [ j ] ) ) ? b [ i + + ] : b [ j mom ];
q
q
ƒ
Informatik II – c Guido Rößling
Listing 31: Mergesort
Sortieralgorithmen – Mergesort : Implementierung
11.39
Beispiel
nicht betrachtet
ausgeführte Bewegungen
sortierte Elemente
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
A O R S T I N G E X A M P L E
A O R S I T N G E X A M P L E
A O R S I T G N E X A M P L E
A O R S G I N T E X A M P L E
A G I N O R ST E X A M P L E
A G I N O R ST E X A M P L E
A G I N O R ST E X A M P L E
A G I N O R ST A E M X P L E
A G I N O R ST A E M X L P E
A G I N O R ST A E M X E L P
A G I N O R ST A E E L M P X
A A E E G I L M N O PR S TX
Abbildung 72: Beispiel zu Mergesort“
”
ƒ
Informatik II – c Guido Rößling
Sortieralgorithmen – Mergesort : Beispiel
11.40
Komplexität
❑ Mergesort garantiert eine Komplexität von sut.r:v€x5y7z { r} .
❑ Allerdings benötigt Mergesort in der Regel sut#r;} zusätzlichen Speicherplatz. Es gibt aber
auch (komplizierte) Implementierungen von Mergesort mit sutˆ‡‰} Platzbedarf.
❑ Mergesort kann so realisiert werden, daß es den Zugriff auf die Dateien hauptsächlich
sequentiell realisiert und sich damit gut für das Sortieren von Daten auf Datenträgern
oder in Listen eignet.
ƒ
Informatik II – c Guido Rößling
Sortieralgorithmen – Mergesort : Komplexität
11.41
Sonstige elementare Sortierverfahren
Hier nicht behandelte Sortierverfahren beinhalten u.a.
❑ Distribution Counting (für ganze Zahlen): zähle die Anzahl Elemente mit Wert Š und
kopiere dann die Werte in entsprechende Feldintervalle;
❑ Digitales Sortieren zum Sortieren von Schlüsseln als Zahl zu einer Basis ‹ ;
❑ diverse Variationen von Mergesort sowie
❑ Externes Mischen zum Sortieren von Daten auf externen Speichern.
ƒ
Informatik II – c Guido Rößling
Sortieralgorithmen – Sonstige Sortierverfahren
11.42
ƒ
Informatik II – c Guido Rößling
Sortieralgorithmen
Kryptologie
Graphentheorie
Graphenalgorithmen
Suchalgorithmen
Suche in Zeichenfolgen
Sortieralgorithmen
Hashing
Kompressionsverfahren
Primitive Datentypen
Listenstrukturen
Bäume
Sonstige Datentypen
Einleitung
Zahlendarstellung
Wo sind wir ŒŒ7Œ ?
11.43
Grundlagen des Hashings
❑ Zusätzlich zu den Datenstrukturen, die auf Seite 3.1–7.23 vorgestellt wurden, ist man an
einer Datenstruktur interessiert, die einfache Einfügeoperationen hat und dennoch einen
Zugriff von sutˆ‡‰} auf die Daten ermöglicht.
❑ Von allen Datenstrukturen bietet nur das Array einen Zugriff von s~tˆ‡‰} ; leider ist aber
das Einfügen in ein Array mit s~t#r;} (Einfügen vor dem ersten Element und Kopieren der
vorhandenen Elemente) zu teuer.
❑ Die Idee des Hashings besteht darin, ein Array fester Größe zum Speichern der Elemente
zu verwenden und die Position eines Elements aus seinem Schlüssel bzw. Wert zu berechnen. Die Funktion zur Berechnung einer (Array-)Position aus einem Element heißt
Hash-Funktion.
❑ Dabei kann es allerdings passieren, daß die Hash-Funktion mehrere Elemente auf die
gleiche Position abbildet: es kommt zu einer Kollision. Kollisionen werden durch eine
Kollisionsbehandlung verarbeitet, die den Elementen eine andere Position zuweist.
❑ Im folgenden werden die gängigsten Hash-Funktionen sowie Kollisionsbehandlungsmechanismen kurz vorgestellt.
ƒ
Informatik II – c Guido Rößling
Hashing
12.1
Formale Definition des Hashings
❑ Gegeben sei ein Array a der Größe ‹ mit den Indizes ŽŒŒŒŽH‹ ‘‡ . Dieses Array wird als
Hash-Tabelle bezeichnet und dient zur Speicherung der Datensätze.
❑ Eine Abbildung
’:“•”
–
—
ŽGŒ7ŒGŒ7Ž0‹
P‡€˜
ordnet
’ jedem Datensatz anhand seines Schlüssels k (englisch: key) bzw. Wertes einen Index tK™F} in der Hash-Tabelle zu.
❑ Im allgemeinen ist die Anzahl möglicher Schlüssel deutlich größer als die Anzahl Indizes
der Hash-Tabelle.
’
’
☞ Es können Adreßkollisionen kommen, d.h. tK™Uš›}œ
tK™€} für ™!šŸœ ž ™€
❑ Ein gutes Hash-Verfahren versucht,
☞ die Anzahl Adreßkollisionen möglichst gering zu halten
’¡
☞ und auftretende Adreßkollisionen
möglichst effizient aufzulösen durch Zuweisung eines anderen Indexes t¢™CL} .
❑ Dabei ergibt sich eine durchschnittliche Komplexität von sutˆ‡‰} für Einfügen und Suche,
im schlimmsten Fall von sut#r} .
ƒ
Informatik II – c Guido Rößling
Hashing – Formale Definition
12.2
Statisches Hashing
❑ Zwei wesentliche Grundsätze für die Hash-Funktion:
☞ einfach zu berechnen
☞ sollte möglichst wenig Kollisionen erzeugen.
❑ Der Grundansatz ist dabei, den Schlüssel eines Elements als Zahl k zu interpretieren und
den Index durch eine Operation modulo ‹ zu berechnen, um nur Werte von  bis ‹ £‡
erzeugen zu können.
❑ Das einfachste Vorgehen ist die Divisions-Rest-Methode:
’
❑ Es ist auf eine sinnvolle Wahl von ‹
tK™V}Oœ ™¤‹¥!¦Z‹
zu achten: ‹
sollte eine Primzahl größer 2 sein.
❑ Sonderfall: die Schlüssel bilden ein abgeschlossenes, kleines Intervall der ganzen Zahlen,
etwa §¨ŽG‡©CGª .
’
☞ In diesem Fall wählt man ‹ œ ‡©|‡ und tK™V}Ÿœ ™ und erhält ein perfektes Hashing,
falls kein Schlüssel mehr als einmal auftritt.
ƒ
Informatik II – c Guido Rößling
Hashing – Statisches Hashing
12.3
Beispiele für Hash-Funktionen
❑ Vielfach muß der Schlüssel erst auf eine Zahl abgebildet werden, die zur Berechnung des
Hash-Werts herangezogen wird.
☞ Dies ist z.B. bei Strings notwendig, zu großen Schlüsseln oder Schlüsseln, bei denen
mit großer Kollisionszahl zu rechnen ist (etwa binärcodierte Dezimalzahlen).
❑ Der Schlüssel wird dann vor der Berechung der Modulo-Operation angepaßt, z.B. durch
Berechnung eines Zahlenwerts für einen Text anhand der Einzelbuchstaben an ausgewählten Positionen, oder durch Faltung der einzelnen Zahlenstellen. Anschließend wird die
Hash-Funktion auf die berechnete Repräsentierung angewendet.
’
Beispiel 1: Berechnen einer Zahl aus einem Text mittels einer Hilfsfunktion «‚¬®­ t°¯±š²} , die
die
den ASCII-Wert) bestimmt:
’
³ Position des’ Buchstabens ’ im Alphabet (nicht
t¢™V}œ tµ´`v7«¬®­ tµ¯©¶0}T·¹¸`v€«¬5­ tµ¯€º»}·¹¼`v€«‚¬®­ t°¯ { }}
³
Beispiel 2: Sei ™ = 124398033. Die Faltung
kann
dann
durch
eine
Funktion
z.B. erfolgen
³
als Summe der Einzelstellen œ ³ ‡_·½¼¾·‘¿`·½À¾·½Áp·½Â¾·½¾·½À¾·½ÀÜeÀCÀ oder
durch Summe von Blöcken, etwa œ ‡©¼¿Ä·¹ÀCÁC·¹CÀCÀŜ-¸C¸C¸
ƒ
Informatik II – c Guido Rößling
Hashing – Beispiele für Hash-Funktionen
12.4
Kollisionsbehandlung
Wird der gleiche ’ÈIndex
zwei
Ç
’ÈÇ verschiedenen Elementen ÆUºLŽLÆ { bzw. deren Schlüsseln ™ºMŽ±™ {
zugewiesen, d.h. ™ºˆÉœ
™ { É , muß eine Kollisionsbehandlung ausgeführt werden, die für
die Speicherung des zweiten Elements dient.
Hierzu gibt es folgende prinzipiellen Möglichkeiten:
❑ Anhängen der Überläufer an das Zielfeld in einer verketteten Liste
Ç
Falls keine Überläufe auftreten, bleibtÇ die Komplexität bei Ê ‡‰É . Andernfalls muß nach
Berechnung der Hash-Funktion (in Ê ‡‰É ) die verkettete ListeÇ durchlaufen werden.
Für ˄ÌdÌX‹ erfordert dies einen Aufwand von ungefähr Ê ËÎÍC‹jÉ .
Dennoch bietet sich dieses Verfahren etwa für den Einsatz von Externspeichern an (Speicherung der Listen auf Platte o.ä.) und erlaubt auch einen Belegungsfaktor von mehr als
1.
❑ Einsetzen einer weiteren Hash-Funktion zum Weiterprobieren“ oder Sondieren einer frei”
en Position
Hierzu gibt es mehrere Funktionen, die auf Seite 12.7f betrachtet werden.
Ï
Informatik II – c Guido Rößling
Hashing – Kollisionsbehandlung
12.5
Beispiel zum Anhängen als Liste
Hash-Tabelle mit Überläufern als verkettete Liste:
0
1
2
3
4
Werte
A S E A R C H E X A M P L E
alph(c)
1 19 5 1 18 3 8 5 24 1 13 16 12 5
h(k) = alph(c) mod 17
1 2 5 1 1 3 8 5 7 1 13 16 12 5
5
A
S
C
E
6
7
X
8
H
A
R
A
next
next
next
E
E
next
next
9
10
11
12 L
13 M
14
15
16 P
Abbildung 73: Hashing mit Anhängen der Überläufer als verkettete Liste
Ï
Informatik II – c Guido Rößling
Hashing – Kollisionsbehandlung : Überläuferliste
12.6
Sondierungsverfahren
❑ Die einfachste Möglichkeit, eine neue Einfügeposition zu bestimmen, ist das Sondieren.
Hierzu wird eine weitere Funktion herangezogen, die eine freie Position bestimmt, so daß
jedes Element mit möglichst wenigen Zugriffen
bleibt.
Ç#ÑÒÔauffindbar
Ó
Ñ
ÇKÓ Ð
É und berechnet die i-te ( ÌPÕÖÉ Einfüge❑ Im allgemeinen hat diese Funktion die Form
position
wird
ÇKÓ nach einer Kollision an Index × É . In der Literatur
ÇKÓ
Ç#ÑÒ±Ó diese Funktion oft auch
als ×FØ É bezeichnet oder der Zielindex definiert als × ÉÙÚÐ
ÉTÛ:ÜÖÝÞÛ .
Gängig sind die folgenden Sondierungsverfahren:
Ç#ÑÒ±Ó
Ç KÇ Ó
Ñ
É à ÇZ
É Û:Ü!ÝZÛ Lineares Sondieren“
❑ Ð Ç#ÑÒ±Ó É+ß × Ç¢Ó T
”
Ø
ä
Ø
æ
ã
å
Ù â‰É
❑ Ð Ç#ÑÒ±Ó É+ß á× Ç¢Ó ÉTà Ñ Ã
{HçÖè Û:Ü!ÝZÛ ”Lineares Sondieren mit Vorzeichenwechsel“
{
❑ Ð Ç#ÑÒ±Ó É+ß á × Ç¢Ó ÉTà Ç è ÛÜ!ÝZÛ Quadratisches Sondieren“
”
Ø {
ä
Ø
æ
ã
å
❑ Ð Ç#ÑÒ±Ó É+ß Ñ á× ÉTÇ¢Ó à ÙÃâ‰É
{Hç è Û:ÜÖÝÞÛ ”Quadr. Sondieren mit Vorzeichenwechsel“
ã
❑ Ð Ç#ÑÒ±Ó É+ß Ç × { ÉÛ:Ü!ÝZÛ ÇKÓ Doppeltes Hashing“
”
Ø ã {
Ø
æ
ã
å
❑Ð
É+ß á ÙÃâ‰É
É è Û:Ü!ÝÞÛ Doppeltes Hashing mit Vorzeichenwechsel“
{ç ×
”
Ï
Informatik II – c Guido Rößling
Hashing – Sondierungsverfahren
12.7
Beispiel
ê { ë ì í î ï ð ñ êµé êòêóê { ê ë ê ì ê í ê î
õ öZ÷CöZõøúùû¤üäöZý‚þÿüûÎöÎûÞõödüCö
`ö
ö
õ ø õ ö ÷ ö ý ö ü ø ü ö ü û ö ö
ö ö û õ¤ù þ
ùZõ ö ÷ ö ý ö
ü ö ü ø ö ö õ ‘õ þ
ö ö üþ ö
õ ø õ ö ÷ ö ý ö ü ø ü ö ü û ö ö õ ö ö ùþ ö
é
Verfahren
Lineares Sondieren
Lin. Sond. mit Vz.
Quadr. Sondieren
Quadr. Sondieren mit Vz.
Zugriffe
ëòñ
{ð
ëé
{î
ô
{Aï ñ
{
{ ê ì
ê ðòî
Tabelle 18: Beispiele für Sondierungsverfahren (Modulo 17)
❑ Die Zahl hinter den Elementen gibt die Anzahl Zugriffe zum Einfügen oder Lesen an.
❑ Falls Û ÌXË ist, die Tabelle also mehr Platz hat als Schlüssel eingefügt werden sollen, und
Ç Alle
die Hash-Funktion geschickt gewählt wird, sind Kollisionen beim Hashing selten.
Operationen – Einfügen, Suchen und Löschen haben dann eine Komplexität von Ê â‰É .
❑ Jeder der genannten Kollisionsbehandlungen hat Vor- und Nachteile, die von den Eingangsdaten abhängen.
Sie lassen sich auch zum Verwalten des Zugriffs auf externe Speicher verwenden.
❑ Eine sequentielle Verarbeitung der Daten sowie Sortierung ist aber nur noch durch vollständiges Auslesen der Tabelle und ggf. der Überlauflisten und anschließende Sortierung
möglich.
Ï
Informatik II – c Guido Rößling
Hashing – Sondierungsverfahren : Beispiel
12.8
Vor- und Nachteile der Sondierung
Vorteile:
❑ Statt Durchlaufen von Listen weiterhin nur Zugriff auf Array
❑ Sondierungsfunktion ist i.d.R. effizient berechenbar
Nachteile:
❑ Gefahr der Clusterbildung (vgl. Beispiel): es müssen viele Positionen durchlaufen werden, bevor das Element gefunden ist.
Anforderungen:
❑Û
❑ Û sollte Primzahl sein, um die Gleichbehandlung ähnlicher Elemente möglichst gering
zu halten.
Ï
Informatik II – c Guido Rößling
Hashing – Sondierungsverfahren : Vor- und Nachteile
12.9
Dynamisches Hashing
Ist die Anzahl Datensätze nicht bekannt, kann das Hash-Verfahren sehr ineffizient werden
oder evtl. nicht alle Elemente speichern.
Im dynamischen Hashing werden die Daten in Blöcken (Buckets) gespeichert, in die jeweils
Datensätze passen ( ist der Bucket-Faktor“), wobei die Anzahl Buckets sei. Ist eines der
”
Felder zu groß, werden folgende Schritte ausgeführt ( Virtuelles Hashing“, Litwin 1978):
”
❑ Verdoppelung des Speicherbereichs durch Erzeugen von
Anhängen an die vorhandenen Buckets.
ã ❑ ;ß
❑ Bestimmen einer neuen Hash-Funktion ×Ø ê , die alle
neuen Buckets und
Buckets abdeckt
❑ Aufteilen des übergelaufenen Buckets: Umverteilen der Hälfte der Werte durch
die neue Hash-Funktion × Ø ê .
❑ Markieren des
Ó alten Buckets in Ó einem Bit-Vektor: Für Zugriffe auf dieses Bucket
auch noch × Ø ê
in Betracht zu ziehen.
ist neben × Ø
Falls alle Daten in den Hauptspeicher passen, liegt die Komplexität bei
"
Informatik II – c Guido Rößling
Hashing – Dynamisches Hashing
! â
.
12.10
"
Informatik II – c Guido Rößling
Kryptologie
#$#%# ?
Graphentheorie
Graphenalgorithmen
Suchalgorithmen
Suche in Zeichenfolgen
Sortieralgorithmen
Hashing
Kompressionsverfahren
Primitive Datentypen
Listenstrukturen
Bäume
Sonstige Datentypen
Einleitung
Zahlendarstellung
Wo sind wir
Hashing
12.11
Kompressionsverfahren: Motivation
❑ Aufgabe: Umwandeln eines Eingabedatenstroms in einen kürzeren Ausgabedatenstrom
❑ Datenströme sind dabei Dateien oder Speicherpuffer
❑ Kompression ist populär, denn:
☞ die meisten Anwender sammeln Daten, werfen sie aber nur ungern weg
☞ unabhängig von der Speicherkapazität ist der Speicher irgendwann voll
☞ durch Kompression der Daten kann der Überlauf verzögert werden
☞ Datentransfers sollen möglichst schnell abgeschlossen sein
☞ da komprimierte Daten kürzer sind, werden sie auch schneller übertragen
❑ Das Prinzip der Kompression ist es, Redundanzen der Eingabedaten zu komprimieren
❑ häufig auftretende Elemente bekommen einen möglichst kurzen Code
☞ Siehe Tabelle 19 auf Seite 13.2 für die Häufigkeit der Buchstaben in englischen
Texten
❑ selten auftretende Elemente bekommen einen (vergleichsweise) langen Code
"
Informatik II – c Guido Rößling
Kompressionsverfahren – Motivation
13.1
Häufigkeit der Buchstaben in Englisch
Letter
A
B
C
D
E
F
G
H
I
%
Letter
%
Letter
%
0.0721
J
0.0013
S
0.0728
0.0240
K
0.0054
T
0.0908
0.0394
L
0.0426
U
0.0235
0.0372
M 0.0282
V
0.0094
0.1224
N
0.0638
W 0.0130
0.0272
O
0.0681
X
0.0077
0.0178
P
0.0290
Y
0.0126
0.0449
Q
0.0023
Z
0.0026
0.0779
R
0.0638
Tabelle 19: Häufigkeit der Buchstaben in englischen Texten (aus dem LATEX-Quelltext des Buches [Sol98])
❑ Häufigste Buchstaben i.a. ETAOINSHRDLU oder ETAONIRSHDLC
❑ Die häufigsten englischen Digramme (Kombinationen aus 2 Buchstaben):
☞ th, ta, re, ia, ak, ej, ek, er, gj, ad, yu, rx, kt
❑ Die häufigsten ersten Buchstaben sind s, p, c
❑ Die häufigsten letzten Buchstaben sind e, y, s
"
Informatik II – c Guido Rößling
Kompressionsverfahren – Motivation
13.2
Verteilung der Zeichen im Skript
❑ Das hier vorliegende Skript zur Informatik II hat folgende Verteilung der Zeichen:
&'
Anzahl
1145
91
62
261
222
135
295
3066
1155
1222
401
1393
1169
2061
876
1227
1570
886
445
345
!
()
*
’
”
(
)
+
,
.
/
0
1
2
3
4
%
0.002844
0.000226
0.000154
0.000648
0.000551
0.000335
0.000733
0.007616
0.002869
0.003036
0.000996
0.003460
0.002904
0.005120
0.002176
0.003048
0.003900
0.002201
0.001105
0.000857
5
6
7
8
9
:
;
=
?
A
B
C
D
E
EOL
F
G
H
I
J
Anzahl
359
203
193
141
133
691
418
771
61
1127
1359
359
1311
1129
12200
707
511
385
592
67
%
0.000892
0.000504
0.000479
0.000350
0.000330
0.001716
0.001038
0.001915
0.000152
0.002800
0.003376
0.000892
0.003257
0.002805
0.030306
0.001756
0.001269
0.000956
0.001471
0.000166
K
L
M
N
O
P
Q
R
S
T
TAB
U
V
W
X
Y
Z
[
#
Anzahl
817
679
391
289
225
430
117
314
1636
69545
417
4
174
708
403
77
17
705
617
4
%
0.002029
0.001687
0.000971
0.000718
0.000559
0.001068
0.000291
0.000780
0.004064
0.172755
0.001036
0.000010
0.000432
0.001759
0.001001
0.000191
0.000042
0.001751
0.001533
0.000010
+
$
%
&
@
,-
]
‘
a
b
c
d
e
f
g
h
i
j
Anzahl
2431
10979
1951
1651
29
605
8008
8193
559
178
12790
5587
6204
10234
42472
3664
6718
8072
23537
531
%
0.006039
0.027273
0.004846
0.004101
0.000072
0.001503
0.019892
0.020352
0.001389
0.000442
0.031771
0.013879
0.015411
0.025422
0.105504
0.009102
0.016688
0.020051
0.058468
0.001319
Anzahl
k
2245
l
11363
m
7027
n
23049
o
8039
p
3106
q
154
r
15272
s
12443
t
25410
u
9328
v
2017
w
1983
x
4586
y
583
z
2542
—
711
Anzahl Zeichen:
%
0.005577
0.028227
0.017456
0.057255
0.019969
0.007716
0.000383
0.037937
0.030909
0.063120
0.023171
0.005010
0.004926
0.011392
0.001448
0.006315
0.001766
402564
Tabelle 20: Häufigkeit der Buchstaben im Skript Informatik II
❑ Nicht einbezogen sind dabei Abbildungen, Inhalts-, Tabellen-, Abbildungs- und Literaturverzeichnis sowie Index und die Tabelle selbst.
.
Informatik II – c Guido Rößling
Kompressionsverfahren – Motivation
13.3
Einige Definitionen
❑ Encoder oder Compressor: Programm zum Umwandeln eines Eingabedatenstroms in
einen komprimierten Ausgabedatenstrom
❑ Decoder oder Decompressor: Programm zum Umwandeln der komprimierten Daten in die Originaldaten
❑ Beide Begriffe werden auch in anderen Kontexten mit anderer Bedeutung benutzt!
❑ Originaldaten werden auch als uncodiert (engl. unencoded) oder roh (engl. raw) bezeichnet
❑ verlustfreie (lossless) Kompression garantiert den Erhalt der Originaldaten
❑ Bei verlustbehafteter (lossy) Kompression entspricht der dekomprimierte Datenstrom nicht
den Originaldaten
☞ unnötige“ Daten können entfernt werden, insb. bei Bildern oder Ton
”
☞ für ausführbaren Programmcode nicht geeignet!
☞ Bei Quelltexten können aber z.B. aufeinanderfolgende Leerzeichen oder -zeilen
gefahrlos eliminiert werden
.
Informatik II – c Guido Rößling
Kompressionsverfahren – Definitionen
13.4
Kompressionstypen
❑ Nichtadaptive Kompression arbeitet unabhängig von den Eingabedaten
☞ jedes Eingabeelement wird bei allen Eingaben auf die gleiche Weise umgesetzt
☞ die Codierung ist dann meist für eine bestimmte Anwendung gedacht und wäre
bei anderen Eingabedaten schlecht
❑ Adaptive Kompression paßt die Codierung an die Eingabedaten an
❑ Semi-adaptive Kompression komprimiert die Daten erst nach einem Komplettdurchlauf
zum Generieren von Statistiken
❑ Symmetrische Kompression verwendet den prinzipiell gleichen Algorithmus für Kompression und Dekompression (nur in umgekehrter Richtung“)
”
❑ Bei asymmetrischer Kompression ist einer der beiden Schritte (deutlich) aufwendiger
☞ Der aufwendigere Teil sollte der seltenere sein, z.B. aufwendige Kompression
bei Erstellung von Tape Archives
☞ Sinnvoll z.B. zur Generierung sehr guter Codierung von Bild-, Audio- und Videomaterial: einmal codiert, oft decodiert
.
Informatik II – c Guido Rößling
Kompressionsverfahren – Definitionen : Kompressionstypen
13.5
Kompressionsgüte
❑ Kompressionsverhältnis (engl. compression ratio):
Ausgabegröße
compression ratio = Eingabegröße
☞ Bei Kompressionsverhältnis 60% benötigen die komprimierten Daten 60% des
Platzes der Originaldaten
☞ Bei Werten größer als 1 ist die Ausgabe größer als die Eingabe (negative Kompression)
❑ Kompressionsfaktor (engl. compression factor):
Eingabegröße
compression factor = Ausgabegröße
❑ Daten lassen sich nicht beliebig oft komprimieren!
☞ Komprimierbare Redundanzen wurden (größtenteils) eliminiert
☞ Andernfalls ließe sich alles in einem Bit darstellen
/%/%/
❑ Konflikt zwischen Kompressionsfaktor und Kompressions-/Dekompressionszeit
.
Informatik II – c Guido Rößling
Kompressionsverfahren – Definitionen : Kompressionsgüte
13.6
Intuitive Kompression
❑ Kennzeichen:
☞ sehr naheliegende Vorgehensweise
☞ relativ ineffizient
☞ dafür aber schnell zu komprimieren / dekomprimieren
❑ Beispiel 1: Braille-Code (entwickelt von Louis Braille ca. 1820, Blindenschrift“):
”
☞ Codierung durch Zellen von
Punkten (flach oder geprägt)
darstellbare Zeichen, davon 26 Buchstaben, 10 Ziffern, Satzzeichen
☞
☞ freier Platz für häufige Worte oder Kombinationen genutzt
☞ Abbildung 74 auf Seite 13.8 gibt Beispiele der englischen Codierung
☞ Kompressionsfaktor ist unbedeutend, aber relevant
☞ Braille-Bücher sind sehr groß (1 Zelle ist etwa so groß wie 10 Buchstaben!)
☞ Verkürzungen nutzen daher besonders
☞ Code muß vom Menschen sehr leicht dekomprimiert werden können
365879$:
.
Informatik II – c Guido Rößling
02143
Kompressionsverfahren – Intuitive Kompression : Braille-Code
13.7
Braille-Code
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
and
for
of
the
with
th
Abbildung 74: Beispiele aus dem englischen Braille-Code
.
Informatik II – c Guido Rößling
Kompressionsverfahren – Intuitive Kompression : Braille-Code
13.8
Front Compression
❑ Gegeben: lexikographische Ordnung aller Elemente (z.B. Wörter- oder Telefonbuch)
❑ Beobachtung: Aufeinanderfolgende Worte fangen oft mit den gleichen Buchstaben an
☞ Ersetze die zum Vorgänger identischen Anfangsbuchstaben (Präfixe) durch deren Anzahl
#
1
2
3
4
5
6
7
8
Wort
a
aardvark
aback
abaft
abandon
abandoning
abandonment
abasement
Präfix
—
a
a
aba
aba
abandon
abandon
aba
Codierung
a
1ardvark
1back
3ft
3ndon
7ing
7ment
3sement
#
9
10
11
12
13
14
15
16
Wort
abash
abate
abated
abbey
abbot
abbreviate
abbreviating
abbreviation
Präfix
abas
aba
abate
ab
abb
abb
abbreviat
abbreviati
Codierung
4h
3te
5d
2bey
3ot
3reviate
9ing
10on
Tabelle 21: Beispiel zur Front Compression
❑ 116 Eingabezeichen, 68 Ausgabezeichen
☞ Kompressionsfaktor 1.706, Kompressionrate 58.6%
;
Informatik II – c Guido Rößling
Kompressionsverfahren – Intuitive Kompression : Front Compression
13.9
Lauflängenkodierung RLE
❑ Bei der Lauflängenkodierung (engl. run length encoding“, rle) werden n Wiederholungen
”
eines gleichen Zeichens d im Text ( runs“) durch
ersetzt
”
❑ Um zwischen der Zahl und einem Character zu unterscheiden, wird ein Escape Character, z.B. @, vorangestellt
<>=
<
❑ Die Codierung eines runs besteht also aus mindestens den drei Zeichen @nd
☞ Die Codierung lohnt sich erst ab 3 Wiederholungen
❑ Tritt der Escape character @ im Text auf, muß er passend“ codiert werden, z.B. als @@
”
☞
Wiederholungen des Zeichens
❑
<?7A@
@CBED
❑ Erwarteter Kompressionsfaktor für
lichen Länge :
H
F
=
Zeichen bei
G
Wiederholungen der durchschnitt-
F
F IJG KLMHNIODQP
;
Informatik II – c Guido Rößling
Kompressionsverfahren – Lauflängenkodierung RLE
13.10
Beispiel zur RLE
Beispiel:
Text
Länge
Eingabe AAAA BBB AA BBBBB CCCC EE AAAA FFFFF EEE A
33
Ausgabe @1A @0B AA @2B
@1C EE @1A @2F @0E A
26
Tabelle 22: Beispiel für Lauflängenkodierung
❑ Nur bei häufigen langen runs ist mit guter Kompression zu rechnen
❑ Die Einsparung beträgt dann
G K6HRIJG K6D
Zeichen
❑ Die Lauflängenkodierung eignet sich gut z.B. für Dateien mit vielen Leerzeichen, führenden Nullen und Grauwertstufen in Bildern.
❑ Ein Sonderfall sind Binärdateien, bei denen nur Nullen oder Einsen als Run auftreten
können
☞ es muß nur das erste Zeichen sowie die Länge der Runs gespeichert werden
;
Informatik II – c Guido Rößling
Kompressionsverfahren – Lauflängenkodierung RLE
13.11
Lauflängenkodierung bei Binärdaten
Originaldaten
010100000011111000011111
100010000000000000010000
000000000000000000000000
Bits
24
24
24
Lauflängencode Zahlen
011116545
9
1 1 3 1 14 1 4
7
0 24
2
Abbildung 75: Lauflängenkodierung bei Binärdaten
❑ Speicherung der Zahlen als Integer (z.B. mit 32 Bit) macht die Vorteile wieder zunichte
☞ das Speichern der beiden Zahlen in der untersten Zeile benötigt 64 Bit und
damit 40 Bit mehr als der Originalcode
❑ Abhilfe: kompaktere Speicherung
☞ Ermittlung des größten auftretenden runs und Wahl einer verkürzten Speicherung der Zahlen
☞ z.B. je 4 Bit (falls kein Run mit mehr als 16 Elementen auftritt)
☞ als Codierung kann - ähnlich wie bei allgemeinem RLE - der Wert als
interpretiert werden, bei 4 Bit also z.B. das Intervall [1, 16]
<SB T
;
Informatik II – c Guido Rößling
Kompressionsverfahren – Lauflängenkodierung RLE
13.12
Statistische Verfahren
❑ Die bisherigen Verfahren nutzen die gleiche feste Zahl Bits pro Zeichen
❑ Statistische Verfahren weisen den Zeichen eine variable Zeichenlänge (variable length
coding, vlc) zu
☞ kürzere Zeichenlängen werden für häufige, längere für seltene Zeichen verwendet
❑ Problemstellung:
1. Die Codes müssen eindeutig decodierbar sein
2. optimale Verteilung der Codes für minimale durchschnittliche Länge
❑ Vorreiter: Morse Code (Samuel Morse, Alfred Vail, 1832 / 1843)
☞ siehe Abbildung 23 auf Seite 13.14
;
Informatik II – c Guido Rößling
Kompressionsverfahren – Statistische Verfahren
13.13
Morse-Code
Zeichen Code Zeichen Code Zeichen Code Zeichen
A
.- L
.-.. X
-..- 0
B
- ... M
-- Y
-.- - .
C
-.-. N
-. Z
- -.. ,
Ch
---- O
--- 1
.- - - - :
D
-.. P
.- - 2
..- - - ?
E
. Q
- -.- 3
...- - ’
F
..-. R
.-. 4
....- –
G
- -. S
... 5
..... H
.... T
- 6
-.... (, )
I
.. U
..- 7
- -... “
J
.- - - V
...- 8
- - -.. Fehler
K
-.- W
.- - 9
- - - -.
Code
----.-.-.- -..- - - -...
..- -..
.- - - -.
.- - - -.
-.- -.-.- -..-..-.
........
Tabelle 23: Morse-Code
;
Informatik II – c Guido Rößling
Kompressionsverfahren – Statistische Verfahren
13.14
Informationsgehalt
❑ Wie kann man die minimale Länge für die Codierung eines Datums bestimmen?
☞ Das hängt vom Informationsgehalt des Datums ab!
☞ Wie kann man also den Informationsgehalt messen?
❑ Der Informationsgehalt eines Münzwurfs ist 1 Bit: die Antwort ist 0 oder 1
❑ Der Informationsgehalt des Ziehens einer Karte aus 64 ist 6
☞ Mit 6 Fragen kann die Karte exakt bestimmt werden (Binäre Suche!)
U UV7XWZY%[\]< .
❑ Sei nun ^`_ die Wahrscheinlichkeit des Ereignisses a_ mit bdc_egf ^`_h7 T
❑ Der Informationsgehalt von Ereignis a_ ist folglich WZY%[\ ^`_
☞ Sichere Ereignisse (^`_h7 T ) haben also Informationsgehalt WiY%[ \ Tj7Xk
❑ Der Gesamtinformationsgehalt eines Codes ist die Entropie l 7 I b c ^ _ K%WiY%[\ ^ _
_mehf
❑ Der Informationsgehalt einer Ganzzahl
<
ist die Stellenzahl :
❑ Die Entropie gibt die minimale durchschnittliche Bitzahl der Zeichencodierung an
n
Informatik II – c Guido Rößling
Kompressionsverfahren – Statistische Verfahren : Informationsgehalt
13.15
Huffman-Codes
❑ Huffman-Codes wurden 1952 von David Huffman entwickelt
❑ Zur Erstellung des Codes wird ein Baum verwendet
1. Generiere einen Blattknoten für jedes auftretende Zeichen.
2. Trage in jedem Knoten die Wahrscheinlichkeit des Zeichens und das Zeichen selbst
ein.
3. Bestimme die beiden nicht bearbeiteten Knoten mit geringster Wahrscheinlichkeit
und berechne deren gemeinsame Wahrscheinlichkeit
4. Erzeuge einen Vaterknoten mit Wahrscheinlichkeit und füge die beiden gewählten
Knoten als linken ( 0“) und rechten ( 1“) Sohn ein.
”
”
5. Markiere den linken und rechten Sohn als bearbeitet
6. Markiere den neuen Vaterknoten als nicht bearbeitet
7. Falls noch nicht alle Elemente bearbeitet sind, fahre fort mit Schritt 3.
o
o
Abbildung 76: Algorithmus Huffman-Code“
”
❑ Der Code der Zeichen wird durch den Pfad von der Wurzel angegeben.
n
Informatik II – c Guido Rößling
Kompressionsverfahren – Statistische Verfahren : Huffman-Codes
13.16
0.045
0.02
1
1
0
Q 0.0025
0.005
1
0
0
X 0.0050
1
K 0.0050
J 0.0050
1
0
V 0.0100
Z 0.0025
1
1
0.01
0.025
W 0.0150
0
0.03
1
B 0.0150
G 0.0150
1
1
0
Y 0.0200
0
P 0.0200
1
0.05
F 0.0200
M 0.0300
0.04
1
0
0
0.01
0.07
0.11
0
1
0
U 0.0300
0.06
0
C 0.0300
1
L 0.0350
D 0.0400
1
0
H 0.0600
0.075
1
0
0.12
S 0.0600
1
0
R 0.0650
0
I 0.0650
1
0.13
1
0
0.15
N 0.0700
1
0
O 0.0800
0.17
A 0.0800
T 0.0900
0
0
E 0.1300
0.195
0.3
0.28
1
0
0.58
0.305
0
1
0
1
0.115
0.42
1
1
Beispiel zum Huffman-Code
Abbildung 77: Beispiel zum Huffman-Code
n
Informatik II – c Guido Rößling
Kompressionsverfahren – Statistische Verfahren : Huffman-Codes
13.17
Eindeutigkeit
❑ In einigen Fällen kann der Benutzer zwischen den zu verwendenden Knoten wählen
☞ Im Beispiel: Zusammenlegen von W mit B oder mit G?
❑ Da die Wahl direkt den Code der betroffenen Zeichen beeinflußt, ist der Huffman-Code
in diesen Fällen also nicht eindeutig
❑ Welche Wahl ist dann die bessere, d.h. welcher Code ist besser?
☞ Der Code mit geringerer Varianz ist besser
❑ Die Varianz bestimmt die Abweichung des Codes von der durchschnittlichen Größe
❑ Erreicht wird das durch folgende Regel:
☞ gibt es mehr als zwei Knoten mit kleinster Wahrscheinlichkeit, kombiniere die
im Baum am weitesten oben und unten stehenden
❑ Auf diese Weise werden Symbole mit hoher und geringer Wahrscheinlichkeit kombiniert
☞ die Varianz bleibt gering
n
Informatik II – c Guido Rößling
Kompressionsverfahren – Statistische Verfahren : Huffman-Codes
13.18
Decodierung von Huffman-Code
❑ Traversierung eines Binärbaums
1. Aufbauen eines Binärbaums, der dem Baum zur Kodierung entspricht.
2. Zeichenweise aus der Eingabe lesen und bei 0 zum linken, bei 1 zum rechten Sohn
gehen, bis Blatt erreicht
3. Im Blatt eingetragenes Zeichen ausgeben, zurück zur Wurzel springen.
4. Weiter bei Schritt 2
❑ Beachten: die Eingabebitrate ist konstant, die Ausgabebitrate aber variabel.
☞ Die Eingabe wird zeichenweise gelesen
☞ Die Anzahl zu lesender Zeichen zur Erzeugung eines Ausgabezeichens ist vom
auszugebenden Zeichen abhängig
❑ Die Tabelle der Huffman-Codes ist entweder immer die gleiche oder sie muß mitübertragen werden.
n
Informatik II – c Guido Rößling
Kompressionsverfahren – Statistische Verfahren : Huffman-Codes
13.19
Arithmetische Kodierung
❑ Grundidee: Codiere Daten als rationale Zahl aus dem Intervall [0, 1) kodiert.
❑ Vorgehensweise:
prqts
uvwxu
1. Setze intervall = [0, 1),
als Unter-,
als Obergrenze des Intervalls
2. Codiere ein Dateiendesymbol eof mit minimaler Wahrscheinlichkeit
☞ z.B. eof = [0.999999, 1)
3. Wiederhole für alle Eingabezeichen die folgenden Schritte:
(a) Zerlege intervall gemäß der Wahrscheinlichkeit der Symbole
(b) Bestimme das zu Eingabezeichen gehörige Subintervall:
y
y
prqtsJz{u vwxu|Oprq6s~}`€y$‚„ƒ…†‡y%ˆŠ‰‹Œˆ}
(c) Setze intervall auf das im letzten Schritt bestimmte Subintervall
4. Bestimme das zu eof gehörige Teilintervall von intervall
5. Das Ergebnis ist ein Teilintervall der rationalen Zahlen.
6. Wähle eine möglichst einfach codierbare Zahl dieses Intervalls und codiere sie.
7. Gib die Wahrscheinlichkeitstabelle sowie die Codierung als Ergebnis aus.
Ž
Informatik II – c Guido Rößling
Kompressionsverfahren – Arithmetische Kodierung
13.20
Beispiel
Zeichen
00
01
10
11
Wahrscheinlichkeiten
0.1
0.4
0.2
0.3
Erste Kodierungsintervalle [0, 0.1) [0.1, 0.5) [0.5, 0.7) [0.7, 1)
Schritt Eingabezeichen Kodierungsentscheidung
1
10
0 + (1-0) [0.5, 0.7)
2
00
0.5 + (0.7-0.5) [0.0, 0.1)
3
11
0.5 + (0.52-0.5) [0.0.7, 1)
4
00
0.514 + (0.52-0.514) [0, 0.1)
5
10
0.514 + (0.5146-0.514) [0.5, 0.7)
6
11
0.5143 + (0.51442-0.5143) [0.7, 1)
7
01
0.514384 + (0.51442-0.514384) [0.1, 0.5)
8
Wähle eine Zahl des Intervalls. z.B. 0.5143876







Kodierungsintervall
[0.5, 0.7)
[0.5, 0.52)
[0.514, 0.52)
[0.514, 0.5146)
[0.5143, 0.51442)
[0.514384, 0.51442)
[0.5143876, 0.514402)
Tabelle 24: Beispiel zur Arithmetischen Kodierung
☞ Aus Übersichtlichkeitsgründen wurde die Codierung von eof hier ausgelassen.
Ž
Informatik II – c Guido Rößling
Kompressionsverfahren – Arithmetische Kodierung : Beispiel
13.21
Grafische Darstellung des Beispiels
0.5146
1
0.7
0.52
0.51442
0.51442
0.52
0.514402
11
10
01
00
0
0.5
0.5 0.514
0.5143
0.5143876
0.514384
0.514
Eingabe:
10
00
11
00
10
11
01
Ausgabe: 0.5143876
Abbildung 78: Grafische Darstellung des Beispiels
Ž
Informatik II – c Guido Rößling
Kompressionsverfahren – Arithmetische Kodierung : Beispiel
13.22
Dekodierung
1. Rekonstruiere die Wahrscheinlichkeitstabelle
2. Unterteile das Intervall [0, 1) wie beim Kodierungsprozeß
3. Lies die Eingabe als Wert

ein
4. Bestimme das zugehörige Intervall von
‘

und damit das codierte Zeichen
5. Gib aus
‘
6. Subtrahiere die Untergrenze des Intervalls des Symbols von
7. Dividiere
☞


durch die Größe des Intervalls von Symbol
‘
‘

ist nun wieder ein Wert aus [0, 1)
8. Fahre mit Schritt 4 fort, bis eof gefunden wurde oder der Wert von

0 ist
Tabelle 25: Dekodierung der Arithmetischen Kodierung
Ž
Informatik II – c Guido Rößling
Kompressionsverfahren – Arithmetische Kodierung : Dekodierung
13.23
Beispiel zur Dekodierung
Schritt
1
2
3
4
5
6
7
8

0.5143876
(0.5143876-0.5) / 0.2 = 0.071938
(0.071938-0) / 0.1 = 0.71938
(0.71938-0.7) / 0.3 = 0.0646
(0.0646 - 0) / 0.1 = 0.646
(0.646 - 0.5) / 0.2 = 0.73
(0.73 - 0.7) / 0.3 = 0.1
(0.1 -0.1) / 0.4 = 0
‘
10
00
11
00
10
11
01
Intervall von
[0.5, 0.7)
[0, 0.1)
[0.7, 1)
[0, 0.1)
[0.5, 0.7)
[0.7, 1)
[0.1, 0.5)
Abbruch
‘
Tabelle 26: Arithmetische Dekodierung
☞ Ausgabe: 10 00 11 00 10 11 01
Ž
Informatik II – c Guido Rößling
Kompressionsverfahren – Arithmetische Kodierung : Dekodierung
13.24
Anmerkungen
❑ Die Kodierung hängt von der Symbolwahrscheinlichkeit und damit dem Kontext ab
❑ Die Wahrscheinlichkeit bestimmt die Kompressionsrate
☞ wahrscheinlichere Symbole werden in größeren Intervallen kodiert und brauchen daher weniger Präzisionsbits
❑ Maschinen arbeiten tw. nicht präzise genug: over- oder underflow möglich
❑ sehr fehleranfällig: ein einziger Bitfehler zerstört die Nachricht!
❑ Bei dynamischer Arithmetischer Kodierung wird die Symbolwahrscheinlich nach dem
Kodieren einer Zeichenkette anhand des bisherigen Auftretens dynamisch angepaßt.
❑ Der Nachweis der Kompressionsrate bei Arithmetischer Kodierung ist nicht einfach
☞ Die durchschnittliche Bitlänge liegt aber meist nur knapp über der Entropie
Ž
Informatik II – c Guido Rößling
Kompressionsverfahren – Arithmetische Kodierung : Anmerkungen
13.25
Dictionary-basierte Kodierung
❑ Ein Dictionary ist eine Sammlung von Zeichenketten, die zur Kodierung herangezogen
wird
❑ Steht in dem Dictionary z.B. Vorlesung an Position 1025, muß nur diese Position codiert
werden (mit vorgegebener Bitlänge)
❑ Zu den bekanntesten Verfahren zählt LZW, benannt nach den den Entwicklern Lempel,
Ziv und dem Weiterentwickler Welch
☞ LZW stammt von 1984 und basiert auf LZ77
❑ Es gibt zwei Varianten:
☞ statische Kodierung
☞ Festes Dictionary – muß daher auch nicht mitübertragen werden
☞ dynamische Kodierung
☞ Dictionary wird anhand der Daten erstellt, muß nicht mitübertragen und zum
Dekodieren rekonstruiert werden
Ž
Informatik II – c Guido Rößling
Kompressionsverfahren – Dictionary-basierte Kodierung
13.26
LZW (Lempel, Ziv, Welch, 1984)
❑ Grundidee: Es werden nur die Indexpositionen von Worten eines Dictionaries gespeichert
❑ Das Dictionary wird dynamisch um neue Einträge erweitert
❑ Vorgehensweise bei Codierung:
’“’%’
1. Füge alle 256 Bytewerte in das Dictionary an Position 0,
255 ein
2. Setze die Eingabe auf das erste Eingabezeichen
3. Lese ein neues Eingabezeichen x
im Dictionary enthalten ist, setze
und fahre fort bei Schritt 3
4. Solange
5. Gib den Zeiger auf die Dictionaryposition von aus
an die nächste freie Stelle im Dictionary ein
6. Füge
7. Setze
und fahre fort mit Schritt 3, bis Eingabeende erreicht
”
”•
”•
”2–—•
Ž
Informatik II – c Guido Rößling
”2–X”•
”
Kompressionsverfahren – Dictionary-basierte Kodierung
13.27
LZW-Decodierung
1. Füge alle 256 Bytewerte in das Dictionary an Position

2. Setze die Eingabe
naryeintrag
”
3. Setze
4. Gib
”
auf den Dictionaryeintrag an Position
aus
ž
ž
ein
auf das erste Eingabezeichen - einen Index auf einen Dictio-
5. Lies ein Eingabezeichen
6. Setze
˜™†%’“’%’“†›štœtœ


auf den Eintrag des Dictionaries an Position
•
7. Falls != null, setze
erste Zeichen von .
”
ž

auf das erste Zeichen von , andernfalls setze
•
auf das
”Ÿ• nicht im Dictionary ist, speichere ”Ÿ• an der nächsten freien Position
9. Falls ž == null, setze žS–X”Ÿ•
10. Gib ž aus
11. Setze ”2– ž und fahre fort bei Schritt 5, bis die Datei abgearbeitet ist
Ž
8. Falls
Informatik II – c Guido Rößling
Kompressionsverfahren – Dictionary-basierte Kodierung
13.28
Bildkompression: Grundlagen
¡£¢
❑ Ein Bild besteht aus einer Menge von
Pixeln
= Breite (width), = Höhe (height)
☞
☞ Pixel ist ein Kunstwort für Picture element
¢
❑ Farbwerte werden meist als Kombination der Farben Rot, Grün, Blau codiert ( RGB“)
”
☞ Für jeden Pixel werden üblicherweise 3 Byte benötigt, um 256 256 256 Farben darstellen zu können ( (24-bit) TrueColor“)
”
❑ Das Bild wird in der Regel zeilenweise gespeichert, aus Effizienzgründen in einem eindimensionalen Array


❑ Falls es sich um ein Schwarz-Weiß-Bild handelt, wäre ein Bit für die Codierung eines
Pixels ausreichend
☞ Kompressionsfaktor 24
❑ Bei Graustufen sind die drei Farbwerte identisch
☞ Für reine Grauwertbilder langt ein Byte pro Pixel, d.h. Kompressionfaktor 3
¤
Informatik II – c Guido Rößling
Kompressionsverfahren – Bildkompression
13.29
Bildkompression: Grundlagen
❑ Für echte“ Farbbilder werden gute Kompressionmethoden benötigt
”
☞ z.B. massenweise Übertragung im Internet,
’“’%’
❑ Lauflängenkodierung (RLE) (s. auf Seite 13.10) ist vielfach verwendbar
☞ benachbarte Pixel haben oft die gleiche Farbe
☞ die Kompressionsrate ist aber nicht allzu groß
❑ Huffman-Codes können verwendet werden
☞ Aufgrund der Anzahl Farben ( ) ist der Codierungsaufwand ziemlich hoch
št¥¦
❑ Häufigen Einsatz findet eine Dictionary-basierte Codierung
☞ Jeder Farbe wird ein Index zugewiesen
☞ Gespeichert wird dann nur die Farbtabelle (Color Lookup Table, CLUT) und
die Indizes
, d.h.
☞ In der Regel wird die Größe der Farbtabelle beschränkt, z.B. auf
Farben
☞ Einsparung:
Byte
š6ª«–Xštœt¬
¤
§
§¨– ©
š­$ ®­Q¢°¯Oštœt¬­6±
Informatik II – c Guido Rößling
Kompressionsverfahren – Bildkompression
13.30
JPEG
❑ Effiziente Verfahren wie GIF, PNG oder JPEG nutzen spezielle Codierungsverfahren
❑ Vorgehen am Beispiel JPEG:
1. Teile das Bild in Helligkeits- und Farbinformation im Verhältnis 4:1:1
-Blöcke
2. Zerlege das Bild in
3. Transformiere jeden Block durch eine diskrete Cosinus-Transformation (DCT)
☞ Es entsteht wieder ein 8 8-Block, die von links oben nach rechts unten diagonal zunehmend detaillierte Informationen codieren
4. Quantisiere die Feldeinträge mit zunehmenden Faktoren
☞ Es gehen Detailinformationen verloren
5. Codiere den Eintrag an Position (0,0) ( DC Coefficient“; Helligkeitsanteil) durch
”
die Differenz zu den DC Coefficients seiner Vorgängerblöcke
6. Codiere die 63 anderen Werte - meist 0 - durch eine spezielle Mischung aus RLE
(für die führenden Nullen) und Huffman-Coding, gefolgt von dem Wert
©2¡4©
¡
❑ Typisch für JPEG ist eine visually lossless compression von ca. 1:10 - 1:20
¤
Informatik II – c Guido Rößling
Kompressionsverfahren – Bildkompression : JPEG
13.31
Schema
auszuführen für jeden 8x8-Block
Quantisierung
Diskrete
CosinusTransformation
Zerlegung
in 8x8-Blöcke
Aufteilen in
Helligkeit und
Farbdifferenz
Originalbild
Dequantisier.
inverse Diskr.
CosinusTransformation
Einfügen aller
8x8-Blöcke
Kombination
Helligkeit und
Farbdifferenz
Originalbild
Decodierung
DC-Eintrag
Decodierung
AC-Einträge
Codierung
AC-Einträge
Komprimierte
Bilddaten
Codierung
DC-Eintrag
Komprimierte
Bilddaten
auszuführen für jeden 8x8-Block
Zickzackanordnung
der AC-Einträge
Da die Ergebnisse der
DCT mit zunehmenden
Index visuell schwerer
wahrnehmbar sind,
können sie stärker
quantisiert werden
Daher sind viele der
letzten Werte 0, was
für die Codierung mit RLE
extrem praktisch ist.
Abbildung 79: Schema der JPEG-Codierung
¤
Informatik II – c Guido Rößling
Kompressionsverfahren – Bildkompression : JPEG
13.32
Soundkompression
❑ Sound, d.h. Musik, Sprache, Effekte,
’$’$’ wird als Schwingungswelle gespeichert
❑ Zur digitalen Speicherung wird ein Sampling vorgenommen: an vielen Punkten wird die
Spannung gemessen
❑ Für gute Klangqualität muß oft gesampled werden, z.B. mit 44 kHz (=44.000/s)
❑ RLE, Statistische und Dictionary-basierte Verfahren sind nicht gut für Sound geeignet
❑ Gewinnbringend ist eine lossy compression, die für den Menschen nicht (oder kaum)
hörbare Geräusche eliminiert oder leicht modifiziert
❑ Psychoakustische Modelle zeigen weitere Einsparmöglichkeiten
☞ Das Ohr hört niederfrequente Töne besser als hochfrequente
☞ Sehr leise Geräusche können u.U. fallengelassen werden
☞ Frequenzen und Lautstärke können andere Töne überdecken“
”
☞ Bestimmte rasche Tonabfolgen mit starkem Höhenunterschied sind nicht wahrnehmbar
❑ Das Verfahren MP3 (MPEG 1 Audio Layer 3) nutzt solche Modelle
☞ auf eine MP3-CD passen ca. 10-12 Audio-CDs ohne merkbaren Qualitätsverlust
¤
Informatik II – c Guido Rößling
Kompressionsverfahren – Soundkompression
13.33
Videokompression: MPEG
❑ MPEG steht für Moving Pictures Experts Group
❑ Die Einzelbilder werden dazu in
©2²4© -Blöcke unterteilt (”Macroblocks“)
❑ Einzelbilder ( Frames“) werden in drei Sorten unterschieden:
”
☞ I-Frames ( Intra“) codieren das gesamte Bild
”
☞ P-Frames ( Predictive“) codieren nur die Verschiebung oder Änderung von Macro”
blocks zum Vorgängerbild
☞ B-Frames ( Bidirectional Predictive“) codieren die Verschiebung und Änderung der
”
Macroblocks zu vorausgehenden und nachfolgenden I- oder P-Frames
❑ Spätestens nach Erreichen eines I-Frames ist das Bild korrekt - unabhängig von Übertragungsfehlern
❑ Die Bilder werden ähnlich wie bei JPEG (s. auf Seite 13.31) codiert
☞ DCT, Quantisierung, spezielle RLE mit festgelegtem Huffman-Code
❑ Die erreichte Kompressionsrate ist in der Regel sehr gut - z.B. etwa doppelt so gut wie
bei Video for Windows
¤
Informatik II – c Guido Rößling
Kompressionsverfahren – Videokompression
13.34
Schema der Frameanordnung
❑ Abbildung 80 zeigt einen typischen Aufbau eines MPEG-Videostroms
❑ Das erste Bild muß immer ein I-Frame sein
❑ Üblicherweise folgen darauf einige B-Frames sowie in regelmäßigen Abständen ein
P-Frame
❑ Das Beispiel besteht aus einer Wiederholung der Reihenfolge I BBB P BBB P BBB
P BBB
❑ Um Frame 2 anzeigen zu können, muß neben Frame 1 auch Frame 5 decodiert vorliegen
❑ die Reihenfolge im Dateistrom ist daher anders als die Anzeigereihenfolge: 1, 5, 2, 3, 4,
9, 6, 7, 8
❑ alle zum Bildaufbau notwendigen Bilddaten sind bei Lesen von Frame 2 schon decodiert
³
Informatik II – c Guido Rößling
Kompressionsverfahren – Videokompression
13.35
Schema der Frameanordnung
Vorwärtsberechnung
(Forward Prediction)
1 2 3 4 5 6 7 8 9
I BB BP BB BP
Bidirektionale Berechnung
(Bidirectional Prediction)
Abbildung 80: Schema der Frameanordnung bei MPEG
Kompressionsverfahren – Videokompression
³
Informatik II – c Guido Rößling
´$´%´ ?
Graphentheorie
Graphenalgorithmen
Suchalgorithmen
Suche in Zeichenfolgen
Sortieralgorithmen
Hashing
Kompressionsverfahren
Primitive Datentypen
Listenstrukturen
Bäume
Sonstige Datentypen
Einleitung
Zahlendarstellung
Wo sind wir
13.36
Kompressionsverfahren
Kryptologie
³
Informatik II – c Guido Rößling
13.37
Verschlüsselungsverfahren
❑ Neben Algorithmen zum Kodieren von Daten zur Platzersparnis gibt es auch Kodierungsalgorithmen zum Verschlüsseln der Daten.
❑ Das Gebiet Kryptologie läßt sich dabei in zwei Teilgebiete unterteilen:
☞ Kryptographie, die Entwicklung von Systemen für geheime Kommunikation, und
☞ Kryptoanalyse, der Untersuchung von Methoden zur Entschlüsselung von solchen Systemen.
❑ Neben den meist militärischen und diplomatischen Anwendungen treten dabei auch die
privaten Anwendungen immer mehr in den Vordergrund:
☞ Codierung in Dateisystemen, etwa bei der Paßwort-Datei
☞ vertrauliche Informationen bei Übertragung etwa von Fragebögen, Telefonaten oder
Fax
☞ elektronische Kapitaltransfersysteme, sowohl im großen (zwischen Banken) als auch
im kleinen (Bestellung aus dem Internet)
³
Informatik II – c Guido Rößling
Verschlüsselungsverfahren
14.1
Grundlagen
❑ Ziel der Kryptologie ist die Entwicklung möglichst sicherer Verfahren
☞ unbefugte Empfänger sollen die Nachricht nicht oder nicht in absehbarer Zeit
entschlüsseln können
❑ Die Verschlüsselung und Entschlüsselung soll relativ schnell durchführbar sein.
❑ Die Kombination aus Ver- und Entschlüsselungssystem ist das Kryptosystem
❑ Der Ablauf kann dabei wie folgt betrachtet werden:
Analyst
ATTACK AT DAWN
Sender
01001011010101010101011111101111
Empfänger
ATTACK AT DAWN
key
Abbildung 81: Schema eines Kryptosystems
❑ Das Verschlüsselungssystem des Senders verwandelt die Nachricht in einen Bitstrom, der
an den Empfänger übertragen wird.
❑ Analysten können den Bitstrom beobachten; die zusätzlich als key übertragenen Schlüsselparameter aber seien dem Analyst unbekannt.
µ
Informatik II – c Guido Rößling
Verschlüsselungsverfahren – Grundlagen
14.2
Schwierigkeit der Verschlüsselung
❑ Die Verwendung von mehr Schlüsselparametern und längeren Schlüsseln macht die Verschlüsselung sicherer
❑ Gleichzeitig wird aber auch der Übertragungs- und Entschlüsselungsaufwand größer
☞ Abwägung zwischen Sicherheit und Kompliziertheit des Kryptosystems
❑ Ähnliches gilt beispielsweise bei der Paßwort-Wahl: rein zufällige, keinen Sinn ergebende
Zeichenfolgen sind zwar am sichersten, aber auch am schwersten zu merken.
❑ Generell kann ein Kryptosystem nur so sicher und zuverlässig sein, wie dies seine Benutzer sind
☞ werden die Schlüsselparameter fahrlässig irgendwo notiert, kann auch das beste
Kryptosystem nicht mehr viel nutzen
❑ Im folgenden werden kurz ein paar einfache Methoden – Cäsar-Chiffre, Tabellenkodierung, Vigenère-Chiffre und Vernam-Chiffre – vorgestellt
❑ Anschließend wird kurz auf die Public Key Encryption des RSA-Verfahrens eingegangen.
µ
Informatik II – c Guido Rößling
Verschlüsselungsverfahren – Grundlagen
14.3
Cäsar-Chiffres und Tabellenkodierung
❑ Zu den einfachsten und ältesten Verschlüsselungsmethoden gehören die Cäsar-Chiffres.
☞ Jeder Buchstabe wird um eine feste Anzahl Stellen im Alphabet verschoben
❑ Die Cäsar-Chiffres sind nach Gaius Julius Cäsar benannt (100 - 44 v. Chr.), der eine
konstante Verschiebung um =3 benutzte.
☞ Auf diese Art wird der Text ATTACK AT DAWN“ ( Angriff in der Mor”
”
gendämmerung“) verschlüsselt als DWWDFNCDWCGDZQ“
”
❑ Die Methode ist unzuverlässig
☞ es müssen nur verschiedene Werte für ausprobiert werden
☞ die unterschiedliche Häufigkeit der Buchstaben kann ausgenutzt werden
¶
¶
❑ Sicherer ist die Tabellenkodierung, bei der für jeden Buchstaben angegeben wird, welcher
Buchstabe zu verwenden ist. Ein einfaches Beispiel:
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
T H E
Q U I C K B R O W N F X J M P D V R L A Z Y G
☞ Für ATTACK AT DAWN“ ergibt sich damit HVVH OTHVTQHAF“
”
”
µ
Informatik II – c Guido Rößling
Verschlüsselungsverfahren – Einfache Verfahren : Cäsar-Chiffre, Tabellenkodierung
14.4
Weitere Ansätze
❑ Die Tabellenkodierung läßt unter Verwendung des Leerzeichens
Tabellen zu
·Q¸Ÿ¹ º »½¼t¾À¿
verschiedene
❑ Dennoch kann sie relativ einfach entschlüsselt werden
❑ Für die gängigen Sprachen Deutsch, Englisch und Französisch liegen Statistiken vor über
die
☞ Häufigkeit von einzelnen Buchstaben (in Deutsch und Englisch ist e“ der häufigste
”
Buchstabe)
☞ sowie Digrammen, d.h. Verknüpfungen von zwei Buchstaben
☞ So tritt etwa die Kombination qj“ in keiner der genannten Sprachen auf
”
☞ die Kombination er“ bzw. re“ ist dagegen in allen dreien häufig
”
”
❑ Ein Analyst wird daher die Häufigkeit der kodierten Zeichen messen und entsprechend
der Häufigkeit der Buchstaben Einsetzungen systematisch austesten, bis er die Nachricht
geknackt hat.
µ
Informatik II – c Guido Rößling
Verschlüsselungsverfahren – Einfache Verfahren : Cäsar-Chiffre, Tabellenkodierung
14.5
Vigenère-Chiffre und Vernam-Chiffre
❑ Um diesen Weg zu erschweren, kann man die Vigenère-Chiffres verwenden
❑ Dabei wird ein kurzer, sich wiederholender Schlüssel benutzt, um den Wert
Buchstaben neu zu bestimmen.
Schlüssel
Wert von
Klartext
Chiffre
Á
A
1
A
B
B
2
T
V
C
3
T
W
A
1
A
B
B
2
C
E
C A B C A
3 1 2 3 1
K
A T
N A C W A
B
2
D
F
C
3
A
D
A
1
W
X
¶
für jeden
B
2
N
P
Tabelle 27: Vigenère-Chiffre
❑ Je länger der Schlüssel ist, desto besser ist auch der Vigenère-Chiffre
❑ Im Idealfall ist der Schlüssel genauso lang wie der Klartext
☞ Das einzige bekannte nachweisbar sichere Kryptosystem ( Vernam-Chiffre“)
”
❑ Angeblich wird diese Codierung für den heißen Draht zwischen Washington und Moskau
und ähnliche essentielle Anwendungen benutzt.
❑ Da für jede Position der Nachricht jede mögliche Verschiebung getestet werden muß, ist
dieser Chiffre praktisch nicht zu knacken.
µ
Informatik II – c Guido Rößling
Verschlüsselungsverfahren – Einfache Verfahren : Vigenère-Chiffre, Vernam-Chiffre
14.6
RSA – Public Key Encryption
❑ Um nicht jeden Nutzer ständig mit langen, sich oft ändernden Schlüsseln versorgen zu
müssen, kann auf die Public Key Encryption (Verschlüsselung mit öffentlichen Schlüsseln)
zurückgegriffen werden
❑ Jeder Nutzer besitzt einen öffentlichen Schlüssel P, der jedem bekannt ist
☞ vielfach werden sie inzwischen als pgp key in den Mail-Signatures angegeben
☞ PGP ( Pretty Good Privacy“) ist eines der populärsten Verfahren
”
❑ Zusätzlich hat jeder Nutzer einen geheimen Schlüssel S, der für die Entschlüsselung benutzt wird und niemand sonst bekannt ist.
Â
zu übermitteln, sucht der Absender nun den öffentlichen Schlüssel
❑ Um eine Botschaft
des Empfängers heraus, benutzt ihn zur Verschlüsselung, und überträgt die so kodierte
Nachricht
.
à ÄXÅ ¾½Æ  Ç
❑ Der
kann dann mit seinem geheimen Schlüssel die Nachricht entschlüsseln:
È ÃÉEmpfänger
È
¾ Æ ÇÊÄ ¾ Æ Å ¾ Æ Â ÇËÇÊÄÌÂ .
µ
Informatik II – c Guido Rößling
Verschlüsselungsverfahren – RSA
14.7
PGP
❑ PGP ist eines der am weitesten verbreiteten Programme zur Verschlüsselung
❑ PGP steht für Pretty Good Privacy“
”
❑ Entwickelt von Phillip Zimmermann
❑ PGP ist für den Anwender relativ einfach zu nutzen
❑ Die von PGP erzeugten Schlüssel können direkt an Mails u.a. zur Authentisierung angehängt werden ( PGP Signature“)
”
❑ Intern wird ein symmetrischer IDEA-Chiffre verwendet sowie RSA
☞ IDEA International Data Encryption Algorithm
☞ Das Vorgehen von IDEA ist recht kompliziert und wird daher nicht vorgestellt
Schlüssel pro Se☞ Sicherheit: falls jeder Mensch einen Rechner hätte, der
kunde testen kann, würde der vollständige Test aller Schlüssel für eine Kodierung
dauern.
❑ Die Zeitschrift c’t startete schon vor Jahren eine Krypto-Kampagne, bei der sich Leser
Schlüssel generieren lassen können.
Í
»½¼6Î
·Vϟ»½¼ÑÐ ¾‡ÒÓÕÔ ÖÑ×
❑ PGP ist bei http://download.mcafee.com unter Encryption“ erhältlich
”
µ
Informatik II – c Guido Rößling
Verschlüsselungsverfahren – RSA : PGP
14.8
Voraussetzungen für RSA
❑ Damit dieses System funktioniert, müssen die folgenden Forderungen erfüllt sein:
ÈCØ Å Ø Â ÙÇ ÇÚÄÌÂ
Æ Æ
È ØÛ Å Ø Ç
Â
☞
für jede Nachricht
☞ Alle Paare (
sind verschieden
☞ jeder öffentliche oder geheime Schlüssel wird nur von einer Person benutzt
☞ Die Ableitung von aus ist genauso schwer wie das Entschlüsseln von
ohne
Kenntnis von
☞ und haben leicht berechenbare Werte
È
È
È
Å
Â
Å
❑ Die erste Bedingung ist eine grundlegende kryptographische Bedingung; die beiden mittleren gewährleisten die Sicherheit und die letzte die praktische Anwendbarkeit des Systems.
µ
Informatik II – c Guido Rößling
Verschlüsselungsverfahren – RSA : Voraussetzungen
14.9
RSA
❑ Die Idee wurde 1976 von Whitfield Diffie und Martin Hellmann entwickelt
❑ zunächst fehlte aber ein Verfahren, das allen diesen Anforderungen genügte.
❑ Kurz danach wurde das Verfahren von R. Rivest, A. Shamir und L. Adleman entdeckt und
nach den Autoren RSA genannt.
❑ RSA beruht auf arithmetischen Algorithmen, die auf sehr große Zahlen angewendet werden, z.B. 100-stelligen Zahlen
☞ Die Grundidee wird im folgenden präsentiert, die (komplexen) mathematischen
Grundlagen aber nicht.
ganzer Zahlen
❑ Der Schlüssel für die Verschlüsselung ist dabei ein Paar
Å
È
ß
❑ Üblicherweise hat z.B.
µ
Informatik II – c Guido Rößling
Ü
Û›ß Ç
ÆÝÜ
Þ
ß
200, und jeweils 100 Stellen.
❑ Der geheime Schlüssel ist ein Paar
☞ wird dabei geheim gehalten
ÛrÞ Ç
ÆÝÜ
Verschlüsselungsverfahren – RSA : Vorgehensweise
14.10
RSA
Das Verfahren der Verschlüsselung und Entschlüsselung arbeitet dann wie folgt:
1. Zerlege die Nachricht in Zahlen, die kleiner als
Ü
sind, z.B. jeweils
2. Potenziere jede dieser Zahlen unabhängig voneinander zur Basis
nung von
.
Ü
àiá%â ¾]ã
Bits
durch Berech-
à ÄXÅ Æ Â ÇÚÄÌÂä8åçæéè Ü
3. Übertrage die einzelnen kodierten Zahlen zum Empfänger.
È ÃÉÇêÄ ÃìëíåîæQè und erhält die Originalnach4. Der Empfänger berechnet  Ä
Æ
Ü
richt.
☞ Da nur der Rest nach der Potenzierung betrachtet werden muß, ist es nicht allzu
und
selbst außerordentlich groß ist.
störend, daß
ÂAä
µ
Ãìë
Informatik II – c Guido Rößling
Verschlüsselungsverfahren – RSA : Vorgehensweise
Bestimmung von
Ü
14.11
ÛïÞíۛß
Ü
ÛÞíۇß
❑ Für
müssen lediglich passende“ Zahlen gewählt werden, um die auf Folie 14.9
”
angegebenen Kriterien zu erfüllen.
❑ Hierfür ist einige Zahlentheorie erforderlich, die Interessenten in der Fachliteratur (z.B.
Communications of the ACM, Volume 21, Number 2 (Feb. 1978)) finden.
ß
❑ Im Prinzip müssen drei große (ca. 100-stellige) zufällige“ Primzahlen erzeugt werden,
”
von denen die größte , die beiden anderen und sind.
ð
ñ
Þ
Þ ß
❑ Nun wird Ü ÄAðòÏ$ñ gesetzt und so bestimmt, daß Ï åçæéè Æ ðôóÌ»Ç`Ï Æ ñ2óÌ»ÇÚÄ » gilt.
ÛrÞ`Û›ß und für alle Nachrichten  gilt ÂäõöëÕåîæéè Ä
❑ Man kann beweisen, daß für solche Ü
Ü
Â
❑ Genau dies wird aber im Zuge der Verschlüsselung und anschließenden Entschlüsselung
berechnet:
È Éà ÇÚÄ È Å Â ÇÙÇÚÄ Â ä åçæéè Ç ë åîæéè ÄÌ äõöë åîæéè ÄÌÂ
Æ
Æ Æ
Æ
Ü
Ü
Ü
❑ Die RSA-Kodierung und -Dekodierung kann sehr effizient ausgeführt werden.
µ
Informatik II – c Guido Rößling
Verschlüsselungsverfahren – RSA : Bestimmung
÷øúùËøiû
14.12
Beispiel zu RSA
❑ Sei die Nachricht ATTACK AT DAWN“ codiert als 012020010311000120000401231
”
gemäß der Position der Zeichen im Alphabet (A = 01, B = 02,
)
$ü ü$ü
Û
›Û ß ÄÿQ¸ .
❑ Anstelle von 100-stelligen Primzahlen wählen wir ðýÄJþѸ ñ°Ä̸6ÿ
Þ
Ä » zu Þ Ä ¸
☞ Die Werte führen zu Ü ÄAð~ÏËñ Ä ¸Ÿ» und durch ÏÿQ¸«åîæéè
❑ Die Eingabe wird nun z.B. in vierziffrige Teile zerlegt und ÂAä8åîæéè Ü berechnet.
☞ Für den Dezimalwert 0120 der Zeichen AT ergibt sich ¼»½·Q¼ åîæQè ¸Ÿ» Ä »›þ ¼$þ
❑ Insgesamt ergibt sich die Nachricht 1404293235360001328422802235.
❑ Zum Decodieren wird der gleiche Prozeß unter Verwendung von
.
sich für die ersten vier Stellen:
»›þ ¼$þ Î åçæéè ¸Ÿ» ļ»½·t¼
ß
wiederholt; es ergibt
❑ Dekodiert ergibt sich wiederum 0120200103110001200004012314 und damit exakt die Nachricht .
Â
Verschlüsselungsverfahren – RSA : Beispiel
Informatik II – c Guido Rößling
ü$ü%ü ?
Graphentheorie
Graphenalgorithmen
Suchalgorithmen
Suche in Zeichenfolgen
Sortieralgorithmen
Hashing
Kompressionsverfahren
Primitive Datentypen
Listenstrukturen
Bäume
Sonstige Datentypen
Einleitung
Zahlendarstellung
Wo sind wir
14.13
Verschlüsselungsverfahren
Kryptologie
Informatik II – c Guido Rößling
14.14
Abbildungsverzeichnis
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
Zahlenkreis für Vorzeichen-Absolutbetrag Darstellung . . . . . . . . . . . . . . . . .
Zahlenkreis für Zweierkomplement-Darstellung . . . . . . . . . . . . . . . . . . . . . .
Vorgehen zur Berechnung einer Gleitpunktdarstellung . . . . . . . . . . . . . . . . .
Zweidimensionales Feld als Matrix und Zugriff in Java . . . . . . . . . . . . . . .
Schematischer Aufbau eines Listenelements . . . . . . . . . . . . . . . . . . . . . . . .
Schematischer Aufbau einer Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Einfügen vor dem ersten Listenelement einer verketteten Liste . . . . . . . . . . .
Einfügen innerhalb einer verketteten Liste . . . . . . . . . . . . . . . . . . . . . . . . . .
Einfügen nach dem letzten Listenelement einer verketteten Liste . . . . . . . . .
Löschen des ersten Listenelements einer verketteten Liste . . . . . . . . . . . . . .
Löschen eines inneren Listenelements einer verketteten Liste . . . . . . . . . . . .
Löschen des letzten Listenelements einer verketteten Liste . . . . . . . . . . . . . .
Schematischer Aufbau eines Listenelements einer doppelt verketteten Liste .
Prinzipieller Aufbau einer doppelt verketteten Liste . . . . . . . . . . . . . . . . . . .
Einfügen am Anfang einer doppelt verketteten Liste . . . . . . . . . . . . . . . . . . .
Einfügen innerhalb einer doppelt verketteten Liste . . . . . . . . . . . . . . . . . . . .
Einfügen am Ende einer doppelt verketteten Liste . . . . . . . . . . . . . . . . . . . .
Löschen des ersten Elements einer doppelt verketteten Liste . . . . . . . . . . . .
Löschen innerhalb einer doppelt verketteten Liste . . . . . . . . . . . . . . . . . . . .
Löschen des letzten Elements einer doppelt verketteten Liste . . . .
Beispiel zur Postfix-Auswertung mittels Stack . . . . . . . . . . . . . . .
Beispiel zur Verwendung einer Queue . . . . . . . . . . . . . . . . . . . . .
Beispiel für einen Baum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Baum: Nachfolger und Vorgänger . . . . . . . . . . . . . . . . . . . . . . . .
Zyklen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiele für Binärbäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Vollständiger, fast vollständiger und strikter Binärbaum . . . . . . . .
Baumdarstellung mit Zeigern und in einem Array . . . . . . . . . . . .
Schema der Traversierung eines Binärbaums . . . . . . . . . . . . . . . .
Beispiel zur Baumtraversierung . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiel zu Heaps und Nicht-Heaps . . . . . . . . . . . . . . . . . . . . . . .
Beispiel zum Erstellen eines Heaps . . . . . . . . . . . . . . . . . . . . . . .
Beispiel zum Löschen in einem Heaps . . . . . . . . . . . . . . . . . . . . .
Beispiele für binäre Suchbäume . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiel zum Einfügen in einen binären Suchbaum . . . . . . . . . . .
Beispiel zum Löschen im binären Suchbaum . . . . . . . . . . . . . . . .
Beispiel für einen Knoten eines AVL-Baums . . . . . . . . . . . . . . . .
Schematische Darstellung der Einfachrotationen in AVL-Bäumen
Schematische Darstellung der Doppelrotationen in AVL-Bäumen
. . . . . . . . . . . . . . . . . . . 2.14
. . . . . . . . . . . . . . . . . . . 2.18
. . . . . . . . . . . . . . . . . . . 2.23
. . . . . . . . . . . . . . . . . . . 3.14
. . . . . . . . . . . . . . . . . . . 4.1
. . . . . . . . . . . . . . . . . . . 4.2
. . . . . . . . . . . . . . . . . . . 4.5
. . . . . . . . . . . . . . . . . . . 4.6
. . . . . . . . . . . . . . . . . . . 4.7
. . . . . . . . . . . . . . . . . . . 4.9
. . . . . . . . . . . . . . . . . . . 4.11
. . . . . . . . . . . . . . . . . . . 4.12
. . . . . . . . . . . . . . . . . . . 4.14
. . . . . . . . . . . . . . . . . . . 4.15
. . . . . . . . . . . . . . . . . . . 4.17
. . . . . . . . . . . . . . . . . . . 4.19
. . . . . . . . . . . . . . . . . . . 4.20
. . . . . . . . . . . . . . . . . . . 4.23
. . . . . . . . . . . . . . . . . . . 4.25
. . . . . . . . . . . . . . . . . . . . . . . . . . . 4.27
. . . . . . . . . . . . . . . . . . . . . . . . . . . 4.33
. . . . . . . . . . . . . . . . . . . . . . . . . . . 4.39
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.5
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.6
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.9
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.11
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.16
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.18
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.19
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.22
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.25
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.27
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.33
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.35
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.37
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.40
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.43
. . . . . . . . . . . . . . . . . . . . . . . . . . . 5.44
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
Beispiel zum Rebalanzieren in AVL-Bäumen: LL . . . . . . . . . . .
Beispiel zum Rebalanzieren in AVL-Bäumen: RR . . . . . . . . . . .
Beispiel zum Rebalanzieren in AVL-Bäumen: RL . . . . . . . . . . .
Beispiel zum Rebalanzieren in AVL-Bäumen: LR . . . . . . . . . . .
Schematischer Aufbau eines Knotens in B-Bäumen . . . . . . . . . .
Schematische Darstellung des Splits in B-Bäumen . . . . . . . . . . .
Beispiel zum Einfügen in B-Bäumen . . . . . . . . . . . . . . . . . . . . .
Beispiel zum Einfügen in B-Bäumen, Teil 2 . . . . . . . . . . . . . . . .
Beispiel zum Löschen in B-Bäumen . . . . . . . . . . . . . . . . . . . . . .
Darstellung von ungerichteten und gerichteten Graphen . . . . . . .
Kantenfolge, Kantenzug, Weg und Zyklus . . . . . . . . . . . . . . . . .
Adjazenzmatrix, -liste und doppelte Liste . . . . . . . . . . . . . . . . . .
Beispiel zur Tiefensuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiel zur Breitensuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aufgabenstellung zum minimalen spannenden Baum nach Prim
Beispiel zum minimalen spannenden Baum nach Prim . . . . . . . .
Beispiel zum minimalen spannenden Baum nach Kruskal . . . . .
Beispiel zur transitiven Hülle nach Warschall . . . . . . . . . . . . . . .
Beispiel zur topologischen Sortierung . . . . . . . . . . . . . . . . . . . .
Ergebnis des Algorithmus von Dijkstra . . . . . . . . . . . . . . . . . . .
Beispiel zur Binären Suche . . . . . . . . . . . . . . . . . . . . . . .
Beispiel zur Interpolationssuche . . . . . . . . . . . . . . . . . . . .
Beispiel zum Suchen im binären Suchbaum . . . . . . . . . . .
Brute Force Suche in Zeichenfolgen . . . . . . . . . . . . . . . . .
Beispiel zum Algorithmus von Knuth, Morris und Pratt . .
Beispiel Sortieren durch Auswahl“ . . . . . . . . . . . . . . . . .
”
Beispiel zu Sortieren durch Einfügen“ . . . . . . . . . . . . . .
”
Beispiel zu Bubble Sort“ . . . . . . . . . . . . . . . . . . . . . . . . .
”
Beispiel Shellsort“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
”
Beispiel zu Quicksort“ . . . . . . . . . . . . . . . . . . . . . . . . . .
”
Beispiel zu Heapsort“, Teil 1 . . . . . . . . . . . . . . . . . . . . .
”
Beispiel zu Heapsort“, Teil 2 . . . . . . . . . . . . . . . . . . . . .
”
Beispiel zu Mergesort“ . . . . . . . . . . . . . . . . . . . . . . . . . .
”
Hashing mit Anhängen der Überläufer als verkettete Liste
Beispiele aus dem englischen Braille-Code . . . . . . . . . . .
Lauflängenkodierung bei Binärdaten . . . . . . . . . . . . . . . .
Algorithmus Huffman-Code“ . . . . . . . . . . . . . . . . . . . . .
”
Beispiel zum Huffman-Code . . . . . . . . . . . . . . . . . . . . . .
Grafische Darstellung des Beispiels . . . . . . . . . . . . . . . . .
Schema der JPEG-Codierung . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.45
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.46
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.47
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.48
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.53
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.56
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.57
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.58
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.61
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.7
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.12
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.19
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.23
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.3
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.4
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.6
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.9
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.13
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.17
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.11
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.13
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.19
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.4
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.13
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.6
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.10
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.14
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.21
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.27
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.35
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.36
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.40
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.6
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.8
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.12
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.16
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.17
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.22
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.32
80
81
Schema der Frameanordnung bei MPEG
Schema eines Kryptosystems . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.36
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.2
Tabellenverzeichnis
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Beispiel zur Auswertung mit dem Horner-Schema . . . . . . . . . . . . .
Rechenregeln für Addition und Subtraktion im Zweierkomplement
Fallunterscheidung für Exponent bei IEEE-Standard . . . . . . . . . . .
Absolute Fehler bei Operationen mit Gleitpunktzahlen . . . . . . . . . .
Zusammenfassung der Fehlerfortpflanzungsfehler . . . . . . . . . . . . .
Primitive Datentypen in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ASCII-Tabelle (7-Bit Code) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ASCII-Codes für Sonderzeichen . . . . . . . . . . . . . . . . . . . . . . . . . .
Unicode für Umlaute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Baum: Nachfolger und Vorgänger . . . . . . . . . . . . . . . . . . . . . . . . .
Kein Baum aufgrund von Zyklen . . . . . . . . . . . . . . . . . . . . . . . . . .
Rotationsformen in AVL-Bäumen . . . . . . . . . . . . . . . . . . . . . . . . .
Entfernungsnetz in Deutschland (Autobahnkilometer, gerundet) . . .
Beispiel zum Algorithmus von Dijkstra für start = A . . . . . . . . . . .
Algorithmus von Floyd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Bestimmung von next bei KMP für p = 10100111 . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . 2.5
. . . . . . . . . . . . . . . . . . . . . . . . . . 2.19
. . . . . . . . . . . . . . . . . . . . . . . . . . 2.26
. . . . . . . . . . . . . . . . . . . . . . . . . . 2.34
. . . . . . . . . . . . . . . . . . . . . . . . . . 2.41
. . . . . . . . . . . . . . . . . . . . . . . . . . 3.4
. . . . . . . . . . . . . . . . . . . . . . . . . . 3.5
. . . . . . . . . . . . . . . . . . . . . . . . . . 3.6
. . . . . . . . . . . . . . . . . . . . . . . . . . 3.7
. . . . . . . . . . . . . . . . . . . . . . . . . . 5.5
. . . . . . . . . . . . . . . . . . . . . . . . . . 5.6
. . . . . . . . . . . . . . . . . . . . . . . . . . 5.42
. . . . . . . . . . . . . . . . . . . . . . . . . . 7.15
. . . . . . . . . . . . . . . . . . . . . . . . . . 8.17
. . . . . . . . . . . . . . . . . . . . . . . . . . 8.22
. . . . . . . . . . . . . . . . . . . . . . . . . . 10.7
Auswirkung der Modifikation von initNext . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiele für Sondierungsverfahren (Modulo 17) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Häufigkeit der Buchstaben in englischen Texten (aus dem LATEX-Quelltext des Buches [Sol98])
Häufigkeit der Buchstaben im Skript Informatik II
Beispiel zur Front Compression . . . . . . . . . . . . . .
Beispiel für Lauflängenkodierung . . . . . . . . . . . . .
Morse-Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiel zur Arithmetischen Kodierung . . . . . . . .
Dekodierung der Arithmetischen Kodierung . . . . .
Arithmetische Dekodierung . . . . . . . . . . . . . . . . .
Vigenère-Chiffre . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . 10.11
. . . . . 12.8
. . . . . 13.2
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.9
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.11
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.14
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.21
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.23
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.24
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.6
Listings
1
Sieb des Erathostenes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.15
2
Navigation in verketteten Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3
3
Pseudo-Programm für Postfix-Auswertung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.32
4
Binärer Baum, Teil 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.13
5
Binärer Baum, Teil 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.14
6
Tiefensuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.17
7
Initialisierung der Tiefensuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.18
8
Breitensuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.21
9
Initialisierung der Breitensuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.22
1
0Algorithmus von Warschall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.8
1
1Algorithmus von Dijkstra, Teil 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.15
1
2Algorithmus von Dijkstra, Teil 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.16
1
3Initialisierung zum Algorithmus von Floyd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.20
1
4Algorithmus von Floyd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.21
1
5Sequentielle Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.5
1
6Binäre Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.9
1
7Binäre Suche, rekursiv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.10
1
8Suche im binären Suchbaum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.17
1
9Einfügen im binären Suchbaum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.18
2
0Brute-Force Suche in Zeichenfolgen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.2
2
1Implementierung von KMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.9
2
2Initialisierung von next bei KMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.12
2
3Routine swap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3
2
4Sortieren durch Auswahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.5
2
5Sortieren durch Einfügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.9
2
6Bubble Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.13
2
7Shellsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.20
2
8Schematische Implementierung von Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.24
2
9Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.26
3
0Heapsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.34
3
1Mergesort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.39
Index
A
Algorithmen 9.1–9.22, 11.1–11.42, 12.1–12.10, 13.1–13.36, 14.1–14.13
Graphenalgorithmen siehe Graphenalgorithmen
Hashing siehe Hashing
Kompressionsverfahren siehe Kompressionsverfahren
Kryptologie siehe Verschlüsselungsverfahren
Sortierung siehe Sortieralgorithmen
Suche siehe Suchalgorithmen
Typische Gebiete 9.1
Array 11.2
Aufbau eines Knotens 5.53
5.53
Beispiel 5.57–5.58, 5.61
Eigenschaften 5.52
Einfügen 5.54–5.58
5.51, 5.52
5.51, 5.52, 5.54, 5.55, 5.60
Löschen 5.59–5.61
Split 5.54–5.57
Vor- und Nachteile 5.62
Bag 3.3, 6.5
Baum siehe Baum, 5.1–5.63, 7.1
-ärer Baum 5.8
2-3-4-Baum 5.63
Beispiel 5.3
Blatt 5.4
Digitaler Suchbaum 5.63
Grad 5.7, 5.9
innerer Knoten 5.4
Kante 5.2
Knoten 5.2
Nachfolger 5.2, 5.4–5.5, 5.7, 5.9
Nachfolger, direkter 5.2, 5.5
Pfad 5.7
Pfadlänge 5.8
Pfadlänge, äußere 5.8
Pfadlänge, innere 5.8
Reihenfolge der Nachfolger 5.8
Rot-Schwarz-Baum 5.63
Sohn 5.2, 5.9
Stufe 5.7
Terminologie 5.2–5.8
D
Datei siehe File
Datenstrukturen 3.1–3.17, 4.1–4.41, 5.1–5.63, 6.1–6.8, 7.1–7.23, 8.1–8.22
Array 3.3, 3.9–3.17, 6.2
als Matrix 3.14
Einschränkungen 3.11
Mehrdimensional 3.13
Vor- und Nachteile 3.16–3.17
Auswahl der 3.2
AVL-Baum 3.3, 5.39–5.50
Balanzierungsfaktor 5.40
Beispiel 5.45–5.48
Einfügen 5.41–5.48
Löschen 5.49
LL 5.41–5.43, 5.45
LR 5.41–5.44, 5.48
Rebalanzierung 5.41
RL 5.41–5.44, 5.47
Rotationstypen 5.42
RR 5.41–5.43, 5.46
Vor- und Nachteile 5.50
B-Baum 3.3, 5.51–5.62, 6.2
15.9
Unterbaum 5.9
Verwendung 5.1
Vorgänger 5.2, 5.4–5.5
Vorgänger ,direkter 5.2
Vorgänger, direkter 5.5
Weitere Baumstrukturen 5.63
Wurzel 5.4
Zyklus 5.4, 5.6
Binärbaum siehe Datenstrukturen - Binärer Baum
Binärer Baum 3.3, 5.9–5.38
Darstellung in einem Array 5.15
fast vollständig 5.10–5.12, 5.21
Grad 5.9
Implementierung 5.12–5.16
In-Order Traversierung 5.17–5.19
Nachfolger 5.9
Post-Order Traversierung 5.17–5.19
Pre-Order Traversierung 5.17–5.19
Sohn 5.9
strikt 5.10
Traversierung 5.17–5.19
Unterbaum 5.9
vollständig 5.10
Vor- und Nachteile 5.20
Binärer Suchbaum 3.3, 5.32–5.38, 5.40, 6.2
Aufbau 5.32
Beispiel 5.33, 5.35, 5.37
Einfügen 5.34–5.35, 9.18
Löschen 5.36–5.37
Suche siehe Suchalgorithmen - Binärer Suchbaum
Vor- und Nachteile 5.38
Datei 3.3, siehe Datenstrukturen - File
Dictionary 6.3
Doppelt verkettete Liste 3.3, 4.14–4.28
Aufbau 4.15
Beispiel 4.17–4.20, 4.22–4.26
Einfügen 4.16–4.20
Löschen 4.21–4.26
Vor- und Nachteile 4.28
File 3.3, 6.6–6.8
Dateiverarbeitung 6.8
Zugriffsmöglichkeiten 6.6–6.7
Graph 7.1–7.23, 8.1–8.22
Adjazenzliste 7.8–7.12
Adjazenzliste, doppelt verkettet 7.8–7.12
Adjazenzmatrix 7.8–7.12, 7.15
azyklisch 7.2, 7.7
Beispiel 7.4, 7.12, 7.15
Beispiel zur Breitensuche 7.23
Beispiel zur Tiefensuche 7.19
benachbarte Knoten 7.3
Breitensuche 7.16, 7.20–7.23
dag siehe Datenstrukturen - Graph - gerichteter azyklischer G.
Definition 7.2
Durchlaufen 7.16–7.23
Endknoten 7.6
Endknoten (einer Kante) 7.3
Feste Anordnung 7.14
gerichtet 7.1, 7.3–7.4
gerichteter 7.3
gerichteter azyklischer G. 8.10
Gewichtung von Kanten 7.13–7.15
innerer Knoten 7.6
Isomorphie 7.5
Kante 7.2
Kantenfolge 7.6
Kantenzug 7.6
Knoten 7.2
minimal spannender Baum 8.1
Quelle (einer Kante) 7.3
Schlinge 7.2
schlingenlos 7.2
Startknoten 7.6
Startknoten (einer Kante) 7.3
Teilgraph 7.5
Tiefensuche 7.16–7.19
ungerichtet 7.1, 7.3–7.4
ungerichteter 7.3
Weg 7.6
zusammenhängend 7.6
Zyklus 7.2, 7.7
Heap 5.21–5.28
Beispiel 5.22, 5.25, 5.27
Erstellen 5.23–5.25
Heap-Eigenschaft 5.23–5.24
Löschen 5.26–5.27
Versickern 5.24
Vor- und Nachteile 5.28
Keller siehe Stack
Kellerspeicher siehe Datenstrukturen - Stack
Motivation 3.1
Primitive Datentypen 3.4
ASCII-Zeichen 3.6
Character 3.5
Sonderzeichen 3.5
Umlaute 3.7
Unicode 3.7
Priority Queue 3.3, siehe Priority Queue
Queue 3.3, 4.37–4.41
Anmerkungen 4.40
Beispiel 4.39
Operationen 4.38, 4.40
Vor- und Nachteile 4.41
Set 3.3, 6.1–6.4
Anmerkungen 6.4
Verfahrensfehler 2.33
Relativer Fehler 2.35–2.41
Abschneiden 2.36
Addition 2.37
Division 2.40
Multiplikation 2.39
Round 2.36
Runden 2.36
Subtraktion 2.38
Truncate 2.36
Unabhängigkeit vom Exponent 2.35
G
Graphenalgorithmen 8.1–8.22
Algorithmus von Dijkstra 8.14–8.17
Beispiel 8.17
Implementierung 8.15–8.16
Komplexität 8.14
Vorgehen 8.14
Algorithmus von Floyd 8.18–8.22
Anmerkungen 8.19
Beispiel 8.22
Implementierung 8.20–8.21
Komplexität 8.19
Vorgehen 8.18
Algorithmus von Kruskal 8.5–8.6
Beispiel 8.6
Algorithmus von Prim 8.1–8.4
Beispiel 8.3, 8.4
Komplexität 8.2
Vorgehen 8.2
Algorithmus von Warschall siehe Graphenalgorithmen - Transitive Hülle
Minimaler spannender Baum 8.1–8.6
Topologische Sortierung 8.10–8.13
Algorithmus 8.12
Implementierung 6.2–6.3
Stack 3.3, 4.29–4.36
Anwendungen 4.30
Anwendungsbeispiel 4.31–4.33
Beispiel 4.33
Fehlermöglichkeiten 4.35
Implementierung 4.34
Operationen 4.29
Vor- und Nachteile 4.36
Stapel siehe Stack, siehe Datenstrukturen - Stack
Verkettete Liste 3.3, 4.1–4.13, 6.2
Aufbau 4.2
Beispiel 4.4–4.7, 4.9–4.12
Einfügen 4.4–4.7
Löschen 4.8–4.12
Navigation 4.3
Vor- und Nachteile 4.13
Warteschlange siehe Queue, siehe Datenstrukturen - Queue
Zeiger 3.8–3.9
Verwendung von 3.9
F
Fehlerfortpflanzung 2.1, 2.30–2.41
Absoluter Fehler 2.34
Addition 2.34
Division 2.34
Multiplikation 2.34
Subtraktion 2.34
Ergebnis 2.41
FDIV-Bug 2.31
Fehlerquellen bei Gleitpunktzahlen 2.32
Darstellungsfehler 2.32
Fehlertypen
Datenfehlereffekte 2.33
Rechenfehler 2.33
Beispiel 8.13
Eigenschaften 8.11
Transitive Hülle 8.7–8.9
Beispiel 8.9
Implementierung 8.8
Zyklus 8.10
H
Höhenbalanzierter Baum siehe Datenstrukturen – AVL-Baum
Hashing 12.1–12.10
Beispiel 12.8
Divisions-Rest-Methode 12.3
Dynamisches Hashing 12.10
Formale Definition 12.2
Grundlagen 12.1
Hash-Funktion 12.4
Kollisionsbehandlung 12.5
Beispiel 12.6
Komplexität 12.2
Sondierungsverfahren 12.7–12.9
Doppeltes Hashing 12.7
Doppeltes Hashing mit Vorzeichenwechsel 12.7
Lineares Sondieren 12.7–12.8
Lineares Sondieren mit Vorzeichenwechsel 12.7–12.8
Quadratisches Sondieren 12.7–12.8
Quadratisches Sondieren mit Vorzeichenwechsel 12.7–12.8
Vor- und Nachteile 12.9
Statisches Hashing 12.3–12.9
K
Kompressionsverfahren 13.1–13.36
Arithmetische Kodierung 13.20–13.25
Anmerkungen 13.25
Beispiel zur Dekodierung 13.24
Beispiel zur Kodierung 13.21–13.22
Dekodierung 13.23–13.24
Kodierung 13.20–13.22
Bildkompression
CLUT 13.30
Color Lookup Table 13.30
Grundlagen 13.29
Huffman-Code 13.30
JPEG 13.31
RLE 13.30
Braille 13.7–13.8
Abbildung 13.8
compression factor 13.6
compression ratio 13.6
Compressor 13.4
Decoder 13.4
Decompressor 13.4
Dictionary 13.26–13.28, 13.30, 13.33
Dictionary-basiert 13.26–13.28
Encoder 13.4
Entropie 13.15
Front Compression 13.9
Häufigkeit von Buchstaben 13.2, 13.3
Huffman-Code
Beispiel 13.17, 13.18
Dekodierung 13.19
Huffman-Codes 13.16–13.19
Algorithmus 13.16
Informationsgehalt 13.15
Kompression 13.1
Kompressionsfaktor 13.6
Kompressionsverhältnis 13.6
Lauflängenkodierung siehe Kompressionsverfahren - RLE
lossless 13.4
lossy 13.4
LZW 13.26–13.28
Codierung 13.27
Sortieralgorithmen 11.1–11.42
AVL-Baum 11.31
B-Baum 11.31
Binärer Suchbaum 11.31
Bubble Sort 11.12–11.16
Algorithmus 11.12
Anmerkungen 11.16
Beispiel 11.14
Implementierung 11.13
Komplexität 11.15
Externes Sortieren 11.1
Heapsort 11.32–11.37
Algorithmus 11.33
Beispiel 11.35, 11.36
Komplexität 11.37
in place 11.1
Insertion Sort siehe Sortieralgorithmen – Sortieren durch Einfügen
Internes Sortieren 11.1
Konventionen 11.2
Meßdaten 11.2
Mergesort 11.38–11.41
Algorithmus 11.38
Beispiel 11.40
Implementierung 11.39
Komplexität 11.41
Problemstellung 11.1
Quicksort 11.23–11.30
Anmerkungen 11.29
Beispiel 11.27
Implementierung 11.26
Komplexität 11.28
partition 11.25
Pivotwahl 11.30
Schematische Implementierung 11.24
Routine swap 11.3
Selection Sort siehe Sortieralgorithmen – Sortieren durch Auswahl
Shellsort 11.17–11.22
Algorithmus 11.18–11.19
Beispiel 11.21
h-sortiert 11.17
Implementierung 11.20
Komplexität 11.22
Sonstige Verfahren 11.42
Sortieren durch Auswahl 11.4–11.7
Algorithmus 11.4
Beispiel 11.6
Implementierung 11.5
Komplexität 11.7
Sortieren durch Einfügen 11.8–11.11
Algorithmus 11.8
Beispiel 11.10
Implementierung 11.9
Komplexität 11.11
Stabilität 11.1
Suchalgorithmen 9.2–9.22, 10.1–10.15
Anmerkung 9.3
AVL-Baum 9.21
B-Baum 9.22
Binäre Suche 9.8–9.11
Algorithmus 9.8
Beispiel 9.11
Implementierung 9.9–9.10
Komplexität 9.8
Binärer Suchbaum 9.16–9.20
Algorithmus 9.17
Anmerkungen 9.20
Beispiel 9.19
Komplexität 9.20
Interpolationssuche 9.12–9.14
Algorithmus 9.12
Anmerkungen 9.14
Beispiel 9.13
Komplexität 9.14
mögliche Fälle 9.2
Selbstanordnende Listen 9.15
Sequentielle Suche 9.4–9.7
Algorithmus 9.4
Decodierung 13.28
RLE 13.10
bei Binärdaten 13.12
Beispiel 13.11–13.12
run 13.10
Soundkompression 13.33
MP3 13.33
Psychoakustische Modelle 13.33
Sampling 13.33
Typen
adaptiv 13.5
asymmetrisch-adaptiv 13.5
nichtadaptiv 13.5
semi-adaptiv 13.5
symmetrisch 13.5
variable Zeichenlänge 13.13
Kriterien 13.13
Morse-Code 13.13, 13.14
verlustbehaftet 13.4
verlustfrei 13.4
Videokompression 13.34
MPEG 13.34
P
Priority Queue 5.29–5.31
Einfügen 5.30
Löschen 5.30
S
Erweiterung 9.6
Implementierung 9.5
Komplexität 9.4, 9.7
Sentinel-Methode 9.6
sortierte Daten 9.7
Suche in Zeichenfolgen siehe Suche in Zeichenfolgen
Suche in Zeichenfolgen 10.1–10.14
Brute Force 10.1–10.4
Algorithmus 10.1
Analyse 10.3
Beispiel 10.4
Implementierung 10.2
Verbesserung 10.5
KMP 10.5–10.14
Algorithmus 10.8
Algorithmus initNext 10.10
Anmerkungen 10.14
Auswirkung Modifikation 10.11
Beispiel 10.7, 10.13
Bestimmung next 10.6–10.7
Implementierung 10.9
Implementierung initNext 10.12
Verbesserung 10.6
Problemstellung 10.1
V
verkettete Liste 5.29
Verschlüsselungsverfahren 14.1–14.13
Anwendungsgebiete 14.1
Cäsar-Chiffre 14.3–14.4
Grundlagen 14.2
PGP 14.8
Public Key Encryption 14.3, 14.7
RSA 14.3, 14.7–14.13
öffentlicher Schlüssel 14.7–14.13
Horner-Schema 2.4
Allgemein 2.4
Beispiel 2.5
K2 siehe Zweierkomplement
Konversion von Dezimal 2.8
Oktalzahlen 2.9
Stellenwertsysteme 2.2–2.3
Vorzeichen 2.12
Vorzeichen-Absolutbetrag 2.12–2.15
Auswertung 2.13
darstellbarer Bereich 2.12
Nachteile 2.15
Zahlenkreis 2.14
Zahlenbasis 2.1, 2.6
Zweierkomplement 2.15–2.20
Überlauf 2.20
Auswertung 2.17
darstellbarer Bereich 2.19
Rechenregeln 2.19–2.20
Vorteile 2.19
Zahlenkreis 2.18
14.12–14.13
Bestimmung von
geheimer Schlüssel 14.7–14.13
Komplexität 14.12
Voraussetzungen 14.9
Schema 14.2
Tabellenkodierung 14.3–14.5
Vernam-Chiffre 14.3, 14.6
Vigenère-Chiffre 14.3
Vigenǹere-Chiffre 14.6
Z
Zahlendarstellung 2.1–2.29
Binärzahlen 2.7–2.11
Fehlerfortpflanzung siehe Fehlerfortpflanzung
ganze Zahlen 2.12–2.20
Gleitpunktzahlen 2.21–2.29
2.26
NaN 2.26
Anforderungen 2.22
Auswertung 2.25
Beispiel 2.24
Darstellung der 0 2.26
Exponent 2.21–2.26, 2.29
Formatdefinition 2.23
Mantisse 2.21–2.26, 2.29
Nachteile 2.28
nicht darstellbare Zahlen 2.22, 2.28
Normierung 2.22–2.23, 2.27–2.28
Rechenfehler 2.28
Sonderfälle 2.26
ungleiche Verteilung 2.28
Vergleich 2.29
Vorteile der Darstellung 2.27
Vorzeichen 2.21–2.26, 2.29
Hexadezimalzahlen 2.10–2.11
Literatur
[Sed92] Robert Sedgewick. Algorithmen in C. Addison-Wesley, 1992.
[Sol98] David Solomon. Data Compression - The Complete Reference. Springer, 1998.