Folien zur Informatik I Dipl.-Inform. Guido R¨oßling Berufsakademie

Folien zur
Informatik I
Dipl.-Inform. Guido Rößling
Berufsakademie Mannheim
EMail: [email protected]
Inhaltsverzeichnis
Allgemeines zur Informatik I
0.1
Überblick über die Informatik
1.1
Was ist Informatik? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.1
Duden Informatik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.1
Begriff Informatik“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2
”
Definition der ACM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3
Einordnung der Informatik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5
Einsatz von Informatik-Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.7
Teilgebiete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.8
Themenbereiche der Informatik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.9
Geschichte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.13
Vom Problem zum Programm
2.1
Aufgabenbeispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4
Schritt 0: Aufgabenstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5
Schritt 1: Erfassung der Problemstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.6
Schritt 2: Analyse der Problemstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.7
Schritt 3: Entwicklung eines Lösungsmodells . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.11
Grafische Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.12
Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.18
Beispiel- Algorithmus“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.20
”
Erkenntnisse und Fragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.21
Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.22
Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.23
Formale Sprachbeschreibung
3.1
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1
Verarbeitung von Eingabedaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.5
Definition von Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.7
BNF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.10
Regelform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.11
Ableitungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.13
Ableitungssequenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.14
Ableitungsbaum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.16
Beispiele:
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.18
Beispiele: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.20
Ein- und Mehrdeutigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.22
BNF für elementare Arithmetik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.24
Syntaxdiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.26
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.29
Vergleich der Ableitungsarten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.30
Logik
4.1
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1
Aussagenlogik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2
Geschichte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2
Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3
Grundbegriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.5
Junktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.6
Unterschiede zu Deutsch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.9
Backus-Naur-Form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.10
Konversionsregeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.14
Prädikatenlogik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.16
Prädikate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.17
Aussagefähigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.18
Quantoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.19
Existenzquantor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.20
Allquantor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.21
Auswertung der Quantoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.23
Berechenbarkeit
5.1
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1
Begriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3
Maschinenmodelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.5
Turingmaschine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.6
Schematischer Aufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.7
Programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.8
Beispielbefehl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.9
Programmausführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.10
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.11
Church’sche These . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.13
Ergebnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.14
Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.15
Komplexität
6.1
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4
Nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.6
Elementare Kosten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.7
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.8
O-Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.11
Rechenbeispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.12
Komplexitätsklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.15
Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.16
Verhalten der Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.18
Ergebnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.21
Average, Best und Worst Case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.22
Ergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.23
Rekursion
7.1
Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.1
Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4
BNF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4
Mathematik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.5
Allgemeines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.8
Summenformel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.9
Bekannte Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.10
Arten von Rekursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.11
Türme von Hanoi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.12
Typische Fehler bei der Rekursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.24
Parallelverarbeitung
8.1
Einsatzgebiete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1
Architekturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2
Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.4
Voraussetzungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.5
Bewertung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.7
Algorithmenklasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.8
Problemstellungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.9
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.11
Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.12
Determinismus und Nichtdet.
9.1
Begriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1
Deterministische Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.2
Probabilistische Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.3
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.4
Heuristische Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.5
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.7
Nichtdeterministische Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.10
Ergebnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.12
Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.13
Korrektheit
10.1
Motivation und Geschichte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.1
Fehlerarten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.2
Testverfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.4
Statische Testverfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.5
Schreibtischtest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.6
Codeinspektion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.7
Dynamisches Testen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.8
Black Box-Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.8
White Box-Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.10
Klassentest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.12
Integrationstest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.13
Top-Down Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.14
Bottom-Up Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.15
Produkttest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.16
Bewertung der Testverfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.17
Korrektheitskriterien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.18
Spezifikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.19
Probleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.20
Motivation der Verifikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.21
Vorgehensweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.22
Weakest Precondition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.23
Regeln für Wertzuweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.24
Beispiele zur Wertzuweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.25
Regeln für Blöcke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.27
Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.30
Regeln für IF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.31
Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.33
Regeln für Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.34
Invariante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.35
Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.37
Totale Korrektheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.39
Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.40
Imperative Programmierung
11.1
Allgemeines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2
Modellierung von Daten und Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3
Objektorientierte Programmierung
12.1
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.1
Schlüsselbegriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.2
Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.2
Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.3
Attribute und Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4
Abstrakte Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.5
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.6
Vom ADT zur Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.7
Von der Klasse zum Objekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.8
Konstruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.9
Verwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.10
Mögliche Fälle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.11
Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.12
Problemstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.12
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.13
Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.14
Folgen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.17
Abstrakte Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.18
Überladen von Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.20
Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.21
Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.21
Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.22
Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.23
Casting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.24
Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.25
Logische Programmierung
13.1
Grundidee . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.1
Anfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.2
Resolution und Unifikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4
Funktionale Programmierung
14.1
Grundidee . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.1
Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.3
Elisp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4
Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.5
Abbildungsverzeichnis
15.1
Tabellenverzeichnis
16.1
Index
17.1
Literaturverzeichnis
18.1
Allgemeines zur Informatik I
Inhalte der Informatik I:
❑ Formale Sprachbeschreibung – wie lassen sich Sprachen beschreiben?
❑ Formale Logik – wie wird Logik mathematisch sauber angewendet?
❑ Algorithmentheorie – Grenzen der Machbarkeit sowie grundlegende Konzepte
❑ Grundkonzepte der Programmierparadigmen:
☞ Imperative Programmierung
☞ Objektorientierte Programmierung
☞ Logische Programmierung
☞ Funktionale Programmierung
Informatik I – c Guido Rößling
Allgemeines zur Informatik I
0.1
Allgemeines zur Informatik I
Ziel der Informatik I“ ist es,
”
❑ logische und systematische Grundlagen für die spätere Verwendung aufzubauen,
❑ grundlegende Konzepte der Theoretischen Informatik und deren Praxisbezug vorzustellen
❑ die verschiedenen Grundarten der Programmierung vorzustellen
❑ und dabei das Interesse an Informatik als Wissenschaft (im Gegensatz zu reiner Programmierung) zu wecken!
Die Informatik I bildet das Fundament für die sich anschließenden Veranstaltungen in der
Informatik.
Informatik I – c Guido Rößling
Allgemeines zur Informatik I
0.2
Was ist Informatik“?
”
Informatik (engl. Computer Science) ist die Wissenschaft von der systematischen Verarbei”
tung von Informationen, besonders der automatischen Verarbeitung mit Hilfe von Digitalrechnern“ (aus [Dud93])
Informatik selbst ist ein Kunstwort aus Information und Automatik:
❑ Information, da die Informatik als Basistechnik die Informationsverarbeitung hat;
insbesondere unter Benutzung von Computern und EDV aller Art, sowie zur Erleichterung
der geistigen Arbeit.
❑ Automatik, da ein zentraler Aspekt die Automatisierung von Tätigkeiten zur Erleichterung
der körperlichen Arbeiten ist.
Ansätze zur Automatisierung gibt es seit (spätestens) Archimedes (Wasserbeförderung).
Informatik I – c Guido Rößling
Überblick über die Informatik – Was ist Informatik? : Duden Informatik
1.1
Begriff Informatik“
”
Der Begriff Informatik stammt ursprünglich von der Definition der informatique“ der Aca”
demie Française: Behandlung von Information mit rationalen Mitteln“.
”
Die für diese Behandlung notwendigen rationalen Mittel“ sind (nach René Descartes (1596”
1650)):
❑ nur dasjenige gilt als wahr, was so klar ist, daß kein Zweifel bleibt;
❑ größere Probleme sind in kleinere aufzuspalten;
❑ es ist immer vom Einfachen zum Zusammengesetzten hin zu argumentieren
❑ und das Werk muß am Ende einer abschließenden Prüfung unterworfen werden.
Informatik I – c Guido Rößling
Überblick über die Informatik – Begriff Informatik“
”
1.2
Methoden der Informatik
Nach einem Bericht ([DCG 89]) der Kommission Task Force on the Core of Computer
”
Science“ zur Bestimmung der wesentlichen Inhalte“ der Informatik basiert die Informatik
”
vor allem auf drei Methoden, die allen Teilgebieten der Informatik zugrundeliegen.
❑ Theorie
☞ Isolation und Definition der zu untersuchenden Gegenstände (Definition);
☞ Postulation der möglichen Beziehungen zwischen den Gegenstände (Theorem);
☞ Bestimmung, ob die Beziehungen gelten (Beweis)
❑ Abstraktion
☞ Bildung einer Modellhypothese,
☞ Konstruktion eines Modells und Formulierung des zu erwartenden Verhaltens,
☞ Entwurf eines Experiments und Sammlung von Beobachtungen,
☞ Analyse der Ergebnisse
Informatik I – c Guido Rößling
Überblick über die Informatik – Begriff Informatik“ : Definition der ACM
”
1.3
Methoden der Informatik
❑ Design
☞ Formulierung der Anforderungen,
☞ Formulierung der Spezifikation,
☞ Entwurf und Implementierung des Systems
☞ Testen des Systems.
Informatik als Wissenschaft ist das systematische Studium von informationsbeschreibenden und -transformierenden Prozessen in Bezug auf deren
Theorie – Analyse – Entwurf – Effizienz – Implementierung – Anwendung
Informatik I – c Guido Rößling
Überblick über die Informatik – Begriff Informatik“ : Definition der ACM
”
1.4
Einordnung der Informatik
Wirtschaftswissenschaften
Mathematik
Ingenieursdisziplinen
Physik
Informatik
Naturwissenschaften
Elektrotechnik
Geisteswissenschaften
Abbildung 1: Einordnung der Informatik
Informatik I – c Guido Rößling
Überblick über die Informatik – Einordnung der Informatik
1.5
Einordnung der Informatik
Aufgabe der Informatik
❑ Erforschung grundsätzlicher Verfahrensweisen der Informationsverarbeitung
❑ Erforschung allgemeiner Methoden und deren Anwendung
Forschungsgegenstand
Struktur und Eigenschaft von künstlichen, maschinellen Informationsverarbeitungssystemen:
❑ Hardware ( Computer“, Rechenanlage) physikalisch verfügbare Bestandteile
”
❑ Software Programme zum Betrieb eines Rechners bzw. Lösung eines Problems
❑ Algorithmen (Verfahren)
Methodik
❑ Analyse (☞ Naturwissenschaften) – Formale Beschreibung (☞ Mathematik)
Konstruktion (☞ Technik, Ingenieurswissenschaften)
Informatik I – c Guido Rößling
Überblick über die Informatik – Einordnung der Informatik
1.6
Einsatz von Informatik-Methoden
❑ Verwaltung von Konten einer Bank (viele Daten)
❑ Textverarbeitung (interaktiv)
❑ Verarbeitung von Meßdaten (z.B. Wettervorhersage, schnell, Realzeit)
❑ Flugzeugsteuerung (Sicherheit)
❑ Kreditkarten (weltweite Kommunikation)
❑ CD-Spieler, DAT, DVD (preiswert)
❑ Bildverarbeitung (Multimedia)
❑ Buchungssysteme
❑ Prozeßsteuerungen
❑ etc.
Informatik I – c Guido Rößling
Überblick über die Informatik – Einsatz von Informatik-Methoden
1.7
Teilgebiete der Informatik
Es gibt vier wesentliche Teilgebiete der Informatik:
❑ Theoretische Informatik
☞ Formale Methoden, Automatentheorie, Grenzen der Machbarkeit (Berechenbarkeits- und Komplexitätstheorie, Analyse von Algorithmen)
❑ Praktische Informatik
☞ Betriebssysteme, Programmiersprachen und Compilerbau, Datenbanken, Rechnernetze, Grafik und Multimedia, Softwaretechnik, Künstliche Intelligenz
❑ Technische Informatik
☞ Hardwareentwicklung, Rechnerarchitektur, Schaltkreisentwurf, VLSI-Entwurfswerkzeuge, Mikroprozessoren und -programmierung
❑ Angewandte Informatik
☞ Verwendung der Methoden der Informatik in anderen Wissenschaften; weitergehende Fragen wie Ergonomie und Akzeptanz.
Informatik I – c Guido Rößling
Überblick über die Informatik – Teilgebiete
1.8
Themenbereiche der Informatik
❑ Algorithmentheorie
☞ Berechenbarkeit von Funktionen: kann das Ergebnis für alle oder wenigstens einige
Parameterwerte bestimmt werden?
☞ Komplexität: In welcher Größenordnung befindet sich Zeit- bzw. Platzbedarf der
Funktion?
☞ Deterministische Algorithmen, Probabilitische Algorithmen und Heuristiken
❑ Datenstrukturen
Wie können Daten in einer dem Problem angepaßten Weise gespeichert werden, so daß
Zugriff und typische“ Operationen möglichst schnell erfolgen können?
” ❑ Betriebssysteme
Grundlegende Bereitstellung der Funktionalität des Rechners, so daß der Benutzer Programme starten kann. Das Betriebssystem übernimmt u.a. die Speicher-, Datei- und Prozeßverwaltung der Programme.
Informatik I – c Guido Rößling
Überblick über die Informatik – Themenbereiche der Informatik
1.9
Themenbereiche der Informatik
❑ Programmiersprachen und Compilerbau
Entwicklung von Werkzeugen, die Programme einer Sprache in eine andere Sprache überführen, insbesondere eine vom Rechner ausführbare Sprache.
❑ Datenbanksysteme
Entwurf und Entwicklung von Datenbanken mit allen dabei anstehenden Fragen (Speicherung, Indizierung, Zugriff, Zugriffskontrolle, Aufsetzen nach Absturz etc.)
❑ Rechnernetze
Überlegungen zur Auswirkung der Vernetzung von mehreren Computern zum Zweck des
Datenaustauschs und der Kooperation.
❑ Computergrafik, Visualisierung, Multimedia
Angemessene“ visuelle Aufbereitung von Daten sowohl in Wissenschaft als auch in der
”
Freizeit (momentan wohl der sichtbarste“ Bereich der Informatik für Laien: Wettervor”
hersagen, Animationen, )
Informatik I – c Guido Rößling
Überblick über die Informatik – Themenbereiche der Informatik
1.10
Themenbereiche der Informatik
❑ Softwaretechnik
Ingenieurmäßiger Entwurf großer Programmsysteme
❑ Künstliche Intelligenz
Versuch, dem Computer das Denken“ beizubringen in Form logischer Schlußregeln. Der
”
Computer soll aus einer Menge von Fakten und Regeln selbständig neue Fakten erschließen können.
❑ Rechnerarchitektur
Aufbau neuer Prozessoren, Speicher und Peripheriegeräte
❑ Datenanalyse (Audio, Video, Bild, Meßreihen, )
z.B. Kamera-Überwachung und Bewegungsmelder, aber auch Aufspüren von Trends in
Meßreihen, Finden von Personen in Bildmaterial u.v.a.
Informatik I – c Guido Rößling
Überblick über die Informatik – Themenbereiche der Informatik
1.11
Themenbereiche der Informatik
❑ Systemüberprüfung und Automatisierung
Automatische Sicherheitsüberwachung, etwa in Flugzeugen (Autopilot) oder Kraftwerken
(Überhitzungsschutz) sowie automatische Steuerung einfacher Vorgänge (Thermostatregelung).
❑ Soft Computing
Diverse Techniken wie Neuronale Netze, Fuzzy Logik und Genetische Algorithmen
❑ Sicherheit und Kryptographie
Wie können Daten so verschlüsselt werden, daß nur der gewünschte Empfänger sie lesen
kann? Wie können Rechner so abgesichert werden, daß keine unzulässigen Zugriffe mehr
möglich sind?
Informatik I – c Guido Rößling
Überblick über die Informatik – Themenbereiche der Informatik
1.12
Geschichte der Informatik
❑ Ägyptische Multiplikation“ (oder Indische Multiplikation“), ca. 16. Jhd. v. Chr.
”
”
❑ Ab ca. 450 v. Chr.: Verwendung des Abakus als Hilfsmittel f ür die Grundrechenarten.
❑ Euklid (365-300 v.Chr.): euklidischer Algorithmus“ zur Berechnung des größten gemein”
samen Teilers.
❑ 230 v. Chr.: Eratosthenes entwickelt einen Algorithmus zur Berechnung von Primzahlen:
Das Sieb des Eratosthenes.
❑ Um Christi Geburt: Entwicklung von automatischen Tempelt üren
❑ 5. Jhd: In Indien wird das Dezimalsystem entwickelt.
❑ 9. Jhd: Ibn Musa Al-Chwarismi (persischer Mathematiker und Astronom) schreibt Lehrbuch Kitab al jabr w’almuqabala“ ( Regeln der Wiedereinsetzung und Reduktion“). Der
”
”
Begriff Algorithmus wird später nach ihm benannt.
❑ 1050: Chinesische Gelehrte entwickeln das Dualsystem, ein Zahlensystem mit Basis 2.
Informatik I – c Guido Rößling
Überblick über die Informatik – Geschichte
1.13
Geschichte der Informatik
❑ 1547: Adam Riese (1492-1559) veröffentlicht ein Rechenbuch zur Rechnung im Dezimalsystem. Das Dezimalsystem setzt sich in Europa durch und erm öglicht gegenüber dem
römischen System eine Automatisierung.
❑ John Napier verwendet zum ersten Mal im Druck den Dezimalpunkt. Er entwickelt Logarithmen und Multiplikationsmaschinen.
❑ 1623: Wilhelm Schickard (1592-1635) konstruiert mit Kepler (1571-1630) eine Maschine
für die vier Grundrechenarten. Aufgrund des 30jährigen Krieges (1618-1648) in Deutschland bleibt sie unbeachtet.
❑ 1641: Blaise Pascal (1623-1662) konstruiert eine Maschine zur Addition zweier sechsstelliger Zahlen.
❑ 1673: Gottfried Wilhelm Leibniz (1646-1716) konstruiert eine Rechenmaschine mit Staffelwalzen für die vier Grundrechenarten.
❑ 1679: (Wieder-)Entdeckung der Dualzahlen durch Leibniz. Dualzahlen werden fast 3 Jahrhunderte später zur Grundlage der Zahlendarstellung in den Computern.
Informatik I – c Guido Rößling
Überblick über die Informatik – Geschichte
1.14
Geschichte der Informatik
❑ 1774: Philipp Matthäus Hahn (1739-1790) entwickelt eine zuverlässige mechanische Rechenmaschine.
❑ 1801: Jacquards mechanischer Webstuhl kann komplexe Muster weben. Die Steuerung
erfolgt durch gestanzte Platten.
❑ ab 1818: Rechenmaschinen nach Vorbild von Leibniz werden serienmäßig produziert und
ständig weiterentwickelt.
❑ 1838: Charles Babbage (1792-1871) plant mit Gräfin Ada Augusta von Lovelace die
Analytical Engine“, die durch Lochkarten gesteuert werden soll. Die Maschine soll einen
”
Zahlenspeicher, Rechenwerk, Steuereinheit und Programmspeicher haben.
Die Analytical Engine“ wird nie voll funktionsfähig und von den Zeitgenossen als Un”
sinn betrachtet.
❑ 1854: George Boole entwickelt eine Algebra auf den logischen Werten wahr und falsch.
Informatik I – c Guido Rößling
Überblick über die Informatik – Geschichte
1.15
Geschichte der Informatik
❑ 1886: Hermann Hollerith (1860-1929) entwickelt elektrische Zählmaschinen für Lochkarten zur Auswertung der Volkszählung in den USA. Es gibt spezielle Druck- und Stanzeinheiten sowie Stecktafeln zur Auswahl spezieller Arbeitsprogramme.
Holleriths Firma Hollerith Tabulating Company wird 1924 zur IBM.
❑ 1934: Konrad Zuse (1910-1995) beginnt mit der Planung einer programmgesteuerten Rechenmaschine auf Basis des Dualsystems.
❑ 1937: Die mechanische Anlage Z1 von Konrad Zuse ist fertig.
❑ 1937: Alan Turing schlägt ein Modell für einen Universalrechner vor: die Turingmaschine.
❑ 1939: Atanasoff-Berry-Computer arbeitet binär zur Lösung von Gleichungssystemen mit
29 Unbekannten.
❑ 1941: Die elektro-mechanische Anlage Z3 von Zuse ist fertig und der erste funktionsf ähige programmgesteuerte Rechenautomat. Die Programmierung erfolgt via Lochstreifen.
Z3 besteht aus 2000 Relais und kann 64 Worte von je 22 Bit speichern. Zur Multiplikation
werden ca. 3 Sekunden benötigt.
Informatik I – c Guido Rößling
Überblick über die Informatik – Geschichte
1.16
Geschichte der Informatik
❑ 1943: Der britische Röhrenrechner Colossus knackt den Enigma-Code der deutschen
Wehrmacht.
❑ 1944: Howard H. Aiken (1900-1973) baut mit der Uni Harvard und IBM
die teilweise
programmgesteuerte Rechenanlage MARK I. Additionen ben ötigen ca. , Multiplikation
ca. 6 Sekunden.
❑ 1946: J. P. Eckert und J. W. Mauchly stellen die ENIAC fertig (Electronic Numerical Integrator and Automatic Calculator), den ersten voll elektronischen Rechner mit ca. 18000
Elektronenröhren. Multiplikationen dauern ca. 3 ms.
❑ 1946-1952: Basierend auf den Ideen von John von Neumann (1903-1957) und anderen
werden in Princeton weitere Rechner entwickelt.
❑ 1947: William Shockley erfindet den Transistor (Nobelpreis f ür Physik 1956).
❑ 1949: M. V. Wilkes (Uni Manchester) stellt den ersten universellen Digitalrechner vor, den
EDSAC.
❑ 1957: Die Programmiersprache Fortran wird von John Backus vorgestellt.
Informatik I – c Guido Rößling
Überblick über die Informatik – Geschichte
1.17
Geschichte der Informatik
❑ 1958/59: Texas Instruments entwickelt den ersten integrierten Schaltkreis.
❑ 1960: ALGOL-60, die erste Programmiersprache mit Blockstruktur und Rekursion, wird
vorgestellt.
❑ 1965: Die erste Rechner-Maus wird von Doug Engelbart entwickelt.
❑ 1967: Dahl u. Nygaard entwickeln Simula-67, die erste objektorientierte“ Program”
miersprache.
❑ 1969: Das ArpaNet verbindet 4 Rechner an UCLA, UCSB, SRI und der University of
Utah. Es ist der Vorläufer des Internet.
❑ 1971: Der Intel 4004 ist der erste kommerzielle Mikroprozessor (2100 Transistoren, 4Bit-Daten).
❑ 1972: Kernighan und Ritchie entwickeln die Programmiersprache C.
Der erste 8-Bit Mikroprozessor, der Intel 8008, wird vorgestellt.
Informatik I – c Guido Rößling
Überblick über die Informatik – Geschichte
1.18
Geschichte der Informatik
❑ 1973: Goldberg, Kay u.a. entwickeln Smalltalk, die erste vollständig objektorientierte
Programmiersprache.
❑ 1974: Der erste Arbeitsplatzrechner mit Rasterbildschirm und grafischer Benutzerschnittstelle, der Xerox Alto, erscheint.
Kahn und Cerf entwickeln TCP, ein Protokoll für Paketvermittlung über Rechnernetze
❑ 1975: Der erste PC Altair ist als Bausatz für $397 erhältlich. Die Programmierung erfolgt
durch Schalter an der Vorderseite; die Ergebnisse werden durch Dioden angezeigt.
❑ 1977: Beginn der PC-Ära mit dem Apple II und dem Radio Shack RTS-80 in den USA.
❑ 1980: Motorola entwickelt den ersten 32-Bit Mikroprozessor, den MC 68000.
❑ 1981: IBM stellt den ersten PC her.
❑ 1984: Apple stellt den Apple Macintosh vor.
Informatik I – c Guido Rößling
Überblick über die Informatik – Geschichte
1.19
Geschichte der Informatik
❑ 1985: Intel präsentiert den 32-Bit Mikroprozessor i80386.
❑ 1986: Commodore stellt den Commodore Amiga vor.
❑ 1990: Der WWW-Browser Mosaic erleichtert das Navigieren im Internet; der Boom des
Internet beginnt.
❑ 1991: Sun entwickelt die Programmiersprache Oak, die später als Java bekannt wird.
Weitere Links zum Thema Geschichte der Informatik“ befinden sich unter
”
http://ourworld.compuserve.com/homepages/computer_museum
Informatik I – c Guido Rößling
Überblick über die Informatik – Geschichte
1.20
Geschichte der Informatik
automatische Tempeltüren
Der Abakus
Die Pascal’sche Maschine Der Jacquard’sche Webstuhl
Informatik I – c Guido Rößling
Überblick über die Informatik – Geschichte
Ibn Musa Al-Chwarismi
Teil des Webstuhls
1.21
Geschichte der Informatik
Ada Augusta Gräfin Lovelace
Hollerith
Konrad Zuses Z1
Atanassof-Berry-Computer
Detailansicht
Erster integrierter Schaltkreis
Informatik I – c Guido Rößling
Überblick über die Informatik – Geschichte
1.22
Geschichte der Informatik
Die erste Rechner-Maus
Detailansicht
Der Intel 8008
Der Alto
Der Altair
Altair von hinten
Informatik I – c Guido Rößling
Überblick über die Informatik – Geschichte
1.23
Geschichte der Informatik
Informatik I – c Guido Rößling
Der Apple II
Der Motorola MC 68000
Der IBM PC
Apple Macintosh
Intel 80386
Commodore Amiga
Überblick über die Informatik – Geschichte
1.24
Geschichte der Informatik: Rechnerentwicklung
1. 50er Jahre: Elektronenröhren (ca. 1000 Additionen pro Sekunde)
2. 60er Jahre: Halbleiterschaltkreise, insb. Transistoren und Dioden (etwa 10000 Additionen
pro Sekunde)
3. Ab Mitte 60er Jahre: Teilweise integrierte Schaltkreise mit ca. 500000 Additionen/s
4. Ab Anfang 70er Jahre: Hochintegrierte Schaltkreise mit ca. 10 Mio. Additionen/s
5. Ab Anfang der 80er Jahre: Höchstintegrierte Schaltkreise, mehrere Prozessoren auf einem
Chip; über Hundert Millionen Additionen/s
Informatik I – c Guido Rößling
Überblick über die Informatik – Geschichte
1.25
Vom Problem zum Programm
Problem
Kreativität
Intuition
Programmierung
Algorithmus
Lösungsidee
Programm
automatisch
Denkschweiß
maschinelle
Ausführung
Abbildung 2: Vom Problem zum Programm
Informatik I – c Guido Rößling
Vom Problem zum Programm
2.1
Vom Problem zum Programm
Eine idealisierte Vorgehensweise sieht wie folgt aus:
1. Saubere, formale Erfassung der Problemstellung
☞ Nebenbedingungen, Sonderfälle, Ein- und Ausgabeformat sind zu beachten!
2. Analyse der Problemstellung
☞ Gibt es ähnliche, gelöste Probleme? Aufteilung in Teilprobleme möglich?
3. Entwicklung eines Lösungsmodells
4. Entwurf eines Lösungsverfahrens (Algorithmus)
5. Nachweis der Korrektheit
6. Analyse der Effizienz und Komplexität
7. Implementierung (Programmierung)
8. Test und Fehlerbeseitigung
9. Dokumentation
Informatik I – c Guido Rößling
Vom Problem zum Programm
2.2
Vom Problem zum Programm
In der Praxis sieht es aber oft anders aus:
❑ Bei Problemen wird oft zu vorherigen Phasen zurückgegangen
❑ Das System wird durch eine schnell erstellte Vorabversion“ (Prototyp) implementiert,
”
die schrittweise verbessert wird
❑ Die einzelnen Phasen werden oft nicht sauber getrennt, sondern laufen nebeneinander
❑ Organisatorische Maßnahmen (Projektmanagement, Qualitätssicherung, aber auch Ressourcen-Probleme)
❑ Nicht alle Probleme sind überhaupt lösbar
❑ Es gibt nicht immer eine ideale“ oder auch nur gute“ Lösung
”
”
❑ Der Nachweis der Korrektheit erfolgt oft durch Plausibilität“
”
Informatik I – c Guido Rößling
Vom Problem zum Programm
2.3
Beispiele für Aufgaben
Um die bei den typischen“ Aufgaben der Informatik auftretenden Probleme zu skizzieren,
”
betrachten wir ein Beispiel: Die Konzeption eines Systems zum Online-Banking f ür die Sparkasse Siegen.
Anhand dieses Beispiels werden bereits einige Inhalte und Begriffe eingef ührt, auf die später
näher eingegangen wird.
Als Voraussetzung nehmen wir an, daß der Auftrag an ein Software-Unternehmen erteilt wurde, dessen Mitarbeiter in Gruppen zusammenarbeiten. Zwei dieser Gruppen sollen nun daf ür
abgestellt werden, das Projekt in Kooperation mit dem Auftraggeber durchzuf ühren.
Informatik I – c Guido Rößling
Vom Problem zum Programm – Aufgabenbeispiele
2.4
Aufgabenstellung
Die vom Kunden gewünschte Funktionalität des fertigen Produkts sieht wie folgt aus:
❑ Anzeigen des Kontoauszugs
❑ Tätigen von Überweisungen
❑ Einsehen, Erteilen, Ändern und Stornieren von Daueraufträgen
❑ Aufnahme von Krediten oder Hypotheken
❑ Terminvereinbarung mit einem Betreuer
❑ Aufladen der Geldkarte, falls ein entsprechendes Ladegerät zur Verfügung steht.
☞ Welche Anforderungen fallen Ihnen noch ein? Was haben die Auftraggeber vergessen?
Informatik I – c Guido Rößling
Vom Problem zum Programm – Aufgabenbeispiele : Schritt 0: Aufgabenstellung
2.5
Schritt 1: Erfassung der Problemstellung
Zunächst ist zu schauen, welche Anforderungen nicht eindeutig definiert wurden:
❑ Wo soll das System wem zur Verfügung gestellt werden?
❑ Wie soll der Zugang zum System erfolgen?
❑ Wie sollen die Aktionen des Kunden protokolliert werden?
❑ Wie sieht das bisherige System aus? Soll es eine Anbindung daran geben?
Nach einigen klärenden Diskussionen legt sich die Sparkasse wie folgt fest:
❑ Das System soll prinzipiell jedem Kunden offenstehen, unabhängig davon, wo er sich
befindet – also etwa auch beim Urlaub auf den Äußeren Hebriden.
❑ Der Zugang soll über Paßwort geschützt werden. Die erforderlichen Unterlagen können
interessierte Kunden bei Vorlage eines Ausweises anfordern.
❑ Die Aktionen des Kunden müssen in entsprechende Transaktionen des bisherigen, weiterhin gültigen Bankcomputers umgesetzt werden, da es kein separates dediziertes OnlineSystem geben soll.
Informatik I – c Guido Rößling
Vom Problem zum Programm – Aufgabenbeispiele : Schritt 1: Erfassung der Problemstellung
2.6
Schritt 2: Analyse der Problemstellung
Um die Anforderungen der Bank möglichst gut realisieren zu können, bietet sich folgendes
an:
❑ Verwendung eines Java Applets für die Interaktion mit dem Kunden – dadurch Unabhängigkeit von bestimmen Rechnerarchitekturen oder besonderer Software.
❑ Zugangskontrolle als Teil des Java Applets; zur Sicherheit werden die Daten verschl üsselt
übertragen
❑ Entwurf eines Java-Servers bei der Bank, der Anfragen von weltweit laufenden Klienten
entgegennimmt und in entsprechende Aktionen auf dem eigentlichen Rechner der Bank
auslöst.
❑ Implementierung einer ansprechenden grafischen Schnittstelle f ür die Kunden; die interne
Kommunikation erfolgt rein binär vom Java-Server zum eigentlichen Server.
Informatik I – c Guido Rößling
Vom Problem zum Programm – Aufgabenbeispiele : Schritt 2: Analyse der Problemstellung
2.7
Schritt 2: Analyse der Problemstellung
WWW
internes Netz
Kunde 1
WWW
Java-Server der Bank
Server der Bank
Kunde 2
Abbildung 3: Schematischer Aufbau des Systems
Informatik I – c Guido Rößling
Vom Problem zum Programm – Aufgabenbeispiele : Schritt 2: Analyse der Problemstellung
2.8
Schritt 2: Analyse der Problemstellung
Folgende Probleme sind u.a. zu klären:
❑ Wie kann man die Kunden, Konten und die Beziehung dazwischen modellieren?
☞ Welche Informationen liegen vor, welche werden benötigt?
❑ Wie können die Daten vor Abhören durch Dritte geschützt werden?
☞ Einige Browser bieten bereits eine Verschlüsselung der Daten an.
❑ Wie erfolgt die Abstimmung mit dem vorhandenen System? Was f ür Eingaben oder Befehle versteht es?
Dazu ist eine Abstimmung mit den Informatikern der Sparkasse sowie Studium der Dokumentation des Banksystems notwendig.
❑ Wie kann die Autorisierung und der Datenschutz der Kunden gewährleistet werden?
❑ Wie kann eine ansprechend gestaltete Oberfläche aussehen? Welche Komponenten werden dafür benötigt?
Informatik I – c Guido Rößling
Vom Problem zum Programm – Aufgabenbeispiele : Schritt 2: Analyse der Problemstellung
2.9
Schritt 2: Analyse der Problemstellung
Elegant wäre eine Aufteilung der zu lösenden Probleme etwa wie folgt:
❑ Modellierung von Kunden, Konten und Transaktionen mit Verwaltung der Daten in einer
geeigneten“ Datenstruktur
”
❑ Datenschutz für die Kundendaten: jeder Kunde darf nur seine eigenen Konten einsehen
❑ Entwurf einer grafischen Schnittstelle: welche Komponenten gibt es, und wie h ängen sie
zusammen?
❑ Überprüfung des Systemzugangs (Autorisierung)
❑ Sichere Übertragung der Daten
❑ Kommunikation mit dem Banksystem
Die letzten drei Punkte werden im folgenden nicht weiter betrachtet.
Informatik I – c Guido Rößling
Vom Problem zum Programm – Aufgabenbeispiele : Schritt 2: Analyse der Problemstellung
2.10
Schritt 3: Entwicklung eines Lösungsmodells
Nach einigen Besprechungen einigen sich die Arbeitsgruppen auf folgendes Vorgehen:
❑ Da Kunden, Konten und Transaktionen drei völlig unterschiedliche Sachen sind, sollen
sie separat modelliert werden.
❑ Um den Datenschutz zu gewährleisten, sollte es eine Unterscheidung in drei Arten von
Daten geben:
☞ Daten, auf die alle zugreifen dürfen, etwa den Bildschirm zum Anmelden ( public“ –
”
öffentlich“),
”
☞ Daten, die nur für den jeweiligen Besitzer sichtbar sein dürfen, etwa die PIN ( private“
”
– privat“), sowie
”
☞ Daten, die nur innerhalb des Programmsystems sichtbar sein sollen, etwa die Kundenliste ( protected“ – geschützt“)
”
”
❑ Auf die grafischen Komponenten gehen wir ab der nächsten Folie ein.
Informatik I – c Guido Rößling
Vom Problem zum Programm – Aufgabenbeispiele : Schritt 3: Entwicklung eines Lösungsmodells
2.11
Grafische Komponenten
Verfolgen wir kurz die Arbeit der Gruppe Grafische Komponenten“ ”
Als erstes wurde eine Liste der Aufgaben bzw. Anforderungen erstellt:
❑ Welche Bausteine“ oder Komponenten gehören zu einer grafischen Oberfläche?
”
❑ Wie können diese sinnvoll modelliert werden?
☞ Die Modellierung sollte möglichst flexibel in der Zuordnung der Komponenten sein!
❑ Die Modellierung sollte so allgemein wie möglich sein – am besten sogar plattformunabhängig (d.h. unabhängig davon, ob Windows 95/98, NT, Unix, Macintosh, zugrundeliegt).
❑ Die Komponenten sollten beliebig anordnenbar sein
❑ Das Aussehen der Komponenten sollte sowohl rechnerunabh ängig einstellbar als auch
vom jeweiligen Rechner abhängig sein können.
Informatik I – c Guido Rößling
Vom Problem zum Programm – Aufgabenbeispiele : Grafische Komponenten
2.12
Grafische Komponenten
Zur besseren Anschaulichkeit stellt die Arbeitsgruppe ein Fenster mit vielen gängigen“
”
Komponenten zusammen:
Fenstertitel
Zeichnung
Schaltknöpfe
("CheckBoxes")
Druckknöpfe
Texte
Schieberegler
Abbildung 4: Ein typisches“ Fenster
”
Informatik I – c Guido Rößling
Vom Problem zum Programm – Aufgabenbeispiele : Grafische Komponenten
2.13
Grafische Komponenten
Folgende Komponenten fallen im Fenster auf bzw. sind anderweitig bekannt:
❑ Fenster
❑ Druckknöpfe und Auswahlknöpfe: 1 aus n“ oder m aus n“
”
”
❑ Texte
❑ Linien, Kreise u.ä.
❑ Grafiken
❑ Zeichen-/Anzeigeflächen
❑ Texteingaben
❑ Aktionsverwaltung, z.B. Mausklick
❑ Menüs: Pulldown, Popup-Menüs, Tool Tips“
”
❑ Listen
❑ Tabellen
❑ Zeichenfunktionalität (etwa Rubber Band“)
”
Informatik I – c Guido Rößling
Vom Problem zum Programm – Aufgabenbeispiele : Grafische Komponenten
2.14
Grafische Komponenten
Nach einem Brainstorming entstehen zur Modellierung der Inhalte folgende Kategorien oder
Klassen“ (von Klassifizierung):
”
❑ Anzeigeflächen
❑ Druckknöpfe und Regler
❑ Listen
❑ Tabellen
❑ Menüs
❑ Bilder
❑ Zeichnungen (Erstellung, Anzeige, Änderung)
❑ Texte (Eingabe, Anzeige, Änderung)
❑ Aktionsverwaltung: Menü anzeigen, Eintrag auswählen, Knopf drücken, Listenelement
wählen, Text eingeben / ändern, zeichnen, Grafik laden oder verschieben, Scrolling
Informatik I – c Guido Rößling
Vom Problem zum Programm – Aufgabenbeispiele : Grafische Komponenten
2.15
Grafische Komponenten
Man kann aber noch weiter gehen, indem man noch allgemeiner klassifiziert. In diesem Fall
erhält man die folgenden allgemeinen Klassen:
❑ Behälter (Container) – Fenster, Anzeige- und Zeichenflächen
❑ Komponenten (Components) – alle grafischen Elemente außer den Behältern
❑ Aktionsverarbeitung – Mausbewegung, Mausklicks und Tastaturdruck
Man erhält dann das Bild der nächsten Folie. Auf der Abbildung geben die Pfeile jeweils die
Beziehung ist Spezialfall oder Erweiterung von“ an: ein Fenster ist ein spezieller Beh älter.
”
Die Einteilung in verschiedene Klassen ist ein wichtiger Schritt bei der objektorientierten
Programmierung, mit der wir uns später noch genauer beschäftigen werden.
Auf die Angabe der noch fehlende Schritte (Entwurf eines L ösungsverfahrens, Nachweis der
Korrektheit, Analyse der Effizienz und Komplexität, Implementierung (Programmierung),
Test und Fehlerbeseitigung sowie Dokumentation) wird hier nicht weiter eingegangen.
Informatik I – c Guido Rößling
Vom Problem zum Programm – Aufgabenbeispiele : Grafische Komponenten
2.16
Grafische Komponenten
Aktionsverwaltung
Behälter
(Container)
Fenster
Zeichenfläche
Anzeigefläche
MenüAktion
ListenAktion
KnopfAktion
Komponente
Grafik
z.B.:
GIF
JPG
BMP
Knopf
Liste
Druckknopf
1 aus n
m aus n
Menü
Auswahl
ein
mehrere
Element(e)
Tabelle
Pulldown
Popup
ToolTips
Text
Zeichensatz
Fett, kursiv,...
Zeichengröße
Zeichenelement
z.B.
Punkt
Linie
Polygonzug
Kreisbogen
Abbildung 5: Klassenhierarchie für grafische Benutzerschnittstellen
Informatik I – c Guido Rößling
Vom Problem zum Programm – Aufgabenbeispiele : Grafische Komponenten
2.17
Algorithmen
Neben der Modellierung ist die Entwicklung von geeigneten Algorithmen entscheidend. Doch
was ist ein Algorithmus eigentlich?
Ein Algorithmus ist ein Verfahren mit einer präzisen, in einer genau festgelegten Sprache
abgefaßten Beschreibung unter Verwendung von effektiven (d.h. tats ächlich ausführbaren) Verarbeitungsschritten.
Informal heißt das: Jedes schematische Lösungsverfahren, das zur Lösung eines Problems
dient, ist ein Algorithmus.
Informatik I – c Guido Rößling
Vom Problem zum Programm – Algorithmen
2.18
Algorithmen
❑ Ein Rechner kann nur dann eine alphabetisch sortierte Kundenliste ausdrucken (vgl. auch
Telefonbuch), wenn ein Mensch das Verfahren zum Sortieren vorher haarklein“ beschrie”
ben hat.
❑ Beim Problem Verzinsung eines Kapitals nach Zins und Zinseszins“ nutzt weder ein
”
Taschenrechner noch ein Supercomputer, wenn man die Zinseszinsformel (=Algorithmus)
nicht kennt.
❑ Ohne Rezept kann man mit einem Ofen alleine keinen Kuchen backen.
Algorithmus genaue und eindeutige Handlungsanweisung
Beispiele: Bastelanleitung, Kochrezepte, Binden einer Krawatte, Musikpartitur, Millionär
”
werden in 30 Tagen“
Informatik I – c Guido Rößling
Vom Problem zum Programm – Algorithmen
2.19
Beispiel- Algorithmus“
”
Zwetschgenkuchen (Auszug)
1. Zutaten: 2. zunächst das Mehl in eine Schüssel sieben 3. Danach den restlichen Zucker, die restliche Milch, das Fett, die Eier und das Salz zugeben.
Alles gut verkneten und solange schlagen, bis sich der Teig vom Sch üsselrand löst und
Blasen wirft.
4. Den Teig zudecken und solange gehen lassen, bis er sich verdoppelt hat.
5. Währenddessen die Zwetschgen waschen, auf Küchenkrepp trocknen, der Länge nach
aufschneiden, entsteinen 6. 7. Falls ein Heißluftofen verwendet wird, bei
vorheizen Informatik I – c Guido Rößling
20 Minuten backen. Ansonsten Ofen auf
Vom Problem zum Programm – Algorithmen : Beispiel- Algorithmus“
”
2.20
Erkenntnisse und Fragen
❑ Handlungsanweisungen sind als schriftliche Texte nichts anderes als eine Folge von Buchstaben (Wörter, Sätze, ) mit einem gewissen“ Sinn.
”
❑ Wie genau und detailliert muß die Beschreibung sein?
☞ Was bedeutet eigentlich, z.B. in Kochrezepten, genau und“ – Reihenfolge
”
(kausal, zeitlich) oder parallele Ausführung?
❑ Was sind die elementaren Schritte, die ohne weitere Verfeinerung und Anweisung ausgeführt werden können?
☞ Kochrezepte haben mächtige Grundoperationen“ und erfordern ein umfang”
reiches Kontextwissen (anbräunen, dünsten, schmoren, )
❑ Offenbar gibt es für alle“ Algorithmen ähnliche Steueranweisungen:
”
☞ tue zuerst dies, dann das
☞ tue dies und das in beliebiger Reihenfolge oder sogar gleichzeitig
☞ wenn dann ansonsten
☞ tue etwas wiederholt solange bis ☞ tue obiges nochmals für das nächste Objekt
Informatik I – c Guido Rößling
Vom Problem zum Programm – Algorithmen : Erkenntnisse und Fragen
2.21
Definition
Schematisch ausführbare Vorschrift endlich beschrieben
☞ Text, Diagramm endlicher Länge
terminierend
☞ kommt bei jeder Ausführung nach endlich vielen Verarbeitungsvorschriften
zum Ende
finite Ressourcen
☞ zu jedem Zeitpunkt der Abarbeitung belegt der Algorithmus nur endlich viel Platz
präzise elementare Einzelschritte
☞ Alle Einzelaktionen müssen im Prinzip ausführbar sein und in ihrer Wirkung
und Aufeinanderfolge präzise festgelegt sein.
Informatik I – c Guido Rößling
Vom Problem zum Programm – Algorithmen : Definition
2.22
Eigenschaften
❑ Algorithmen sind auf eine Klasse von Problemen anwendbar, also i.a. auf eine unbegrenzte Anzahl von Einzelfällen.
❑ Für die Anzahl der Einzelschritte gibt es i.a. keine feste obere Schranke, die f ür alle Einzelfälle gilt.
❑ Oft gibt es für ein und das selbe Problem mehrere ganz unterschiedliche Algorithmen, die
das Problem auf eine jeweils andere Art und mit unterschiedlichem Aufwand l ösen.
❑ Algorithmen sind unabhängig von der Programmiersprache und dem Computertyp.
Informatik I – c Guido Rößling
Vom Problem zum Programm – Algorithmen : Eigenschaften
2.23
Formale Sprachbeschreibung
Folgende Fragen müssen für eine effektive Kommunikation geklärt werden:
❑ Welche Kommunikationsform ist zu wählen?
☞ mündlich,
☞ schriftlich,
☞ mimisch (z.B. Pantomime),
☞ gestisch (z.B. Gebärdensprache der Stummen),
☞ symbolisch (z.B. Mathematik, Comics und Icons)
❑ Welche Sprache soll verwendet werden?
☞ Natürliche“ Sprache (Deutsch, aber auch Esperanto),
”
☞ Künstliche Sprache (z.B. Mathematik),
☞ Programmiersprache (z.B. Java),
☞ Abfragesprachen (z.B. SQL für Datenbankanfragen)
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – Motivation
3.1
Formale Sprachbeschreibung
Unmittelbare Folgefragen:
❑ In welcher Sprachform wird kommuniziert?
☞ Telegrammstil,
☞ Umgangssprache,
☞ Schriftsprache (etwa Oxford English),
☞ Amts- und Behördensprache,
☞ Lyrik, evtl. gereimt,
☞ Dialekt
❑ Wie werden – bei Schriftform – die Sätze notiert?
☞ Lateinische, kyrillische, chinesische, koreanische, arabische, Schriftzeichen?
☞ Welche Größe hat die Trägermenge, z.B. das lateinische Alphabet?
Von den Buchstaben des lateinischen Alphabets verwendet Englisch alle 26, Deutsch
zusätzlich noch vier Umlaute. Gälisch hingegen verwendet nur 18 Buchstaben Informatik I – c Guido Rößling
Formale Sprachbeschreibung – Motivation
3.2
Formale Sprachbeschreibung
Es muß daher eine (meist informelle) Einigung über die folgenden Punkte erzielt werden:
❑ Kommunikationsform, z.B. schriftlich,
❑ Verwendete Sprache, z.B. Deutsch,
❑ Sprachform, z.B. Umgangssprache
❑ Schriftzeichen, z.B. lateinische Buchstaben mit deutschen Umlauten,
❑ Notation, z.B. Fließtext, alte Rechtschreibung.
Bei der Kommunikation mit dem Computer muß dieser über Regeln verfügen, mit denen
er korrekte Sätze erzeugen sowie überprüfen kann. Menschen lernen diese Regeln meist an
Beispielen, haben also eine informelle Grammatik“ im Kopf.
”
☞ Ist der Satz Der 3. Oktober ein Feiertag ist“ korrekt?
”
Warum, bzw. warum nicht?
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – Motivation
3.3
Formale Sprachbeschreibung
Diese Punkte führen direkt zur Frage, wie die Mensch-Rechner- bzw. Rechner-RechnerKommunikation formalisiert werden kann.
Um angeben zu können, wie die Kommunikation zwischen dem Geldautomat und dem Zentralserver des Bankkonsortiums erfolgen soll, muß definiert werden, welche Daten in welcher Reihenfolge auszutauschen sind.
☞ Festlegen eines Formats für den Austausch von Nachrichten, das angibt, wie
Nachrichten zusammenzusetzen bzw. zu interpretieren sind.
So muß jede Nachricht etwa die folgenden Informationen enthalten:
❑ Wer ist der Adressat der Nachricht (Geldautomat, Zentralrechner, Bankrechner, )?
❑ Wer ist der Urheber der Nachricht (Geldautomat, Zentralrechner oder Bankrechner)?
❑ Welche Art von Aktion ist betroffen (Auszahlung, Kontoauszug, )?
❑ Was ist der Inhalt der Nachricht (ggf. mit weiterer Unterteilung)?
Um diese Inhalte zu charakterisieren, wird eine formale Notation ben ötigt.
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – Motivation
3.4
Verarbeitung von Eingabedaten durch den Computer
Damit der Computer Eingaben verarbeiten kann, führt er üblicherweise folgende Schritte aus:
Lexikalische Analyse
Zerlegen der (für den Computer) unstrukturierten Eingabe in Einzelkomponenten, sogenannte
Tokens.
Ein typisches Token ist Zahl und steht für Eingaben wie 0, 4711, -123.3231.
Syntaktische Analyse
Anwenden von Regeln, welche Bedeutung bestimmte Anordnungen von Tokens haben.
Eine solche Regel könnte etwa lauten (in informeller Schreibweise)
Addition: Zahl + Zahl
und besagt dann, daß die Abfolge Zahl, +, Zahl“ als Addition zu verstehen ist.
”
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – Verarbeitung von Eingabedaten
3.5
Verarbeitung von Eingabedaten durch den Computer
Semantische Analyse
Nach der syntaktischen Analyse ist die Syntax der Eingabe erfaßt, und eventuelle Syntaxfehler
wurden gemeldet.
Nun wird der syntaktisch korrekten Eingabe ein Inhalt zugeordnet und überprüft, ob der Satz
Sinn ergibt.
So ist der Satz
Der 3. Oktober ißt ein Feiertag“
”
syntaktisch korrekt, semantisch aber nicht.
Auswertung / Ausführung
Gab es auch in der semantischen Analyse keine Fehler, ist die Eingabe korrekt und kann nun
ausgewertet bzw. ausgeführt werden.
Im folgenden soll betrachtet werden, wie die Regeln f ür die syntaktische Analyse aufgestellt
werden können.
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – Verarbeitung von Eingabedaten
3.6
Definition von Sprachen
Jede Sprache besteht mindestens aus den folgenden Teilen:
❑ dem Alphabet der verwendeten Zeichen - evtl. inklusive von ganzen Worten,
❑ der Syntax, die die Struktur von Sätzen der Sprache beschreibt;
❑ der Semantik, die den Sätzen eine Bedeutung zuordnet, sowie
❑ einem Regelsystem, das angibt, wie man aus syntaktisch korrekten Sätzen neue syntaktisch
korrekte Sätze erzeugen kann.
Ein einfaches Beispiel aus den natürlichen Sprachen ist etwa die Syntaxregel SPO“ für die
”
Wortreihenfolge in englischen Sätzen (Subjekt, Prädikat, Objekt).
Erst die Semantik gibt an, ob ein syntaktisch wohlgeformter Satz auch semantisch (inhaltlich)
wohlgeformt ist:
"0# ein Feiertag
Der 3. !"Oktober# !ißt
!"
# 0!"#
$%'&)(+*-,/.
1325684 7/9 , 6 .
:;&)(+*-,/.
1 %=<,/.
Syntaktisch ist dieser Satz korrekt; semantisch hingegen nicht.
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – Definition von Sprachen
3.7
Definition von Sprachen
Prinzipiell läßt sich eine (Programmier-)Sprache in die folgenden Bestandteile zerlegen:
❑ Feste, reservierte Wörter (auch: Schlüsselwörter), etwa while, boolean;
❑ Konstante oder Literale, wie etwa Zahlen oder Zeichenkettenkonstante;
❑ Sonderzeichen, wie etwa >@?AB?CD?FE .
Aus den Sonderzeichen werden oft Operatoren oder Satzzeichen gebildet.
Teilweise werden auch zwei Zeichen zusammen als ein einziges, neues Zeichen interpretiert: ’ G ’ und ’ H ’ ergibt das Zeichen ’ GIH ’ bzw. ’ J ’.
❑ Namen für Variablen, Objekte, ❑ Kommentare, die durch besondere Zeichen oder Zeichenfolgen eingeleitet werden und bis
zum Ende der Zeile reichen bzw. zu einem entsprechenden Kommentarende“-Zeichen.
”
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – Definition von Sprachen
3.8
Definition von Sprachen
Eine der gebräuchlichsten Formen zur Notation der Syntax von Programmiersprachen ist die
Backus-Naur Form, benannt nach ihren Entwicklern John Backus und Peter Naur, die sie
1959 im Kontext einer der ersten Programmiersprachen (erstmals) vorstellten.
Aus mehreren Gründen ist die Formalisierung von Sachverhalten oft nicht einfach:
❑ In der Umgangssprache wird oft relativ unpräzise gesprochen
❑ Es sind viele implizite Annahmen vorhanden
❑ Es wird massiv auf (unterstelltes) Wissen zurückgegriffen, etwa was natürliche Zahlen
sind, oder was die elementare Arithmetik umfaßt.
❑ Die Bedeutung einiger Wörter ist vom Kontext abhängig: etwa Bank“.
”
Zur Formalisierung müssen alle diese Aspekte sauber ausgearbeitet werden.
Die formale Notation kann jeder Leser auf die gleiche Weise interpretieren – unabh ängig
von sprachlichen oder kulturellen Barrieren.
Zusätzlich kann die Notation von Computern verarbeitet werden und damit erkannt werden,
ob eine gegebene Eingabe syntaktisch korrekt ist.
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – Definition von Sprachen
3.9
Backus-Naur-Form (BNF)
❑ 1959 von John Backus und Peter Naur entwickelt für die Spezifikation von ALGOL-60
❑ Eine BNF definiert eine Grammatik zu einer gegebenen Sprache
❑ Es gibt mehrere verschiedene Notationsformen der Backus-Naur-Form
Aufbau:
Eine BNF besteht aus
❑ einer Menge von Zeichen oder Terminalen“, die Bestandteil des Alphabets sind.
”
Terminale können sowohl Einzelzeichen wie 1 als auch reservierte W örter wie etwa while
sein und werden i.a. nicht gesammelt angegeben.
❑ einer Menge von Hilfszeichen ( Nonterminale“), die zur Erzeugung von Worten
”
dienen, umgeben von K@G ,
❑ einem ausgezeichneten Hilfszeichen, dem Startsymbol
❑ sowie einer Menge von Regeln.
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF
3.10
Form der BNF-Regeln
Die Regeln der BNF haben die folgende Form:
K Nonterminal G
::= beliebige Folge von Terminalen und K Nonterminalen G
❑ Die rechte Regelseite kann auch aus einem einzelnen Nonterminal oder Terminal
bestehen:
K Null G
K Faktor G
::= 0
::= K Zahl G
❑ K A G ::= B“ ist zu lesen als A kann durch B ersetzt werden“, A steht für B“.
”
”
”
❑ B wird auch als Alternative für A bezeichnet.
❑ Die Ersetzung eines Nonterminals durch eine Alternative heißt Ableitungsschritt.
❑ Zusätzlich sind für eine komplette Grammatik anzugeben:
☞ Startsymbol,
☞ Grundmengen, d.h. Startsymbole anderer verwendeter Grammatiken ( Zahl“).
”
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF : Regelform
3.11
Form der BNF-Regeln
Unterschiedliche Regeln für das gleiche Nonterminal werden durch
L
“ getrennt.
”
Falls Ziffer, Zahl Nonterminale, 0, 1 Terminale sind, kann man daher f ür
K Zahl G
K Zahl G
K Ziffer G
K Ziffer G
::=
::=
::=
::=
K Ziffer G
K Ziffer G@K Zahl G
0
1
auch schreiben
K Zahl G
K Ziffer G
oder verkürzt
K Zahl G
K Ziffer G
::=
K Ziffer G
L
K Ziffer GMK Zahl G
::=
0
L
1
::= K Ziffer
G
L
::= 0 1
L
K Ziffer G@K Zahl G
Denkaufgabe: Was kann mit diesen Regeln erzeugt werden?
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF : Regelform
3.12
Darstellung von Ableitungen
Jede aus dem Startsymbol ableitbare Folge von Terminalen ohne Nonterminal wird als Wort
der Sprache bezeichnet. Jedes Wort ist automatisch ein syntaktisch korrektes Element der
Sprache!
Die Angabe der Ableitung eines Wortes
❑ zeigt die durchgeführte Reihenfolge der Ableitungsschritte.
Hieraus läßt sich auch die (implizite) Klammerung“ (etwa Punkt vor Strich“) ablesen.
”
”
❑ beweist, daß das Wort Teil der Sprache ist.
Zusätzlich kann mit Angabe von Ableitungen nachgewiesen werden, daß eine Sprache mehrdeutig ist, es also für ein Wort mehr als eine Ableitung (und damit Interpretation) gibt: im
Deutschen etwa Bank“.
”
Verwendungszweck von Ableitungen
❑ Erzeugen eines konkreten, gegebenen Wortes
In diesem Fall muß die richtige Regelwahl ggf. durch Probieren gefunden werden.
❑ Erzeugen eines beliebigen, gültigen Elements
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF : Ableitungen
3.13
Ableitungssequenz
Aufbau einer Ableitungssequenz
❑ Der erste Eintrag hat die Form K Startsymbol GON V oder K Startsymbol GONPK V G
Für V bzw. K V G ist dabei eine der Alternativen des Startsymbols einzusetzen.
❑ In jedem weiteren Ableitungsschritt wird nun ein Nonterminal des bisher erzeugen Wortes
durch eine seiner Alternativen ersetzt.
Hierzu wird einfach der Pfeil ( N ) angegeben, gefolgt von dem Wort, das durch Ersetzen
des Nonterminals durch seine Alternative entsteht.
Zur Verdeutlichung der Ersetzung kann das ersetzte Nonterminal unterstrichen werden.
❑ Die Ableitungssequenz ist beendet, wenn das Wort rechts des Pfeils keine Nonterminale
mehr enthält oder für die auftretenden Nonterminale keine Ersetzung mehr m öglich ist.
Im ersten Fall hat man ein Wort der Sprache erzeugt, im zweiten Fall handelt es sich um
kein Wort der Sprache.
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF : Ableitungssequenz
3.14
Ableitungssequenz
Beispiel
Erzeugen des Wortes 10“ der Grammatik für Binärzahlen (auf Seite 3.12):
”
L
K Zahl G
::= K Ziffer
G
K Ziffer G@K Zahl G
L
K Ziffer G ::= 0 1
K Zahl G
N
N
N
10
N
K Ziffer G@K Zahl G
1 K Zahl G
1 K Ziffer G
Ersetzen Startsymbol
Weitere Ableitung
Weitere Ableitung
letzter Schritt
❑ Das Wort 10“ enthält keine Nonterminale mehr. Da die Ableitung mit dem Startsymbol
”
K Zahl G begann, ist 10 also ein Wort der Sprache.
❑ 1 K Ziffer G ist kein Wort der Sprache, da es noch ein Nonterminal beinhaltet (analog
für 1 K Zahl G ).
❑ 2 ist ebenfalls kein Wort der Sprache, da das Terminal 2 nicht ableitbar ist.
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF : Ableitungssequenz
3.15
Ableitungsbaum
❑ Angabe der Ersetzung eines Nonterminals durch freie Wahl einer seiner Alternativen.
❑ Aufführung des Nonterminals in einer Zeile, die einzelnen Zeichen der Alternative
eine Zeile darunter.
❑ Zur besseren Übersicht werden Nonterminal und Alternative durch eine Linie verbunden.
❑ Diese Regeln gelten auch für das Startsymbol. Es steht immer in der ersten Zeile.
Im Extremfall entartet der Ableitungsbaum zu einer Liste.
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF : Ableitungsbaum
3.16
Ableitungsbaum
<Zahl>
<Ziffer>
<Zahl>
1
<Ziffer>
0
Abbildung 6: Ableitungsbaum für eine einfache Grammatik
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF : Ableitungsbaum
3.17
Natürliche Zahlen
Natürliche Zahlen sind wie folgt definiert:
❑ Jede Ziffer von 0 bis 9 ist eine natürliche Zahl
❑ Wenn Q eine natürliche Zahl ungleich 0 ist, sind auch Q
?RQ
??=QTS natürliche Zahlen
Diese Definition kann einfach in eine BNF umgesetzt werden:
Startsymbol:
natürlicheZahl
Grundmengen: (keine)
Regeln:
K natürlicheZahl G ::= K Ziffer G
L
K Ziffer ohne 0 G@K Restzahl G
K Ziffer G
K Restzahl G
::=
L
K Ziffer G
K Restzahl G
L
K Ziffer G
::= 0 L K Ziffer
ohne 0 G
L L L L L L L
::= 1 2 3 4 5 6 7 8 9
K Ziffer ohne 0 G
Tabelle 1: BNF für natürliche Zahlen
☞ Wozu dient das Nonterminal Restzahl“?
”
U
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF : Beispiele:
3.18
Ableitungen von natürlichen Zahlen
Hier die Ableitungsbäume für die natürlichen Zahlen 0, 9 und 42:
K natürlicheZahl G
K natürlicheZahl G
K Ziffer G
K Ziffer G
0
K natürlicheZahl G
K Ziffer ohne 0 G
K Ziffer ohne 0 G
4
K Restzahl G
K Ziffer G
K Ziffer ohne 0 G
9
2
Abbildung 7: Ableitungsbäume für natürliche Zahlen
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF : Beispiele:
U
3.19
Ganze Zahlen
Wir erweitern die BNF mit Startsymbol natürlicheZahl nun auf ganze Zahlen.
Ganze Zahlen sind alle natürlichen Zahlen sowie alle natürlichen Zahlen ohne die 0 mit
vorangestelltem -“.
”
Startsymbol:
ganzeZahl
Grundmengen: natürlicheZahl
Regeln:
K ganzeZahl G ::= K natürlicheZahl G
L
- K Ziffer ohne 0 G
L
- K Ziffer ohne 0 G@K Restzahl G
Tabelle 2: BNF für ganze Zahlen
☞ Was bewirkt die Ersetzung der obigen Regel durch
K ganzeZahl G
L
::= K natürlicheZahl G
Informatik I – c Guido Rößling
- K natürlicheZahl G
?
V
Formale Sprachbeschreibung – BNF : Beispiele:
3.20
Ganze Zahlen
Hier die Ableitungsbäume für die ganzen Zahlen 0, 42 und -42:
W
W
W
ganzeZahl X
W
natürlicheZahl X
W
Ziffer X
0
W
W
ganzeZahl X
W
Restzahl X
W
4
W
W
– W Ziffer ohne 0 X
natürlicheZahl X
Ziffer ohne 0 X
ganzeZahl X
4
W
W
Ziffer X
Ziffer ohne 0 X
Restzahl X
Ziffer X
Ziffer ohne 0 X
2
2
Abbildung 8: Ableitungsbäume für ganze Zahlen
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF : Beispiele:
V
3.21
Ein- und Mehrdeutigkeit
Eine wesentliche Frage ist, ob ein gegebenes Wort sich stets auf genau eine Weise ableiten
läßt, also eindeutig ist. Andernfalls läßt sich nicht ohne weiteres entscheiden, welche der
Bedeutungen die tatsächlich intendierte ist.
❑ Ein Wort heißt eindeutig, wenn es nur genau einen Ableitungsbaum zum Erzeugen des
Wortes gibt.
❑ Worte, zu denen es mehr als einen Ableitungsbaum gibt, heißen mehrdeutig.
❑ Grammatiken ohne mehrdeutige Worte heißen eindeutig.
❑ Grammatiken mit mindestens einem mehrdeutigen Wort heißen mehrdeutig.
Wichtig: Abstützung auf Ableitungsbaum, nicht Ableitungssequenz!
Bei der Ersetzung von mehr als einem Nonterminal ist die Reihenfolge hinsichtlich Eindeutigkeit unwesentlich.
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF : Ein- und Mehrdeutigkeit
3.22
Ein- und Mehrdeutigkeit
Betrachten Sie folgende Grammatiken:
Startsymbol:
Formel Y
Grundmengen: Bezeichner
Regeln:
Startsymbol:
Formel Z
Grundmengen: Bezeichner
Regeln:
W
W
W
W
::
\
Term X
::=
\ W
Faktor X
::=
W
Formel Y[X
W
W
W
Term X
W
Formel Y X + Term X
Faktor X
W
Term X^] Faktor X
Bezeichner X
Formel Z_X
W
W
::= Formel Z`X + Formel Z_X
\ W
W
\ W Formel Z`Xa] Formel Z`X
Bezeichner X
Tabelle 3: Ein- und mehrdeutige BNF für Teile der elementaren Arithmetik
☞ Wie kann die Formel
K Bezeichner G + K Bezeichner GbCMK Bezeichner G “
”
in den beiden Grammatiken erzeugt werden? Welcher Unterschied fällt auf?
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF : Ein- und Mehrdeutigkeit
3.23
Elementare Arithmetik
Gegeben sei folgende BNF mit Terminalzeichen + - C / ( ):
Startsymbol:
Formel
Grundmengen: ganzeZahl, Bezeichner
Regeln:
K Formel G ::= K Term G
L
K Formel G + K Term G
L
K Formel G – K Term G
K Term G
K Faktor G
::=
L
K Term GcCdK Faktor G
L
K Term G / K Faktor G
K Faktor G ::= K ganzeZahl G
L
K Bezeichner G
L
( K Formel G )
Tabelle 4: BNF für elementare Arithmetik
Beachten Sie die Ähnlichkeit zur BNF mit Startsymbol Formel der vorigen Folie.
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF für elementare Arithmetik
3.24
Erzeugte Sprache der Grammatik
Welche Eigenschaften hat die BNF der letzten Seite?
❑ Alle mathematischen Ausdrücke mit ganzen Zahlen über den vier Grundoperationen sind
erzeugbar
❑ Es lassen sich nur syntaktisch korrekte Ausdrücke erzeugen
❑ Die BNF beschreibt nur eine Untermenge der mathematischen Ausdr ücke, da zahlreiche
andere Operationen fehlen
❑ Durch die Verwendung mehrerer Nonterminale wird die Einhaltung der Operatorprioritäten gesichert:
a + b C c wird interpretiert als a + (b C c).
❑ Die verwendete Grammatik ist eindeutig.
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – BNF für elementare Arithmetik
3.25
Syntaxdiagramme
Eine alternative gebräuchliche Form der Darstellung von Regeln sind die Syntaxdiagramme.
Sie haben folgenden Aufbau:
❑ Das Nonterminal auf der linken Regelseite wird über die Darstellung gesetzt.
❑ Nonterminale werden in ein rechteckiges Kästchen gesetzt.
❑ Terminale werden in ein rundes Kästchen gesetzt.
❑ Die einzelnen Kästchen werden durch Pfeile verbunden, die die Leserichtung“ angeben.
”
❑ Pfeile können sich aufspalten (Alternativen) oder zusammenlaufen (Ende einer Alternative).
❑ Es führt stets genau ein Pfeil in eine Regel hinein und ein Pfeil aus ihr heraus.
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – Syntaxdiagramme
3.26
Syntaxdiagramme
Eine Ableitung in einem Syntaxdiagramm wird wie folgt erzeugt:
❑ Starte mit dem Diagramm für das Startsymbol.
❑ Folge den Pfeilen; wähle bei Abzweigungen eine beliebige Richtung.
❑ Jedes Terminal kann direkt aufgeschrieben werden.
❑ Jedes Nonterminal muß durch eine mögliche Ableitung ersetzt werden (weiter beim
ersten Schritt, wobei das Nonterminal das Startsymbol“ ist).
”
Formel:
Term:
Faktor:
ganzeZahl
Faktor
Term
Formel
+
Term
Term
*
Faktor
Bezeichner
Formel
-
Term
Term
/
Faktor
(
Formel
)
Abbildung 9: Syntaxdiagramm zur BNF auf Seite 3.24
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – Syntaxdiagramme
3.27
Syntaxdiagramme
Ziffer_ohne_0:
ganzeZahl:
natürlicheZahl
-
1
Ziffer_ohne_0
Restzahl
2
3
natürlicheZahl:
4
Ziffer
5
Ziffer_ohne_0
Restzahl
6
7
Restzahl:
Ziffer:
8
Ziffer
Restzahl
0
9
Ziffer_ohne_0
Abbildung 10: Syntaxdiagramm für ganze Zahlen
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – Syntaxdiagramme
3.28
Zusammenfassung
❑ Für reibungslose Kommunikation müssen einige Punkte geklärt sein (s. auf Seite 3.1).
❑ Mit Hilfe der BNF können die Grammatiken von Sprachen notiert werden.
❑ Die BNF unterstützt die Abbildung von Prioritäten und Präzedenzen.
❑ Ableitungsbäume und -sequenzen dienen
☞ zum Nachweis, daß ein Wort Bestandteil der Sprache ist
☞ sowie zur Angabe der genauen Ableitung des Wortes.
❑ Die meisten BNF-Grammatiken sind rekursiv.
❑ Anstatt der BNF werden teilweise Syntaxdiagramme verwendet.
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – Zusammenfassung
3.29
Vergleich der Darstellungen
Merkmal
Reihenfolge Ableitungsschritte erkennbar
Transparenz der Ersetzungen
Bindungsregeln offenkundig
Geeignet für formale Beweise
Übersichtlichkeit
Fehleranfälligkeit der Ersetzungen
Platzbedarf
Ablesen des erzeugten Worts
Ableitungssequenz
ja
Ableitungsbaum
nein
gering
nein
ja
wenig
hoch
gering
letztes Sequenzelement
groß
ja
eingeschränkt
hoch
gering
hoch
Alle Terminalzeichen im
Ableitungsbaum, gelesen
von links nach rechts
Nachweis, daß ein Wort Bestandteil der Sprache ist: wahlweise durch
❑ Angabe der Ableitungssequenz des Worts
❑ Angabe des Ableitungsbaums des Worts
Informatik I – c Guido Rößling
Formale Sprachbeschreibung – Zusammenfassung : Vergleich der Ableitungsarten
3.30
Motivation der Logik
Logik wird u. a. benötigt für ❑ Mathematische Beweise
❑ Formulieren von Aussagen oder Behauptungen
❑ Schlußfolgerungen
❑ allgemeine, eindeutige Interpretation von Aussagen
Logik wird von Menschen ständig eingesetzt, oftmals ohne sich dessen bewußt zu sein.
Die Logik wird unterteilt in
❑ Aussagenlogik: Lehre von dem Aufbau und der Interpretation von Aussagen
❑ Prädikatenlogik: Einbettung von logischen Funktionen sowie Variablen mit Wertebereich
Informatik I – c Guido Rößling
Logik – Motivation
4.1
Geschichte der Aussagenlogik
❑ Ursprung im Organon (ca. 330 v. Chr.) von Aristoteles (384-322 v. Chr.)
Beinhaltet
☞ Kategorien (Lehre von Klassen von Dingen),
☞ Urteilslehre,
☞ Analytische Untersuchungen (Regeln für gültige Schlußfolgerungen) und
☞ Topische Untersuchungen (Leitsätze für Beweisen oder Widerlegen von Aussagen).
❑ Weiterführung durch Schule der Stoiker (ca. 300 v. Chr.) mit Einf ührung von Variablen
für Aussagen und Aufbau von Wahrheitstabellen.
❑ Mittelalter: Weiterführung u.a. durch Wilhelm von Occam (ca. 1330) und Melanchthon
(ca. 1547).
Insbesondere Einschränkungen von Widerspruchsaussagen aus theologischen Gr ünden.
❑ Neuzeit: Leibniz (um 1700), de Morgan (ca. 1850), Russell/Whitehead (1910)
Informatik I – c Guido Rößling
Logik – Aussagenlogik : Geschichte
4.2
Beispiele für Logik
Oi
❑ Mathematik: Äquivalenzumformungen, etwa eIfghH
gjHlk
Äquivalenzumformungen stellen die Behauptung auf beide Formeln sind äquivalent“.
”
i
darf nur dann gesetzt werden, wenn diese Aussage zutrifft.
Das Äquivalenzzeichen“
”
❑ Aussagen: Heute ist Sonntag.
Heute ist Donnerstag und morgen ist Montag.
❑ Schlußfolgerungen: Wenn es regnet, (dann) wird die Straße naß.
❑ Interpretation von Aussagen:
☞ Sind diese Aussagen wahr oder falsch?
☞ Wovon hängt die Interpretation der Aussage ab?
Informatik I – c Guido Rößling
Logik – Aussagenlogik : Beispiele
4.3
Wozu ist die Logik notwendig?
In den meisten Sprachen sind folgende Problemfelder enthalten:
❑ Mehrdeutige Worte: etwa Bank
❑ Konstruktion widersprüchlicher Aussagen:
Dieser Satz ist falsch.
❑ implizite Verwendung (vermeintlich) feststehender Begriffe und Konventionen.
(Nur) durch logische, sprachunabhängige Regeln läßt sich der Wahrheitsgehalt einer Aussage
bewerten.
☞ Insbesondere in der Mathematik ist es zwingend erforderlich, daß eine gegebene
Aussage von jedem Leser auf die gleiche, eindeutige Art interpretiert wird.
In der Informatik sollten die Aussagen zusätzlich auch vom Computer interpretierbar sein –
dazu wird eine eindeutige Notation und Interpretation ben ötigt, ähnlich wie bei der formalen
Sprachbeschreibung im letzten Abschnitt.
Informatik I – c Guido Rößling
Logik – Aussagenlogik : Beispiele
4.4
Grundbegriffe der Aussagenlogik
❑ Aussagen sind Sätze – mathematisch-logisch oder in natürlicher Sprache –, die wahr oder
falsch sein können.
❑ Aussagen können Variablen beinhalten.
x G 5 ist eine Aussage, deren Wahrheitswert vom Wert von x abhängt.
❑ Eine Aussage ist erfüllt, wenn sie bei einer konkreten Einsetzung aller auftretenden Variablen wahr ist.
Folglich ist die obige Aussage x G 5 beispielsweise für x = 6 erfüllt.
❑ Eine Aussage heißt erfüllbar, wenn es (mindestens) eine Einsetzung aller auftretenden
Variablen gibt, bei der sie erfüllt ist.
Die Aussage x G 5 ist erfüllbar, da sie z.B. für x = 6 erfüllt ist.
❑ Eine Aussage heißt allgemeingültig, wenn sie immer wahr ist, d.h. bei jeder Ersetzung der
Variablen.
Die Aussage x K x+1 ist allgemeingültig.
Informatik I – c Guido Rößling
Logik – Aussagenlogik : Grundbegriffe
4.5
Junktoren und Atomare Aussagen
Im folgenden stehen A und B jeweils für eine Aussage.
Junktoren“ (lat.: Zusammenfügende“) verknüpfen Aussagen miteinander. Es gibt folgende
”
”
Grundjunktoren:
Symbol
m A
An B
Ao B
AN B
Ap B
Name
Negation
Konjunktion
Disjunktion
Implikation
Äquivalenz
Leseweise
nicht A
A und B
A oder B
A impliziert B
A äquivalent B
Tabelle 5: Leseweise der Junktoren
Eine atomare Aussage beinhaltet keinen einzigen Junktor.
☞
Heute ist Freitag“ ist daher eine atomare Aussage, Gestern war
”
”
nicht Freitag“ hingegen nicht (warum?).
Informatik I – c Guido Rößling
Logik – Aussagenlogik : Junktoren
4.6
Wahrheitstabelle der Junktoren
Im folgenden wird wahr“ stets mit T“ (für englisch true“), falsch“ mit F“ für false“
”
”
”
”
”
”
abgekürzt.
Die Wahrheitstabellen sind wie folgt zu lesen:
1. Wahl der Zeile, die die gewünschte Belegung der Variablen bzw. Teilaussagen enthält
2. Nachsehen des Wahrheitswerts des Ergebnisses in der entsprechenden Spalte der Wahrheitstabelle
A
F
F
T
T
B m A An B Ao B AN B Ap B
F T
F
F
T
T
T T
F
T
T
F
F F
F
T
F
F
T F
T
T
T
T
Tabelle 6: Wahrheitstabelle der Junktoren
Informatik I – c Guido Rößling
Logik – Aussagenlogik : Junktoren
4.7
Faustregeln zur Interpretation
❑ Negation: m A ist nur dann erfüllt, wenn A nicht erfüllt ist.
Wie der Name schon sagt, wird bei der Negation der Wahrheitswert umgedreht (negiert).
❑ Konjunktion: A n
❑ Disjunktion: A o
B ist nur dann erfüllt, wenn sowohl A als auch B erfüllt sind.
B ist erfüllt, wenn wenigstens eine der beiden Teilaussagen erf üllt ist.
B ist erfüllt, wenn (A nicht erfüllt ist) oder (sowohl A als auch B
❑ Implikation: A N
erfüllt sind).
Gedankenstütze: Aus etwas Falschem darf man alles schließen; aus
”
etwas Wahrem muß etwas Wahres folgen.“
❑ Äquivalenz: A p
B ist erfüllt, wenn A und B den gleichen Wahrheitswert besitzen, d.h.
beide erfüllt oder beide nicht erfüllt sind.
Informatik I – c Guido Rößling
Logik – Aussagenlogik : Junktoren
4.8
Unterschiede zur Umgangssprache
An folgenden Beispielen weicht z.B. Deutsch stark von der Logik ab:
❑ Negation: verneinte Fragen sowie , nicht wahr?“
”
❑ Konjunktion: Aufzählung oder Zusammenfügung von Sätzen.
Vielfach mit temporaler oder kausaler Bedeutung: und (dann erst, daraufhin, deshalb)“
”
– Sie wurde krank und ging (anschließend) zum Arzt“.
”
❑ Disjunktion: dient oft als (entweder) oder“: Ja oder Nein?“
”
”
❑ Implikation: Die Interpretation ex falsum quodlibet“ ( aus etwas falschem darf alles
”
”
gefolgert werden“) wird selten verwendet.
Vielfach dient die Implikation in der Umgangssprache eher als Äquivalenz.
❑ Äquivalenz: Fast ausschließlich für gleichbedeutende Aussagen verwendet, die sich ineinander überführen lassen (vgl. Äquivalenzumformungen in der Mathematik!), nicht als
Gleichheit der Wahrheitswerte von (möglicherweise) unzusammenhängenden Aussagen.
Logisch ist 10 G 5 p qrJ 3“ wahr, sprachlich aber seltsam bis unverständlich.
”
Informatik I – c Guido Rößling
Logik – Aussagenlogik : Unterschiede zu Deutsch
4.9
Backus-Naur-Form für die Aussagenlogik
Startsymbol: Aussage
Grundmengen: Bezeichner
Regeln:
K Aussage G
K Impl Ausdruck G
K Ausdruck G
K Term G
K Faktor G
::=
K Impl Ausdruck G
L
K Aussage Gsp K Impl Ausdruck G
K Ausdruck G
::=
L
K Impl Ausdruck GcN K Ausdruck G
K Term G
::=
L
K Ausdruck GsotK Term G
K Faktor G
::=
L
K Term GunvK Faktor G
m
K Faktor G
::=
L
( K Aussage
G )
L
L
L
K Bezeichner G
T
F
Tabelle 7: Backus-Naur-Form für die Aussagenlogik
Informatik I – c Guido Rößling
Logik – Aussagenlogik : Backus-Naur-Form
4.10
Syntaxdiagramm für die Aussagenlogik
Impl_Aussage:
Aussage:
Impl_Ausdruck
Aussage
Ausdruck:
Ausdruck
Impl_Ausdruck
Term:
Term
Ausdruck
Term
Faktor
Faktor:
Faktor
(
Aussage
)
T
F
Bezeichner
Abbildung 11: Syntaxdiagramm für Aussagenlogik
Informatik I – c Guido Rößling
Logik – Aussagenlogik : Backus-Naur-Form
4.11
Syntaxdiagramm für die Aussagenlogik
❑ Die Prioritäten der Operatoren können aus der Grammatik abgelesen werden:
je höher die Priorität, desto tiefer im Ableitungsbaum
❑ Alle Operatoren sind linksassoziativ:
a op b op c (( a op b ) op c )
für jeden Operator op außer m “.
”
bedeutet dabei inhaltlich gleichbedeutend“ und ist von p
”
ren.
verschieden zu interpretie-
❑ Die Grammatik ist eindeutig durch die Schachtelung der Ableitungsm öglichkeiten.
❑ Denkaufgabe: Wie ist die folgende Aussage zu klammern?
mxw nzy{oz|}N
Informatik I – c Guido Rößling
~p

Logik – Aussagenlogik : Backus-Naur-Form
4.12
Ableitungsbaum für mw nzyor|}N
~p

<Aussage>
<Aussage>
<Impl_Ausdruck>
<Impl_Ausdruck>
<Ausdruck>
<Impl_Ausdruck>
<Ausdruck>
<Term>
<Ausdruck>
<Term>
<Faktor>
<Ausdruck>
<Term>
<Faktor>
<Bezeichner>
<Term>
<Faktor>
<Bezeichner>
e
<Term>
<Faktor>
<Faktor><Bezeichner>
<Bezeichner>
<Faktor>
d
c
b
<Bezeichner>
a
Abbildung 12: Interpretation von O
Informatik I – c Guido Rößling

Logik – Aussagenlogik : Backus-Naur-Form
_O/O/

R
4.13
Konversionsregeln
Konversionsregeln geben semantisch äquivalente Umformungen von Aussagen an.
I ?
?
stehen im folgenden für beliebige Aussagen,
Nummer
I
1
n
2
3
4
5
6

o
p
n o o n m m m m
m o
o

I
I
n

o
I
n
I
o

Konversion
I

m
m
¢¡
¡
¢¡
¢¡
¡
¡
¤¡
n
I ¡

n
¡

o
I ¡
n£ I ¡
o£ I
m
o
m I
o
p
n
o
o
n
n
o
n
für wahr“ und für falsch“.
”
”
Regelname
Kommutativ-Gesetz
Assoziativ-G.
R¡
R¡
Distributiv-G.
G. von De Morgan
G. der doppelten Negation
G. vom ausgeschlossenen Dritten

Tabelle 8: Konversionsregeln 1-6
Informatik I – c Guido Rößling
Logik – Aussagenlogik : Konversionsregeln
4.14
Konversionsregeln
Nummer
¥ Y
¦
¥ Y
7
8
¥ Y ¥ Z
¨
¥TZ
9
10
11
12
Konversion
§
¦¥ Y ¥ Z
¥©Z
¥ Y ¥ Z

¥ Y O¥ Y

¨
¥«Yª

¥«YªO§

¥ Y B¬¥ Y ¥ Z 
¥ Y O¥ Y

¨
¥«Yª

¥«YªO§

¥«YªB¬¥Yª¥©Z®
¥«Y

¨
¥ Y
¥ Y
¥ Z ªM¥ Z
Regelname
G. vom Widerspruch
G. von der Implikation
¥ Y G. v. d. Äquivalenz
G. der Oder-Vereinfachung
¥Y
¥ Y
¥ Y
¥ Y

G. der Und-Vereinfachung
§
¥Y
¥ Y

G. der Identität
Tabelle 9: Konversionsregeln 7-12
Die Gültigkeit der Konversionsregeln kann über Wertetabellen nachgewiesen werden.
Achtung: Konversionsregeln sind in beiden Richtungen anwendbar!
Informatik I – c Guido Rößling
Logik – Aussagenlogik : Konversionsregeln
4.15
Prädikatenlogik
Bisher sind nur Aussagen mit booleschen Variablen möglich (etwa a o b“).
”
Ziel:
❑ Erweiterung (ohne Angabe der BNF) auf mathematische logische Aussagen, insbesondere
(Un-)Gleichungen.
Damit werden u.a. Aussagen der Form ((a J b) n (a ¯H b)) N (a G b)“ möglich.
”
❑ Verwendung von Variablen mit eingeschränktem Wertebereich
❑ Einbettung von natürlichsprachlichen Aussagen durch ein die Aussage repräsentierendes
Symbol
❑ Aussagen der Form für alle Werte in einem Bereich gilt“ (Verallgemeinerung) bzw. für
”
”
mindestens einen Wert in einem Bereich gilt“ (Existenzaussage).
☞ Vereinfachte Notation komplexer Aussagen (mathematisch, logisch oder
natürlichsprachlich) mit einer oder mehreren Variablen; zusätzlich Ermöglichen von Aussagen mit Variablen über Bereiche.
Informatik I – c Guido Rößling
Logik – Prädikatenlogik
4.16
Prädikatenlogik
Funktion
<
Eine Funktion °²±0³
N
³
ordnet Q Variablen einen Funktionswert zu.
Bekannt sein sollten viele Funktionen auf natürlichen Zahlen, etwa
❑ ´¶µ w ~ · w ¸ : ³ N
❑ y'¹ºQ©»¶¼ : ³ N
³
³
mit ´µ w ª~ · w¸ [g ¡ Hlg
H g
mit y'¹ºQ©»¶¼£ g?R½ ¡ ¾

fg¿f½À>Á½
Prädikat
Prädikate sind
❑ Funktionen
❑ mit einer beliebigen (aber festen) Anzahl Variablen,
❑ deren Ergebnis immer ein Wahrheitswert aus der Menge ÂÄÃ
= Å F, T Æ ist.
❑ Ein Prädikat P wird beispielsweise
notiert als

Ç
Ç
: ³ N È mit g?R½ ¡ H¾gÉGÊ½
Informatik I – c Guido Rößling
Logik – Prädikatenlogik : Prädikate
4.17
Aussagefähigkeit
Bisher darstellbar sind damit:
❑ beliebige Aussagen über Konstanten und booleschen Variablen (Tabelle 7 auf Seite 4.10)
❑ Aussagen mit mathematischen Aussagen (Gleichheit, Ungleichheit) (s. auf Seite 4.16)
❑ natürlichsprachliche Aussagen (s. auf Seite 4.16), sofern ihnen einen Wahrheitswert zugeordnet werden kann.
Natürlichsprachlichen Aussagen wird dabei stets ein Prädikat zugeordnet, etwa der Aussage x ist eine Primzahl“ ein Prädikat Prim(x) mit Prim(x): IN N IB mit
”
Ë
T falls x Primzahl ist
Prim(x) =
F sonst
❑ beliebige Aussagen mit Prädikaten (analog zu Bezeichnern zu betrachten).
Noch gewünscht: Aussagen über bestimmte Wertebereiche; Verallgemeinerungen und
Existenzaussagen.
Informatik I – c Guido Rößling
Logik – Prädikatenlogik : Aussagefähigkeit
4.18
Prädikatenlogische Quantoren
Startsymbol: Aussage (s. Aussagenlogik, BNF auf Seite 4.10)
Grundmengen: Bezeichner, Prädikat (nicht angegeben)
Regeln:
W
Aussage X
8Í Í¢Í
Faktor X
W
W
Quantor X
W
::= Impl Ausdruck X
\ W
W
Aussage XÌ
Impl Ausdruck X
Í¢Í8Í (s. BNF auf Seite 4.10)
W
::=
Quantor X
\ W
Quantor X
W
W
::= Î
Bezeichner X . ( Aussage X )
\ Ï W
W
Bezeichner X . ( Aussage X )
\
W
\ ( Aussage X )
T
\
F
\ W
\ W Bezeichner X
Prädikat X
Tabelle 10: BNF für die Prädikatenlogik
Informatik I – c Guido Rößling
Logik – Prädikatenlogik : Quantoren
4.19
Existenzquantor Ð
Interessant sind vielfach Existenzaussagen der Form Es gibt (mindestens) ein g , das das
Ç
”
Prädikat (bzw. eine Aussage Ñ ) erfüllt“.
Definition des Existenzquantors Ð :
ÐDg . (P(x)) bzw. Ð;g . (A)
ist zu lesen als
Ð
g
Ç
[g ¡+¡
Es gibt (mindestens) ein x für das gilt (P(x))
_yÒÓÔÕ `Ñ ¡+¡
(bzw. (A))
Wie sind daher die folgenden Aussagen zu lesen?

❑ ÐDgÕ g
H
e ¡
❑ ÐDgÕ gÖGce ¡
Informatik I – c Guido Rößling
Logik – Prädikatenlogik : Existenzquantor
×
4.20
Allquantor Ø
Zusätzlich sind Verallgemeinerungen wichtig: Alle g erfüllen das Prädikat
”
sage Ñ )“.
Ç
(bzw. die Aus-
Definition des Allquantors Ø :
ØÙg . (P(x)) bzw. Øg . (A)
ist zu lesen als
Ø
g
Ç
g ¡+¡
Für alle x gilt (P(x))
`yÒÓÚÛ `Ñ ¡+¡
(bzw. (A))
Wie sind daher die folgenden Aussagen zu lesen?

❑ ØÙgÕ g
J
¡
❑ ØÙgÕ gÖGce ¡
Informatik I – c Guido Rößling
Logik – Prädikatenlogik : Allquantor
Ü
4.21
Allquantor Ø
Bei beiden Quantoren kann zusätzlich der Bereich der Variablen eingeschränkt werden.
Die Bereichsangabe erfolgt durch einen Doppelpunkt und anschließend den Bereich in der
Form untere Grenze obere Grenze“ bzw. durch Angabe der Menge (etwa ³ ):
”

❑ ÐDgÖ±³ÝÛ [g HßÞà ¡
¡
¡
❑ ØÙgÖ±
Û fgÉG
❑ ØÙgÖ±
Û g
K
(Bitte beachten Sie, daß Aussagen natürlich auch falsch sein können!)
In der BNF sind dazu folgende Regeln einzufügen:
K Quantor G
K Bereich G
Ð^K Bezeichner G : K Bereich G . ( K Aussage G )
::=
L
ØÖK Bezeichner G : K Bereich G . ( K Aussage G )
L
::=
notiert ³ “ etc.
³
³ÖáK natürlicheZahl G
L
”
K natürlicheZahl G âK natürlicheZahl G
Tabelle 11: BNF Prädikatenlogik mit beschränkten Quantoren
Informatik I – c Guido Rößling
Logik – Prädikatenlogik : Allquantor
Ü
4.22
Auswertung der Quantoren
Der Wahrheitswert einer Aussage mit Existenzquantor wird wie folgt bestimmt:
1. Anlegen Zwischenergebnis“ mit dem Anfangswert falsch“
”
”
2. Falls der Bereich der Variablen leer ist, bei Schritt 7 fortfahren.
3. Wähle und entferne einen beliebigen Wert aus dem Bereich.
4. Bestimmen des Wahrheitswerts der Aussage für den gewählten Wert.
5. Verknüpfen dieses Werts mit dem Zwischenergebnis durch o (=oder); Erhalten eines
neuen Zwischenergebnisses.
6. Fortfahren mit Schritt 3 (beachten: der Bereich schrumpft mit jedem Durchlauf um
ein Element!), falls Zwischenergebnis falsch“, sonst Schritt 7.
”
7. Das Zwischenergebnis“ ist das Endergebnis.
”
Der Existenzquantor ist damit ein oder“ auf allen Elementen eines Bereichs. Bei leeren Be”
reichen ist das Ergebnis falsch“.
”
Informatik I – c Guido Rößling
Logik – Prädikatenlogik : Auswertung der Quantoren
4.23
Auswertung der Quantoren
Der Wahrheitswert einer Aussage mit Allquantor wird wie folgt bestimmt:
1. Anlegen Zwischenergebnis“ mit dem Anfangswert wahr“
”
”
2. Falls der Bereich der Variablen leer ist, bei Schritt 7 fortfahren.
3. Wähle und entferne einen beliebigen Wert aus dem Bereich.
4. Bestimmen des Wahrheitswerts der Aussage für den gewählten Wert.
5. Verknüpfen dieses Werts mit dem Zwischenergebnis durch n (=und); Erhalten eines
neuen Zwischenergebnisses.
6. Fortfahren mit Schritt 3 (beachten: der Bereich schrumpft mit jedem Durchlauf um
ein Element!), falls Zwischenergebnis wahr“, sonst Schritt 7.
”
7. Das Zwischenergebnis“ ist das Endergebnis.
”
Der Allquantor ist damit ein und“ auf allen Elementen eines Bereichs. Bei leeren Bereichen
”
ist das Ergebnis wahr“.
”
Informatik I – c Guido Rößling
Logik – Prädikatenlogik : Auswertung der Quantoren
4.24
Auswertung der Quantoren
Bei unendlichen Mengen, etwa ³ , tritt ein Problem auf: Die Auswertung kann nicht f ür alle
Elemente erfolgen, da es unendlich viele gibt.
❑ Vereinfachung: Die Auswertung von Ð (bzw. Ø ) kann abgebrochen werden, sobald ein
Element gefunden wurde, das die Aussage wahr (bzw. falsch) werden läßt.
❑ Dennoch sind viele Aussagen nicht auswertbar: Ð;g
bestimmbar ohne Zusatzwissen aus der Arithmetik.
±³Àäãåg
H
æ¶ç
ist maschinell nicht
❑ In der Praxis werden Aussagen auf endliche Bereiche, etwa Intervalle der nat ürlichen
Zahlen, beschränkt.
Sonderform des Existenzquantors: der Einsquantor ÐÙè es gibt genau ein“ (Syntax wie Exi”
stenzquantor).
Interpretation:
ÐÙèég Informatik I – c Guido Rößling
Ç
g ¡/¡ Ð;g Ç
Ç
g ¡ n ÛØ½ê [½ ¡ p
Logik – Prädikatenlogik : Auswertung der Quantoren
gjH¾½ ¡+¡/¡
4.25
Motivation der Algorithmentheorie
Die Algorithmentheorie beschäftigt sich u.a. mit folgenden Gebieten:
❑ Berechenbarkeit von Funktionen: gibt es ein Programm, das f ür alle Eingaben die gegebene Funktion berechnet?
❑ Komplexität: In welcher Größenordnung befinden sich Zeit- bzw. Platzbedarf der Funktion?
❑ Rekursion: in vielen Fällen einfachere Darstellung von Funktionen
❑ Parallelität: Wie können Programme parallel ausgeführt werden? Welche Vorteile bietet
es? Wann ist es sinnvoll?
❑ Deterministische Algorithmen, Probabilitische Algorithmen und Heuristiken
❑ Korrektheit von Algorithmen
Je besser man die einzelnen theoretischen Grundlagen kennt, desto besser kann das Ergebnis
der Programmierung sein!
Es gibt nichts praktischeres als eine gute Theorie“ (Goethe) – außer dem Verst ändnis der
”
Theorie.
Informatik I – c Guido Rößling
Berechenbarkeit – Motivation
5.1
Motivation der Berechenbarkeitstheorie
Die Berechenbarkeitstheorie untersucht, ob ein Funktionsergebnis f ür alle, einige oder gar
keinen Parameter bestimmt werden kann.
Generelles Ziel der Berechenbarkeitstheorie ist es dabei,
❑ allgemeine Aussagen zu machen,
❑ unabhängig von der verwendeten Hardware,
❑ dem verwendeten Betriebssystem,
❑ sowie der Programmiersprache.
Aus diesem Grund kann nicht einfach in (beispielsweise) PASCAL argumentiert werden; es
wird eine allgemeine Grundlage für die Berechnung von Funktionen benötigt.
Informatik I – c Guido Rößling
Berechenbarkeit – Motivation
5.2
Berechenbarkeit
❑ Berechenbarkeit von Funktionen auf Zahlen oder Worten
Gibt es ein Programm, daß für alle (oder wenigstens eine eingeschränkte Menge) Eingaben die gegebene Funktion berechnet?
❑ Berechenbarkeit von Mengen von Worten
Ist eine gegebene Eingabe Element der Menge? Die Menge liegt dabei nicht als Aufz ählung
in Form einer Liste vor, sondern durch eine Beschreibung der Eigenschaften, die alle Elemente besitzen.
Es gibt dabei folgende Kategorien von Berechenbarkeit:
☞ Für jede Eingabe stoppt die Berechnung irgendwann und liefert als Ergebnis ja“ bzw.
”
nein“ ë
entscheidbar“
”
”
☞ Für jedes Element der Menge stoppt die Berechnung mit Ergebnis ja“. Bei allen ande”
ren Eingaben darf die Berechnung ggf. unendlich lange laufen
rekursiv aufzählbar“ oder semi-entscheidbar“
ë
”
”
☞ Die Berechnung erfüllt keine der beiden Bedingungen, kann also auf jeder Eingabe
nicht rekursiv aufzählbar“
unendlich lange laufen ë
”
Informatik I – c Guido Rößling
Berechenbarkeit – Begriffe
5.3
Berechenbarkeit
❑ Das Komplement einer Menge ì besteht aus allen Elementen der Grundmenge, die nicht
in der Menge ì enthalten sind.
Es wird als ì notiert: gÖí ì p gîí
¯ ì
❑ Jede entscheidbare Menge ist automatisch auch rekursiv aufz ählbar.
☞ Stoppt die Berechnung für jede Eingabe, so stoppt sie insbesondere auch
für alle Elemente der Menge.
❑ Sind sowohl eine Menge ì als auch ihr Komplement ì rekursiv aufz ählbar, so ist M
(und damit auch ì ) entscheidbar.
☞ Idee: Programm A berechnet x í M“, Programm B x í ¯ M“. Da eine der beiden
”
”
Bedingungen erfüllt sein muß, wird eines der beiden Programme stoppen.
Daher wird für jede Eingabe entschieden, ob sie zur Menge gehört (Programm
A stoppt und akzeptiert) oder nicht (Programm B stoppt und akzeptiert).
❑ Das Komplement einer rekursiv aufzählbaren Menge, die aber nicht entscheidbar ist,
ist nicht einmal rekursiv aufzählbar.
Andernfalls wäre nämlich die Menge auch entscheidbar (s.o.).
Informatik I – c Guido Rößling
Berechenbarkeit – Begriffe
5.4
Maschinenmodelle
Es gibt mehrere verschiedene Maschinenmodelle; die wichtigsten sind:
❑ Turingmaschine, benannt nach Alan Turing (1912–1954), entwickelt 1936.
Eine genauere Beschreibung folgt.
❑ RAM (Register-Address Maschine)
Register zum Lesen und Schreiben; elementare Arithmetik sowie Test von Registerinhalten und goto“ (Sprunganweisung).
”
Die Anzahl der Register sowie die Größe der Zahlen ist unbegrenzt.
❑ sowie ï -rekursive Funktionen.
Ein mathematischer Funktionenkalkül mit wenigen Grundfunktionen und der Möglichkeit, aus bereits beschriebenen Funktionen neue zusammenzusetzen.
Informatik I – c Guido Rößling
Berechenbarkeit – Maschinenmodelle
5.5
Turingmaschinen
Prinzipiell besteht eine Turingmaschine aus folgenden Komponenten:
❑ Ein unendlich langes Band von Einzelzellen.
Jede Zelle enthält stets genau ein Zeichen aus dem Alphabet.
Der Anfangswert unbenutzter Felder ist ein Leerzeichen“ (oft B für Blank“).
”
”
❑ einer Menge von Zuständen (grob vergleichbar zu Programmzeilen),
❑ einem Startzustand,
❑ beliebig vielen akzeptierenden Endzuständen,
Endzustände dürfen dabei keine Befehle enthalten.
❑ einem Schreib-/Lesekopf auf dem Band,
❑ sowie einem Programm.
Informatik I – c Guido Rößling
Berechenbarkeit – Turingmaschine
5.6
Schematischer Aufbau
δ
q
0
q1
q
0
1
B
(q0,1,R)(q0,0,R)(q1,B,L)
(q1,0,L)(q1,1,L) (q2,B,R)
2
òó
Programm
δ
der
Turingmaschine
òó
òó
òó
òó
òó
ñ8ñ
Schreib-/Lesekopf
... B B B B 0 1 1 0 1 0 1 1 0 0 1 0 1 1 0 0 0 1 1 0 B B ...
ð
unendlich langes ð8
Band
Abbildung 13: Schematischer Aufbau einer Turingmaschine
Informatik I – c Guido Rößling
Berechenbarkeit – Turingmaschine : Schematischer Aufbau
5.7
Turingmaschinen-Programme
Generell haben Befehle des Turingmaschinen-Programms die folgende Form:
ô
`´ 9 ? w ¡ H
_´ ( ?5y , D)
õ ö?÷õâø sind Zustände der Turingmaschine. ´ 9 ist dabei der Zustand beim Lesen des Zei❑
chens, ´ der Zustand nach Ausführung des Befehls ( Folgezustand“)
”
❑ a, b sind Zeichen aus dem Alphabet. a ist dabei das Zeichen, das auf dem Band gelesen
wurde, b das zu schreibende Zeichen, das a ersetzt.
❑ D ist die Richtung, in die der Schreib-/Lesekopf nach Bearbeiten des Befehls zu bewegen
ist. Mögliche Werte sind L (=nach Links), R (=nach Rechts) und N (=nicht bewegen).
Die Turingmaschine kann also in einem Rechenschritt
❑ den Zustand wechseln zum Folgezustand,
❑ das gelesene Zeichen auf dem Band durch ein anderes ersetzen,
❑ und ggf. den Kopf um eine Zelle nach links oder rechts bewegen.
Informatik I – c Guido Rößling
Berechenbarkeit – Turingmaschine : Programme
5.8
Turingmaschinen-Programme
ô
_´ù , 0) = ( ´ù , 1, R)“
”
Dieser Befehl bewirkt folgendes, falls sich die Turingmaschine in Zustand ´ ù befindet und auf
der aktuellen Bandposition eine 0 steht:
Beispiel:
❑ Ersetzen der 0 durch eine 1
❑ Bewegen des Kopfes um ein Feld nach rechts auf dem Band
❑ Verbleiben in Zustand ´ ù
Der Befehl wird also solange ausgeführt, wie sich die Turingmaschine in Zustand ´¶ù befindet
und auf der aktuellen Bandposition eine 0 steht.
Ist eine der beiden Bedingungen verletzt, wird der Befehl nicht ausgeführt.
Informatik I – c Guido Rößling
Berechenbarkeit – Turingmaschine : Beispielbefehl
5.9
Programmausführung
Anfangs ist der aktuelle Zustand der Startzustand; der Schreib-/Lesekopf steht auf dem ersten Zeichen der Eingabe.
Nun werden der Reihe nach folgende Schritte ausgeführt:
1. Lese das Zeichen an der aktuellen Kopfposition
2. Falls im Programm für den aktuellen Zustand und das gelesene Zeichen kein Befehl vorliegt, gehe zu Schritt 6.
3. Ersetze das gelesene Zeichen durch das im Befehl vermerkte Zeichen
4. Wechsele den Zustand auf den im Befehl angegebenen Folgezustand
5. Bewege den Kopf ggf. nach links oder rechts und fahre mit Schritt 1 fort.
6. Stoppe die Auswertung.
Falls der aktuelle Zustand ein akzeptierender Endzustand ist, gilt die Berechnung als er”
folgreich“.
Alle Einträge auf dem Band von der Kopfposition bis zum ersten Leerzeichen werden als
Ergebnis interpretiert.
Informatik I – c Guido Rößling
Berechenbarkeit – Turingmaschine : Programmausführung
5.10
Beispiel zur Turingmaschine
Gesucht ist ein Turingmaschinenprogramm zum Invertieren einer Binärzahl, d.h. dem Vertauschen der Nullen und Einsen.
Zu beachten ist dabei, daß es für akzeptierende Endzustände keine Befehle und damit auch
keine weiteren Übergänge gibt.
Außerdem muß der Kopf am Ende auf dem ersten Zeichen des Ergebnisses stehen.
Idee:
1. Es werden zunächst alle Zeichen ersetzt, bis das erste Leerzeichen (als Signal Ende der
”
Eingabe“) erreicht wird.
Damit ist die Zahl invertiert; der Kopf steht hinter dem letzten Zeichen.
2. Es wird über alle Zeichen nach vorne gelaufen, bis das Leerzeichen vor dem ersten Zeichen erreicht wird und nach rechts gegangen.
Der Kopf steht nun auf dem ersten Zeichen der invertierten Zahl.
3. Wechsel in den akzeptierenden Endzustand.
Da keine Befehle vorliegen, stoppt die Turingmaschine.
Informatik I – c Guido Rößling
Berechenbarkeit – Turingmaschine : Beispiel
5.11
Beispiel zur Turingmaschine

❑ Zustände: Å0´ù?5´ ?÷´ Æ
❑ Startzustand: ´ù

❑ akzeptierende Endzustände: Å0´ Æ
Programm:
ô
0
1
B
Kommentar
´ù ( ´ù , 1, R) ( ´ù , 0, R) ( ´ , B, L) Invertieren der Zahlen; Zustandswechsel bei Eingabeende

( ´ , 0, L) ( ´ , 1, L) ( ´ , B, R) Zurücklaufen über die Eingabe bis zum Leerzeichen
´

(steht links vom ersten Zeichen) und Wechsel in ´

´
—
—
—
Stoppen der Bearbeitung; Kopf auf erstem Zeichen
des Ergebnisses
Tabelle 12: Turingmaschinen-Programm zum Invertieren von Binärzahlen
Denkaufgabe: Was passiert, wenn die Eingabe leer war, der Kopf also anfangs auf B steht?
Informatik I – c Guido Rößling
Berechenbarkeit – Turingmaschine : Beispiel
5.12
Church’sche These
Warum die aufwendige Programmierung einer Turingmaschine?
❑ Die Church’sche These sagt aus, daß alle (intuitiv) berechenbaren Funktionen ebenfalls
per Turingmaschine berechenbar sind.
❑ Um die Berechenbarkeit eines Problems nachzuweisen, muß also lediglich ein entsprechendes Turingmaschinenprogramm angegeben werden.
❑ Turingmaschinen sind äquivalent zu RAM, ï -rekursiven Funktionen und z.B. PASCAL.
❑ Um die Nicht-Berechenbarkeit eines Problems zu zeigen, muß ein formaler Beweis gef ührt
werden (wird hier nicht vertieft).
Turingmaschinen werden in allen Gebieten der Algorithmentheorie eingesetzt.
Eine wichtige Menge, die nicht entscheidbar, aber rekursiv aufz ählbar ist, ist das Halteproblem: gegeben ein Programm einer Turingmaschine und eine Eingabe. Stoppt die Maschine bei der Berechnung, oder läuft sie unendlich lange?
Damit kann ebenfalls nicht allgemein entschieden werden, ob ein gegebenes Programm einer beliebigen Programmiersprache sich in einer Endlosschleife befindet oder aber die
Berechnung noch abschließen wird.
Informatik I – c Guido Rößling
Berechenbarkeit – Church’sche These
5.13
Ergebnis
❑ Nicht alle mathematisch definierbaren Funktionen lassen sich maschinell berechnen(!)
❑ Es gibt Mengen, für die nicht allgemein entscheiden werden kann, ob ein gegebenes Element Teil der Menge ist oder nicht
❑ Für viele Mengen lassen sich aber wenigstens die Elemente der Menge aufz ählen.
❑ Typische Probleme bei nicht oder nur partiell berechenbaren Funktionen oder Mengen
sind
☞ unbeschränkte Suche über unendlichen Bereichen (insb. IN)
☞ Benutzung oder Voraussetzung von ebenfalls nicht berechenbaren Funktionen oder
Mengen
☞ Exponentielles Wachstum der Lösungen – ab einem gewissen Q wird (fast) unendlich
viel Platz für das Schreiben der Ausgaben benötigt.
Informatik I – c Guido Rößling
Berechenbarkeit – Ergebnis
5.14
Literatur zur Berechenbarkeit
❑ [Kre93a]
❑ [Hop88]
❑ [Dud93]
❑ [GZZZ95]
Informatik I – c Guido Rößling
Berechenbarkeit – Literatur
5.15
Aufwand von Algorithmen
Jede Operation eines Programms verursacht einen gewissen Aufwand:
❑ Algorithmen verbrauchen Rechenzeit,
❑ Datenstrukturen verbrauchen Speicher.
Der Verbrauch dieser Ressourcen soll möglichst minimal sein, d.h. es stellen sich folgende
Fragen:
❑ Wieviel Ressourcen verbraucht ein gegebener Lösungsansatz?
❑ Was ist der minimale Aufwand zur Lösung des Problems?
Dazu ist die Frage zu präzisieren: Ist die Rede vom besten, dem durchschnittlichen oder
dem aufwendigsten Fall?
Informatik I – c Guido Rößling
Komplexität – Motivation
6.1
Entwurfsüberlegungen
Folgende Fragen sollte man sich stellen, bevor man Datenstrukturen und Algorithmen entwickelt bzw. verwendet:
❑ Für welchen Zweck soll der Einsatz erfolgen?
❑ Welche Operationen werden unbedingt benötigt, welche hingegen nicht?
❑ Welche Operationen werden am häufigsten verwendet? Welche sind typisch?
❑ Mit welchem Aufwand ist bei den einzelnen Operationen zu rechnen?
Wir wollen nun die letzte Frage näher betrachten, da sie für die Entscheidung für oder gegen
bestimmte Datenstrukturen oder Algorithmen eine große Rolle spielen kann.
Informatik I – c Guido Rößling
Komplexität – Motivation
6.2
Begriffe
Folgende Begriffe werden bei der Aufwandsuntersuchung benutzt:
❑ Problemumfang Q : meist der Wert oder die Stellenanzahl der Eingabe
❑ Zeitaufwand: Abstraktion von konkreten Zeiten zu Größenordnungen
❑ Platzbedarf : konkrete Berechnung des Speicherbedarfs des Algorithmus
❑ günstigster, durchschnittlicher und ungünstigster Fall, z.B. bei Sortierung.
❑ Komplexität eines Algorithmus: asymptotischer Aufwand (für Q²N ú ) der Implementierung.
❑ Komplexität eines Problems: minimale Komplexität eines Algorithmus zur
Lösung des Problems
Informatik I – c Guido Rößling
Komplexität – Motivation
6.3
Motivation der Komplexitätsbetrachtung
Die Komplexität untersucht also folgende Fragen:
❑ Wieviel Rechenzeit wird für die Ausführung bei gegebener Eingabe in etwa benötigt?
❑ Wie ändert sich die Rechenzeit (größenordnungsmäßig) bei Vergrößerung der Eingabe?
❑ Wieviel Speicher wird für die Ausführung (in Abhängigkeit von der Eingabe) benötigt?
❑ Ist die Rechenzeit des Algorithmus noch zumutbar für große“ Eingaben?
”
Generell wird in der Komplexitätsabschätzung unterschieden nach
❑ (Turingmaschinen)-Zeitkomplexität
Hier wird nur eine sehr grobe, aber wichtige Unterscheidung gemacht.
❑ (Implementierungs-)Zeitkomplexität
Für eine konkrete Implementierung wird das asymptotische Verhalten bestimmt.
❑ Platzbedarf: Wieviel Speicher wird, abhängig von der Eingabe, benötigt?
Informatik I – c Guido Rößling
Komplexität – Motivation
6.4
Motivation
Die Komplexität mißt nicht konkrete Zeiten ( 1456 ms“), da diese u.a. abhängen von
”
❑ Prozessortyp und Taktrate,
❑ Betriebssystem, Arbeits- und ggf. virtuellem Speicher (Gr öße und Zugriffszeit),
❑ Entwicklungs- und Laufzeitumgebung,
❑ Compiler- oder Interpreterversion, Übersetzungsparameter und Optimierung,
❑ Buslast zum Zeitpunkt der Ausführung
❑ sowie Speicherfragmentierung.
Meßergebnisse in Sekunden etc. sind daher
❑ nur in Einzelfällen exakt reproduzierbar,
❑ sehr schwer auf andere Situation (gemäß der obigen Liste) übertragbar
❑ und daher von sehr geringer Aussagefähigkeit.
Informatik I – c Guido Rößling
Komplexität – Motivation
6.5
Nutzen
Wozu wird die Komplexität benötigt?
❑ Vergleichbarkeit von Algorithmen anhand ihres Aufwands
❑ Beurteilung, ob ein gegebener Algorithmus für ein Problem praktisch verwendbar ist
❑ Prognose, wie sich die Laufzeit im Verhältnis zur Problemgröße ändert
Ist der Algorithmus nur bis zu einer bestimmten Problemgr öße akzeptabel?
Im folgenden werden nur Funktionen auf natürlichen Zahlen betrachtet. Die Problemgröße
ist in der Regel der Wert des Parameters.
Auf die Betrachtung des Platz- bzw. Speicherbedarfs wird dabei im folgenden verzichtet.
Informatik I – c Guido Rößling
Komplexität – Motivation : Nutzen
6.6
Elementare Kosten
Zur Bestimmung der Komplexität wird zunächst die Anzahl der Rechenschritte bestimmt.
Dabei werden folgende Faktoren verwendet (etwas vereinfacht):
Operation
Anzahl Rechenschritte
elementare Arithmetik, Vergleich, 1
Wertzuweisung
Ein- und Ausgabe
1
Funktionsaufrufe
Komplexität der Funktion
logische Ausdrücke
gemäß den obigen Faktoren
Fallunterscheidung
Komplexität des logischen Ausdrucks
+ Maximum der Rechenschritte beider Zweige
zusammengesetzte Anweisung
Summe der Kosten der einzelnen Befehle
Schleifen
Falls ¼ Durchläufe:
Initialisierung
+ ¼¾û Komplexität des Schleifenkörpers
+ ¼¾û Komplexität des Weiterzählens
Tabelle 13: Faktoren für die Komplexität
Informatik I – c Guido Rößling
Komplexität – Elementare Kosten
6.7
Ein Beispiel
Wieviele Rechenschritte führt das auf Seite 6.9 angegebene Programmstück aus?
❑ Verwenden Sie die Faktoren von Folie auf Seite 6.7
❑ Faktoren hintereinander ausgeführter Befehle werden addiert
❑ Bei Schleifen wird die (maximale) Anzahl der Durchläufe mit den Kosten des Schleifenkörpers multipliziert
Informatik I – c Guido Rößling
Komplexität – Elementare Kosten : Beispiel
6.8
Ein Beispiel
ü
/ ]3]
] i s t P r i m t e s t e t , ob n prim i s t und l i e f e r t
] /
p u b l i c boolean i s t P r i m ( i n t n )
ü
boolean i s t P r i m = t r u e ;
i n t i =2 ;
W
if ( n 2)
return f a l s e ;
W
w h i l e ( i s t P r i m && i n )
if (( n % i ) == 0)
istPrim = false ;
i ++;
ý
ý
return i s t P r i m ;
Informatik I – c Guido Rößling
t r u e bzw . f a l s e .
/ / Default : Primzahl
/ / Zaehler fuer die S c h l e i f e
/ / Die k l e i n s t e P r i m z a h l i s t 2
/ / Bei e r s t e m T e i l e r a b b r e c h e n !
/ / F a l l s n%i ==0 , i s t n n i c h t prim .
/ / weitergehen
/ / Ergebnis z u r u e c k l i e f e r n
Komplexität – Elementare Kosten : Beispiel
6.9
Ein Beispiel
ü p u b l i c boolean i s t P r i m ( i n t n )
ü
boolean i s t P r i m = t r u e ;
i n t i =2 ;
W
if ( n 2 )
return f a l s e ;
W
w h i l e ( i s t P r i m && i n )
if (( n % i ) == 0 )
istPrim = false ;
i ++;
ý
ý
//
//
//
//
//
Wertzuweisung :
1
Wertzuweisung :
1
Vergleich :
1
Befehl :
( e n t f a e l l t , da Fkt . ende )
2 V e r g l e i c h e : ( nþ 2 ) ] ( 2
/ / Arithm . , Vergl . :
/ / Wertzuweisung :
/ / Wertzuweisung :
return i s t P r i m ;
/ / Befehl :
Insgesamt werden daher >
Rechenschritte ausgeführt.
>
>ÿ QrA
¡
f >
>
+ 2
+ 1
+ 1)
>
1
¡
>
= k >à f QrA
¡
= à fFQ A
Die Anzahl der auszuführenden Rechenschritte hängt hier also linear von Q ab.
Informatik I – c Guido Rößling
Komplexität – Elementare Kosten : Beispiel
6.10
O-Notation
Wie bereits erwähnt, interessiert nur das grundsätzliche Verhalten des Algorithmus für größer
werdende Eingaben.
Hierzu gibt es die O-Notation“, die eine Einteilung der Algorithmen in Gr ößenordnungen
”
erlaubt. Dabei wird von unwesentlichen Konstanten abstrahiert.
❑ Sei ° Q ¡ die Anzahl auszuführender Rechenschritte für den Algorithmus in Abhängigkeit
von der Problemgröße Q
❑ Q ¡ sei eine von Q abhängige Funktion
❑ Man schreibt ° [Q ¡ Q ¡ Ð| ÛØÙQ -° Q ¡ | f Q ¡/¡/¡
H àQÌA
In unserem Beispiel mit ° Q ¡ ß
kann man also beispielsweise |Hßà und [Q ¡ H¾Q
wählen, denn ØQxÛ `àQhA
àQ ¡
❑ Definition der O-Notation:
° Q ¡ í^ Q ¡+¡ p
Ð|ù -Ðdù ÛØQx Q£Gdù N
° Q ¡
|ù f
Q ¡+¡+¡+¡
Gesprochen ab einem Wert Úù liegt die Komplexität von f unter der |ù -fachen Komple”
xität von g“ oder verkürzt: f liegt in der gleichen Größenordnung wie g“.
”
Informatik I – c Guido Rößling
Komplexität – O-Notation
6.11
Rechenbeispiele
í^ Q ¡ , denn ØÙQ QÁG
N ÞQhA
æ
¡ , denn ØQx Q£Gcà@N k0Qa> æ ❑ f(n) = k0Q^
>
í
^
[
Q

¡
❑ f(n) = Q >
Q A
í a Q : ØÙQ3ãåQG
N Q £
> QrA
❑ f(n) = ÞQrA
ÞQ ¡ mit |ù{HÊÞ3?BùH
? [Q ¡ ¾
H Q
eQ ¡ mit
|ùHÊe3?BùHßà3? [ Q ¡ H¾Q

ç
¡
mit |ùH ? BùH ? [Q l
Q
H Q
Beachten Sie:
❑ Es kommt nicht auf den kleinstmöglichen Startwert Ô
ù an. Statt B
ùÉH
Beispiel hätte man auch ÚùH
wählen können.
à im zweiten
❑ Es kommt nicht auf die kleinstmögliche Konstante |ù an. Im zweiten Beispiel hätte man
wählen können.
statt | ù Hße genausogut | ù H
Die Konstante |ù ist nur ein Multiplikator für die Laufzeit, die unabhängig von der Problemgröße ist und daher für die Einteilung in Klassen vernachlässigt werden kann.
❑ Unter mehreren möglichen Komplexitätsklassen ist stets die kleinste zu wählen.
Q und somit ÞQÔA
í^ Q ¡ , diese Aussage ist aber
So gilt zwar rechnerisch ÞQA
nicht konstruktiv und daher zu unterlassen.
<
❑ Faustregel: der höchste Exponent bzw. die höchste Basis ( ?5Þ
Informatik I – c Guido Rößling
<
etc.) dominiert.
Komplexität – Rechenbeispiele
6.12
Weitere Symbole
Die O-Notation“ geht auf den Zahlentheoretiker Edmund Landau (1877-1938) zur ück, das
”
O“ wird daher auch als Landau’sches Symbol“ bezeichnet.
”
”
+
¡
¡
a Q bezeichnet dabei eine ganze Klasse von Funktionen; so liegen in ^ [Q ¡ alle Funktionen, die maximal linear mit Q wachsen.
Es gibt insgesamt drei verschiedene Symbole:
❑ ° Q ¡ ía Q +¡ ¡ :
° Q ¡ wächst höchstens so schnell wie [Q ¡ “ (obere Schranke)
”
¡
+
¡
¡
❑ ° Q í Q : ° Q ¡ wächst mindestens so schnell wie Q ¡ “ (untere Schranke)
”
¡
+
¡
¡
❑ ° Q í@ Q : ° Q ¡ wächst genauso schnell wie Q ¡ “ (exakte Schranke)
”
Informatik I – c Guido Rößling
Komplexität – Rechenbeispiele
6.13
Weitere Symbole
c 2* g(n)
f(n)
c * g(n)
f(n)
f ε O(g)
f(n)
c 1* g(n)
c * g(n)
f ε Ω(g)
f ε Θ(g)
Abbildung 14: Schema von und Informatik I – c Guido Rößling
Komplexität – Rechenbeispiele
6.14
Komplexitätsklassen
Die folgende Tabelle enthält die wichtigsten Komplexitätsklassen:
Klasse
Leseweise
Die Rechenzeit ist unabhängig von der Problemgröße.
Die Rechenzeit wächst logarithmisch (zur Basis 2) mit
der Problemgröße.
Die Rechenzeit wächst linear mit der Problemgröße.
^ Q ¡
¡
^ QzfQ Die Rechenzeit wächst linear logarithmisch mit der
Problemgröße.

¡
^ Q
Die Rechenzeit wächst quadratisch mit der Problemgröße.
Die Rechenzeit wächst kubisch mit der Problemgröße.
^ Q < ¡
¡
^ Die Rechenzeit wächst exponentiell (zur Basis 2) mit
der Problemgröße.
^ ¡
^ Q ¡
Tabelle 14: Die wichtigsten Komplexitätsklassen
Informatik I – c Guido Rößling
Komplexität – Komplexitätsklassen
6.15
Beispiele zu den Komplexitätsklassen
a ¡
a xQ
a Q
¡
¡
a Q"Q
¡
Informatik I – c Guido Rößling
Tritt ein, wenn das Programm nur einmal linear durchlaufen wird, ohne
von der Problemgröße abzuhängen (d.h. auch ohne Schleifen über Q )
☞ konstante Laufzeit“
”
Die Rechenzeit wächst logarithmisch zur Problemgröße.
Häufig bei Zerlegung von Problemen in Teilprobleme und Berechnung
eines der Teilprobleme
Beispiel: Binäre Suche
Lineare Zunahme der Rechenzeit mit Q .
Typischer Vertreter sind Schleifen von ¹êRQ (¹K Q ) sowie alle Operationen, die jedes Element genau ! -mal referenzieren f ür ein von Q
unabhängiges ! .
Beispiel: Invertieren eines Bildes; Sequentielle Suche
Linear logarithmische Zunahme der Rechenzeit.
Typisch bei Zerlegung des Problems in Teilprobleme mit Bearbeitung
aller Teilprobleme.
Beispiel: Bessere Sortierverfahren, etwa Quicksort
Komplexität – Komplexitätsklassen : Beispiele
6.16
Beispiele zu den Komplexitätsklassen

^ Q
^ Q
^ ¡
¡
< ¡
^ Qxè ¡
Quadratische Zunahme der Rechenzeit mit Q .
Typisch bei verschachtelten Schleifen.
Beispiel: Paarweiser Vergleich aller Elemente bei naheliegendem“
”
Sortierverfahren.
Kubische Zunahme der Rechenzeit mit Q .
Typisch bei dreifach verschachtelten Schleifen.
<
%
Beispiel: Matrixmultiplikation mit | 9$# ( H ', & w 9$# , f¶y , # (
Exponentielle Zunahme der Rechenzeit (zur Basis 2).
Typisch bei der erschöpfenden Suche in allen Kombinationen von Paaren oder Teilmengen.
Zunahme gemäß Fakultätsfunktion.
Tritt bei der Bildung aller Permutationen auf.
Auf den beiden nächsten Folien sind Diagramme für das Wachstum dieser Funktionen angegeben.
Informatik I – c Guido Rößling
Komplexität – Komplexitätsklassen : Beispiele
6.17
Verhalten Grundfunktionen
Verhalten fuer n=1,...,5
140
1
log(n)
n
n*log(n)
n^2
n^3
2^n
120
n^3
100
f(n)
80
60
40
2^n
n^2
n*log(n)
n
20
0
1
2
3
n
4
5
Abbildung 15: Verhalten der Funktionen für n=1, Í8Í¢Í ,5
Informatik I – c Guido Rößling
Komplexität – Komplexitätsklassen : Verhalten der Funktionen
6.18
Verhalten Grundfunktionen
Verhalten fuer n=1,...,5
4500
n^2
n^3
2^n
4000
3500
3000
f(n)
2500
2^n
2000
1500
1000
n^3
500
n^2
0
5
6
7
8
9
10
11
12
n
Abbildung 16: Verhalten der Funktionen für n=5, Í8Í¢Í ,12
Informatik I – c Guido Rößling
Komplexität – Komplexitätsklassen : Verhalten der Funktionen
6.19
Verhalten Grundfunktionen
Beispiel für einen 500 Mhz-Rechner mit Rechenzeit Q pro Taktzyklus:
^ + ¡
^
^ n¡
^ n ^ n
¡
^ n ¡
^ n ¡
^ `Þ n ¡
^ n è ¡
n¡

k
n¡
Q
k Q
0
k Q
0
Q
àQ
Q
Q k0Q k0Q Q àQ Þ Q Q Þ Q à Q k Q àQ à Q k Q Q ï e
Q Þï ï Þ
e
Þ
à¼
Wert von n
à
Q Q Q Q ï ï Þ
Q àk0Q Þ
Q ï àeï eS k .S- ~
æ w
à f
à,+
àk
f
Q
Q
æ à Q
ï
e k0ï
àS
) (
SIf
(
w
w
w
k0Q
e àQ
æ S Q
Þ ï
k0¼ ¤
f
æ
(*(
eIf )(
f
w
w
w
Tabelle 15: Berechnungsdauer von n Rechenschritten nach Komplexitätsklasse
Deutlich zu erkennen ist das geringe Wachstum (Addition) bei
Wachstum von n n und das starke Zunehmen von n.
n, das ebenfalls geringe
Aufgrund der Berechnung von n (zur Basis 2) wurden nur Zweierpotenzen verwendet.
Informatik I – c Guido Rößling
Komplexität – Komplexitätsklassen : Verhalten der Funktionen
6.20
Ergebnis zu den Grundfunktionen
❑ Solange Q noch sehr klein ist, verhält sich
❑ Das schnelle Wachstum der Funktionen Q
<
sogar günstiger als etwa Q
und
<
(bis Q HßS )
ist deutlich zu erkennen.
❑ Die Funktionen lassen sich in der in der Tabelle 14 angegebenen Reihenfolge anordnen.
❑ Günstige
Komplexitäten liegen bis ^ Q/ Q ¡

Q ¡ ist ebenfalls noch mit akzeptablem Wachstum verbunden
❑a
Q ¡ ist nur für relativ geringe Q akzeptabel.
❑a
❑ Exponentielles Wachstum vervielfacht die Laufzeit bei Hinzunahme eines Elements
☞ nicht mehr akzeptable Laufzeiten.
Informatik I – c Guido Rößling
Komplexität – Komplexitätsklassen : Ergebnis
6.21
Average, Best und Worst Case
Die Komplexitätstheorie unterscheidet weiter in folgende Kategorien:
❑ worst case-Komplexität ( worst“)
”
Gibt die Komplexität des rechenintensivsten Falls an.
❑ average case-Komplexität ( avg“)
”
Dies gibt die Komplexität des durchschnittlichen Falls an.
❑ best case-Komplexität ( best“)
”
Beschreibt die Komplexität des günstigsten Falls.
Naheliegenderweise gilt
best
avg
worst
Für einige Algorithmen fallen die Komplexitätsklassen zusammen, so daß z.B. avg“ und
”
worst“-case identisch sind, z.B. bei dem Sortierverfahren Sortieren durch Auswahl.
”
Die Bestimmung des tatsächlichen durchschnittlichen“ Falls ist in der Regel nicht trivial.
”
Die übliche Kenngröße eines Algorithmus ist der worst case - es interessiert vor allem, womit
im schlimmsten Fall zu rechnen ist.
Informatik I – c Guido Rößling
Komplexität – Average, Best und Worst Case
6.22
Ergebnisse
❑ Algorithmen lassen sich über ihre Komplexität, d.h. den Aufwand in Abhängigkeit
von der Problemgröße, gruppieren.
❑ Es wird zwischen best, average und worst case Komplexität unterschieden.
Die wichtigste Kategorie ist die worst case-Komplexit ät.
❑ Das Verhalten der Grundfunktionen
wurde auf Seite 6.18 bis 6.20 dargestellt.

❑ Eine Komplexität bis ^ [Q ¡ ist tolerierbar, ^ Q ¡ ist bereits bei mittelgroßen Werten
für Q sehr aufwendig.
<
Exponentielles Wachstum wie ^ ¡ ist für die Praxis inakzeptabel.
❑ Beim Programmieren sollte auf die Komplexität geachtet werden.
Viele schlecht programmierte Algorithmen lassen sich um eine oder sogar zwei Komplexitätsklassen drücken“, wenn ein besserer Ansatz gewählt wird.
”
Informatik I – c Guido Rößling
Komplexität – Ergebnisse
6.23
Einführung in die Rekursion
Ein Objekt (oder Problem, Methode, ) heißt rekursiv, wenn es sich teilweise selbst enth ält:
❑ Russische Holzpuppen (Matrioschka);
❑ Einige Bilder von M. C. Escher;
❑ Fernsehbild, bei dem die Kamera den eigenen Monitor zeigt
Eine Definition heißt rekursiv, wenn das zu definierende teilweise durch sich selbst definiert
wird.
Um zu einem Abschluß zu gelangen, muß die Rekursion irgendwo beendet werden, etwa
durch elementare Fälle oder Objekte, die unmittelbar erklärt werden können.
Andernfalls läßt sich die Rekursion endlos fortsetzen - ohne abschließende Aussage:
Hofstadter’s Law: (aus: [Hof79])
It always takes longer than you expect, even when you
take into account Hofstadter’s Law.
Informatik I – c Guido Rößling
Rekursion – Einführung
7.1
Einführung in die Rekursion
Abbildung 17: Russische Matrioschkas
Jede Puppe enthält wiederum eine kleinere Puppe (bis hin zur kleinsten Puppe).
Informatik I – c Guido Rößling
Rekursion – Einführung
7.2
Einführung in die Rekursion
In der Modellierung und in der Programmierung findet Rekursion häufig Verwendung.
Zur Modellierung von Personen in einem Stammbaum ist es etwa notwendig, daß eine Person
folgende Attribute hat:
❑ Vor- und Nachname,
❑ Geburts- und ggf. Sterbedatum,
❑ Vater, Mutter und Kinder.
Die hervorgehobenen Attribute sind wiederum vom Typ Person: jede Person ist also u.a.
durch andere Personen definiert!
Auch bei vielen Verfahren ist Rekursion häufig. Viele Beispiele stammen direkt aus der Mathematik, wo die rekursive Definition von Funktionen oder Relationen gerne verwendet wird,
da viele rekursive Definitionen elegant und prägnant sind.
Diese Definitionen können in der Regel direkt in Java umgesetzt werden.
Auf den folgenden Folien werden einige Beispiele für rekursive Definitionen gegeben.
Informatik I – c Guido Rößling
Rekursion – Einführung
7.3
Beispiele zu rekursiven Definitionen
In den Sprachdefinitionen der BNF befinden sich zahlreiche Beispiele f ür rekursive Regeln:
L
❑ K Restzahl G ::= K Ziffer G
K Ziffer G@K Restzahl G
Eine Restzahl (aus der Grammatik für natürliche Zahlen auf Seite 3.18) besteht also
aus einer Ziffer gefolgt wiederum von einer Restzahl.
L
K Term GunvK Faktor G
❑ K Term G ::= K Faktor G
Ein Term kann also neben einem Faktor auch wiederum ein Term sein, der durch n
mit einem Faktor verknüpft ist.
Zu beachten ist dabei, daß durch beide Regeln jeweils beliebig lange Sequenzen erzeugt
werden können, bevor eine andere, nicht-rekursive Regel verwendet wird.
Informatik I – c Guido Rößling
Rekursion – Beispiele : BNF
7.4
Beispiele zu rekursiven Definitionen
Einige rekursive mathematische Funktionen :
❑ Fakultätsfunktion ° w ! Q ¡ HlQxè ist für natürliche Zahlen definiert als
Ë
° w
! Q ¡ H¾Q èªH
1
Qzfª QrA
falls Ö
Q H
Q G
falls £
¡
è
Die Fakultätsfunktion gibt die Anzahl möglicher Anordnungen von Q Elementen an.
< ç
ã , :
❑ Binomialkoeffizient y'¹ºQ Q?! ¡ H
0
y'¹ºQ Q?! ¡ H
Q
H
!21
465
3 <7
ã ,87
ç
>
falls !aH
falls QÉ
H !
n ! ¾
9
¯H Q
falls !£¯H
<7 ç
ã ,
Binomialkoeffizienten geben die Anzahl Möglichkeiten an,
Informatik I – c Guido Rößling
!
Elemente aus Q zu wählen.
Rekursion – Beispiele : Mathematik
7.5
Beispiele zu rekursiven Definitionen
❑ Größter gemeinsamer Teiler : d ¼?=Q ¡ für natürliche Zahlen:
;
Ë
d [¼£?=Q ¡ H
¼
;
falls É
Q H
falls Á
Q G
d Qx?R¼=<ÀQ ¡
’%’ ist dabei die Modulo-Operation, d.h. der nach (Ganzzahl-)Division entstehende Rest.
❑ Fibonacci-Zahlen, ursprünglich 1202 von Leonardo Pisano definiert:
°ä¹/y0 Q ¡ H
465
3
°¦¹+y0 [QhA
¡
>î°¦¹+y0 [QrA
¡
Q H
falls É
falls É
Q H
falls Á
Q G
Die Fibonacci-Zahlen dienten anfangs als (abstrakte) Rechenaufgabe zur Fortpflanzung
von Kaninchen, haben aber einige interessante Anwendungen, etwa den Goldenen Schnitt.
Der Goldene Schnitt ist ein geometrischer Faktor, der zur ästhetisch möglichst ansprechenden Aufteilung von Flächen und Strecken in harmonischem Verhältnis dient und in
vielen Gemälden des Mittelalters Verwendung findet.
Informatik I – c Guido Rößling
Rekursion – Beispiele : Mathematik
7.6
Beispiele zu rekursiven Definitionen
In allen angegebenen Beispielen ist es sehr einfach, direkt aus der Definition eine entsprechende Java-Methode zu programmieren.
Das darf aber nicht darüber hinwegtäuschen, daß die Berechnung eines konkreten Ergebnis-<
ses sehr zeitaufwendig sein kann: so benötigt etwa die Berechnung von °ä¹/y0 Q ¡ ungefähr
Rechenschritte.
Zur Begründung: Für QG
ist die Anzahl Rechenschritte ° Q ¡ Hs° [Q A ¡ >@° [Q A ¡ > .
¡>
¡? fª° QÉA ¡ und man erhält damit
Daher
gilt
f

É
Q
A

°
[
Q

<7 <7 ° Q ¡
.
Im Abschnitt Komplexität“ auf Seite 6.4f wird eine nähere Bestimmung des Aufwands
”
durchgeführt.
Informatik I – c Guido Rößling
Rekursion – Beispiele : Mathematik
7.7
Allgemeines
Generell lassen sich rekursive Definitionen in zwei Teile aufteilen:
❑ den Rekursionsanker
❑ und den Rekursionsschritt.
Der Rekursionsanker definiert den Wert für eine bestimmte Eingabe durch eine nicht-rekursive Formel. Es kann sich dabei um einen einfachen Zahlenwert handeln, aber auch um eine
(andere) Formel. Es kann auch für mehr als eine Eingabe einen Rekursionsanker geben (vgl.
Fibonacci-Zahlen).
Der Rekursionsschritt hingegen definiert den Wert für eine bestimmte Eingabe durch den Wert
für eine andere Eingabe. In der Regel wird dabei ein Schritt in Richtung des Rekursionsankers
gemacht, d.h. es wird z.B. immer die Eingabe um eins heruntergezählt.
☞ Was ist in der folgenden Formel der Rekursionsanker, was der Rekursionsschritt?
Was wird definiert?
<
falls
gêù
Ö
Q
H
6
4
5
<7 %
9& ù
Informatik I – c Guido Rößling
g 9 H
3
g < >
%
9& ù
g 9
Rekursion – Allgemeines
falls Q£G
7.8
Summenformel
%
Beispiel: Zu berechnen sei die Summe der Werte g 9 für ¹ H
%

9& ù
g 9 H
g
H
H
%

g
>

>
"
?? .
9 & #ù
g >
>Ág >
g 9
!
ù
&
" 9 #ù
gäù
g 9
!
Rekursive Definitionen sind im allgemeinen
❑ kürzer,
❑ leichter verständlich und
❑ einfacher nachzubilden (d.h. zu implementieren)
als herkömmliche“ iterative Definitionen.
” Informatik I – c Guido Rößling
Rekursion – Allgemeines : Summenformel
7.9
Bekannte rekursive Algorithmen
Folgende Algorithmen bzw. Vorgehensweisen sind einigen von Ihnen vielleicht bekannt:
❑ Quicksort
Ein einfaches Sortierverfahren, das in vielen Fällen sehr schnell ist.
❑ Türme von Hanoi
Umsortieren von Scheiben unterschiedlicher Größe von einem Stab auf einen anderen
unter Zuhilfenahme eines dritten Stabs.
❑ 8-Damenproblem
Anordnung von 8 Damen auf einem Schachbrett, so daß keine Dame eine andere schlagen
kann.
❑ Backtracking
Systematisches Ausprobieren eines Ansatzes mit anschließender R ückverfolgung der
Schritte und Wahl von Alternativen.
❑ Einige Operationen auf Datenstrukturen, z.B. Bäumen
Insbesondere die Operationen Suchen, Einfügen
Informatik I – c Guido Rößling
Rekursion – Allgemeines : Bekannte Algorithmen
7.10
Arten von Rekursion
❑ Wechselseitige Rekursion (auch: indirekte Rekursion)
m ruft eine andere Methode n auf, die wiederum m aufruft.
❑ Endrekursion (engl. tail recursion)
¼ wird in der Rekursion als letztes verwendet.
Ë
° g ¡ H
Ç
[ g ¡
° · g ¡+¡
Ç
falls g ¡
Ç
falls m [ g ¡
g ¡ ist dabei eine boole’sche Funktion und · g ¡ eine beliebige Funktion oder Anweisungsfolge, die nicht auf ° zurückgreift.
❑ Lineare Rekursion (allgemeinste Form der Rekursion)
Ë
° [g ¡ H
g ¡
+T g?'° · [g ¡+¡/¡
Ç
falls g ¡
Ç
falls m g ¡
+T g?'° [· g
¡+¡+¡ ist dabei eine zusätzliche Funktion. Dieser Fall liegt z.B. bei der Fakultäts
Ç
funktion für +T g?R½ ¡ Hlg¿f½Ù?R·; g ¡ H¾g A ? g ¡ H ? g ¡ H gjH}H ¡ .
Informatik I – c Guido Rößling
Rekursion – Arten von Rekursion
7.11
Türme von Hanoi
Ein vielzitiertes Problem für Rekursion sind die Türme von Hanoi.
Das 1883 von dem französischen Mathematiker Eduard Lucas erfundene Spiel“ ist wie folgt
”
definiert:
Ein Mönchsorden in Benares (Indien) besitzt den Turm des Brahma“, der aus drei
”
Stäben besteht, auf die 64 goldene Scheiben verteilt sind. Die Scheiben sind alle unterschiedlich groß und daher auch unterschiedlich schwer.
Anfangs befinden sich alle Scheiben auf dem linken Stab. Die M önche haben nun die
Aufgabe, alle Scheiben auf den mittleren Stab zu verschieben, wobei sie aber immer
nur eine Scheibe bewegen dürfen.
Aufgrund des Gewichts der Scheiben darf nie eine Scheibe auf einer kleineren Scheibe
liegen.
Wenn alle Scheiben korrekt verschoben wurden, ist die Aufgabe des M önchsordens
gelöst und die Welt geht unter.
Wie können die Mönche ihr Problem möglichst einfach und elegant lösen ?
Informatik I – c Guido Rößling
Rekursion – Arten von Rekursion : Türme von Hanoi
7.12
Türme von Hanoi
Ein paar Vorüberlegungen:
1. Wann kann die unterste Scheibe bewegt werden?
2. Wohin muß die unterste Scheibe geschoben werden?
3. Wie sieht die Lösung für Q H
4. Wie sieht die Lösung für Q H
Scheibe aus?
aus?
5. und die Lösung für QÖHßÞ Scheiben?
6. ☞ Welcher Bezug besteht zwischen den Lösungen?
Informatik I – c Guido Rößling
Rekursion – Arten von Rekursion : Türme von Hanoi
7.13
Türme von Hanoi
Prinzipiell wird das Problem ausschließlich durch das Verschieben von einzelnen Scheiben
gelöst. Es macht aber Sinn, eine feste Methode vorzugeben, die das Verschieben der Scheibe
¹ von Stab A nach Stab B erlaubt.
Gegeben sei also eine Methode bewege(i, A, B), die genau dies tut.
auf das Problem
Nun muß man sich überlegen, wie sich das Problem für ein konkretes Q£G
für QrA
zurückführen läßt. Dazu betrachten wir die Überlegungen zu den Fragen :
1. Die unterste Scheibe (Nummer Q ) kann nur dann bewegt werden, wenn alle anderen QMA
Scheiben schon vom Stab entfernt wurden.
2. Die unterste Scheibe muß direkt auf den Zielstab gelegt werden.
3. Q H
:
bewege(1, start, ziel)
Informatik I – c Guido Rößling
Rekursion – Arten von Rekursion : Türme von Hanoi
7.14
Türme von Hanoi
4. Q H
:
bewege(1, start, frei)
bewege(2, start, ziel)
bewege(2, start, ziel)
Informatik I – c Guido Rößling
Rekursion – Arten von Rekursion : Türme von Hanoi
7.15
Türme von Hanoi
5. Q HßÞ :
bewege(1, start, ziel)
bewege(2, start, frei)
Rekursion – Arten von Rekursion : Türme von Hanoi
bewege(1, ziel, frei)
bewege(3, start, ziel)
bewege(1, frei, start)
bewege(2, frei, ziel)
bewege(1, start, ziel)
Informatik I – c Guido Rößling
7.16
Türme von Hanoi
Um Scheibe ¹ von Stab A nach Stab B zu bewegen, müssen also folgende Bedingungen erfüllt
sein:
❑ Scheibe ¹ ist die oberste Scheibe auf Stab A;
❑ auf Stab B befindet sich keine kleinere Scheibe als Scheibe ¹ .
Aus diesen Aussagen folgt direkt, daß alle kleineren Scheiben sich auf dem dritten Stab (C)
befinden müssen – unabhängig davon, wie die Zuordnung von A, B, C auf die Stäbe ist.
☞ Zum Verschieben von Scheibe ¹ müssen die Scheiben ? ??R¹TA
Wie kommen die Scheiben ? ? ?R¹«A
dorthin?
☞ Das ist das gleiche Problem wie oben - nur für Scheibe ¹A
Informatik I – c Guido Rößling
auf Stab C liegen.
!
Rekursion – Arten von Rekursion : Türme von Hanoi
7.17
Lösung
Um Q Scheiben von Stab A nach Stab B zu verschieben, geht man also wie folgt vor :
❑ Verschiebe die QhA
oberen Scheiben vom Startstab zum Hilfsstab;
❑ Verschiebe die oberste Scheibe vom Startstab zum Zielstab;
❑ Verschiebe die QhA
Scheiben vom Hilfsstab zum Zielstab.
Für den ersten und den dritten Schritt ist wiederum der gleiche Algorithmus ( hanoi“) ein”
zusetzen.
Eine mögliche Implementierung ist auf den folgenden Folien angegeben.
Informatik I – c Guido Rößling
Rekursion – Arten von Rekursion : Türme von Hanoi
7.18
Lösung
package e i . misc ;
ü
/ ]3]
] D i e s e K l a s s e i m p l e m e n t i e r t das ” Tuerme von Hanoi ” Problem .
] /
p u b l i c c l a s s Hanoi
/ ]3]
] K o n s t a n t e n f u e r d i e Zuordnung der S t a e b e
] /
p r i v a t e s t a t i c f i n a l i n t LINKER STAB = 0 , MITTLERER STAB = 1 ,
RECHTER STAB = 2 ;
/ ]3]
] T e x t f u e r d i e S t a e b e ( h i n t e r ’ vom ’ oder ’ zum ’ , daher D a t i v f o r m )
] /
ü
p r i v a t e s t a t i c f i n a l S t r i n g [ ] STAEBE =
” l i n k e n Stab
”,
” m i t t l e r e n Stab ” ,
ý
” r e c h t e n Stab ” ;
Informatik I – c Guido Rößling
Rekursion – Arten von Rekursion : Türme von Hanoi
7.19
Lösung
/ ]3]
] A n z a h l a u s g e f u e h r t e r Bewegungen
] /
p r i v a t e s t a t i c i n t nrMoves = 0 ;
ü
/ ]3]
] V e r s c h i e b e S c h e i b e n vom S t a b ’ s t a r t ’ zum S t a b ’ z i e l ’ .
]
] G i b t e i n e n p a s s e n d e n T e x t aus und z a e h l t d i e Bewegung .
] /
p r i v a t e void bewege ( i n t n , i n t s t a r t , i n t z i e l )
ý
System . e r r . p r i n t l n ( ” Bewege S c h e i b e ” + n + ” vom ” + STAEBE[ s t a r t ]
+ ” zum ” + STAEBE[ z i e l ] ) ;
nrMoves ++;
Informatik I – c Guido Rößling
Rekursion – Arten von Rekursion : Türme von Hanoi
7.20
Lösung
ü
/ ]3]
] V e r s c h i e b e den Turm der Hoehe n von S t a b ’ von ’ nach S t a b ’ nach ’ u n t e r
] Nutzung von S t a b ’ f r e i ’ .
] /
p u b l i c void h a n o i ( i n t n , i n t von , i n t nach , i n t f r e i )
ü
if ( n == 1)
bewege ( n , von , nach ) ;
else
h a n o i ( n þ 1 , von , f r e i , nach ) ;
bewege ( n , von , nach ) ;
h a n o i ( n þ 1 , f r e i , nach , von ) ;
ý
ý
// direktes
Informatik I – c Guido Rößling
Verschieben moeglich
/ / ( n þ 1) þ Turm a u f ’ f r e i ’
/ / u n t e r s t e Scheibe verschieben
/ / ( n þ 1) þ Turm a u f ’ nach ’
Rekursion – Arten von Rekursion : Türme von Hanoi
7.21
Lösung
ý
ü
/ ]3]
] V e r a r b e i t e d i e Eingabe und g e n e r i e r e e i n n e u e s O b j e k t .
] Erwartet die Anzahl Scheiben als Parameter .
] /
p u b l i c s t a t i c void main ( S t r i n g [ ] a r g s )
ý
Hanoi h a n o i = new Hanoi ( ) ;
h a n o i . h a n o i ( I n t e g e r . v a l u e O f ( a r g s [ 0 ] ) . i n t V a l u e ( ) , LINKER STAB ,
MITTLERER STAB , RECHTER STAB ) ;
System . e r r . p r i n t l n ( nrMoves + ” Bewegungen i n g e s a m t . ” ) ;
Informatik I – c Guido Rößling
Rekursion – Arten von Rekursion : Türme von Hanoi
7.22
Ausgabe des Programms für QÖHlk
Bewege Scheibe 1 vom linken Stab
Bewege Scheibe 2 vom linken Stab
Bewege Scheibe 1 vom rechten Stab
Bewege Scheibe 3 vom linken Stab
Bewege Scheibe 1 vom mittleren Stab
Bewege Scheibe 2 vom mittleren Stab
Bewege Scheibe 1 vom linken Stab
Bewege Scheibe 4 vom linken Stab
Bewege Scheibe 1 vom rechten Stab
Bewege Scheibe 2 vom rechten Stab
Bewege Scheibe 1 vom mittleren Stab
Bewege Scheibe 3 vom rechten Stab
Bewege Scheibe 1 vom linken Stab
Bewege Scheibe 2 vom linken Stab
Bewege Scheibe 1 vom rechten Stab
15 Bewegungen ingesamt.
Informatik I – c Guido Rößling
zum
zum
zum
zum
zum
zum
zum
zum
zum
zum
zum
zum
zum
zum
zum
rechten Stab
mittleren Stab
mittleren Stab
rechten Stab
linken Stab
rechten Stab
rechten Stab
mittleren Stab
mittleren Stab
linken Stab
linken Stab
mittleren Stab
rechten Stab
mittleren Stab
mittleren Stab
Rekursion – Arten von Rekursion : Türme von Hanoi
7.23
Typische Fehler
Folgende Fehler werden bei Rekursion häufig gemacht:
❑ Rekursionsanker fehlt
❑ Rekursionsanker nicht immer erfüllt oder wird übersprungen
❑ Falsche Rekursionsrichtung (zählt hoch, aber Anker bei 0)
❑ Inkorrekte oder fehlende Verarbeitung der Ergebnisse des Rekursionschritts
❑ Rekursionsanker inkorrekt
❑ Rekursionsschritt inkorrekt
❑ Reihenfolge Ergebnisberechnung/Rekursion ungünstig (erst Rekursion)
Informatik I – c Guido Rößling
Rekursion – Typische Fehler bei der Rekursion
7.24
Einsatzgebiete der Parallelverarbeitung
Haupteinsatzgebiet der Parallelverarbeitung sind Anwendungen, die sehr viele Operationen
pro Sekunde benötigen, bzw. mehrere Daten gleichzeitig bearbeiten m üssen.
Typische Vertreter sind etwa
❑ Wettervorhersage
❑ Quantenchemie
❑ Astrophysik
Z.B. Bestimmung und Lokalisierung von Schwarzen Löchern“ anhand der Krümmung
”
von Planetenlaufbahnen
❑ Modellierung der Umwelt
❑ Materialwissenschaft
❑ Künstliche Intelligenz
❑ Komplexe Probleme in der Statik (Bauwissenschaft)
Informatik I – c Guido Rößling
Parallelverarbeitung – Einsatzgebiete
8.1
Architekturen
Unterschiedliche Einzelrechnermodelle:
❑ Herkömmliches Maschinenmodell (von Neumann-Architektur)
Rechner mit einem Prozessor, der zu einem gegebenen Zeitpunkt nur genau einen Befehl
abarbeiten kann und auch nur ein Programm gleichzeitig laufen läßt.
❑ Multitasking-fähiger Rechner
Rechner mit (üblicherweise) einem Prozessor, der (scheinbar) mehrere Programme gleichzeitig ablaufen lassen kann.
In der Praxis besitzt jedes Programm eine Priorität und wird je nach vorhandener Rechenzeit und Ausführungszustand der Programme höherer Priorität abgearbeitet.
❑ Multithreading
Jeder Prozeß auf dem Rechner kann sich in verschiedene Threads aufteilen, die mit geringerer Priorität ausgeführt werden und Unteraufgaben übernehmen.
❑ (Echter) Parallelrechner
Rechner mit mehreren Prozessoren, die geeignet“ miteinander verbunden sind. Jeder Pro”
zessor führt auf den ihm zugeordneten Daten bestimmte Befehle aus.
Informatik I – c Guido Rößling
Parallelverarbeitung – Architekturen
8.2
Architekturen
Eine übliche Unterteilung erfolgt über den Steuerungsmechanismus.
SISD Single Instruction, Single Data – herkömmlicher Rechner mit CPU und Speicher
MISD Multiple Instruction, Single Data – Q Prozessoren f ühren gleichzeitig (verschiedene)
Aktionen auf den selben Daten aus.
Im Prinzip trifft dies eingeschränkt auch auf Pipeline-Architekturen zu, wie etwa bei Pen
tium/Pentium II, bei denen während der Ausführung von Befehl ¹ bereits Befehl ¹ >
gelesen wird.
SIMD Single Instruction, Multiple Data – Q Prozessoren f ühren die selbe Aktion gleichzeitig
auf jeweils unterschiedlichen Daten aus ( Vektor-Rechner“ oder Array-Rechner“).
”
”
Vor allem von Vorteil bei regulären“ Strukturen, z.B. Matrixaddition, wo in allen Teilbe”
reichen die gleiche Operation auszuführen ist.
MIMD Multiple Instruction, Multiple Data – Q Prozessoren f ühren gleichzeitig verschiedene
Aktionen auf unterschiedlichen Daten aus.
Mischformen Systolische Arrays bzw. Wavefront Arrays mit unabhängigen MIMD-Rechnern
und synchronem bzw. asynchronem Betrieb.
Informatik I – c Guido Rößling
Parallelverarbeitung – Architekturen
8.3
Beispiele
❑ Quicksort
Jede Einzelfolge wird von einem eigenen Prozessor sortiert.
❑ Vektorenoperationen (Addition, Subtraktion, Multiplikation und Division)
Jedem Prozessor wird dabei ein Vektorelement (oder mehrere) der beiden Vektoren zugeordnet.
❑ Mandelbrot-Berechnung ( Apfelmännchen“).
”
Die Menge kann in Blöcke zerteilt werden, die unabhängig voneinander berechnet werden.
❑ Bild-, Audio- und Video-Kompressionsverfahren (JPEG bzw. MPEG).
Zur Kompression wird bei diesen Verfahren das Bild in Bl öcke der Größe 8 û 8 zerlegt.
Diese Blöcke können parallel codiert werden.
❑ Spezielle Sortierverfahren (Bitonisches Mischen)
❑ Numbercruncher“-Programme, die beispielsweise versuchen, Codierungen zu knacken
”
(vgl. RSA-Wettbewerbe).
Informatik I – c Guido Rößling
Parallelverarbeitung – Beispiele
8.4
Voraussetzungen
❑ mehrere Prozessoren (oder mindestens Multithreading)
❑ Kommunikationswege zwischen den Prozessoren mit geeigneter“ Topologie.
”
Achtung: bei all to all“ (jeder Prozessor ist mit allen verbunden) ist die maximale Anzahl
”
der Prozessoren durch die Anschlüsse bereits festgelegt.
❑ Ein Master“-Programm oder Prozeß, verantwortlich für
”
☞ Verteilen der Daten auf die Prozessoren oder Worker“
”
Alternativ Verfügbarkeit der Daten in gemeinsamen Speicherraum.
☞ Zuteilung der Anweisungen bzw. Programme an die Worker,
☞ Entgegennahme der Ergebnisse der Worker,
☞ Zusammensetzen der Teilergebnisse zum Gesamtergebnis.
Dazu muß der Master jedem Teilergebnis die ursprüngliche Position im Datenraum
zuordnen können.
Informatik I – c Guido Rößling
Parallelverarbeitung – Voraussetzungen
8.5
Voraussetzungen
❑ Parallelisierbarkeit des Algorithmus:
☞ gleichzeitige Ausführung von (verschiedenen) Befehlen auf den gleichen Daten oder
☞ gleichzeitige Ausführung von gleichen Befehlen auf verschiedenen Daten
muß Vorteile bringen – das ist nicht immer gegeben!
❑ spezielle Umgebung oder Programmiersprache, die Verteilung von Daten oder Befehlen
an Worker unterstützt, etwa OCCAM oder PVM.
❑ Anpassung des Programms an Parallelisierung, etwa durch Implementierung eines spezifischen Masters und Aufteilung der Daten von Hand“.
”
Informatik I – c Guido Rößling
Parallelverarbeitung – Voraussetzungen
8.6
Bewertung
Zur Bewertung des Gewinns bei Parallelverarbeitung wird der Speedup verwendet:
❑ Sei 9 Q ¡ die Laufzeit des Algorithmus bei ¹ Prozessoren und Eingabegr öße Q .
Der Speedup bei Verwendung von @ Prozessoren wird dann definiert als
ACB
Dabei gilt
AB
[Q ¡
@
Q ¡ H
Q ¡

B
Q ¡
.
¡
WähltAman
B ¡ als Basis für Q die Laufzeit eines (optimalen) sequentiellen Algorithmus, so
kann Q auch kleiner als 1 werden.
Dies passiert in der Regel durch
❑ schlechte Parallelisierbarkeit der Daten und des Algorithmus,
❑ Wartezeiten in der Prozeßkommunikation,
❑ zusätzlichen Kommunikationsaufwand sowie
❑ Aufwand zur Aufteilung und Zusammensetzung der Ergebnisse.
Informatik I – c Guido Rößling
Parallelverarbeitung – Bewertung
8.7
Algorithmenklasse
Die entscheidende Frage ist: Wie schnell kann man Probleme mit effizienten sequentiellen
Algorithmen im besten Fall parallel lösen?
Auf Nick Pippenger geht die Klasse NC ( Nick’s Class“) zurück. Elemente dieser Klassen
”
heißen NC-Probleme“ und haben folgende Eigenschaften:
”
❑ Das Problem gilt als effizient parallelisierbar.
❑ Es gibt einen parallelen Algorithmus, der das Problem auf polynomiell vielen Prozessoren
9

in poly-logarithmischer Zeit löst, d.h. in ^ + D Q ¡ ¡ .
Es gilt NC E P, da jeder parallele NC-Algorithmus in Polynomialzeit mit einem einzelnen
Prozessor simulierbar ist.
Bis heute ist ungeklärt, ob auch NC = P gilt, also alle effizienten sequentiellen Algorithmen
effizient parallelisierbar sind. Es wird aber vermutet, daß dies nicht der Fall ist.
Informatik I – c Guido Rößling
Parallelverarbeitung – Algorithmenklasse
8.8
Problemstellungen
❑ Das Programm muß in der Regel die Aufteilung der Daten und Aufgaben explizit vorgeben.
❑ Parallelverarbeitung ist nur dann hilfreich, wenn sich das Gesamtprogramm in einzelne,
möglichst weitgehend unabhängige Probleme aufteilen läßt.
❑ Der Kommunikationsaufwand zwischen den Prozessoren, etwa zur Übertragung der Daten, des Status und der Ergebnisse sind zu berücksichtigen
❑ Wahl der Vernetzung der Prozessoren: jeder mit jedem direkt, über Bus oder Ring, ?
❑ Synchronisation der Prozesse
❑ Master“-Prozeß zur Vergabe der Daten und Entgegennahme der Ergebnisse sowie Zu”
sammenfügung der Daten.
❑ Anzahl der benötigten Prozessoren kontra Anzahl vorhandener Prozessoren
Informatik I – c Guido Rößling
Parallelverarbeitung – Problemstellungen
8.9
Problemstellungen
❑ Lastverteilung an die Prozessoren: Einsparen von Wartezeiten durch Bereitstellen der
Aufgaben und Selbstbedienung“ der Worker
”
❑ Zusammenfügen der Einzelergebnisse.
Hierzu ist in der Regel eine Markierung vorhanden, welchen Eingangsdaten bzw. welcher
Position oder Koordinaten das Ergebnis zugeteilt war, sowie ggf. die Identifikation des
bearbeitenden Workers.
❑ Spezielle Teilprozessoren mit besonderer (aber eingeschränkter) Funktionalität kontra
Verknüpfung von normalen Prozessoren.
❑ Anzahl der Prozessoren wird durch Hardware festgelegt; der Algorithmus muß dem Rechnung tragen
Informatik I – c Guido Rößling
Parallelverarbeitung – Problemstellungen
8.10
Zusammenfassung
❑ Paralleles Abarbeiten auf mehreren Prozessoren kann die Effizienz deutlich erh öhen
❑ Algorithmen müssen an Parallelverarbeitung angepaßt werden, u.a. durch explizite Anweisungen, welche Daten an welche Prozessoren zu leiten sind
❑ Oft Aufteilung in einen Master für Aufteilung und Zusammensetzen und mehrere Worker
für die eigentliche Berechnung
❑ Zeitgewinn durch Speedup meßbar (siehe auf Seite 8.7)
❑ zusätzlicher Kommunikationsaufwand gegenüber sequentiellem Algorithmus
❑ Teilweise erhebliche Leistungssteigerung, z.B. bei Mandelbrot oder JPEG-Codierung.
❑ Vermutlich sind nicht alle Algorithmen effizient parallelisierbar
Informatik I – c Guido Rößling
Parallelverarbeitung – Zusammenfassung
8.11
Literatur zur Parallelverarbeitung
❑ [FBK97]
❑ [Dud93]
❑ [GZZZ95]
❑ [Sed92]
Informatik I – c Guido Rößling
Parallelverarbeitung – Literatur
8.12
Determinismus und Nichtdeterminismus – Begriffe
Algorithmen lassen sich in verschiedene Klassen unterteilen:
❑ deterministische Algorithmen,
❑ probabilistische Algorithmen,
❑ heuristische Algorithmen sowie
❑ nichtdeterministische Algorithmen.
Generell wird noch unterschieden zwischen
❑ determinierten und
❑ nicht-determinierten Algorithmen.
Determiniert“ bzw. nicht-determiniert“ sagt aus, ob der Algorithmus bei gleichen Eingaben
”
”
und Startsituation immer die gleichen Ergebnisse liefert.
Im folgenden werden die einzelnen Klassen kurz näher betrachtet.
Informatik I – c Guido Rößling
Determinismus und Nichtdet. – Begriffe
9.1
Deterministische Algorithmen
❑ Ein Algorithmus heißt deterministisch, wenn es zu jeder m öglichen Programmsituation
höchstens eine Folgesituation geben kann.
Anders formuliert: Die nächste auszuführende Anweisung ist zu jedem Zeitpunkt eindeutig definiert (oder nicht existent).
❑ Deterministische Algorithmen sind immer auch determiniert, d.h. sie liefern zu einer
gewählten Eingabe bei gleichen Startbedingungen immer das gleiche Ergebnis.
❑ Deterministische Algorithmen stellen den Großteil der vorzufindenden Algorithmen dar.
❑ Beispiel: Quicksort mit vorgegebener Wahl des Pivot-Elements, etwa stets des
zweiten Elements, oder des Medians der ersten drei Elemente.
Informatik I – c Guido Rößling
Determinismus und Nichtdet. – Deterministische Algorithmen
9.2
Probabilistische Algorithmen
❑ Ein Algorithmus heißt probabilistisch, wenn es mindestens eine Programmstelle gibt, in
der die auszuführende Anweisung von zufälligen“ Ereignissen abhängt.
”
❑ In der Regel wird eine (Pseudo-)Zufallszahl bestimmt und je nach Wert eine Aktion ausgelöst.
❑ Probabilistische Algorithmen sind nicht-determiniert, d.h. sie k önnen zu einer gewählten
Eingabe bei gleichen Startbedingungen unterschiedliche Ergebnisse berechnen.
❑ Haupteinsatzgebiet sind Entscheidungsprobleme mit Ergebnis ja“ oder nein“
”
”
❑ Randomisierte Algorithmen irren sich bei Antwort nein“ nicht und haben bei minde”
stens 50% der positiven Fälle recht.
❑ Las Vegas Algorithmen können neben ja“ und nein“ auch noch ein unbestimmt“ aus”
”
”
geben. Die Antworten ja“ und nein“ müssen stets korrekt sein.
”
”
Zu beachten ist, daß man die Genauigkeit des Ergebnisses von randomisierten bzw. Las
Vegas Algorithmen durch mehrfache Ausführung steigern kann. Nach ¹ Ausführungen sinkt
die Wahrscheinlichkeit
einer fehlerhaften positiven Antwort bei randomisierten Algorithmen
G F
so auf K
.
Informatik I – c Guido Rößling
Determinismus und Nichtdet. – Probabilistische Algorithmen
9.3
Beispiel: randomisierter Algorithmus
Ein berühmtes Beispiel für randomisierte Algorithmen ist der Primzahltest von Solovay und
Strassen, der (vereinfacht) wie folgt vorgeht (Q sei die zu untersuchende Zahl):
❑ Für a, b í IN sei H w ?5y ¡ eine Funktion mit H w ?5y ¡ HJI , falls ggT(a, b) = 1
Die genaue Definition von H w ?5y ¡ befindet sich z.B. im Duden K Informatik L “.
”
w
w
QhA
❑ Zufälliges Auswählen einer Zahl mit K
❑ Falls ggT(a, n) ¯H 1, kann Q keine Primzahl sein.
❑ Falls ggT(a, n) = 1, berechne H w ?RQ ¡ .
Y
H w ?=Q ¡ H wNMPO Z modulo Q , antworte ”Primzahl“, andernfalls ”keine Primzahl“.
❑ Falls x
Es läßt sich zeigen, daß der Algorithmus
❑ nie eine Primzahl als Nicht-Primzahl klassifiziert,
❑ und bei Antwort Q ist eine Primzahl“ in mindestens 50% der Fälle recht hat.
”
Informatik I – c Guido Rößling
Determinismus und Nichtdet. – Probabilistische Algorithmen : Beispiel
9.4
Heuristische Algorithmen
❑ Heuristik: griechisch heuristikein“ ( finden“ oder entdecken“) (vgl. Eureka“ – ich
”
”
”
”
”
habe es gefunden“)
❑ Heuristiken sind Strategien oder Lösungsverfahren
❑ Zweck einer Heuristik ist das Finden einer guten“ (d.h. fast optimalen) Lösung in ak”
”
zeptabler“ Rechenzeit.
Unter Umständen kann keine Lösung gefunden oder die Qualität (als Distanz zum Optimum) nicht bestimmt werden.
❑ Heuristische Algorithmen sind Algorithmen, die zum Lösen eines Problems eine Heuristik benutzen.
❑ Die Güte der Heuristiken läßt sich nicht beweisen, sondern nur durch (mehrere) Testläufe
mit verschiedenen Eingabedaten beurteilen.
❑ Haupteinsatzgebiet sind Optimierungs- und Entscheidungsprobleme, deren L ösung nicht
effizient (deterministisch) berechenbar ist.
❑ Heuristiken erzeugen in der Regel recht schnell relativ gute Ergebnisse – aber oft nicht
das optimale Ergebnis.
Informatik I – c Guido Rößling
Determinismus und Nichtdet. – Heuristische Algorithmen
9.5
Heuristische Algorithmen
❑ Viele Heuristiken basieren auf
☞ Faustregeln,
☞ (plausiblen) Annahmen, die fast immer“ gelten,
”
☞ Erfahrungswerten,
☞ Ansätzen zum Herantasten“ an die Lösung (z.B. Local Search und Genetische Algo”
rithmen)
☞ oder der Nachbildung menschlichen Verhaltens bei der Probleml ösung.
❑ heuristische Algorithmen können determiniert oder nicht-determiniert sein, da vielfach
Zufallszahlen mit in die Heuristik einfließen.
❑ Beispiel: Ansätze zur Lösung NP-vollständiger Probleme, etwa TSP (Travelling Salesman Problem)
Informatik I – c Guido Rößling
Determinismus und Nichtdet. – Heuristische Algorithmen
9.6
Beispiel für heuristische Algorithmen
Das eben schon erwähnte Travelling Salesman Problem ist wie folgt definiert:
Gegeben ist ein Netz von Punkten, die jeweils eine Stadt repräsentieren, sowie die Entfernungen zwischen allen Städten. Für jedes Paar A, B von Städten gebe es eine direkte Route von
A nach B (und zurück), wobei die Entfernungen unterschiedlich sein dürfen.
Gesucht ist eine Route, die
❑ in einer beliebigen Stadt beginnt,
❑ jede Stadt genau einmal besucht,
❑ und am Ende wieder im Ausgangspunkt angelangt.
Der Name des Problems rührt von der Verwandschaft zu dem (überaus realen) Problem der
Streckenplanung eines Handelsreisenden, der von zuhause startet und alle Kundenstandorte
genau einmal besuchen muß.
Informatik I – c Guido Rößling
Determinismus und Nichtdet. – Heuristische Algorithmen : Beispiel
9.7
Beispiel für heuristische Algorithmen
1. Suche die Verbindung zweier Punkte A, B mit minimalen Kosten
2. Wählen einen der beiden Punkte als Startpunkt, z.B. A.
3. Wähle die billigste“ Strecke als ersten Reiseabschnitt, reise also von A nach B. Setze die
”
Kosten der Strecke als bisherige Kosten.
Bisher wurden daher die Punkte A und B besucht.
4. Falls bereits alle Städte besucht wurden und durch einen Linienzug miteinander verbunden
sind, fahre mit Schritt 8 fort.
5. Suche die billigste Strecke, die entweder zwei noch nicht besuchte Städte, eine der bisher
besuchten Städte mit einer noch nicht besuchten Stadt oder aber zwei isolierte Linienz üge
verbindet.
6. Folge dieser Strecke, d.h. füge die Stadt zur Liste der besuchten Städte hinzu und addiere
die Entfernung zu den Kosten.
7. Gehe zu Schritt 4.
8. Schließe die Rundreise durch Wählen der Strecke von der letzten besuchten Stadt zur
Ausgangsstadt und addieren der Kosten hierfür.
Informatik I – c Guido Rößling
Determinismus und Nichtdet. – Heuristische Algorithmen : Beispiel
9.8
Beispiel für heuristische Algorithmen
❑ Der Ansatz benutzt eine Vorgehensweise aus der Graphentheorie, den minimal aufspan”
nenden Baum“.
❑ Falls stets Ñ N Ã N Q JbÑ N Q gilt, ist das Ergebnis maximal doppelt so groß wie die
optimale Lösung – wenn man von der letzten Kante absieht.
❑ Die Reihenfolge der Wahl der Städte kann entscheidend sein.
❑ Für viele praktische Anwendungen ist dies aber zu schlecht; vielfach ist auch die oben
angegebene Dreiecksungleichung nicht erfüllt.
❑ Eine nachgeschaltete Heuristik wird daher die gefundene L ösung schrittweise leicht modifizieren und nach sich ergebenden besseren Lösungen suchen.
❑ Die anfangs bestimmte Lösung kann bereits ein lokales Minimum sein, d.h. jede einfache
Änderung führt zu einer Verschlechterung.
Um das globale Optimum zu finden, werden daher oft weitergehende Vertauschungen von
Teilstrecken durchgeführt.
Informatik I – c Guido Rößling
Determinismus und Nichtdet. – Heuristische Algorithmen : Beispiel
9.9
Nichtdeterministische Algorithmen
❑ Bei deterministischen Algorithmen ist in jeder Programmstelle die nächste auszuführende
Anweisung eindeutig festgelegt (oder nicht existent).
❑ Bei nichtdeterministischen Algorithmen braucht entsprechend die nächste auszuführende Anweisung nicht eindeutig festgelegt sein: das Programm kann aus mehreren Alternativen wählen.
❑ Ein gängiges Modell für Nichtdeterminismus ist die (fiktive!) Rate-Verifikations-Turing”
maschine“, die im Fall der Wahlmöglichkeit automatisch den richtigen“, d.h. zur Lösung
”
führenden, Befehl wählt ( Ratephase“) und die Korrektheit der Wahl dann durch (deter”
ministisches) Weiterrechnen überprüft ( Verifikationsphase“).
”
Gibt es keinen richtigen“ Befehl, oder mehr als einen, so kann die Maschine einen der in
”
Frage kommenden gleichwertigen Befehle wählen.
❑ Da der richtige“ Befehl nicht im voraus bestimmt werden kann, ist diese Maschine nicht
”
unmittelbar implementierbar.
Aber: durch Austesten aller Möglichkeiten kann die richtige Wahl deterministisch bestimmt werden – jedoch nur mit exponentiellem Aufwand ( Backtracking“).
”
Informatik I – c Guido Rößling
Determinismus und Nichtdet. – Nichtdeterministische Algorithmen
9.10
Nichtdeterministische Algorithmen
❑ Jeder deterministische Algorithmus kann auch als nichtdeterministischer Algorithmus interpretiert werden, der von der Möglichkeit des Nichtdeterminismus keinen Gebrauch
macht.
❑ Die Klasse NP der nichtdeterministisch polynomiellen Algorithmen umfaßt genau die Algorithmen, die von einer Rate-Verifikations-Turingmaschine“ in polynomieller Zeit be”
rechnet werden können.
❑ Aus den beiden letzten Punkten folgt die Beziehung P E NP, da jeder deterministisch
polynomielle Algorithmus ebenfalls nichtdeterministisch polynomiell ist.
Zur Abgrenzung der deterministisch polynomiellen von den zunächst nur nichtdeterministisch polynomiellen Algorithmen gibt es eine Teilklasse NPC der NP-vollständigen“
”
Probleme, die zu den schwierigsten“ Problemen in NP zählen.
”
Es ist bislang nicht bewiesen, ob tatsächlich die Gleichheit zwischen den Klassen P und
NP gilt.
Informatik I – c Guido Rößling
Determinismus und Nichtdet. – Nichtdeterministische Algorithmen
9.11
Ergebnis
❑ Soweit die Problemstellung sowie die Komplexität es erlaubt, sollten deterministische
Algorithmen gewählt werden.
Dies gilt insbesondere, wenn eine exakte oder optimale L ösung erforderlich ist.
❑ Zur Prognose eines Ergebnisses in recht kurzer Rechenzeit k önnen insbesondere bei Entscheidungsprobleme probabilistische Algorithmen herangezogen werden.
❑ Für sehr komplexe Probleme, bei denen eine deterministische Berechnung einer exakten
bzw. optimalen Lösung nicht effizient möglich ist, können vielfach heuristische Algorithmen hilfreich sein.
Das gilt insbesondere bei Optimierungsproblemen, in denen nur eine (sehr) gute, nicht
aber zwangsläufig optimale Lösung erforderlich ist.
Beispiele hierfür sind die meisten NP-vollständigen Probleme.
❑ Nichtdeterministische Algorithmen lassen sich nur durch systematische Suche über (im
schlimmsten Fall) dem gesamten Suchraum realisieren (Backtracking, Branch and Bound).
Die Laufzeit dieser wiederum deterministischen Verfahren ist in der Regel exponentiell
zur Problemgröße und daher nicht mehr von praktischer Relevanz.
Informatik I – c Guido Rößling
Determinismus und Nichtdet. – Ergebnis
9.12
Literatur zu Determinismus und Nichtdeterminismus
❑ [Kre93a]
❑ [GJ79]
❑ [Dud93]
❑ [GZZZ95]
Informatik I – c Guido Rößling
Determinismus und Nichtdet. – Literatur
9.13
Geschichte der Korrektheit
❑ Schon seit Entwicklung des Algorithmusbegriffes, und noch fr üher in den Beweisen der
Mathematik sowie der Statik, ist die entscheidende Frage:
Leistet die gegebene Realisierung (Algorithmus, Beweis, Skizze, ) das geforderte?“
”
❑ In der Informatik kann zunächst zwischen zwei Sorten von Fehlern unterschieden werden:
☞ Hardware-Fehler, etwa Rechnungsfehler im Gleitkommabereich (vgl. Pentium-Prozessor) und
☞ Software-Fehler, in der Regel Programmierfehler.
❑ Die übliche Bezeichnung für (Software-)Fehler ist Bug.
☞ Bug (engl. Käfer“) geht auf einen lange unerklärlichen Fehler im Großrechner
”
Mark II im Jahr 1945 zurück, der sich schließlich auf eine Motte zurückführen
ließ, die auf zwei Leitungen gefallen war
Informatik I – c Guido Rößling
Korrektheit – Motivation und Geschichte
10.1
Fehlerarten
Folgende Software-Fehlerquellen sind häufig:
❑ Zugriff auf nicht existente Elemente ( null pointer“),
”
❑ Seiteneffekte bei Zeigern (Mitänderung von anderen Variablen),
❑ Division durch 0,
❑ nicht berücksichtigte Fälle,
❑ Endlosschleifen und inkorrekte Rekursionsanker,
❑ Ignorierung unerwarteter Werte ohne Überprüfung oder Fehlverhalten des Algorithmus
❑ und viele andere.
Informatik I – c Guido Rößling
Korrektheit – Fehlerarten
10.2
Fehlerarten
Als kleine Demonstration die geschätzte Anzahl Fehler in Windows 95 und Windows NT
gemäß gängiger Schätzmethoden in Abhängigkeit der Programmzeilen:
Abbildung 18: Fehleranzahl in Windows 95 und Windows NT (aus c’t 19/1998)
Informatik I – c Guido Rößling
Korrektheit – Fehlerarten
10.3
Testverfahren
❑ Wie kann festgestellt werden, ob ein gegebener Algorithmus korrekt ist?
☞ Prinzipiell gibt es zwei Möglichkeiten: Testverfahren und Verifikation
❑ Wir gehen nun zunächst auf die Testverfahren ein.
❑ Die Testverfahren lassen sich in zwei Untertypen unterteilen:
☞ Statisches Testen
Hierzu zählen die Verfahren Schreibtischtest“, Walkthroughs und Codeinspektion.
”
☞ Dynamisches Testen mit den Unterverfahren Black Box-Test und White Box-Test.
❑ Auf die einzelnen Testverfahren wird auf den nächsten Folien kurz eingegangen.
Informatik I – c Guido Rößling
Korrektheit – Testverfahren
10.4
Statische Testverfahren
Bei den statischen Testverfahren können folgende Eigenschaften überprüft werden:
❑ Einhaltung von Darstellungskonventionen
❑ Dokumentationseigenschaften
Insbesondere Namensgebung und Kommentierung
❑ Komplexität
Insbesondere Schnittstellenbreite, Im- und Exportzahl von Klassen sowie Schachtelungstiefe.
❑ Kontrollstrukturen
Sind alle Programmteile überhaupt erreichbar?
Informatik I – c Guido Rößling
Korrektheit – Statische Testverfahren
10.5
Schreibtischtest und Walkthrough
Beim Schreibtischtest wird wie folgt vorgegangen:
❑ Ein Testfall wird mit ausgewählten Testdaten geplant
❑ Es werden nur Programmteilstücke getestet
❑ Basis des Tests ist das Listing, d.h. der Programmtext
❑ Die Testpersonen sind Programmierer
❑ Beim Testen werden kontextabhängige Annahmen gemacht.
☞ Das Verfahren Walkthrough“ funktioniert wie der Schreibtischtest, allerdings
”
wird der Code von einem Testteam statt einer Einzelperson getestet.
Informatik I – c Guido Rößling
Korrektheit – Statische Testverfahren : Schreibtischtest
10.6
Codeinspektion
❑ Bei der Codeinspektion besteht das Testteam aus einem Moderator, Vorleser, Protokollant
und Inspektoren.
❑ Das gesamte Programm wird von dem Team sequentiell durchgegangen auf Basis der
Listings und alle gefundenen Fehler werden gesammelt.
❑ Sehr hohen Nutzen (im Durchschnitt werden ca. 60-70% der Fehler gefunden)
❑ allerdings auch hohe Kosten
☞ bis zu 20% des Erstellungsaufwandes
Informatik I – c Guido Rößling
Korrektheit – Statische Testverfahren : Codeinspektion
10.7
Black Box-Test
❑ Testen der Schnittstelle einer Klasse getestet ohne Beachtung der Interna
❑ Hierzu werden Testeingaben gewählt, die in die Klasse(n) geleitet werden und Ausgabedaten produzieren.
❑ Vergleich mit denerwarteten Ausgabedaten
❑ Bei Unterschieden liegen folglich Programmfehler vor, die auszubessern sind.
❑ Es bleiben aber noch einige Fragen offen:
☞ Gab es Zustandsänderungen durch Methodenaufrufe?
☞ Werden alle Methoden des Programms benutzt?
☞ Welche Wirkungen haben die Methoden auf andere Objekte?
❑ Insgesamt ist die ausschließliche Betrachtung der Ausgabedaten daher nicht ausreichend.
Informatik I – c Guido Rößling
Korrektheit – Dynamisches Testen : Black Box-Test
10.8
Schema des Black Box-Tests
Abbildung 19: Schema des Black Box-Tests
Informatik I – c Guido Rößling
Korrektheit – Dynamisches Testen : Black Box-Test
10.9
White Box-Test
❑ Der White Box-Test setzt an den Schwachstellen des Black Box-Tests an:
☞ Beim Test der Klassen wird der Objektzustand mitberücksichtigt
☞ Es werden alle Methoden getestet
☞ Es werden alle möglichen Pfade durchlaufen (Testdeckung)
❑ Nachteile des White Box-Tests:
☞ große Komplexität
☞ hoher Aufwand
❑ Zusätzlich wird automatische Unterstützung benötigt.
Informatik I – c Guido Rößling
Korrektheit – Dynamisches Testen : White Box-Test
10.10
Testdeckungsgrade
Es gibt folgende Testdeckungsgrade für den Pfaddurchlauf bei White Box-Tests:
C0 Jede Anweisung wird mindestens einmal durchlaufen
C1 Jeder Zweig wird mindestens einmal durchlaufen
C2 Jede Bedingung wird mindestens einmal durchlaufen
C3 Jeder Zweig und jede Schleifengrenze wird mindestens einmal durchlaufen
... beliebige weitere Kombinationen
Informatik I – c Guido Rößling
Korrektheit – Dynamisches Testen : White Box-Test
10.11
Klassentest
Zum Testen von Klassen kann man wie folgt vorgehen:
1. Testplanung: in welcher Reihenfolge sollen die Methoden getestet werden?
2. Testvorbereitung für Methodentest
❑ Ermittlung der Testdatenmenge: alle Eingaben und Zustände der Klasse
❑ Auswahl geeigneter Testdaten
❑ Festlegen der Sollergebnisse
3. Testdurchführung: Ermittlung und Dokumentation der Istergebnisse
4. Testauswertung: Vergleich von Soll- und Istergebnissen
Informatik I – c Guido Rößling
Korrektheit – Klassentest
10.12
Integrationstest
Zuletzt ist noch ein Integrationstest durchzuführen, um zu überprüfen, ob das Zusammenspiel
der Klassen korrekt ist:
❑ Schrittweises Zusammenfügen der bereits einzeln getesteten Klassen;
❑ Neuer Test nach jedem Integrationsschritt
❑ Verwendung existierender Testdaten und -objekte sowie Treiber
❑ Überprüfung der Schnittstelle zwischen den Klassen
Hierzu gibt es zwei Vorgehensweisen:
❑ Top-Down Integration
❑ Bottom-Up Integration
Informatik I – c Guido Rößling
Korrektheit – Integrationstest
10.13
Top-Down Integration
❑ Die Wurzelklasse bildet den Ausgangspunkt
❑ Anfang des Tests ist ein lauffähiger“ rudimentärer Prototyp
”
☞ Design-Fehler können frühzeitig erkannt werden
☞ die Benutzungsschnittstelle kann frühzeitig getestet werden
Nachteile:
❑ Die Implementierung von Testobjekten ( Dummies“) kann aufwendig sein
”
❑ Bei einfachen Dummies“ bleiben Fehler verborgen
”
Die Variante Depth-First Integration unterstützt die Präsentation einer abgeschlossenen Teilfunktionalität des Programms; die Breadth-First Integration hingegen mehr den PrototypCharakter.
Informatik I – c Guido Rößling
Korrektheit – Integrationstest : Top-Down Integration
10.14
Bottom-Up Integration
❑ Bei der Bottom-Up Integration wird von unten nach oben integriert
☞ der Aufbau erfolgt auf Basis von getesteten, sicheren Grundlagen
❑ Die Bottom-Up Integration erlaubt daher evtl. auch paralleles Vorgehen unter Verwendung von Testtreibern.
❑ Nachteile:
☞ Benutzungsschnittstelle und Dynamik werden erst spät sichtbar
☞ Die Behebung spät erkannter Fehler ist besonders teuer
☞ Bei vernetzten Klassenhierarchien ist das unten“ schwer erkennbar
”
Informatik I – c Guido Rößling
Korrektheit – Integrationstest : Bottom-Up Integration
10.15
Produkttest
❑ Am Abschluß der Tests steht der Produkttest
☞ Test des fertiggestellten Produkts ohne Dummies oder Treiber
❑ Bei der Testplanung ist dazu die Reihenfolge der zu testenden Benutzerfunktionen festzulegen.
❑ In der Testvorbereitung sind folgende Schritte auszuf ühren:
☞ Ermittlung der Testdatenmenge,
☞ Auswahl geeigneter Testdaten,
☞ Festlegung des Sollergebnisses.
❑ Bei der Testdurchführung und Auswertung wird wie beim Klassentest vorgegangen.
Informatik I – c Guido Rößling
Korrektheit – Produkttest
10.16
Bewertung der Testverfahren
Allen Testmethoden ist gemeinsam, daß
❑ sie vor allem zum Bestimmen und Ausmerzen von bekannten“ Fehlern dienen , die bei
”
Testläufen aufgetreten sind und
❑ sie stark davon abhängen, daß die Testdaten gut“ ausgewählt wurden, d.h. insbesondere
”
auch Sonderfälle abgedeckt werden.
Aber: gute“ Testdaten können nicht durch einen allgemeinen Algorithmus generiert wer”
den!
❑ mit ihnen nur bekannte“ Fehler eliminiert werden.
”
☞ Ein Algorithmus ist nur dann korrekt, wenn er überhaupt keine Fehler enthält
– also nicht nur die bekannten“ Fehler ausgebessert sind.
”
☞ Program testing can be used to show the presence of bugs, but never their
”
absence“ – Edsgar W. Dijkstra, 1972.
Im folgenden wird ein mathematischer Kalkül vorgestellt, der die Korrektheit von Programmen beweisbar macht.
Informatik I – c Guido Rößling
Korrektheit – Bewertung der Testverfahren
10.17
Korrektheitskriterien
Was macht einen korrekten Algorithmus aus?
❑ Spezifikation: Es wird sauber definiert, aus welchen Eingaben welche Ausgaben erzeugt
werden sollen.
❑ partielle Korrektheit I: Auf allen erwarteten Eingaben liefert der Algorithmus das gew ünschte Ergebnis, erfüllt also die Spezifikation.
❑ partielle Korrektheit II: Auf ungültigen Eingaben signalisiert der Algorithmus eine Verletzung der Spezifikation, etwa durch Abbruch der Routine oder Setzen eines daf ür reservierten Ergebnisses.
❑ Terminierung: Der Algorithmus beendet bei allen Eingaben seine Rechnung nach endlicher Zeit.
❑ Totale Korrektheit Spezifikation und partielle Korrektheit I + II sowie Terminierung.
Im folgenden wird betrachtet, wie man diese Aspekte mathematisch sauber fassen und auch
in viele Programme einbetten kann.
Informatik I – c Guido Rößling
Korrektheit – Korrektheitskriterien
10.18
Spezifikation
Vor der Implementierung eines Algorithmus sollte man erst eine Spezifikation des Algorithmus erstellen.
Bestandteil der Spezifikation sind:
❑ Wieviele Parameter welchen Typs erwartet der Algorithmus in welcher Reihenfolge?
❑ Welche Werte oder Kombinationen sind für die Parameter zulässig? Welche sind unzulässig?
❑ Welche Ausgabe soll der Algorithmus liefern, wenn alle Parameter zulässig sind?
❑ Wie soll der Algorithmus sich verhalten, wenn mindestens ein Parameter nicht zul ässig
war?
❑ Wie läßt sich das Ergebnis formal-logisch (etwa in Aussagenlogik oder Prädikatenlogik)
formulieren?
Umgangssprachliche Definitionen sind oft zu ungenau!
Informatik I – c Guido Rößling
Korrektheit – Spezifikation
10.19
Probleme bei der Spezifikation
Empfehlenswert ist folgendes Vorgehen:
1. Überlegen, was der Algorithmus für ein Ergebnis liefern soll, etwa f(a, b) =
”
max(a, b)“
2. Versuch, das Ergebnis mathematisch präzise zu fassen, ggf. unter Zuhilfenahme
von Prädikaten und Arithmetik
3. Schrittweise Transformation des Ergebnisses in einzelne Komponenten, etwa
durch Fallunterscheidung
4. Angabe von Befehlen oder Befehlssequenzen, die genau diese Transformationen
repräsentieren
5. Überprüfung des Ergebnisses durch Verifikation
6. Betrachten aller übriggebliebenen Voraussetzungen: diese geben die g ültigen Werte für die Parameter an.
Vorsicht: Dieses Verfahren ( Algorithmensynthese“) ist sehr zeitaufwendig und erfordert
”
einige Übung!!!
Informatik I – c Guido Rößling
Korrektheit – Spezifikation : Probleme
10.20
Motivation der Verifikation
❑ Egal, ob man einen Algorithmus einfach so“ programmiert oder durch die auf Seite 10.20
”
angegebenen Schritte gewonnen hat: es muß getestet werden, ob der Algorithmus das
gewünschte leistet.
❑ Hierzu dient die Verifikation, ein Kalkül zur Überprüfung der Programmkorrektheit.
❑ Gegeben: Ein Algorithmus sowie die mathematische Spezifikation des erwarteten
Ergebnisses.
❑ Ziel: Eine mathematische Formel, die die Bedingungen enthält, unter denen der Algorithmus die Spezifikation des Algorithmus erfüllt.
❑ Im schlimmsten Fall ergibt sich falsch“: der Algorithmus erfüllt die Spezifikation
”
nie.
❑ Im besten Fall ergibt sich wahr“: der Algorithmus erfüllt die Spezifikation immer.
”
❑ In vielen Fällen enthält die Formel Beschränkungen für die Parameter, etwa
x GIH 0“. In diesen Fällen liefert der Algorithmus nur dann das korrekte Ergebnis,
”
wenn diese Bedingungen erfüllt sind.
Informatik I – c Guido Rößling
Korrektheit – Motivation der Verifikation
10.21
Generelle Vorgehensweise
☞ Inhalt der Verifikation ist die schrittweise Anpassung der Bedingungen an die einzelnen Befehle.
☞ Das Vorgehen ist dabei folgendes:
❑ Gegeben seien ein Befehl und eine Bedingung, die nach seiner Ausf ührung gelten
soll ( Nachbedingung“).
”
❑ Gesucht ist eine Bedingung, die vor der Ausführung des Befehls gelten muß, damit
anschließend die Nachbedingung erfüllt ist ( Vorbedingung“).
”
❑ Die Verifikation arbeitet den Algorithmus von unten nach oben durch und erstellt
zu jeder Nachbedingung eines Befehls eine passende Vorbedingung.
❑ Die Vorbedingung sollte die schwächst mögliche sein, die die Nachbedingung
erfüllt.
Muß vor der Ausführung eines Befehls etwa g¾G
gelten, so lautet die korrekte
æ
Vorbedingung gÖG , nicht etwa g²G .
Andernfalls wird die Nutzbarkeit des Algorithmus künstlich eingeschränkt.
Informatik I – c Guido Rößling
Korrektheit – Vorgehensweise
10.22
Weakest Precondition
❑ Warum arbeitet die Verifikation von unten nach oben?
☞ Es wird davon ausgegangen, daß der Autor weiß, was der Algorithmus leisten soll
☞ Diese Anforderung liegt als Spezifikation im Sinne einer logischen Aussage vor, die
gleichzeitig Nachbedingung des Algorithmus ist
☞ Überprüft werden soll, in welchen Fällen der Algorithmus das gewünschte leistet.
❑ Das Schema der Notation der Berechnung der Vorbedingung ist folgendes:
wp(Befehl, Nachbedingung) Vorbedingung
❑ Leseweise: Die schwächste Vorbedingung zur Erfüllung von Nachbedingung nach dem
”
Befehl Befehl ist Vorbedingung.“
❑ wp steht für weakest precondition“ ( schwächste Vorbedingung“) und berechnet zu je”
”
dem gegebenen Befehl und seiner Nachbedingung die (schwächste) Vorbedingung.
❑ Die Vorbedingung des ¹«A ¸ Q Befehls ist die Nachbedingung des [¹«A
¡
A
¸ Q Befehls
❑ Durch diese Kettenbildung“ erhält man schließlich aus der Nachbedingung des gesamten
”
Algorithmus die Vorbedingung für den Algorithmus.
Informatik I – c Guido Rößling
Korrektheit – Weakest Precondition
10.23
Regeln von wp für Wertzuweisung
❑ Wie berechnet man nun
wp(Befehl, Nachbedingung) = Vorbedingung?
❑ Offensichtlich hängt dies von der Art des Befehls sowie der Nachbedingung ab.
❑ Im folgenden werden die einzelnen Arten der Befehl und die zugeh örige Regel für wp
Ç
angegeben. Für die Nachbedingung wird im folgenden das Prädikat verwendet.
❑ Befehl ohne Änderung von Variablen, etwa Ausgaben, Kommentare etc.:
wp(Befehl,
Ç
)
Ç
☞ Nachbedingung und Vorbedingung sind also identisch
❑ Einfache Wertzuweisung:
wp(x = ausdruck,
ÇSR
Ç
)
T
ÇSR
T
6 %VU 7 2 %8W_,VX
Ç
☞ Der Ausdruck 6 %VU 7 2 %W`, X bedeutet dabei, daß in alle Vorkommen von g , die
µ |Y! ersetzt werden.
nicht durch einen Quantor gebunden sind, durch w µ ~· ê
Informatik I – c Guido Rößling
Korrektheit – Regeln für Wertzuweisung
10.24
Beispiele zur Wertzuweisung
❑ wp(x = i;, gÉGce ) c¹Gce
☞ Damit der Wert von g nach der Wertzuweisung (dann identisch zu ¹ ) gr ößer als
5 ist, muß der Wert von ¹ bereits größer als 5 gewesen sein
❑ wp(x = 2 f i + 5, ÞIfgÉG
à ) Þf f ¹> e ¡ G
àOf¹ê>
e G
d
à
àOf¹ G
¹ G Z
à
☞ Falls ¹ eine Variable vom Typ Integer (ganze Zahl) ist, ist die letzte Aussage
äquivalent mit
:
für
Integer
gilt
¹G
¹G
N ¹J
N ¹G Z

❑ wp(x = 8, ÐDgÛ [g
HlkS ¡ ) ÐDgÕ g
¸ ·0µÙ
HlkS ¡
☞ Das Auftreten von g ist gebunden, wird also durch die Wertzuweisung nicht
beeinflußt
❑ wp(x = a, ½jGce ¡ P½jGce
☞ g tritt in der Nachbedingung nicht auf, daher hat die Wertzuweisung keine Auswirkung auf die Nachbedingung
Informatik I – c Guido Rößling
Korrektheit – Regeln für Wertzuweisung : Beispiele zur Wertzuweisung
10.25
Beispiele zur Wertzuweisung
❑ wp(x = y, gÉGÊ½ ¡ P½jG¾½ ° w\[ .
☞ Dies deckt sich offensichtlich
auch mit der Erwartung

æ
ØÙ½¿± Û ½ K¾k ¡

¡
æ
ØÙ½¿± 5à3Û ½ K¾k
n
K¾k
ØÙ½¿± 5à3Û ½ K¾k ¡ nÖ° w;[
w [
° \
☞ Wäre der Bereich des Quantors nur 5à gewesen, oder der g zugewiesene
❑ wp(x = 42, Ø½¿±
æ
Õ ½
KÊg ¡/¡
Wert mindestens 50, wäre die Aussage erfüllt
Informatik I – c Guido Rößling
Korrektheit – Regeln für Wertzuweisung : Beispiele zur Wertzuweisung
10.26
Regeln von wp für Blöcke
❑ Blöcke oder zusammengesetzte Anweisungen haben die Form
Å
]2^`_^badcfe'g
]2^`_..^badchg
Æ
❑ Die Vorbedingung des Blocks ergibt sich hierbei durch das schrittweise Berechnen der
Vorbedingungen aller Befehle von unten nach oben gemäß der folgenden Regeln:
]^:_C^,aicjekg
]2^`_^badchg
Ç
Æ , ¡ ]2^`_^badcjelg
]^:_C^,aicmh
Ç
1. wp( Å
wp( Å
, )
☞ Die Nachbedingung des letzten Befehls ist identisch zur Nachbedingung des
]^:_C^,aicjekg ]2^`_^badc;n elgP]2^`_^badc\ng Ç
Blocks
? ]2^`)_^badc n
2. wp( Å
]2^`_^bad c e g ]^:7 _C^,aic n e
Ç
7 , wp(
wp( Å
? ))
☞ Die Vorbedingung des ¹ A ¸ Q Befehls des Blocks ist gleichzeitig die Nachbe
dingung des ¹©A ¡ A ¸ Q Befehls
Informatik I – c Guido Rößling
Korrektheit – Regeln für Blöcke
10.27
Regeln von wp für Blöcke
]^:_C^,aic e
]^:_C^,aic e
Ç
? ¡ Ç
3. wp( Å
wp( Å , wp(
? ))
☞ Die Nachbedingung des Blockanfangs ist identisch zur Vorbedingung des ersten Befehls
Ç
Ç
4. wp( Å , ¡ ☞ Die Vorbedingung des Blocks ist die Vorbedingung des ersten Befehls
☞ Ist der Block leer, so ist die Vorbedingung des Blocks identisch zur Nachbedingung des Blocks (Regel 1 und 4)
Informatik I – c Guido Rößling
Korrektheit – Regeln für Blöcke
10.28
Regeln von wp für Blöcke
üofprqtsvuwqÛý
ü
üo
8Y
8
...
ý
prqtsvuwq ý

üo ý
Z
üo ý
üo
ü.xmy

ü'Nx
ü'Nx

...
kz
ü8o ý
Y
ý

ü.xmy
ü'Nx
Y8,V
Y8,
ý
o
Y8YG Z`
of ý
o\ ý
ü.xmy

ü.xmy
ý
{m$.w|

ü.xmy

Y8'¡
m{ w.wG|~ ý ü.x,8P z
ü.x,8P
ý
{mw.wG|
ü.x,8P
{mw.wG| ý

{m$.w| ý
ü.xmy
ý
P{mw.wG| ¢£k
o ý

MlO
O M
8 ¡ O üo ý ü'¤x
o ý ü.xmy {mw.$| ¢
8 ¡ M¥
M
8'¡' üo ý ü.x,8P ý ü.xP
ý
M*¥
{m|~}$
{mw.w| ¢
üo
M*¥ ý ü.x,8P {m|~}$ ý
Y
ý
ü'Nx
P{m|~}$
ý

ü.x,8P
ü.x,8P
ý
{mw.wG| ¢G£
{mw.$| ¢£k
ý
ý
Tabelle 16: Schema der Verifikation von Blöcken
Informatik I – c Guido Rößling
Korrektheit – Regeln für Blöcke
10.29
Beispiel zu Blöcken
Å ½jG
Å
¦
Æ@
Å@ ½À>tÞ ¡ C eBG
x = y + 3;
Å gaC eBG
x = x C
5;
Å gÉG
Å gÉG
Å gÉG
Æ (natürliche Zahlen!)
àªÆM
Å0eC ½À>
eBG
àªÆM
Å¶½jG
¦
Æ
àOÆ
àÝÆ
y = y + 1;
Æ
Å¶½¿G
àÝÆ
àªÆM
Å
Ç *_<
7 Æ
Tabelle 17: Beispiel zur Verifikation von Blöcken
Informatik I – c Guido Rößling
Korrektheit – Regeln für Blöcke : Beispiele
10.30
Regeln von wp für IF
❑ Im Fall eines if-Befehls ohne else gibt es zwei mögliche Abläufe:
☞ Die Bedingung Ausdruck ist wahr, so daß der Befehl Befehl ausgef ührt wird.
Ç
☞ Damit nach der Ausführung des Befehls gilt, muß vorher sowohl Ausdruck
Ç
als auch wp(Befehl, ) gelten
Ç
☞ Vor dem if muß die Aussage Ausdruck n wp Befehl ? ¡/¡ gelten
☞ Die Bedingung Ausdruck ist falsch, so daß Befehl nicht ausgef ührt wird.
Ç
Ç
☞ Damit nach dem if gilt, muß in diesem Fall also bereits vorher gelten, was
Ç
zu der folgenden Aussage führt: m Ausdruck n
❑ Die beiden Teilaussagen werden nun zusammengesetzt.
☞ Es muß mindestens eine der beiden Aussagen wahr sein, so daß sie über oder
( o ) verknüpft werden können
❑ Man erhält insgesamt also
Ç
wp(if (Ausdruck) Befehl, )
Ç
Ç ¡
Ausdruck n wp Befehl ? +¡ ¡ £
o m Ausdruck n
Informatik I – c Guido Rößling
Korrektheit – Regeln für IF
10.31
Regeln von wp für IF
❑ Ein vorhandener else-Teil kann identisch behandelt werden:
]2^`_^badcCe
wp(if Ausdruck
Ausdruck n wp(
2] ^`_^badc`§
] else
^:_C^,aic e Ç
?
)o
?
Ç
)
m¨:©«ª¬\`©«®m¯ n wp ]2^`_^badc §
?
Ç ¡
❑ Die auf]^:der
_C^,ailetzte
c § Folie angegebene Regel für if ohne else ist ein Spezialfall dieser Regel,
leer ist
in der
]^:_C^,aic;§ Ç
Ç
☞ entsprechend gilt dann wp(
? ¡ Informatik I – c Guido Rößling
Korrektheit – Regeln für IF
10.32
Beispiele zu Fallunterscheidungen
ü
ü'°
if (x X
y)
z = x;
else
z = y;
ý
°´³ ± ý
ü'°
° µ ± °¶³ ± ·± µS°ý
´
X²±
ü'°
°¹¸²º ° ° G± °¶³ ± ·± ¸»º ° ° ± ý
X²±
ü'°
°¹¸²¼¾½¿ ° ±ªT ° X»±ª·± ¸»¼¾½¿ ° G ± ý
X²±
ü'°¹¸²¼¾½¿ °
ý
ü.xmy q ý
±
M
ü8ÃÄ¸²¼
½¿ °
G
± ý ü.x,8P À GÁ M*Â | p ý ü.x,8P q G M ý
ü ¸²¼¾½¿ °
ý
ü.xmy p ý
±
±
Å|
ü8ÃÄ¸²¼
½¿ °
ý
ü.x,8P
p ý ü.x,8P w| p ý

G
±

À
G

|
M*Â
ü8ÃÄ¸²¼
½¿ °
G
± ý ü.x,8P À GÁ M*Â | p ý
T
X²±

ü.xby
À
GÁG M*Â | p ý
Tabelle 18: Beispiel zur Verifikation von Fallunterscheidungen
☞ Der angegebene Algorithmus bestimmt also das Maximum zweier beliebiger
Zahlen x, y
☞ @· bzw. @ä» ¸ stehen dabei als Abkürzung für Precondition und Postcondition
Informatik I – c Guido Rößling
Korrektheit – Regeln für IF : Beispiele
10.33
Regeln von wp für Schleifen
❑ Schleifen bestehen üblicherweise aus folgenden Teilen:
☞ Initialisierung, insb. des Schleifenzählers,
☞ Abbruchs- oder Fortsetzungsbedingung
☞ Schleifenkörper, sowie
☞ Befehlen zum Ändern des Schleifenzählers.
❑ Zur Verifikation von Schleifen muß zunächst eine Invariante gefunden werden
☞ Die Invariante ist eine logische Aussage, die nach jedem Schleifendurchlauf
erfüllt ist
❑ Da alle Schleifen von Java funktional äquivalent sind, wird nur die while-Schleife als
einfachste betrachtet
☞ Denkaufgabe: Wie kann eine for-Schleife in eine while-Schleife umgesetzt
werden?
Informatik I – c Guido Rößling
Korrektheit – Regeln für Schleifen
10.34
Invariante
❑ Um eine Schleife verifizieren zu können, muß sie noch um zwei Komponenten ergänzt
werden: eine Invariante und eine Variante.
☞ Die Invariante ist eine logische Bedingung, die vor und nach jedem Schleifendurchlauf
gelten muß.
☞ Damit gilt sie insbesondere auch nach der Initialisierung sowie bei Schleifenende
☞ Da bei Schleifen i.a. nicht bekannt ist, wie oft sie durchlaufen werden, muß
die Invariante Inhalte absichern, die auch bei beliebig ofter Wiederholung wahr
bleiben
☞ Die Variante ist ein Integer-Ausdruck, der bei jedem Schleifendurchlauf kleiner werden
muß, ohne dabei negativ zu werden.
❑ Die Invariante beschreibt daher unveränderliche“ Bedingungen, deren Gültigkeit durch
”
die Schleife nicht verändert wird – wenngleich sie während des Schleifenkörpers durchaus
verletzt sein darf.
Informatik I – c Guido Rößling
Korrektheit – Regeln für Schleifen : Invariante
10.35
Invariante
Folgende Schritte sind der Reihe nach durchzuführen:
1. Die Nachbedingung der Schleife muß aus ` Ñyy'· µê|Y+ y¶~¹ºQ µäQ
bzw. `M»· ¸ ¸ ÒµäQ y~ªº¹ Q µ¦Q nzÂQ«Æ w · ¹ w Q ¸ ) folgerbar sein.
n
ÂQÇÆ w · ¹ w Q ¸ )
2. Die Nachbedingung des letzten Schleifenbefehls ist Å0ÂQ«Æ w ·0¹ w Q ¸ Æ
3. Falls der Schleifenzähler am Schleifenende geändert wird, sind zunächst diese
Befehle zu verifizieren.
4. Der Körper wird mit den Regeln für Blöcke verifiziert, siehe auf Seite 10.27ff.
5. Die Vorbedingung des ersten Schleifenbefehls muß folgen aus
nzÂªQÇÆ w · ¹ w Q ¸ )
m Ñyy'· µê|Y+ y¶~ª¹¤Q µäQ
bzw.
nzÂªQÇÆ w · ¹ w Q ¸ )
`M»¶· ¸ ¸ Òµ¦Q y¶~¹ºQ µäQ
6. Die Nachbedingung der Initialisierungsbefehle ist Å0ÂQ«Æ w ·0¹ w Q ¸ Æ
7. Die Vorbedingung der Schleife ist die Vorbedingung der Initialisierungsbefehle.
Informatik I – c Guido Rößling
Korrektheit – Regeln für Schleifen : Invariante
10.36
Beispiele zu Schleifen
❑ Die unten angegebene Schleife implementiert die Fakultätsfunktion für natürliche Zahlen.
❑ Als Invariante wurde gewählt
¹
Q¿nÖ° w a
! H¾¹÷è
❑ Die nicht betrachtete Variante ist QrA ¹ .
i = 0;
fak= 1;
while (i K
n)
Å
i = i + 1;
fak = fak * i;
Æ
Informatik I – c Guido Rößling
Korrektheit – Regeln für Schleifen : Beispiele
10.37
Beispiele zu Schleifen
i = 0;
fak = 1;
È
while (i
Í
n)
i = i + 1;
fak = fak *
Ê
Informatik I – c Guido Rößling
È nÉ 0Ê
È n É 0 Ë true Ê
È 0 Ì n Ë 1 = 0! Ê
È i Ì n Ë 1 = i! Ê
È i Ì n Ë fak = i! Ê
È i Ì n Ë fak = i!
È i Ì n Ë fak = i! Ë i Í n Ê
È i Í n Ë fak = i! Ê
È i+1 Ì n Ë fak = ((i+1)-1)! Ê
È i Ì n Ë fak = (i-1)! Ê
È i Ì n Ë fak Ð i = i! Ê
i; È
i Ì n Ë fak = i! Ê
È i Ì n Ë fak = i! ËbÑ (i Í n) Ê
È i Ì n Ë fak = i! Ë i É n Ê
È i = n Ë fak = i! Ê
È fak = n! Ê
Vorbedingung
Definition Fakultät
wp Wertzuweisung
wp Wertzuweisung
Invariante
Ë
Ì Ë iÍ n Î i Í
Invariante Bedingung (i n
i:N
I . ( i n i+1 n)
wp Wertzuweisung
Ï
Í Î
Ì
n)
Definition der Fakultätsfunktion
wp Wertzuweisung
Invariante
ËbÑ
Ò É
Invariant
Bedingung
(i n) i n
i = n fak = i!
fak = n!
Nachbedingung
Ñ Í
Ë
ÊfÎ
Korrektheit – Regeln für Schleifen : Beispiele
10.38
Totale Korrektheit
❑ Die bisherigen Betrachtungen bezogen sich lediglich auf die partielle Korrektheit, d.h. die
Frage, ob der Algorithmus das tut, was er tun soll.
❑ Um einen komplett korrekten Algorithmus zu erhalten, muß jedoch auch die Terminierung, d.h. die Beendigung der Rechnung, sichergestellt werden.
❑ Erst wenn sowohl Terminierung als auch partielle Korrektheit nachgewiesen sind, gilt der
Algorithmus als total korrekt.
❑ Der Nachweis der Terminierung ist für Schleifen und Rekursion erforderlich.
Informatik I – c Guido Rößling
Korrektheit – Totale Korrektheit
10.39
Schleifen
❑ Hier wird ein Integer-Ausdruck verwendet (etwa AÀ¹ bei Schleifenzähler ¹ ) der mit jedem
Schleifendurchlauf kleiner werden muß, ohne den Wert 0 zu unterschreiten.
❑ Für Schleifen, die z.B. ¹ von einem gegebenen Startwert bis zu dem Endwert Q hochz ählen,
kann daher der Ausdruck QrA ¹ verwendet werden.
☞ Da ¹ mit jedem Durchlauf um (z.B.) eins größer wird, wird dieser Ausdruck mit
jedem Durchlauf kleiner, ohne die 0 zu unterschreiten
❑ In den Nachweis der partiellen Korrektheit sind dazu Umformungen einzuf ügen, die das
Kleinerwerden des Ausdrucks nachweisen.
Informatik I – c Guido Rößling
Korrektheit – Totale Korrektheit : Schleifen
10.40
Schleifen
❑ Rekursion
☞ Auch hier läßt sich ein Zähler verwenden, der allerdings nachträglich einzuführen ist
☞ In vielen Fällen kann auch über die Änderung der Argumente argumentiert wer
den, z.B. bei der Fakultätsfunktion (QxèªH¾QdfF QMA ¡ è ), bei der das Argument mit
jedem Schritt um eins kleiner wird
Informatik I – c Guido Rößling
Korrektheit – Totale Korrektheit : Schleifen
10.41
Programmierparadigmen
Es gibt in der Informatik mehrere grundsätzliche Alternativen zum Entwurf von Programmiersprachen.
Jeder Alternative liegt ein separates Modell des Herangehens an die Implementierung zugrunde, ein Paradigma (Grundsatz oder Denkmuster).
Die wichtigsten Paradigmen in der Programmierung sind
❑ Imperative Programmierung,
❑ Objektorientierte Programmierung (aus der Imperativen Programmierung entstanden),
❑ Logische Programmierung und
❑ Funktionale Programmierung.
Im folgenden werden die einzelnen Paradigmen kurz vorgestellt.
Informatik I – c Guido Rößling
Imperative Programmierung
11.1
Allgemeines zur Imperativen Programmierung
❑ Imperative Programmierung ist die älteste Form der Programmierung. Imperativ“
”
stammt aus dem Lateinischen und bedeutet befehlend“.
”
❑ Vorgehen: Aufgliedern des Algorithmus in einzelne Befehle, meist Wertzuweisungen sowie Funktions- und Prozeduraufrufe.
Aus diesem Grund wird Imperative Programmierung auch als befehlsorientiert“ bezeich”
net.
❑ Sehr viele Programmiersprachen sind imperativ. Typische Vertreter sind beispielsweise:
☞ Assembler,
☞ BASIC-Dialekte,
☞ PASCAL und Turbo-Pascal
☞ sowie C.
❑ Daten werden in imperativen Programmiersprachen manipuliert durch direkte Wertzuweisungen an Variablen sowie Prozedur- und Funktionsaufrufe.
Informatik I – c Guido Rößling
Imperative Programmierung – Allgemeines
11.2
Modellierung von Daten und Objekten
Grundlegend zur Modellierung von Daten in imperativen Programmiersprachen sind Variablen der folgenden Typen:
❑ einfache Datentypen (etwa Integer, Float),
❑ Zeiger (auch als Referenz oder Pointer bezeichnet), die die Adresse von Variablen repräsentieren,
❑ Verbunde und Strukturen (records bzw. structs), in denen einzelne Datenelemente
in fester Reihenfolge angeordnet sind.
Durch Strukturen lassen sich auch dynamische Strukturen modellieren, etwa Listen:
TYPE i n t l i s t =
RECORD
v a l u e : INTEGER ;
next : i n t l i s t ˆ ;
END ;
Im Beispiel verweist next auf einen weiteren RECORD vom Typ intlist.
Informatik I – c Guido Rößling
Imperative Programmierung – Modellierung von Daten und Objekten
11.3
Objektorientierte Programmierung
Worum geht es bei objektorientierter Programmierung (OOP)?
❑ Die reale Welt besteht aus einer Menge unterscheidbarer, klassifizierbarer und interagierender Dinge ( Objekte“)
”
❑ Modellierung (eines Ausschnitts) der realen Welt durch kommunizierende Objekte
❑ Objekte bestehen aus einer Menge von Daten und Operationen auf diesen Daten
❑ Jedes Objekt hat einen eigenen Zustand (Instanzvariablen) sowie ein typisches Verhalten
(Methoden)
❑ ☞ Zusammenfassung (Kapselung) von Daten und Funktionen auf diesen Daten
☞ bessere Wartbarkeit
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Motivation
12.1
Schlüsselbegriffe: Klassen
Eine Klasse umfaßt Daten und Methoden, die auf diesen Daten arbeiten.
Die Daten werden meist als Attribute bezeichnet.
Beispiel: Eine Klasse Auto“ umfaßt (u.a.) die folgenden
”
❑ Attribute: Karosserie, Typbezeichnung, Benzinpegel, Gangschaltung,
Höchstgeschwindigkeit, aktuelle Geschwindigkeit
❑ Methoden: abbiegen, fahren, bremsen, beschleunigen, halten, parke
hochschalten, herunterschalten
Eine Klasse ist ein Muster“ für alle Objekte diesen Typs.
”
Klassen geben eine statische Definition der Daten und Methoden an.
☞ Die Klasse Auto“ gibt eine (unvollständige) Beschreibung von Eigenschaften an, die
”
allen Autos gemeinsam sind.
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Schlüsselbegriffe : Klassen
12.2
Objekte
Ein Objekt ist eine Instanz einer Klasse, also eine konkrete Auspr ägung.
Das Objekt übernimmt von der Klasse die Methoden sowie die Deklaration der Attribute,
kann aber die Werte der Attribute nach Belieben ändern.
Die Klasse definiert damit die Möglichkeiten, die alle Objekte dieser Klasse besitzen (im
Zuge der Methoden) sowie die Daten der Objekte (Attribute); die Werte der Attribute sowie
die Arbeit darauf bleibt den einzelnen Objekten überlassen.
Objekte entstehen zur Laufzeit
☞
Klassen entstehen zur Kompilierzeit ☞
dynamisch
statisch
Objekte die zu einer Klasse X gehören, haben den Typ X.
Beispiel: Alle möglichen Arten von Autos sind Objekt vom Typ Auto“.
”
Die Unterschiede zwischen den Objekten liegt in der Fahrgeschwindigkeit, H öchstgeschwindigkeit, Karosserie etc. – aber beide können alle vorhin angegebenen Methoden benutzen,
wie fahren, bremsen, beschleunigen.
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Schlüsselbegriffe : Objekte
12.3
Attribute und Methoden
Wie bereits erwähnt, werden die Daten einer Klasse als Attribute bezeichnet.
Attribute können dabei sowohl primitive Typen (Zahlen, Zeichen, boole’sche Werte) sein, als
auch (Referenzen auf) Objekte.
☞ Sinnvollerweise wird man die Karosserie eines Autos nicht einfach als Zahl
codieren, sondern als Objekt einer Klasse mit Attributen wie Anzahl und Lage
der Scheinwerfer, Anzahl der Türen, Attribute können sichtbar oder auch versteckt sein (in verschiedenen Abstufungen).
Beispielsweise sollte das Attribut Passwort einer Klasse Rechneraccount“ nicht für alle
”
les- oder schreibbar sein.
In der Objektorientierung wird Methode als Sammelbegriff f ür Funktion und Prozedur verwendet. Es gibt drei Arten von Methoden:
❑ Zustand abfragend: get X()
❑ Zustand ändernd: set X()
❑ Zustand abfragend und ändernd: evaluate()
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Schlüsselbegriffe : Attribute und Methoden
12.4
Abstrakte Datentypen
Ein sehr gutes Hilfsmittel zum Finden und Spezifizieren von Klassen sind die Abstrakten
Datentypen (ADT).
Ein ADT besteht aus
❑ einem Namen,
❑ der Angabe anderer verwendeter ADTs (vgl. Grundmengen“ bei der BNF),
”
❑ einer Spezifikation aller verfügbaren Methoden des ADTs,
❑ der Angabe aller Vorbedingungen oder Einschränkungen der Methoden,
❑ sowie der Angabe der Axiome“, die das Verhalten der Funktionen beschreiben.
”
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Abstrakte Datentypen
12.5
Beispiel zu Abstrakten Datentypen
Name: ARRAY
Verwendete ADTs: INTEGER
Methoden:
new
: INTEGER
INTEGER
get
: ARRAY
put
: ARRAY
INTEGER
length : ARRAY
Ó
Ó
DÕ¤Ö ×
BÙ DÖtÖtÚ Ú # # T × #
Î
Ó
INTEGER
Ò <9 Ø ù 9 *_< .$ÝÖtÚj×
Û Ù
× ÒÒ 9 ÉÉ ùù ËË 9 ÌÜ
ÌÜÛ *_< Ù .$ÝÖtÚj×
Axiome:
Ï Ú¶ÞÚjßfß;*_Ú\< à,á.$ÝÖ Ï Ö 9$<# *D( Õ¤& Ô Ö <9w×w# ×< & # T < ÞâPãåä\æçæß·á
Û *[.ÙÖ <*DÕ¤Ö <× Õ# 9 ×&
Ù *[.Ö B %=.ÖtÚ # T Õ# 9 × Õ# 9 ×Yù & T
Ù B
BÙ %=*[..DÖ Ö B %=%=..ÖtÖtÚ Ú # # T T Õ# Õ# 9 9 × × # #w(Pè8×YÕ# 9 & ×& Ù *B .Öt%=Ú .DÖt# Ú (P× #wè8Õ# 9 ×
B %=.DÖtÚ # *.DÖtÚ Õ# 9 × Õ# 9 ×Y&ÜÚ
ÙB
Û *_< Ù .$ÝÖ %R.ÖtÚ # T # 9 ×w×& Û *_< Ù .$ÝÖtÚj×
Vorbedingungen:
<* <
pre
*[. Õ9
pre
%=.
Õ9
pre
Î
Î
ÎÔ
ARRAY
INTEGER
INTEGER
INTEGER
Mindestens ein Element groß
Lesezugriff nur auf existente Felder
Schreibzugriff nur auf existente Felder
<
gibt beim Erzeugen die Länge an
beachten: Falls Vorbedingung nicht erfüllt, Fehler!
*.
%=.
geschriebenen Wert aus
%=. liest den mit
hat keinen Nebeneffekt
%=.
überschreibt vorhandene Werte
Schreiben des gelesenen Wertes ändert nichts am Feld
%=.
verlängert das Feld nicht
BÙ
B
B
B
Tabelle 19: Beispiel-ADT ARRAY“
”
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Abstrakte Datentypen : Beispiel
12.6
Vom ADT zur Klasse
Die Definition des ADTs kann als Gerüst für eine Klasse genommen werden:
❑ Der Name des ADTs entspricht dem Klassennamen
❑ Jeder Funktion des ADTs entspricht genau eine Methode der Klasse
❑ Die Axiome können wenigstens teilweise als Spezifikation der Methoden dienen – und
damit als Nachbedingungen
❑ Die Vorbedingungen entsprechen den Vorbedingungen der Methoden
❑ Es ist lediglich“ der Inhalt der Methoden so zu implementieren, daß er der Spezifikation
”
entspricht.
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Abstrakte Datentypen : Vom ADT zur Klasse
12.7
Von der Klasse zum Objekt
Wie kann man ein Objekt als Instanz einer Klasse erstellen, also z.B. ein bestimmtes ARRAY?
Zunächst ist eine Variable zu deklarieren, z.B. wie folgt:
Klassenname Variablenname;
Anschließend wird die Variable durch
Variablenname = new Klassenname()
instantiiert und enthält nun eine Referenz auf ein Objekt.
Es können auch Parameter angegeben werden:
Objektname = new Klassenname(Parameter)
Die Deklaration und Instantiierung kann auch zusammengefaßt werden:
Klassenname Objektname = new Klassenname();
bzw.
Klassenname Objektname = new Klassenname(Parameter)
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Von der Klasse zum Objekt
12.8
Konstruktoren
In den meisten OO-Sprachen besitzen die Klassen Konstruktoren, mit denen Objekte erzeugt werden können.
Konstruktoren sind wie Methoden aufgebaut, haben aber einen besonderen Namen. In C++
und Java ist der Name des Konstruktors immer der Name der Klasse.
Der Konstruktor für ein ARRAY hat also die Form
public ARRAY()
Å@3Æ
oder aber – mit Parametern – beispielsweise
public ARRAY(int size)
Å@3Æ
Der Standardkonstruktor ohne Parameter wird – wenn nicht neu definiert – vom System
vorgegeben und legt lediglich ein entsprechendes Objekt an.
Konstruktoren haben das erzeugte Objekt als Ergebnis und ben ötigen daher kein return.
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Von der Klasse zum Objekt : Konstruktoren
12.9
Konstruktoren
Bei Erzeugung des Objektes werden automatisch alle Attribute initialisiert; die Initialisierung
erfolgt im Sourcecode von links nach rechts und oben nach unten.
Der Konstruktor mit Parametern für ARRAY könnte beispielsweise wie folgt aussehen:
public ARRAY(int size)
Å
// reserviere Speicher für ¹/Ò Elemente;
Æ
und wird dann aufgerufen durch
ARRAY anArray;
anArray = new ARRAY(5);
oder direkt
ARRAY anArray = new ARRAY(5);
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Von der Klasse zum Objekt : Verwendung
12.10
Konstruktoren
Der Programmierer hat für jede Klasse die Wahl zwischen folgenden Alternativen:
❑ Die Klasse hat keinen (expliziten) Konstruktor.
In diesem Fall wird der Standardkonstruktor verwendet, der implizit stets definiert ist.
❑ Die Klasse hat genau einen Konstruktor.
Der Konstruktor darf dabei auch beliebige Argumente enthalten.
❑ Die Klasse besitzt mehrere Konstruktoren.
Die Konstruktoren müssen sich in Reihenfolge, Anzahl oder Typ der Parameter unterscheiden, damit Java zur Laufzeit erkennen kann, welcher Konstruktor zu verwenden ist.
(Zur Erinnerung: Der Name aller Konstruktoren ist der Klassenname!)
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Von der Klasse zum Objekt : Mögliche Fälle
12.11
Vererbung
Oft kann eine Klasse als eine Erweiterung oder eine Spezialisierung einer anderen Klasse
angesehen werden.
☞ Beispielsweise sind sowohl LKWs als auch Formel-1 Wagen spezielle Autos,
die eigene Eigenschaften besitzen (Nutzlast und Achsenzahl, bzw. Gewicht,
Rennstall und Spoiler).
❑ Duplizierung von viel Code aufgrund gemeinsamer Attribute und identischer Methoden –
insbesondere der gesamte Code der Klasse Auto“.
”
❑ Probleme bei Änderung von Auto-Attributen oder Methoden
☞ Versionskontrolle, Inkonsistenzen.
Insgesamt also :
❑ unschöne und unsaubere Modellierung
❑ Variablen müssen vom passenden“ Typ (Auto, LKW, Formel1Auto) deklariert wer”
den, da man sonst nicht auf Nutzlast bzw. Rennstall zugreifen kann.
❑ einem Auto kann nie ein LKW zugewiesen werden – ein LKW ist also kein Auto (!!!)
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Vererbung : Problemstellung
12.12
Vererbung
Die objektorientierten Sprachen besitzen daher das Konzept der Vererbung.
Vererbung bedeutet, daß eine Klasse B (der Erbe“) eine Erweiterung oder Spezialisierung
”
einer Klasse A ( Vorfahr“) ist, notiert als A N B ( N “ = ist Vorfahr von“).
”
”
”
Der Erbe übernimmt dabei
❑ alle Attribute des Vorfahrs sowie
❑ alle Methoden des Vorfahrs.
Der Erbe kann gegenüber dem Vorfahr
❑ weitere Attribute besitzen,
❑ zusätzliche Methoden beinhalten, sowie
❑ die geerbten Methoden anders implementieren.
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Vererbung : Motivation
12.13
Beispiele zur Vererbung
Einige Beispiele für sinnvolle Vererbung:
❑ Person N Student
Studenten sind Personen, die zusätzliche Attribute wie Uni und Fachrichtung, sowie
Methoden wie graduieren und vorlesung besuchen besitzen.
❑ Rechteck N Quadrat
Ein Quadrat ist ein Rechteck mit speziellen Eigenschaften, insb. bez üglich der Methode
flaeche, die anders (effizienter!) implementiert werden kann.
❑ Auto N LKW sowie Auto N Formel1Auto
Objekte vom Typ LKW oder Formel1Auto sind immer auch Autos.
Aus meiner Sicht nicht sinnvoll ist dagegen zum Beispiel Punkt N Polygon, da ein Polygon kein spezieller“ oder erweiterter“ Punkt ist.
”
”
Allerdings ist dies Anlaß für (fast) philosophische Streitfragen in der Modellierung – oft
dienen Punkte als Basis für alle Objekte in Grafiksystemen.
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Vererbung : Beispiele
12.14
Beispiel zur Vererbung Teil 1
Zur Implementierung eines Grafiksystems wurden bereits die folgenden Klassen CGPoint
zum Modellieren eines Punktes und CGPolygon zum Modellieren eines Polygons entwickelt:
public class CGPoint
public class CGPolygon
Å
Å
Æ
int x, y;
Vector nodes = new Vector();
public void set(int x value,
int y value) Å@3Æ
public void translate(int d x,
int d y)
public void set(Vector new nodes)
public void translate(int d x,
int d y)
ÅM3Æ
ÅM3Æ
public void paint(Graphics g)
public void paint(Graphics g)
ÅM3Æ
ÅM3Æ
Informatik I – c Guido Rößling
ÅM3Æ
Æ
Objektorientierte Programmierung – Vererbung : Beispiele
12.15
Beispiel zur Vererbung Teil 2
Es bestehen offenbar Gemeinsamkeiten zwischen CGPoint und CGPolygon, die die Methoden translate und paint betreffen.
❑ Erstellen einer Klasse CGObject mit Methoden translate und paint, aber ohne
Attribute
❑ Deklarieren von CGPoint und CGPolygon als Erben von CGObject:
public class CGPoint extends CGObject
sowie
public class CGPolygon extends CGObject
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Vererbung : Beispiele
12.16
Folgen der Vererbung im Beispiel
CGPoint und CGPolygon haben nun den gleichen Vorfahren CGObject.
❑ Überall, wo ein CGObject erwartet wird, kann nun auch ein CGPoint oder CGPolygon
benutzt werden
❑ Jedes CGObject-Objekt weiß, ob es sich um einen CGPoint oder einen CGPolygon
handelt und ruft die entsprechende korrekte Methode paint bzw. translate auf
☞ dynamisches Binden
❑ Es kann beispielsweise allen vorhandenen CGObjects gesagt werden, sie sollen sich anzeigen – CGPoint-Objekte benutzen dann die Methode der Klasse CGPoint, und CGPolyg
Objekte die Methode der Klasse CGPolygon.
❑ Das System kann konsistent ausgebaut werden durch Einf ührung weiterer Erben von
CGObject (etwa CGOval) oder CGPolygon (etwa CGFilledPolygon); die gemeinsamen Methoden können weiterhin direkt angesprochen werden.
❑ Befehle folgender Form sind möglich:
CGObject anObject = new CGPoint();
anObject = new CGPolygon();
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Vererbung : Folgen
12.17
Abstrakte Klassen
Für (denkbare) Objekte vom Typ CGObject gibt es keine allgemeine M öglichkeit, den Methodenkörper für translate bzw. paint anzugeben, da sie keine Koordinaten besitzen
und daher auch nicht verschoben oder gezeichnet werden k önnen.
Anstatt die Methoden einfach leer zu lassen, bietet Java ein besseres Konzept: abstract Methoden bzw. Klassen.
Eine als abstract deklarierte Methode besitzt keinen K örper:
public abstract void paint(Graphics g);
Sobald wenigstens eine Methode einer Klasse abstract ist, muß die ganze Klasse als abstract
deklariert werden:
public abstract class CGObject
Å
Æ
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Abstrakte Klassen
12.18
Abstrakte Klassen
Konsequenzen der Deklaration einer Klasse X als abstract:
❑ Da der Code der Klasse nicht vollständig ist, kann kein Objekt vom Typ dieser Klasse
instantiiert werden:
CGObject anObject = new CGObject();
gibt eine Compiler-Fehlermeldung.
❑ Jeder Erbe der Klasse muß entweder alle als abstract deklarierten Methoden implementieren oder selbst als abstract deklariert werden. CGObject wird quasi gezwungen,
translate und paint zu implementieren.
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Abstrakte Klassen
12.19
Überladen von Methoden
Geerbte Methoden können auch überladen werden. Dazu wird die Methode neu implementiert unter Beibehaltung der Schnittstelle des Vorfahren; die Methode des Vorfahren im Erben
nicht mehr direkt sichtbar.
Auf die geerbte Methode kann über super zugegriffen werden. Diese Größe erlaubt den
Zugriff auf die Methoden des Vorfahren.
Beispiel:
❑ Klasse X habe eine Methode build window components, die verschiedene Buttons
und Textfelder in ein Fenster einfügt.
❑ Klasse Y, die von X erbt, will alle Buttons von X übernehmen, aber noch einen weiteren
Button einfügen.
build window components() Å
super.build window components();
//uebernehme Buttons
//Code zum Zufuegen eines Buttons
Æ
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Überladen von Methoden
12.20
Definition von Interfaces
Interface = reine Schnittstellendefinition
Im Gegensatz zu einer abstrakten Klasse, die Attribute besitzen und Methoden implementieren darf, besteht ein Interface nur aus der Deklaration abstrakter Methoden sowie ggf.
Konstanten.
Interfaces können sowohl erweitert (☞ extends) als auch implementiert werden. Wie bei
der Vererbung einer abstrakten Klasse muß der Implementierer alle Methoden implementieren.
In Java-Notation:
public interface Interfacename
Å
public void methodenname(Parameter);
Æ
(Zugriffsrechte, Modifikatoren und Rückgabewerte sind beliebig wählbar)
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Interfaces : Definition
12.21
Implementierung eines Interfaces
Implementierung eines Interfaces:
public class Klassenname implements Interfacename
Å
public void methodenname(Parameter)
Å
Æ
Æ
Eine Klasse kann auch mehrere Interfaces implementieren, die dann durch Komma getrennt
angegeben werden:
public class Klassenname implements Interfacename1, Interfacename2
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Interfaces : Implementierung
12.22
Anwendung von Interfaces
❑ Jede Klasse, die das Interface implementiert, kann die Methoden anders implementieren
❑ Klassen können auf Interfaces für die Realisierung von Funktionen zurückgreifen
☞ Delegation“ der Aufgaben
”
❑ Normalerweise wird die Zuordnung der das Interface realisierenden Klasse zur aktuellen
Klasse durch eine Methode realisiert, etwa set Interface.
❑ Vorteil: Zur Laufzeit kann die Delegation geändert werden.
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Interfaces : Anwendung
12.23
Casting
Casting ist die explizite Umwandlung eines Datentyps in einen anderen.
Casting ist nur möglich, wenn die Datentypen einander ähnlich sind, z.B. kann int nach
float umgewandelt werden und umgekehrt, aber nicht nach oder von boolean.
❑ Casting von einem Objekt object in einen Datentyp Typ wird notiert als
(Typ)object
Beispiel: float f = 5.5; int i = (int)f; führt zu i = 5.
❑ Casts sind z.B. bei der Verwendung von Vector sinnvoll, da ein Vector nur (allgemeine) Object-Objekte speichert. Um auf konkrete Funktionalität eines Objekts zuzugreifen, muß es erst gecastet“ werden:
”
(CGObject)elementVector.elementAt(0)
❑ Ist der Cast zwischen unverträglichen statisch deklarierten Typen, erzeugt der Compiler
eine Fehlermeldung, z.B. beim Casten von int nach boolean.
❑ Beim Downcasten“, dem Cast von einem allgemeinen Objekttyp (etwa CGObject) zu
”
einem Erben dieses Typs (etwa CGPolygon), wird ggf. eine ClassCastException zur
Laufzeit erzeugt.
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Casting
12.24
Literatur zur Objektorientierung
❑ [Kre93b]
❑ [Fla96]
❑ [Rö97]
Informatik I – c Guido Rößling
Objektorientierte Programmierung – Literatur
12.25
Logische Programmierung
❑ Logische Programmierung wird auch als Prädikative Programmierung bezeichnet.
❑ Grundkonzept der Logischen Programmierung sind Fakten sowie Regeln. Die Berechnung
erfolgt durch Anwenden der Regeln und Fakten auf die Eingabedaten; die Antwort ist
wahr“ oder falsch“ bzw. eine Belegung von Variablen, die die Aussage erf üllt.
”
”
❑ Fakten sind eine Ansammlung von gültigen, d.h. erfüllten Prädikaten, die sozusagen das
Grundwissen“ darstellen.
”
❑ Regeln geben an, wie man anhand schon bekannter Fakten neue Fakten gewinnen kann.
❑ Der wichtigste Vertreter der Logischen oder Prädikativen Programmiersprachen ist PROLOG ( PROgramming in LOGic“)
”
❑ Einfaches mathematisches Beispiel: Eine Funktion zur Berechnung von Potenzen.
ù
potenz(x, 0, 1).
# g < H
potenz(x, n, m) :- potenz(x, n-1, m/x). # g ¾
H ¼
p
g
<7 H¾¼ÖEg
Tabelle 20: PROLOG-Programm zum Berechnen von Potenzen
Informatik I – c Guido Rößling
Logische Programmierung – Grundidee
13.1
Anfragen
❑ Anfragen an das System erfolgen in folgender Art:
☞ ? potenz(5, 2, 25)
Mit
dieser Art der Anfrage wird die Gültigkeit der Frage überprüft, d.h. gefragt gilt
”
e H
e ?“. Das Ergebnis der Anfrage ist true bzw. false.
☞ ? potenz(5, 3, m)
Hier wird nach dem Wert ¼ gefragt, für den das Prädikat true liefert, falls es einen
solchen Wert gibt. Ergebnis dieser Anfrage ist m=125.
❑ Zur Beantwortung von nicht-elementaren Anfragen wird die Resolution benutzt, bei der
systematisch alle Möglichkeiten ausprobiert werden, bis eine Lösung gefunden wurde
oder keine Alternative mehr existiert.
Durch eine Erweiterung von PROLOG um Funktoren“, die logisch zusammengehörige Da”
ten zusammenfassen (einem PASCAL Record ähnlich) sowie die definierten arithmetischen
Operationen ist PROLOG äquivalent zu den Imperativen oder Funktionalen Programmiersprachen: jedes algorithmisch lösbare Problem kann durch PROLOG gelöst werden.
Informatik I – c Guido Rößling
Logische Programmierung – Anfragen
13.2
Resolution und Unifikation
Grundidee:
1. Kann ein Teil der Behauptung mit einem Faktum unifiziert“ werden, so ist nur der Rest
”
der Behauptung weiter zu untersuchen.
Unifiziert“ bedeutet dabei im wesentlichen die Überführung eines Ausdrucks in einen an”
deren durch Einsetzen von Termen in Variable, etwa – im obigen Beispiel – der Ersetzung
von ¼ durch e .
2. Kann ein Teil der Behauptung mit einer linken Regelseite unifiziert werden, so kann dieser
Teil durch die rechte Regelseite ersetzt werden.
3. Die Behauptung ist bewiesen, wenn sie durch Anwendungen der beiden ersten Schritte in
eine leere Behauptung überführt werden kann.
Informatik I – c Guido Rößling
Logische Programmierung – Resolution und Unifikation
13.3
Beispiel zur Resolution
Beispiel:
Zu beweisen
Regel
potenz(5, 3, m)
Anfrage
—
Regel 1: 3 ¯H 0, Faktum greift nicht.
potenz(5, 2, m / 5)
Regel 2: Wählen der Regel für potenz
potenz(5, 1, (m / 5) / 5)
Regel 2 (Regel 1 greift nicht)
potenz(5, 0, ((m / 5) / 5) / 5) erneut Regel 2 (Regel 1 greift nicht)
((m / 5) / 5) / 5 = 1
Regel 1, Unifiziere ((m / 5) / 5) / 5 mit 1
(m / 5) / 5 = 5
Arithmetische Umformung zur Unifikation
m / 5 = 25
Arithmetische Umformung zur Unifikation
m = 125
Arithmetische Umformung zur Unifikation
m = 125
Systemantwort
Tabelle 21: Beispiel zur Resolution
Informatik I – c Guido Rößling
Logische Programmierung – Resolution und Unifikation : Beispiel
13.4
Funktionale Programmierung
❑ Zentrales Element der Funktionalen Programmierung ist die Funktion, die die Eingabedaten in Ergebnisse abbildet.
❑ Beschreibung der Beziehung von Eingabe- zu Ausgabedaten durch mathematische Funktionen
❑ Zugrunde liegen relativ wenige elementare Ausdrücke und (Grund-)Funktionen, aus denen komplexere Funktionen zusammengebaut werden.
❑ Jede Funktion kann wiederum als Argument dienen, so daß etwa auch Funktionen auf
Funktionen definierbar sind.
❑ Grundlegendes Konzept: Rekursion
❑ Programm“ ist eine Sammlung von Funktionen; Berechnung“ ist das Anwenden ( Ap”
”
”
plikation“) einer oder mehrerer Funktionen auf einer Liste von Werten oder Ausdr ücken
(die wiederum Funktionen sein können).
❑ Mit funktionaler Programmierung können alle algorithmischen Aufgabenstellungen gelöst
werden; sie ist daher äquivalent zur Imperativen oder Objektorientierten Programmierung.
Informatik I – c Guido Rößling
Funktionale Programmierung – Grundidee
14.1
Funktionale Programmierung
❑ Wichtigster Vertreter der Funktionalen Programmiersprachen ist LISP ( list processing
”
language“)
❑ Essentiell für die Programmierung ist es, Variablen nicht als Behälter“ für Werte zu
”
interpretieren, sondern als Platzhalter für Werte oder Funktionen, mit denen – im mathematischen Sinn – symbolisch gerechnet wird.
❑ Grundlegende Datenstruktur von LISP ist die Liste. Es stehen Funktionen zur Verf ügung,
um die wesentlichsten Listenoperationen durchzuführen, etwa Zugriff auf das erste Element (CAR), Zugriff auf die Liste ohne das erste Element (CDR) sowie die Vereinigung
von Listen (CONS).
❑ Beispiel: Ein LISP-Ausdruck, der alle Elemente einer Liste aufsummiert:
( d e f i n e sum ( l i s t e )
( COND
; Fallunterscheidung
( ( EQUAL l i s t e NIL ) 0 )
; Falls leer , Ergebnis 0
( T ( + ( CAR l i s t e ) ( sum ( CDR l i s t e ) ) ) ) ) ) ; Kopf + Summe R e s t l i s t e
Informatik I – c Guido Rößling
Funktionale Programmierung – Grundidee
14.2
Beispiele zur Funktionalen Programmierung
❑ Mit einer einfachen Änderung kann man die obige Funktion in folgende Funktion transformieren: <
° [ ¹ ¸ ¡ H
[9
%
[ 9 ¡ Hs° [ / ¡ >î° [ ¡ ¾

°
> fff>î° [ < ¡
9& sei dabei das ¹ -te Element einer Liste liste, die Q Elemente habe.
Die LISP-Funktion hat dann folgende Form:
( d e f i n e fktsum ( f l i s t e )
( COND
; Fallunterscheidung
( ( EQUAL l i s t e NIL ) 0 ) ; F a l l s l e e r , E r g e b n i s 0
( T ( + ( f ( CAR l i s t e ) )
; s o n s t Summe aus F u n k t i o n a n g e w e n d e t aus Kopf
( f k t s u m f ( CDR l i s t e ) ) ) ) ) )
; und R e k u r s i o n u e b e r R e s t der L i s t e
Bitte beachten Sie, daß die Funktion ° hier als Argument verwendet wird, d.h. nichts über
den Aufbau der Funktion (oder der Listenelemente!) gesagt wird.
Informatik I – c Guido Rößling
Funktionale Programmierung – Beispiele
14.3
Elisp
❑ Die wohl bekannteste Anwendung von Funktionalen Programmiersprachen ist der sehr
populäre Texteditor Emacs (für Unix, OS/2, Linux, Windows etc.), der eine LISP-Variante
namens Elisp ( Emacs Lisp“) benutzt.
”
Sämtliche Operationen – z.B. Einfügen und Löschen von Text, aber auch Suchen, Sortieren von Zeilen oder Blöcken sowie Befehlsdefinitionen und Menüs – sind in Elisp implementiert.
Der Benutzer kann jederzeit vorgefertigte oder selbstgeschriebene Elisp-Programme eingeben oder einladen, die die Funktionalität des Editors erweitern, aber auch abändern
können.
Informatik I – c Guido Rößling
Funktionale Programmierung – Elisp
14.4
Beispiel zu Elisp
Beispiel: Die folgende Funktion fragt vom Benutzer einen Dateinamen und eine Beschreibung ab und erstellt daraus einen HTML-Link.
( d e f i n e sum ( l i s t e )
( COND
; Fallunterscheidung
( ( EQUAL l i s t e NIL ) 0 )
; Falls leer , Ergebnis 0
( T ( + ( CAR l i s t e ) ( sum ( CDR l i s t e ) ) ) ) ) ) ; Kopf + Summe R e s t l i s t e
Es ergibt sich folgender Dialog:
Filename: haus.cg
Description: Skizze eines Hauses
Das Ergebnis ist dann folgender HTML-Text:
K P G@K LI GMK A HREF=“../Bsp/haus.cg“ G haus.cg K /A G (Skizze eines Hauses)
Informatik I – c Guido Rößling
Funktionale Programmierung – Elisp : Beispiel
14.5
Abbildungsverzeichnis
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Einordnung der Informatik . . . . . . . . . . . . . . . . . . . . .
Vom Problem zum Programm . . . . . . . . . . . . . . . . . .
Schematischer Aufbau des Systems . . . . . . . . . . . . . .
Ein typisches“ Fenster . . . . . . . . . . . . . . . . . . . . . . .
”
Klassenhierarchie für grafische Benutzerschnittstellen
Ableitungsbaum für eine einfache Grammatik . . . . . .
Ableitungsbäume für natürliche Zahlen . . . . . . . . . . .
Ableitungsbäume für ganze Zahlen . . . . . . . . . . . . . .
Syntaxdiagramm zur BNF auf Seite 3.24 . . . . . . . . . .
Syntaxdiagramm für ganze Zahlen . . . . . . . . . . . . . . .
Syntaxdiagramm für Aussagenlogik . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.8
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.13
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.17
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.19
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.21
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.27
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.28
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.11
Interpretation von I _Õ//
Schematischer Aufbau einer Turingmaschine . . . . . . . . . . . . . . . . .
Schema von und . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Verhalten der Funktionen für n=1, Í¢Í8Í ,5 . . . . . . . . . . . . . . . . . . . . . .
Verhalten der Funktionen für n=5, Í¢Í8Í ,12 . . . . . . . . . . . . . . . . . . . . .
Russische Matrioschkas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fehleranzahl in Windows 95 und Windows NT (aus c’t 19/1998) . .
Schema des Black Box-Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
R
. . . . . . . . . . . . . . . . . . . . . . 4.13
. . . . . . . . . . . . . . . . . . . . . . . . . . 5.7
. . . . . . . . . . . . . . . . . . . . . . . . . . 6.14
. . . . . . . . . . . . . . . . . . . . . . . . . . 6.18
. . . . . . . . . . . . . . . . . . . . . . . . . . 6.19
. . . . . . . . . . . . . . . . . . . . . . . . . . 7.2
. . . . . . . . . . . . . . . . . . . . . . . . . . 10.3
. . . . . . . . . . . . . . . . . . . . . . . . . . 10.9
Tabellenverzeichnis
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
BNF für natürliche Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
BNF für ganze Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein- und mehrdeutige BNF für Teile der elementaren Arithmetik . .
BNF für elementare Arithmetik . . . . . . . . . . . . . . . . . . . . . . . . . . .
Leseweise der Junktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Wahrheitstabelle der Junktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Backus-Naur-Form für die Aussagenlogik . . . . . . . . . . . . . . . . . . .
Konversionsregeln 1-6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Konversionsregeln 7-12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
BNF für die Prädikatenlogik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
BNF Prädikatenlogik mit beschränkten Quantoren . . . . . . . . . . . . .
Turingmaschinen-Programm zum Invertieren von Binärzahlen . . . .
Faktoren für die Komplexität . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die wichtigsten Komplexitätsklassen . . . . . . . . . . . . . . . . . . . . . . .
Berechnungsdauer von n Rechenschritten nach Komplexitätsklasse
Schema der Verifikation von Blöcken . . . . . . . . . . . . . . . . . . . . . . .
Beispiel zur Verifikation von Blöcken . . . . . . . . . . . . . . . . . . . . . .
Beispiel zur Verifikation von Fallunterscheidungen . . . . . . . . . . . .
Beispiel-ADT ARRAY“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
”
PROLOG-Programm zum Berechnen von Potenzen .
Beispiel zur Resolution . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . 3.18
. . . . . . . . . . . . . . . . . . . . . . . . . . 3.20
. . . . . . . . . . . . . . . . . . . . . . . . . . 3.23
. . . . . . . . . . . . . . . . . . . . . . . . . . 3.24
. . . . . . . . . . . . . . . . . . . . . . . . . . 4.6
. . . . . . . . . . . . . . . . . . . . . . . . . . 4.7
. . . . . . . . . . . . . . . . . . . . . . . . . . 4.10
. . . . . . . . . . . . . . . . . . . . . . . . . . 4.14
. . . . . . . . . . . . . . . . . . . . . . . . . . 4.15
. . . . . . . . . . . . . . . . . . . . . . . . . . 4.19
. . . . . . . . . . . . . . . . . . . . . . . . . . 4.22
. . . . . . . . . . . . . . . . . . . . . . . . . . 5.12
. . . . . . . . . . . . . . . . . . . . . . . . . . 6.7
. . . . . . . . . . . . . . . . . . . . . . . . . . 6.15
. . . . . . . . . . . . . . . . . . . . . . . . . . 6.20
. . . . . . . . . . . . . . . . . . . . . . . . . . 10.29
. . . . . . . . . . . . . . . . . . . . . . . . . . 10.30
. . . . . . . . . . . . . . . . . . . . . . . . . . 10.33
. . . . . . . . . . . . . . . . . . . . . . . . . . 12.6
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.1
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4
Index
Symbols
Backtracking 9.10
Halteproblem 5.13
MIMD 8.3
MISD 8.3
Master 8.5–8.6, 8.9–8.10
Primzahltest Solovay/Strassen 9.4
Quicksort 8.4, 9.2
SIMD 8.3
SISD 8.3
TSP 9.6–9.9
Worker 8.5–8.6, 8.9–8.10
NC 8.8
NPC 9.11
NP 9.11
P 9.11
Informatik I
Ziel 0.2
PROLOG 13.1
B
Berechenbarkeit 5.1, 5.3–5.14
Typische Probleme 5.14
Ziel 5.2
C
Church’sche These 5.13
D
determiniert 9.1–9.2, 9.6
Determinismus u. Nichtdeterminismus 9.1–9.12
deterministisch 5.1, 9.1–9.2, 9.10–9.12
dynamisch 12.3
E
entscheidbar 5.3–5.4, 5.13
Bezug zu rekursiv aufzählbar 5.4
F
Folgezustand 5.8
Formale Sprachbeschreibung 3.1–3.29
Ableitungsschritt 3.11
Alphabet 3.2, 3.3
Alternative 3.11
Backus-Naur-Form 3.8, 3.10–3.24
3.12
Ableitung 3.13
Ableitungsbaum 3.16–3.28
Ableitungssequenz 3.14–3.15, 3.28
Alternative 3.14
Arithmetische Ausdrücke 3.23
Binärzahlen 3.12
Ein- und Mehrdeutigkeit 3.21–3.22
Erzeugte Sprache 3.24
A
Abstrakte Datentypen 12.5–12.7
Axiome 12.5–12.7
Beispiel 12.6
Vom ADT zur Klasse 12.7
Vorbedingungen 12.5–12.7
Algorithmen 2.17–2.18
Aufwand siehe Komplexität
Definition 2.17
Typische Gebiete 2.18
Aufwand von Algorithmen siehe Komplexität
é
17.2
Ganze Zahlen 3.19–3.20
Natürliche Zahlen 3.17–3.18
Nonterminal 3.24
Notation 3.11–3.12
Priorität 3.24
Wort der Sprache 3.11, 3.13–3.15, 3.28
Kommentarzeichen 3.8
Kommunikationsform 3.1, 3.3
Konstante 3.8
Lexeme 3.5
Lexikalische Analyse 3.5
Literal 3.8
Nonterminal 3.10–3.11, 3.14
Notation 3.2, 3.3, 3.8
Parser 3.5
Regeln 3.3
Regelsystem 3.7
Reservierte Wörter 3.8
Semantik 3.7
Semantische Analyse 3.6
Sonderzeichen 3.8
Sprache 3.1, 3.3
Sprachform 3.3
Sprachstufe 3.2
Syntaktische Analyse 3.5, 3.6
Syntax 3.6, 3.7
Syntaxdiagramm 3.25–3.26
Terminal 3.10, 3.11, 3.14
Token 3.5
Zusammenfassung 3.27
Funktion 12.4, 14.1
Funktionale Programmierung 11.1, 14.1–14.5
Elisp 14.4–14.5
Emacs 14.4–14.5
LISP 14.2
Applikation 14.1
Beispiele 14.2–14.3, 14.5
Funktion 14.3
Rolle der Variablen 14.2
Funktionen siehe auch bei Rekursion
H
Heuristik 5.1, 9.5–9.9
heuristisch 9.1, 9.5–9.9, 9.12
I
Imperative Programmierung 11.1–11.3
Modellierung von Daten u. Objekten 11.3
Informatik
Begriff 1.1–1.6
Geschichte 1.8–1.19
Problemstellungen siehe Problemstellungen
Teilgebiete 1.7
Themengebiete 1.20–1.23
K
Komplement einer Menge 5.4
Komplexität 5.1, 6.1–6.24
6.13, 6.14
6.13, 6.14
average case 6.22, 6.23
Begriffe 6.3
average case 6.3
best case 6.3
Komplexität eines Algorithmus 6.3
Komplexität eines Problems 6.3
Platzbedarf 6.3
Problemumfang 6.3
worst case 6.3
Zeitaufwand 6.3
best case 6.22, 6.23
ê
ë
Elementare Kosten siehe Komplexität - Rechenschritte
Entwurfsüberlegungen 6.2
Implementierungs-Zeitkomplexität 6.4
Klassen 6.15–6.21
Y 6.15–6.21
Z 6.15–6.21
6.15–6.21
6.15–6.21
6.15–6.21
6.15–6.21
6.15–6.21
Laufzeitangaben 6.5
Motivation 6.4
Nutzen 6.6
O-Notation 6.11–6.21
Beispiele 6.12
Definition 6.11
Faustregel 6.12
konstanter Vorfaktor 6.11, 6.12
Startwert 6.11, 6.12
Platzkomplexität 6.4
Rechenschritte 6.7–6.10
Beispiel 6.8–6.10
Turingmaschinen-Zeitkomplexität 6.4
worst case 6.22, 6.23
KomplexitätskNC siehe NC
Korrektheit 5.1, 10.1–10.43
Fehlertypen 10.1
Geschichte 10.1
partielle Korrektheit 10.18, 10.42
Spezifikation 10.18–10.20
Terminierung 10.18
Testverfahren 10.4–10.17
Black Box-Test 10.4, 10.8, 10.9
Codeinspektion 10.4, 10.7
ìîí $ï
ìîí wðvï
ìîí~ñ òvó ï
ìîí ñ M òõó ï
ìîí Mîï ô M
ìîí M ï
ìîí M*ö ï
M*÷
ú
Grundbegriffe 4.5
Implikation ( ) 4.6–4.9
Junktoren 4.6–4.9
Äquivalenz siehe Logik - Äquivalenz ( )
Disjunktion siehe Logik - Disjunktion ( )
Faustregeln 4.8
Implikation siehe Logik - Implikation ( )
Konjunktion siehe Logik - Konjunktion ( )
Negation siehe Logik - Negation ( )
Unterschiede zur Umgangssprache 4.9
Konjunktion ( ) 4.6–4.9
Konversionsregeln 4.13–4.14
Negation ( ) 4.6–4.9
Nutzen 4.4
Prädikat 4.16–4.17
Definition 4.16
Prädikatenlogik 4.1, 4.15–4.24
Quantoren 4.18–4.24
Bereichsangabe 4.21
Probleme bei Auswertung 4.24
Variable 4.5
Wahrheitstabelle 4.7
Logische Programmierung 11.1, 13.1–13.4
Anfragen 13.2
Faktum 13.1–13.3
Funktoren 13.2
Regeln 13.1
Resolution 13.2–13.4
Unifikation 13.3
ü
ø
ü
û
M
Multitasking 8.2
Multithreading 8.2
N
nicht rekursiv aufzählbar 5.3
ú
ù
û
Integrationstest 10.13–10.15
Klassentest 10.12
Produkttest 10.16
Schreibtischtest 10.4, 10.6
Walkthrough 10.4, 10.6
White Box-Test 10.4, 10.10, 10.11
totale Korrektheit 10.18, 10.42
Totale Korrektheit
Rekursion 10.43
Schleifen 10.42
Typische Fehlerquellen 10.2
Verifikation 10.4, siehe Verifikation
L
Las Vegas-Algorithmus 9.3
Logik 4.1–4.25
Äquivalenz ( ) 4.6–4.9
F 4.7
T 4.7
allgemeingültig 4.5
Allquantor 4.20
Auswertung 4.23
Aussage 4.3, 4.5–4.6
Aussagenlogik 4.1–4.14
Backus-Naur-Form 4.10–4.11
Geschichte 4.2
Backus-Naur-Form
Aussagenlogik 4.10–4.11
Priorität 4.11
Disjunktion ( ) 4.6–4.9
Einsquantor 4.24
erfüllbar 4.5
erfüllt 4.5
Existenzquantor 4.19
Auswertung 4.22
ø
ù
nicht-determiniert 9.1, 9.3, 9.6
nichtdeterministisch 9.1, 9.10–9.12
O
Objektorientierte Programmierung siehe OOP
OOP 11.1, 12.1–12.24
Überladen von Methoden 12.20
Abstrakte Klasse 12.21
Abstrakte Klassen 12.18–12.19
Folgen 12.19
Abstrakte Methoden 12.18
Attribut 12.2–12.4
Casting 12.24
Downcasting 12.24
Fehler 12.24
Daten 12.2
Instanz 12.3
Instanzvariablen 12.1
Interface 12.21–12.23
Anwendung 12.23
Deklaration 12.21
Implementierung 12.22
Kapselung 12.1
Klasse 12.1–12.4
Konstruktor 12.8–12.11
Form 12.9
Standardkonstruktor 12.9
Verwendung 12.10
Methode 12.1–12.8
Objekt 12.1–12.4
statisch 12.2, 12.3
Vererbung 12.12–12.17
Beispiele 12.14–12.17
dynamisches Binden 12.17
Folgen 12.17
Möglichkeiten 12.13
P
Parallelität 5.1
Parallelrechner 8.2
Parallelverarbeitung 8.1–8.11
NC siehe NC
Architekturen 8.2
MIMD 8.3
MISD 8.3
SIMD 8.3
SISD 8.3
Multitasking 8.2
Multithreading 8.2
Parallelrechner 8.2
steuerungsorientiert 8.3
Einsatzgebiete 8.1
Problemstellungen 8.9–8.10
Speedup siehe Speedup
Voraussetzungen 8.5–8.6
Prädikative Programmierung siehe Logische Programmierung
probabilistisch 5.1, 9.1, 9.3, 9.12
Problemstellungen 2.1
Aufgabenbeispiele 2.3
Beispiel
Grafische Komponenten 2.11–2.16
idealisiertes Vorgehen 2.1
Vorgehen 2.4–2.10
Analyse der Problemstellung 2.6
Aufgabenstellung 2.4
Entwickeln Lösungsmodell 2.10
Erfassen der Problemstellung 2.5
zu klärende Fragen 2.8
Programmierparadigma 11.1
Struktur 11.3
T
Türme von Hanoi 7.11–7.20
Definition 7.11
Implementierung 7.17–7.20
Lösungsansatz 7.15
Vorüberlegungen 7.12
Travelling Salesman Problem siehe TSP
Turingmaschine 5.5–5.13
Form des Programms 5.8
Komponenten 5.6
Programm
Ausführung 5.10
Beispiel 5.11–5.12
Beispiel f. Befehl 5.9
Rate-Verifikations- 9.10–9.11
Rechenschritt 5.8
V
Verbund 11.3
Verifikation 10.21
Bindung von Variablen 10.25–10.27
Beispiele 10.26–10.27
Nachbedingung 10.22, 10.23
Richtung 10.23
Vorbedingung 10.22, 10.23
Vorgehensweise 10.22
weakest precondition siehe weakest precondition
W
weakest precondition 10.23–10.40
Befehl ohne Variablenänderung 10.24
Blöcke 10.30–10.33
Beispiel 10.32–10.33
Fallunterscheidung 10.34–10.36
R
randomisiert 9.3–9.4
Rekursion 5.1, 7.1–7.22, 14.1
Anwendungsgebiete 7.2
Arten der Rekursion 7.10
Beispiele 7.3–7.5, 7.8–7.9, 7.11–7.20
8-Damenproblem 7.9
Backtracking 7.9
Quicksort 7.9
Türme von Hanoi siehe Türme von Hanoi
ggt 7.5
Binomialkoeffizient 7.4
Fakultätsfunktion 7.4, 7.10
Fibonacci-Zahlen 7.5
Sprachbeschreibung 7.3
7.8
Summenformel
Türme von Hanoi siehe Türme von HanoiDefinition 7.1
Effizienz 7.6
Endrekursion 7.10
indirekte Rekursion 7.10
Lineare Rekursion 7.10
Literatur 7.22
Rekursionsanker 7.7
Rekursionsschritt 7.7
Typische Fehler 7.21
Vorteile 7.8
wechselseitige Rekursion 7.10
rekursiv siehe Rekursion
rekursiv aufzählbar 5.3–5.4, 5.13
ý
S
semi-entscheidbar siehe rekursiv aufzählbar
Speedup 8.7
Startzustand 5.8
Stolpersteine 2.19–2.20, 3.4
Beispiel 10.36
Schleifen 10.37–10.40
Beispiel 10.40
Invariante 10.38
Wertzuweisung 10.24
Beispiele 10.28, 10.29
Z
Zeiger 11.3
Literatur
þ
[DCG 89] Peter J. Denning, D. E. Comer, David Gries, Michael C. Mulder, Allen Tucker, A. Joe Turner, und Paul R. Young. Computing as a Discipline.
Communications of the ACM, 32(1):9–23, 1989.
ÿ
[Dud93]
Duden Verlag. Duden Informatik – Ein Sachlexikon für Studium und Praxis. Dudenverlag, 2. Ausgabeedition, 1993.
[FBK97]
Bernd Freisleben, Jörg Baumgart, und Thilo Kielmann. Skript zur Vorlesung Parallelverarbeitung. Technischer Bericht, Uni Siegen, 1997.
[Fla96]
David Flanagan. Java in a Nutshell - Deutsche Ausgabe. O’Reilly, 1996. Eine knappe, beispielorientierte Einführung in Java.
[GJ79]
Michael R. Garey und David S. Johnson. Computers and Intractability: a Guide to the Theory of NP-Completeness. Freeman, 1979.
[GZZZ95] G. Grosche, V. Ziegler, D. Ziegler, und E. Zeidler. Teubner-Taschenbuch der Mathematik, Teil II. Teubner, 7 Ausgabeedition, 1995.
[Hof79]
Douglas R. Hofstadter. Gödel, Escher, Bach. Penguin, 1979.
[Hop88]
John E. Hopcroft. Einführung in die Automatentheorie, formale Sprachen und Komplexit ätstheorie. Addison-Wesley, 1988.
[Kre93a]
Christoph Kreitz. Skriptum zur Informatik I. Skript, TU Darmstadt, 1993.
[Kre93b]
Christoph Kreitz. Tutorium zur Informatik IV. Skript, TU Darmstadt, 1993.
[Rö97]
Guido Rößling. Einführung in Java. Skript, Universitat-Gesamthochschule Siegen, 1997. http://www.informatik.uni-siegen.de/psy/gdv/EinfuehrungJava/java.html/.
[Sed92]
Robert Sedgewick. Algorithmen in C. Addison-Wesley, 1992.