2-up - ETH Zürich

Informatik II 

(Studiengang Informationstechnologie und Elektrotechnik) 

Vorlesung FS 2013 

Friedemann Mattern 

Departement Informatik, ETH Zürich 

Version vom 24. Januar 2013 

© F. Mattern, 2013 

1 

Inhalt der Vorlesung 

1. Ein Algorithmus und seine 

Implementierung in Java 

2. Java: Elementare Aspekte 

3. Klassen und Referenzen 

4. Syntaxanalyse und Compiler 

5. Pakete in Java 

6. Objektorientierung 

7. Exceptions 

8. Binärbäume als 

Zeigergeflechte 

9. Binärsuche 

10. Backtracking 

11. Spielbäume 

12. Rekursives Problemlösen 

13. Komplexität von 

Algorithmen 

14. Simulation 

15. Heaps 

16. Parallele Prozesse 

und Threads 

Relevant für die Prüfung ist der gesamte Inhalt der Vorlesung 

und der Übungen, nicht alleine diese Präsentationskopie! 

2 

1

Wer sind wir? 

Fachgebiet „Verteilte Systeme“ 

im Departement Informatik, 

Institut für Pervasive Computing 

Friedemann 

Mattern 

Simon Mayer 

Ansprechperson für 

organisatorische Aspekte 

(z.B. Übungsbetrieb) 

5 

Mit was beschäftigen wir uns sonst? 

Interaction 

Smart Environment 

Communication 

Context Awareness 

Internet of Things 

Cyber-Physical Systems 

Web Technologies 

Service Discovery 

Sensor Networks 

Privacy 

Ubiquitous Computing 

Security 

Augmented Reality 

Mehr zu uns: 

www.vs.inf.ethz.ch 

Social Impact 

Web of Things 

Smart Energy 

9 

2

Um was geht es in der Vorlesung? 

• Algorithmen und Datenstrukturen 

• Programmieren 

• Java, Objektorientierung 

• Allgemeine Grundlagen 

• Abstraktion, Modellbildung, 

Formalisierung,… 

• Teilaspekte der 

„praktischen Informatik“ 

• Simulation, Multitasking,… 

11 

Themen 








7. Exceptions 








Algorithmen 


15. Heaps 


und Threads 

12 

3

Um was geht es NICHT in der Vorlesung? 

• Die Vorlesung ist KEIN 

Java-Programmierkurs! 

• Es wird vorausgesetzt, 

dass man gut in C++ 

programmieren kann 

• Vorlesung „Informatik I“ 

13 

Organisatorisches 

• Bestellte Folienkopien auf Papier in der Pause 

• Übungsbetrieb beginnt in der 2. Vorlesungswoche! 

• Anmeldung für Übungsgruppen via mystudies-Applikation baldmöglichst 

(d.h., man muss sich für die Vorlesung eingeschrieben haben!) 

• Heute: 14:00-16:00 Uhr, CAB G11: Java-Einführung 

(optional, aber empfohlen!) 

• Aufgabenblatt jede Woche 

• Testat: mind. insgesamt 75% bearbeitete Aufgaben und 50% Punkte 

• Bearbeitung in Zweiergruppen 

• Prüfung (schriftlich) zusammen mit Informatik I 

• www.vs.inf.ethz.ch/edu/I2/ für weitere Informationen 

14 

4

Materialien zur Vorlesung 

• Folienkopien 

• in vorläufiger Version (gedruckt / pdf) 

• evtl. Nachträge später auf Web-Seite 

• Lehrbuch 

• Mark Allen Weiss: Data Structures & Problem 

Solving Using Java, Addison Wesley, 4. Auflage, 

2010, ISBN 0-321-54140-5, Fr. 160,00 

• Hörsaalverkauf (Fr. 135,- Barzahlung mit Legi; 

2. Semesterwoche, Mi 27. Feb., 9:00 Uhr) 

• Zu Java gibt es sehr viele Bücher (diverser Qualität), gut z.B.: 

• Christian Ullenboom: Java ist auch eine Insel, Galileo Computing, 

10. Auflage, 2011, ISBN 978-3-8362-1802-3 (auch online!) 

• Ken Arnold, James Gosling, David Holmes: The Java Programming 

Language, Addison-Wesley, 4th ed., 2005 

(evtl. in deutscher Übersetzung), auch Online-Tutorial im Web 

16 

FAQ 

• Wieso werden in Informatik I / Informatik II 

verschiedene Programmiersprachen verwendet? 

• Was unterscheidet Teil 2 von Teil 1 der Vorlesung? 

• Wieso benutzen wir in der Vorlesung so selten Computer? 

• Wieso gibt es keine Musterlösungen? 

• Wären die Konzerte von Beethoven 

nicht viel weniger chaotisch, wenn erst 

das Klavier alleine seinen Teil spielen 

würde und dann der Reihe nach...? 

17 

5

Der rote Faden zur Orientierung 

18 

Konzepte 

Die „Komposition“ 

der Vorlesung 

Java 

Korrektheitsnachweis (Invarianten und vollst. Indukt.) 

Robustes Programmieren 

Bäume 

Syntaxdiagramme 

Rekursiver Abstieg 

Infix, Postfix, Operatorbaum, Stack 

Codegenerierung, Compiler, Interpreter 

Verzahnte und verwobene Einführung konzeptioneller 

Aspekte und programmiersprachlicher Konstrukte 

Java: C-Level 

Java-Klassen als Datenstrukturen 

Dynamische Klassen und Referenzen 

Der rote Faden 

Java-VM als Bytecode-Interpreter 

Pakete 

Klassenhierarchie 

Polymorphie 

Suchbäume, Sortieren 

Backtracking 

Spieltheorie, Minimax, AlphaBeta 

Rekursives Problemlösen 

Effizienz, O-Notation 

Simulation (zeitgesteuert, ereignisgesteuert) 

Heap, Heapsort 

Pseudoparallelität 

Abstrakte Klassen 

Exceptions 

Programmbeispiele dienen gleichzeitig der 

Einführung programmiersprachlicher Konstrukte 

und der Illustration von Informatikkonzepten 

Threads in Java 

20 

6

Confusion? Clarity? 

Sometimes … effective teaching 

involves the deliberate inducing 

of confusion, the withholding of 

clarity, the refusal to provide 

answers... 

Sometimes that disappointment, 

while extremely annoying at the 

moment, is the sign that you've 

just been the beneficiary of a 

great course, although you may 

not realize it for decades... 

Stanley Needless Fishto say, that kind of 

teaching is unlikely to receive 

high marks on a questionnaire. 

Stanley Fish 

The New York Times (June 29, 2010) http://opinionator.blogs.nytimes.com/2010/06/21/deep-in-the-hear-of-texas/ 

21 

7

Laptops & Co.? 

• Notizen machen 

• Web? 

• Google, 

Wikipedia,… 

• Kommunikation? 

• Facebook, 

E-Mail, 

Twitter,… 

• Games? 

• … 

25 

Laptops & Co.? 

• Laptop-Nutzer künftig bitte nur hier sitzen 

Auch in der 

Toleranzzone 

bitte nur Vorlesungsbezogenes 

26 

8

Auszug aus dem ETH-Merkblatt für 

Studierende zum Thema Plagiate 

Ein Plagiat (teilweise Übernahme eines fremden Werks ohne Angabe von Quelle / Urheber) 

ist ein Disziplinarverstoss und muss umgehend der Rektorin gemeldet werden. 

a) Der Verfasser reicht ein Werk, das von einer anderen Person auf Auftrag erstellt wurde 

(„Ghostwriter“), unter seinem Namen ein. 

b) Der Verfasser reicht ein fremdes Werk unter seinem Namen ein. 

c) Der Verfasser reicht (Teile einer) Arbeit zu verschiedenen Prüfungs- oder Seminaranlässen ein. 

d) Der Verfasser übersetzt fremdsprachige Textteile und gibt sie als eigene aus. 

e) Der Verfasser übernimmt Textteile aus einem fremden Werk, ohne die Quelle mit einem Zitat 

kenntlich zu machen. Dazu gehört namentlich auch das Verwenden von Textteilen aus 

dem Internet ohne Quellenangabe. 

f) Der Verfasser übernimmt Textteile aus einem fremden Werk und nimmt leichte 

Textanpassungen und -umstellungen vor […], ohne die Quelle kenntlich zu machen. 

g) Der Verfasser übernimmt Textteile aus einem fremden Werk, paraphrasiert sie allenfalls und 

zitiert die entsprechende Quelle zwar, aber zitiert nicht im Kontext der übernommenen 

Textteile (Beispiel: Verstecken der plagiierten Quelle in einer Fussnote am Ende der Arbeit). 

Wissenschaftliches Ethos verlangt, dass geistige Schöpfungen, Ideen, Theorien anderer Personen 

kenntlich gemacht werden, auch wenn sie im Text bloss sinngemäss wiedergegeben sind. 

28 

Wissenschaftliches Ethos auch bei den Übungen 

• Alle Quellen / Ko-Autoren zitieren 

• Web, Bücher 

• Studierende anderer Übungsgruppen 

(z.B. bei Lerngruppen) 

• Studierende früherer Jahrgängen 

• … 

Coders’ top excuses 

• Nur Eigenbeitrag wird bewertet 

• Unehrliches Handeln führt zumindest 

zur Annullierung des gesamten 

Übungsblatts ( 0 Punkte) 

http://geekandpoke.com 

30 

9

36 

49 

70 

1. 

21 

07 

 

0 

24 

58 

Ein 

Algorithmus 

65 

 

und 

35 

seine 

Implementierung 

8 

in 93 

Java 

12 

84 

«Ein Algorithmus ist eine aus endlich vielen Schritten 

bestehende eindeutige 93 

Handlungsvorschrift 76 

zur Lösung 

eines Problems oder einer Klasse von Problemen.» 

49 

67 

[u.a.: Wikipedia] 

51 

12 

Einer der ältesten Algorithmen – das 

„altägyptische Multiplikationsverfahren“ 

Grundidee bereits im Papyrus 

Rhind (16. Jh. v. Chr.); wird 

auch als abessinische oder 

russische Bauernmethode 

bezeichnet 

«Wenn ihr nur duplieren und 

halbieren könnet, so könnet 

ihr das übrige ohne das 

Eins mal Eins multipliciren.» 

Christian von Wolff, 1679-1754 

Beispiel: 9 × 5 beziehungsweise 5 × 9: 

„Der Multiplikand wird ständig 

verdoppelt, der Multiplikator 

(unter Wegwerfen des 

Restes) ständig halbiert; 

aufaddiert werden sogleich 

oder schlussendlich – ganz 

wie man will – diejenigen 

Vielfachen, bei denen in der 

Multiplikatorhalbierung ein 

Rest weggeworfen wurde.“ 

-- F. L. Bauer 

- Verdoppeln (linke Spalte) bzw. ganzzahliges Halbieren (rechte Spalte) 

- Zeilen streichen, bei denen rechts eine gerade Zahl steht 

- Übrige Zahlen der linken Spalte aufaddieren 

33 

10

Altägyptisches Multiplizieren 

Das Verfahren ist auch unter 

„ Abessinische Bauernregel“ bekannt 

Nach C. Stanley Ogilvy [„Ethiopian multiplication“, Pentagon, Herbst 1950, S. 17-18]: 

Ein Oberst unternahm einmal eine Expedition nach Äthiopien, und irgendwo im Landesinneren ergab sich 

die Gelegenheit, acht Ochsen zu kaufen. 

“Wir versuchten dies”, so berichtete er, “auf dem ersten Markt, auf den wir stiessen, doch obwohl es dort 

Ochsen zu kaufen gab, wusste weder ihr Besitzer noch mein Führer, wie viel Maria-Theresien-Taler dazu 

ihren Besitzer wechseln sollten. Da keiner von ihnen rechnen konnte, stritten sie nur miteinander und kamen 

nicht von der Stelle. Schliesslich wurde der Priester des Ortes gerufen, da er der einzige war, der mit solchen 

Fragen fertigzuwerden imstande war. Der Priester erschien mit einem jungen Diener und ging daran, eine 

Reihe von Löchern in den Boden zu graben, jedes etwa in der Grösse einer Teetasse. Die Löcher waren in 

zwei parallelen Reihen angeordnet; mein Dolmetscher sagte, sie würden ‘Häuser’ genannt. Ihr Tun umfasste 

die ganze Mathematik, die in jener Gegend zur Abwicklung von Geschäften notwendig war, und die einzigen 

Voraussetzungen hierfür bestanden darin, zählen sowie mit zwei multiplizieren und dividieren zu können. 

Der Diener des Priesters hatte eine mit Kieselsteinen gefüllte Tasche. In das erste Loch der ersten Reihe 

legte er acht Kiesel (für jeden Ochsen einen), und 11 in das erste Loch der zweiten Reihe, da jeder Ochse 11 

Maria-Theresien-Taler kosten sollte. Mir wurde erklärt, dass die erste Reihe für die Multiplikation mit zwei 

verwendet würde: d.h. dass die doppelte Anzahl der Kiesel im ersten Loch in das zweite gelegt würde, und 

davon wieder die doppelte Anzahl in das dritte usw. Die zweite Reihe diene für die Division durch zwei: die 

halbierte Anzahl von Kieseln im ersten Loch würde in das zweite gelegt, und so weiter, bis im letzten Loch 

nur mehr ein Kiesel liege. Brüche würden vernachlässigt. 

Dann würden die Löcher der Divisionsreihe geprüft, ob sie eine gerade oder ungerade Anzahl von Kieseln 

enthielten. Alle ‘Häuser’ mit einer geraden Anzahl würden als ‘böse’, alle mit eine ungeraden Anzahl als 

‘gute’ bezeichnet. Aus allen ‘bösen Häusern’ würden die Kiesel herausgenommen und nicht gezählt. Die in 

den verbleibenden Löchern der Multiplikationsreihe enthaltenen Kiesel würden dann gezählt, und die Summe 

lieferte das Ergebnis.” Der Oberst staunte darüber, dass dieses Multiplikationssystem immer das richtige 

Ergebnis liefert, obwohl beim Halbieren einer ungeraden Zahl ein Fehler begangen wird. 

34 

Ethiopian Multiplication 

C. Stanley Ogilvy, „Ethiopian multiplication“, Pentagon, Fall 1950, pp. 17-18: 

Col. L. B. Roberts, now with the Merritt-Chapman & Scott Co. in New York, and formerly a Colonel of the U.S. 

Army Engineers, gives an amusing account of what he calls “Mathematics a la Ethiopea.” During an expedition 

whichheoncemadeintotheinteriorofthatcountryforthe purpose of finding the headwaters of the Blue Nile, 

his party had occasion to purchase eight bulls. 

“This we attempted to do,” he writes, “at the first market place we came to, but although there were bulls for 

sale there, neither the owner of the stock nor my headman knew how many Maria Theresa dollars should change 

hands. As neither could do simple arithmetic, they just stood and yelled at each other, getting nowhere. Finally 

a call was put in for the local priest, as he was the only one who could handle questions like this. 

“The priest and his boy helper arrived and began to dig a series of holes in the ground, each about the size of 

a tea cup. These holes were ranged in two parallel columns; my interpreter said they were called houses. What 

they were about to do covered the entire range of mathematics necessary to transact business in this area, and 

the only requirement was ability to count, and to multiply by and divide by two. 

“The priest's boy had a bag full of little pebbles. Into the first cup of the first column he put eight stones (one 

for each bull), and eleven into the first cup of the second column, since each bull was to cost ($MT) 11. It was 

explained to me that in this way of doing business, the first column of houses is used for multiplying by two; that 

is, twice the number of pebbles in the first cup are placed in the second, then twice that number in the third, 

and so on. The second column is for dividing by two: half the number of pebbles in the first cup are placed in 

the second, and so on down until there is one pebble in the last cup. Fractions are discarded. 

“The division column is then examined for odd or even numbers of pebbles in the cups.” (The colonel makes no 

comment on the fact that the comparatively subtle notion of parity is evidently within the grasp of these primitive 

mathematicians.) “All even houses are considered to be evil ones, all odd houses good. Whenever an evil house 

is discovered, the pebbles are thrown out and not counted. All pebbles left in the remaining cups of the multiplication 

column are then counted. The sum of them is the answer.” 

35 

11

Vorteile der altägyptischen 

Multiplikationsmethode 

• Beschreibung ist kurz 

• Einfach in der Anwendung 

• Effizient für Computer im Dualsystem 

• Verdoppeln → „left shift“ 

0 0 1 0 1 

0 1 0 1 0 

• Halbieren → „right shift“ 

0 0 1 0 1 

0 0 0 1 0 

(„ganzzahlig“, d.h. 

abgerundet) 

• Algorithmus wird daher in der „arithmetic 

logic unit“ (ALU) einiger CPUs verwendet 

Grundidee bereits im Papyrus Rhind 

(16. Jh. v. Chr.). Der Papyrus Rhind 

ist eine altägyptische, auf Papyrus 

verfasste Abhandlung zu verschiedenen 

mathematischen Themen, die 

wir heute als Arithmetik, Algebra, 

Geometrie, Trigonometrie und Bruchrechnung 

bezeichnen. 

36 

Historische Notiz 

Gottfried Wilhelm Leibniz 

Explication de l'Arithmétique 

Binaire, Academie Royale 

des Sciences, Paris, 1703 

37 

12

Fragen zur altägyptischen 

Multiplikationsmethode 

• Funktioniert das immer? 

• Was heisst „immer“? (z.B. negative Zahlen?) 

• Wenn nicht: wann? 

• Warum funktioniert es für alle (?) natürlichen Zahlen? 

• Wie beweist man die Korrektheit? 

• Ist das besser als die „Schulmethode“? 

• Was heisst „gut“? 

• Lässt sich Güte linear anordnen? 

• Wie schreibt man das Verfahren unmissverständlich auf? 

• In welcher Notation / Sprache? 

Kernaspekte der Informatik! 

38 

Wieso funktioniert die Methode? 

• Beobachtung bei 

a × b = 3 × 18: 

a 

3 

6 

12 

24 

48 

54 

b 

18 

9 

4 

2 

1 

Die erste Zeile wird 

sowieso gestrichen 

a 

6 

Gleiches Ergebnis, 

als hätte man 6 × 9 12 

(statt 3 × 18) berechnet 

24 

48 

Denkübung: Was geschieht, 

wenn b eine Zweierpotenz ist? 

54 

b 

9 

4 

2 

1 

• Also: a × b wird auf 

2a × b/2 zurückgeführt, 

falls b gerade 

• Das ist offenbar richtig 

(wie jeder weiss) 

• Bei geradem b darf 

man die erste Zeile 

also einfach streichen 

• Aber bei ungeradem b? 

39 

13

Ungerade Multiplikatoren 

• Beispiel a x b = 6 x 9: 

a 

6 

12 

24 

48 

54 

b 

9 

4 

2 

1 

Würde man die erste 

Zeile einfach streichen, 

dann würde am Ende 

ein Mal die 6 (d.h. der 

Multiplikand a) fehlen 

+ Korrektur der 

„vergessenen“ 

6 liefert 54! 

a 

12 

24 

48 

48 

b 

4 

2 

1 

• Also: Wenn b ungerade 

ist, muss man a zum 

Multiplikationsergebnis 

(des in der 2. Zeile spezifizierten 

Multiplikationsproblems) 

hinzuaddieren 

• Rechtfertigung: 

a × b = a + (2a × (b-1)/2) 

Wir haben also 6 × 9 durch 12 × 4 „approximiert“ 

Bzw. durch 6 × 8 (indem 9 zu 8 „abgerundet“ wurde) 

40 

Problemreduktion 

• Es gilt a × b = 


falls b ungerade 

• Was nützt diese leicht zu beweisende Eigenschaft? 

Wenn Duplizieren und Halbieren triviale Operationen 

sind, dann kann die Multiplikation zweier Zahlen auf 

ein „einfacheres“ Problem zurückgeführt werden 

- 12 × 4 ist „einfacher“ als 6 × 9, da mit 4 

zu multiplizieren einfacher ist als mit 9 

- „Einfacher“ heisst näher bei der 1: 

mit 1 zu multiplizieren, ist ganz einfach! 

41 

14

Endlose Reduktion? 

• Wir müssen aber noch festlegen, wann man mit der 

Problemreduktion am Ende ist 

• Eine endlose Reduktion ist schliesslich nicht praktikabel 

• Wir hören auf, wenn das Problem (hoffentlich) trivial geworden ist 

• In diesem Fall, wenn b = 1 ist 

• Denkübung: Wieso nicht bei b = 0 (wäre doch noch einfacher!)? 

falls b = 1 

• Wir schreiben daher: a × b = 


sonst 

42 

Rekursion 

To understand recursion, one 

must first understand recursion 

• Wir haben ein Problem auf eine einfachere „Instanz“ 

des gleichen Problems zurückgeführt („Rekursion“) 

• Im Beispiel sieht das etwa so aus: 

54 

-um 6 9 zu berechnen: 54 

berechne 12 4 und addiere 6 

-um 12 4 zu berechnen: 

berechne 24 2 

48 


berechne 48 1 

48 


fertig, das ist 48 

48 

Ein Multiplikationsalgorithmus 

könnte als rekursive Funktion f 

daher so definiert werden: 

Denkübung: Mathematisch exakte 

Rechtfertigung für Korrektheit? 

(Und für welchen Definitionsbereich?) 

43 

15

Der Algorithmus in Java 

Das interessiert 

uns jetzt nicht 

Die Methode 

heisst „f“ 

Das Ergebnis und die beiden 

Parameter sind ganze Zahlen 

static int f(int a, int b){ 

system.out.println(a + " 

Zugehörige schliessende 

Klammer „}“ am Ende 

" + b); 

if (b == 1) return a; 

if (b%2 == 0) return f(a+a, b/2); 

else return a + f(a+a, (b-1)/2); 

} Liefert der Rest bei der 

ganzzahligen Division 

Jedes Mal, wenn die Methode f 

„aufgerufen“ wird, schreibt sie 

die Parameter auf das Display 

Denkübung: Kann man das Schlüsselwort „else“ hier auch weglassen? 

44 

Ein ganzes Java-„Programm“ 

In Java ist immer alles in Klassen eingepackt; 

unsere Klasse haben wir „Mult“ genannt 

class Mult { 

public static void main(String args[]) { 

int i = 5, j = 9; Zwei Variablen für ganzahlige 

Werte (hier 5 bzw. 9) 

system.out.println 

(i + " mal " + j + " ist " + f(i,j)); 

} Das Ende der 

Methode „main“ Aufruf der Methode „f“ 


system.out.println(a + " " + b); 



else return a + f(a+a, b/2); 

} 

} 

Das Ende der Klasse 

Die Methode 

„f“ kennen 

wir schon 

Hier steht jetzt aber b/2 statt 

(b-1)/2: wieso ist das korrekt? 

Wir brauchen noch ein 

„Hauptprogramm“, das 

die Methode f aufruft 

und das Ergebnis ausgibt 

- diese Methode, die 

alles startet, heisst 

„main“ 

- um die anderen Dinge 

in dieser Zeile („public“ 

etc.) kümmern wir uns 

nicht; man schreibe 

das zunächst immer 

exakt so hin 

45 

16

Ausführen des Java-Programms 

Angenommen, wir haben 

unter Unix oder Linux 

unser Programm in einer 

Datei Mult.java stehen 

- Dateien mit Java- 

Quelltext sollten immer 

den Suffix .java haben 

- bei einer einzigen 

Klasse sollte die Datei 

wie die Klasse heissen 

46 

Illegale Eingaben? Terminierung? 

• Was würde geschehen, 

wenn wir diese Zeile 

vergessen hätten? 


system.out.println(a + " " + b); 




} 

• Oder: Woher wissen wir, dass stets b schliesslich 1 wird? 

• Was geschieht bei den Aufrufen f(1,0), f(0,1), f(0,5) ? 

• Und was bei negativen Zahlen? 

47 

17

Ein Experiment: f(1,0) 

1 0 

2 0 

4 0 

8 0 

16 0 

32 0 

64 0 

128 0 

256 0 

512 0 

1024 0 

2048 0 

4096 0 

8192 0 

16384 0 

32768 0 

65536 0 

131072 0 

262144 0 

524288 0 

1048576 0 

2097152 0 

4194304 0 

8388608 0 

16777216 0 

33554432 0 

67108864 0 

134217728 0 

268435456 0 

536870912 0 

1073741824 0 

-2147483648 0 

0 0 

0 

... 

0 ? 

java.lang.StackOverflowError 

48 

4. Juni 1996: „An Overflow Occurred“ 


Am 4. Juni 1996 misslang der erste Flug einer Ariane 5-Rakete. Sie explodierte 

nur 40 Sekunden nach dem Start in einer Höhe von ca. 3700 m. 

49 

18

An Overflow Occurred... 

Fri, 2 Aug 1996 – The causes of the Ariane 5 rocket crash (summary): 

• An overflow occurred in the Inertial Reference System (SRI) computer 

when converting a 64-bit floating point to 16-bit signed integer value. 

• There was no error handler for that specific overflow. The default 

handler shut down the SRI unit. 

• The standby SRI unit had previously shut itself down for the same 

reason. The hot SRI and the standby were running the same software. 

• The shutdown caused the SRI to output a memory dump on the bus. 

The main computer interpreted the memory dump as flight data, causing 

such a violent trajectory correction that the rocket disintegrated. 

• The program that failed was a pre-flight program, and should not have 

been running during the flight. 

50 

An Overflow Occurred... 

• “The investigation team concluded that the designers of 

the computer system put in protections against hardware 

faults but did not take into account software faults.” 

• Das gesamte Ariane-Programm wurde dadurch 

eineinhalb Jahre verzögert; dies kostete (die 

Steuerzahler...) schätzungsweise 10 Milliarden Euro 

Vgl. dazu: J. Jezequel, B. Meyer: “Design by Contract: 

The Lessons of Ariane”, Computer, Jan. 1997, 129-130. 

51 

19

Korrektheit von f(a,b) = a × b 

• Wir wollen zeigen, dass die Funktion 

, 1 

f(a,b) = 

2, /2 , 

2, 

 

, 

für alle a, b ∈ G + das Produkt von a und b berechnet. 

Wir beschränken also ganz bewusst den Definitionsbereich 

der Funktion (keine 0, keine negativen Zahlen, 

keine rationalen Zahlen bzw. Gleitpunktzahlen...) 

52 

Korrektheit des Java-Programms? 

• Damit wäre auch gezeigt, dass das Programmstück 



if (b%2 == 0) return f(2*a, b/2); 

else return a + f(2*a, (b-1)/2); 

} 

das erwartet tut. 

• Aber… 

• Woher wissen wir eigentlich, dass das Programm der oben 

definierten Funktion genau entspricht? (→ Semantik) 

• Wie ist eigentlich das „sonst“ zu interpretieren? Als Alternative zu 

„gerade“ (also: „ungerade“) oder auch zu b=1? 

• Müsste nicht zwischen den beiden if-Zeilen ein „else“ stehen? 

53 

20

Korrektheit von f induktiv 

• Behauptung: ∀ a, b ∈ G + : f(a,b) = a × b 

, 1 

f(a,b) = 

2, /2 , 

2, 

 

, 

• Beweis induktiv über b: 

• b = 1: 

∀ a ∈ G + : f(a,1) = a = a × 1 (gilt offensichtlich nach der Def. von f, Fall 1) 

• b = n+1, mit der Induktionsannahme ∀ a ∈ G + , ∀ b ∈ {1,...,n}: f(a,b) = a×b: 

a) Sei b gerade: Es gilt 

f(a,b) = f(2a,b/2) [nach Definition, Fall 2] 

= 2a × b/2 [wg. Induktionsannahme, da b/2 ∈ {1,...,n}] 

= a × b. 

b) Sei b ungerade (und ≠1): Es gilt 

f(a,b) = a + f(2a, (b-1)/2) [nach Definition, Fall 3] 

= a + 2a × (b-1)/2 [wg. Induktionsannahme da (b-1)/2 ∈ {1,...,n}] 

= a + a × (b-1) 

= a × b. 

Aber wieso eigentlich? 

54 

Denkübungen zum Induktionsbeweis 

• Darf a (im Beweis) auch eine negative ganze Zahl sein? 

• Hätte man im Beweis nicht auch den Fall b=0 mit 

einschliessen können? 

• Augustus De Morgan (1806 - 1871): Induction 

Published inThe Penny Cyclopedia of the Society for 

the Diffusion of Useful Knowledge, Vol. 12., 1838 


INDUCTION (Mathematics). The method of induction, in the sense in which the word is used in natural philosophy, is not known in pure 

mathematics. There certainly are instances in which a general proposition is proved by a collection of the demonstrations of different cases, which 

may remind the investigator of the inductive process, or the collection of the general from the particular. Such instances however must not be 

taken as permanent, for it usually happens that a general demonstration is discovered as soon as attention is turned to the subject. 

There is however one particular method of proceeding which is extremely common in mathematical reasoning, and to which we propose to give 

the name of successive induction. It has the main character of induction in physics, because it is really the collection of a general truth from a 

demonstration which implies the examination of every particular case; but it differs from the process of physics inasmuch as each case depends 

upon one which precedes. Substituting however demonstration for observation, the mathematical process bears an analogy to the experimental 

one, which, in our opinion, is a sufficient justification of the term ‘successive induction.’ A couple of instances of the method will enable the 

mathematical reader to recognise a mode of investigation with which he is already familiar. 

55 

21

Ausnahmen (Exceptions) 

• Ausnahmen sind Fehlerereignisse 

• Werden oft vom System ausgelöst 

• Können aber auch explizit im Programm ausgelöst werden 

• Können abgefangen und behandelt werden („catch“) 

• Fehlertypen sind hierarchisch gegliedert 

(z.B. Exception ⊃ RuntimeException ⊃ ArithmeticException) 

• Strukturierung durch „try“ und „catch“: 

Z.B. StackOverflowError 

try { 

// Hier stehen Anweisungen, bei denen 

// eine Fehlerbedingung eintreten kann 

} catch (Fehlertyp1) { 

// "Behandlung" dieses Fehlertyps; 

} catch (Fehlertyp2) { 

// "Behandlung" dieses Fehlertyps; 

} 

57 

Abfangen einer Exception 

static int f(int a, int b) { 


try 

{ 

if (b%2 == 0) return f(2*a, b/2); 

else return a + f(2*a, b/2); 

} 

} 

catch (StackOverflowError e) 

{ 

... 

System.out.println("..."...a...b...); 

System.exit(1); 

} 

… 

Hier erwarten wir keine Fehler, 

daher ausserhalb des try-Blocks 

e könnte man benutzen, 

um mehr über den 

Fehler zu erfahren 

Notausstieg aus dem Programm 

(könnten wir statt dessen etwas sinnvolleres tun?) 

Zu Exceptions siehe Buch 

von M. A. Weiss, Kap. 2.5 

58 

22

Was geschah eigentlich bei f(1,0)? 

1 0 

2 0 

4 0 

8 0 

16 0 

32 0 

64 0 

128 0 

256 0 

512 0 

1024 0 

2048 0 

4096 0 

8192 0 

16384 0 

32768 0 

65536 0 

131072 0 

262144 0 

524288 0 

1048576 0 

2097152 0 

4194304 0 

8388608 0 

16777216 0 

33554432 0 

67108864 0 

134217728 0 

268435456 0 

536870912 0 

1073741824 0 

-2147483648 0 

0 0 

0 

... 

0 

? 

java.lang.StackOverflowError 

59 

Arithmetischer Überlauf 

• Eigentlich trat in f (bei der Multiplikation mit b=0) 

schon lange vor dem Stack-Überlauf ein Fehler auf: 

-1073741824 0 

-2147483648 0 

-0 0 

-0 0 

• Die Sprachspezifikation von Java erläutert das Phänomen: 

“If an integer multiplication overflows, then the 

result is the low-order bits of the mathematical 

product as represented in some sufficiently large 

two's-complement format. As a result, if overflow 

occurs, then the sign of the result may not be the 

same as the sign of the mathematical product of 

the two operand values.” 

60 

23

Arithmetischer Überlauf (2) 

• Hier kam es also zu einem „arithmetischen“ Überlauf 

• Durch die Multiplikation mit 2 entstand eine Zahl, die grösser ist als 

der bei int darstellbare Bereich (-2147483648 bis 2147483647), man 

läuft im Zahlenring in den anschliessenden negativen Bereich hinein 

• Dies könnte auch bei einem Eingabewert b 0 passieren! 

• Diesen Fehlertypus würde man gerne abfangen, aber: 

• “Despite the fact that overflow, underflow, or loss 

of information may occur, evaluation of a multiplication 

operator never throws a run-time exception.” 

• Man muss also selbst dafür sorgen, dass das Produkt 

aus a und b nicht grösser als 2147483647 wird 

• Denkübung: wie? 

61 

Nochmal zur „altägyptischen Multiplikation“ 

• Beispiel 3 × 18: 

a 

3 

6 

12 

24 

48 

54 

b 

18 

9 

4 

2 

1 

Etwa 

log 2 b 

Zeilen 

1) Zeilen streichen, bei denen rechts eine gerade Zahl steht 

2) Übrige Zahlen der linken Spalte aufaddieren 

• Dieses Aufaddieren realisieren wir jetzt noch auf eine andere Art, 

indem wir schritthaltend „akkumulieren“ 

62 

24

a 

a 

Altägyptische Multiplikation iterativ 

static int f(int i, int j) 

int a = i; 

int b = j; 

int z = 0; 

while (b > 0) { 

z akkumuliert die 

Werte der linken 

Spalte nicht gestrichener 

Zeilen 

} 

Hier ist b 

gerade 

if ungerade(b) { 

z = z+a; 

b = b-1; 

} 

b = b/2; 

a = 2*a; 

} 

return z; 

Zur Übung: Geht b/2 bzw. 2*a 

auch mit den Shift-Operatoren 

b >>= 1 bzw. a

Effizienz des Multiplikationsalgorithmus 

• Frage: Wie lange dauert eine Multiplikation von a und b? 





} 

• Effizienzmass: Gesamtzahl der elementaren Operationen 

• Verdoppeln, Halbieren, Test auf „gerade“ bzw. „1“, Addition 

• Kommen offenbar pro Aufruf insgesamt nicht mehr als 5 Mal vor 

• Aber: Handelt es sich bei „b%2 == 0“ nicht um zwei Operationen statt einer einzigen? 

• Antwort: So wie der Test auf „gerade“ hier realisiert ist, werden für „b%2 == 0“ 

tatsächlich mehr Maschineninstruktionen ausgeführt, als z.B. für „b == 1“ – wir wollen 

aber von der konkreten Realisierung abstrahieren; auf Maschineninstruktionsebene lässt 

sich ein Test auf „gerade“ jedenfalls einfach und effizient realisieren, indem man testet, 

ob das rechteste Bit der Speicherzelle von b eine 0 oder eine 1 ist. 

67 

Effizienzabschätzung 

• Genauere Überlegungen müssten die unterschiedlichen 

„Kosten“ der verschiedenen Operationen berücksichtigen 

• Verdoppeln ist „billiger“ als Addieren etc. 

Kosten ≈ Zeit 

• Grosse Zahlen sind „teurer“ als kleine Zahlen 

• Wir setzen aber (vereinfachend) alle Operationen als gleich „teuer“ an 

• Wesentliches Kriterium: Anzahl der (rekursiven) Aufrufe 

• Dies ist nur von b abhängig, nicht von a 




• Also: wie viele rekursive Aufrufe gibt es? 

• Wie oft kann man b halbieren, bis ein Wert 1 herauskommt? 

(durch das Abrunden beim Halbieren ist dies konservativ geschätzt) 

• b / (2 x ) ≤ 1 ⇒ x ≥ log 2 b (Logarithmen in der Informatik i.Allg. zur Basis 2) 

• Es werden also nicht mehr als 5 log 2 b Operationen benötigt 

68 

26

Aufwands- / Qualitätsvergleich 

• Aus der Schule bekannt: „schriftliche“ Multiplikation 

• Wieso lernt man dies statt der altägyptische Methode? 

• Wie gut ist diese „Schulmethode“? 

• Wie viele (vergleichbar teure) Elementaroperationen? 

3 1 2 X 4 1 5 

1 2 4 8 + 

3 1 2 + 

1 5 6 0 = 

1 2 9 4 8 0 

69 

Aufwands- / Qualitätsvergleich (2) 

a 

b 

◊ ◊ ◊ ◊ X ◊ ◊ ◊ ◊ ◊ 

◊ ◊ ◊ ◊ 

◊ ◊ ◊ ◊ 

 

log log 

log log 

≈ 0.3 log 2 b 

◊ ◊ ◊ ◊ 

◊ ◊ ◊ ◊ 

◊ ◊ ◊ ◊ 

 

• Also N a N b „elementare“ 

Multiplikationen (kleines 

Einmaleins kann man 

auswendig!) und fast 

ebenso viele Additionen, 

also insgesamt etwa 

2 (log 10 a) (log 10 b) 

elementare Operationen 

Wann ist 5 log 2 b besser 

als 2 (log 10 a) (log 10 b) ? 

• Die multiplikativen Konstanten 

5 bzw. 2 sind nicht exakt, 

das ist aber nicht so relevant 

• Hängt wesentlich von a ab: 

2 (log 10 a) (log 10 b) kann (bei 

festem b) mit grösserem a 

über alle Grenzen wachsen! 

70 

27

Kosten ≈ Zeit ? 

„Jede Minute kostet 33 Franken im Rechenzentrum 

der ICS-Corporation in Zürich. Das steht 

auf Schildern, die der Schichtleiter Martin Kern 

überall anbringen lässt. Damit seine Operatoren 

ständig vor Augen haben, warum die Computer 

Tag und Nacht laufen müssen.“ (Limmat-Verlag, 

1977) 

Emil Zopfi studierte nach einer Berufslehre zum 

Fernmelde- und Elektronikapparatemonteur 

Elektrotechnik am Technikum Winterthur und 

arbeitete als Programmierer und Systemingenieur 

am Institut für Physikalische Chemie der 

ETH Zürich, bei Siemens und IBM. 

71 

Elementaroperationen 

• Wir haben mit der altägyptischen Multiplikationsmethode 

die Multiplikation auf die Addition zurückgeführt 

• Elementaroperationen waren dabei 

• Halbieren 

• Verdoppeln 

• Test auf gerade / ungerade (bzw. =1) 

• Wie könnte man diese Operationen weiter reduzieren? 

72 

28

Drei “Hilfsfunktionen” 

static boolean gerade(int x){ 

if (x == 0) return true; 

return !gerade(x-1); 

} 

static int verdopple(int x){ 

if (x == 0) return 0; 

return 2 + verdopple(x-1); 

} 

Der Wertebereich sei G 0 

Wieder mittels Rekursion 

Datentyp aus den beiden 

Werten true und false 

Die gleichbenannten formalen 

Parameter x haben 

nichts miteinander zu tun 

(verschiedene Kontexte) 

static int halbiere(int x){ 



return 1 + halbiere(x-2); 

} 

Was ergibt Halbieren 

ungerader Zahlen? 

Statt -2 (bzw. +2) könnten wir sogar -1-1 bzw. +1+1 

schreiben. Man braucht also eigentlich nur eine 

Maschine, die inkrementieren und dekrementieren kann 

(sonst keine Arithmetik) und würde z.B. schreiben: 

return incr(halbiere(decr(decr(x)))) 

73 

Ein funktionales Programm 

• Die Funktion f für die Multiplikation sieht dann so aus: 


if (b == 0) return 0; // neu: 0 statt 1 

if gerade(b) return f(verdopple(a),halbiere(b)); 

else return add(a, f(verdopple(a),halbiere(b))); 

} 

Die Methode add 

als Übungsaufgabe 

• Das ganze erscheint gekünstelt und unnötig aufwendig 

• Es soll hier auch nur das Prinzip illustrieren 

• Multiplikation geht eben auch im „funktionalen“ Stil! 

74 

29

Funktionale Programmiersprachen 

• Man kommt tatsächlich im Prinzip stets ohne explizite 

Zuweisungen und ohne „while“ aus! 

• Man könnte gewissermassen jedes Programm auch einfach 

in Form einer „mathematischen Funktion“ hinschreiben 

• Konsequent umgesetzt ist dies bei funktionalen Programmiersprachen 

(z.B. Lisp): im Gegensatz zu „imperativen 

Programmiersprachen“ (wie z.B. Java) enthalten diese 

• Keine Variablen (d.h. „Speicherzellen“), die im Programmablauf 

unterschiedliche Werte zugewiesen bekommen können 

• Keine Schleifen – wären auch überflüssig, wenn es keine 

Wertzuweisungen (und keine Seiteneffekte) gibt! 

75 

Apropos Lisp – die altägyptischen Multiplikation 

könnte man damit so programmieren: 

(defun mult (l r) 

(flet ((halbiere (n) (floor n 2)) 

(verdopple (n) (* n 2)) 

(gerade-p (n) (zerop (mod n 2)))) 

(do ((product 0 (if (gerade-p l) product (+ product r))) 

(l l (halbiere l)) 

(r r (verdopple r))) 

((zerop l) product)))) 

Quelle: www.stumbleupon.com/su/7yMsZ3/ 

rosettacode.org/wiki/Ethiopian_Multiplication 

• Wobei hier „halbiere“, „verdopple“ und „gerade-p“ nicht selbst als 

rekursive Funktion definiert sind – was aber einfach möglich wäre 

• Dies nur der Kuriosität halber; wir gehen nicht näher darauf ein 

76 

30

Ist Dekrementieren elementar? 

• Kann man einer Maschine, die nur Vorwärtszählen („incr“) 

kann, das Rückwärtszählen „per Programm“ beibringen? 

• Ja, wir benutzen dazu eine rekursive Hilfsmethode h: 

static int h(int x, int y){ 

if (x == incr(y)) return y; 

else return h(x, incr(y)); 

} 

Bei y x terminiert 

die Methode nicht; 

das ist für unseren 

Zeck aber irrelevant 

• Ein Aufruf h(5, 4) liefert offenbar 4 

• Allgemein: h(u, u-1) liefert u-1 

• Der Aufruf h(5, 3) führt zu h(5, 4) in der Rekursion 

• Also liefert h(u, 0) schliesslich h(u, u-1) = u-1 (für u > 0) 

77 

Ist Dekrementieren elementar? (2) 

• Wegen h(u,0) = u-1 lässt sich decr (für z ∈ G 0 ) so definieren: 

static int decr(int z) 

if (z == 0) return 0; 

return h(z,0); 

} 

• Rückwärtszählen lässt sich durch Vorwärtszählen „simulieren“ 

bzw. implementieren! 

• Erstaunlich? 

• Fragestellung der theoretischen Informatik: Was muss ein 

Computer („in Hardware“) nur mindestens können, damit 

er als „Universalrechner“ funktioniert? 

78 

31

2. 

Java 

Wir setzen gute Kenntnisse von C++ aus Teil I der Vorlesung voraus! 

Buch Mark Weiss „Data Structures & Problem Solving Using Java“ siehe: 

- 39-104 (primitive java, strings, arrays, input and output) 

79 

Java: Datenstrukturen und Algorithmen 

• Buch von Mark Allen Weiss: Data Structures & 

Problem Solving Using Java, Addison Wesley, 

4th edition, 2010, ISBN 0-321-54140-5 

• Zur Java-Sprache siehe insbes. Kapitel 1 – 4 

• Quellcode der Beispiele: 

http://users.cis.fiu.edu/~weiss/dsj4/code/ 

• Schwerpunkt des Buches liegt allerdings nicht auf Java 

selbst, sondern auf Algorithmen und Datenstrukturen 

• Alternativ bzw. als Ergänzung: 

Adam Drozdek: Data Structures 

and Algorithms in Java, Cengage 

Learning, 3rd edition, 2008 

80 

32

Java: Programmiersprache 

• Zum Programmieren lernen mit Java ist 

eventuell auch geeignet: Michael Goedicke, 

Klaus Echtle: Lehrbuch der Programmierung 

mit Java, dpunkt-Verlag 

• Empfehlenswert auch die Online-Version 

des Buches von Guido Krüger, Thomas Stark: 

Handbuch der Java-Programmierung 

www.javabuch.de/download.html 

• Eine Referenz für die Klassenbibliotheken 

ist die Java Platform API Specification: 

http://java.sun.com/reference/api/index.html 

81 

Java: Tutorial 

• Man konsultiere evtl. auch das Java-Online-Tutorial 

http://java.sun.com/docs/books/tutorial/ 

• Auch als Buch erhältlich: 

82 

33

Wieso Java statt C++ ? 

• C++ und Java bilden eine gemeinsame Sprachfamilie 

• Einheitliche Syntax und analoge Semantik 

nur Java 

Gemeinsamer 

Sprachkern 

Vorlesungen 

Informatik 

I und II 

nur C++ 

83 

Java: „Removed from C/C++“ 

• Templates 

• Strukturen, union (statt dessen: Klassen / Objekte) 

• Zeigerarithmetik, malloc (aber: Arrays und new) 

• Funktionen (statt dessen: Methoden) 

• Mehrfachvererbung (statt dessen: Interfaces) 

• Präprozessor: TYPEDEF, ... 

• #DEFINE und const (statt dessen: final) 

• Überladen von Operatoren 

• goto (statt dessen: break/continue, Exceptions) 

• using namespace, #include, .h-Dateien (aber: Pakete) 

• Destruktoren, free, delete (aber: Garbage-Collector; finalize) 

• Implizite Typkonvertierung 

• Friends (aber: „friendly access“ innerhalb von Paketen) 

• sizeof x (statt dessen: x.length) 

84 

34

Neu gegenüber C++ (u.a.) 

• Parallelverarbeitung in der Sprache („Threads“) 

• Viele vorgefertigte Pakete mit nützlichen Klassen 

• … 

• Generell: Java ist moderner, konsequenter, mehr „high-level“ 

und von einigem historischen Ballast von C und C++ befreit 

• C++ hat allerdings in den letzten Jahren aufgeholt 

und auch einige gute Konzepte von Java „adoptiert“ 

• C# („C sharp“) ist ebenfalls ein moderneres Element 

dieser Sprachfamilie, greift u.a. auch Konzepte der 

Sprachen Haskell und Delphi auf 

85 

Java-Entwicklung und Versionen 

• 1995: Version 1.0 (Sun Microsystems: James Gosling und Andere) 

• 2000: Java 1.3 

• Häufig benutzte Codefragmente werden zur Laufzeit von Bytecode 

in Maschinencode übersetzt Leistungssteigerung 

• 2002: Java 1.4 

• U.a. assertions 

Für unsere Zwecke sind die Unterschiede 

der Versionen weitgehend irrelevant 

• 2004: Java 5.0 (bzw. 1.5 oder „Java 2 Platform Standard Edition 5.0“) 

• U.a. generische Typen und Aufzählungen (enum) 

• Implizite Umwandlung einfacher Datentypen in Objekte und zurück 

• 2006: Java 6.0 

• Keine Sprachänderungen, aber Verbesserungen bei Anbindung von 

Skriptsprachen, Datenbanken, Web-Applikationen etc. 

• 2011: Java 7.0 

• Verbesserungen und Erweiterungen bestehender Funktionalitäten 

86 

35

Plattformunabhängigkeit durch 

Bytecode-Interpretation 

Kommando „javac“ 

(z.B. bei Linux) 

Ein Java-Programm läuft (prinzipiell) 

auf allen gängigen Computern und 

Betriebssystemen (PC, Server, Smartphones, 

Linux, Windows, Anroid,...) 

Bytecode ist die „Maschinensprache“ 

für eine virtuelle Maschine (VM) 

(steht in einer .class-Datei) 

87 

Die Virtuelle Machine (VM) 

• Die VM ist ein Bytecode-Interpreter 

• Programmierter Simulator eines abstrakten Prozessors 

• Relativ einfach für verschiedene Plattformen realisierbar 

• Unter Linux: Start der VM mit dem Kommando „java“ 

• Effizienzverlust durch Interpretation? 

• Evtl. statt dessen Bytecode in Zielsprache (weiter-)übersetzen 

(zumindest wiederholt gebrauchte Programmteile „just in time“) 

88 

36

Ausführung von Applets 

Applets sind kleine „mobile“ 

Java-Applikationen 

Der Bytecode-Verifizierer stellt 

sicher, dass der Bytecode nicht 

so verfälscht ist, dass (über 

Pointer, Indexüberschreitungen 

bei Arrays...) illegale Zugriffe 

möglich sind, die man mit Java 

gar nicht programmieren kann 

89 

Applets im Web-Browser 

• Ein Applet kann insbesondere von einem Web-Browser 

beim Anzeigen einer Webseite geladen werden: 

 

 

 

 

Hier sendet der Browser 

eine Request-Nachricht 

an den Server, das 

Applet (über das Netz) 

herunterzuladen 

90 

37

Java-Programmstruktur 

• Mit import werden evtl. anderweitig vorhandene 

Pakete von Klassen verfügbar gemacht 

• Der Klassenkörper enthält 

• Instanzen- und Klassenvariablen („Attribute“) 

• Benannte Konstanten 

• Klassenbezogene („static“) Methoden 

Manchmal auch 

„Felder“ genannt 

91 

Java-Programmstruktur (2) 

• Methoden übernehmen die Rolle von 

Funktionen bzw. Prozeduren anderer Sprachen 

• Konstruktoren sind spezielle Methoden (bei 

Erzeugen der Klasse automatisch aufgerufen) 

• Methoden haben einen Namen und bestehen aus 

• Parametern 

• Lokalen Variablen 

• Anweisungen 

92 

38

Java-Programmstruktur (3) 

• Bei eigenständigen Programmen (d.h. keinen 

Applets) muss es eine „main“- Methode geben: 

public static void main(String[] args) { 

... 

... 

} 

… main(…) 

• Jede Klasse kann eine solche main-Methode enthalten; 

sie wird bei „Aufruf“ der Klasse ausgeführt 

• Z.B. Linux: wenn der entsprechende Klassenname 

beim „java“-Kommando genannt wird 

• Klassen können getrennt übersetzt werden 

• Variablen im Klassenkörper ausserhalb von 

Methoden sind global zu allen Methoden der Klasse 

93 

Einfache Datentypen in Java 

Bildquelle: Christian Ullenboom: Java ist auch eine Insel, 

Galileo Computing, 8. Auflage, 2009, ISBN 3-8362-1371-4 

94 

39

Einfache Datentypen in Java 

• Integer (ganze Zahlen im 2er-Komplement): 

• byte (8 Bits) 

• short (16 Bits) 

• int (32 Bits) 

• long (64 Bits) 

Bereits von 

C++ bekannt 

Bsp. für Literale: 17 , -3914 

Range: -2147483648 ... 2147483647 

• Gleitpunktzahlen 

• float (32 Bits) 

• double (64 Bits) 

• Zeichen („Unicode“) 

• char (16 Bits) 

• Wahrheitswerte 

• boolean 

Bsp. für Literale: 18.0 , -0.18e2 , .341E-2 

65536 versch. Werte, dadurch 

„internationale“ Zeichensätze möglich 

Literale: true , false 

Operatoren: &&, | |, ! 

95 

Einfache Datentypen in Java (2) 

Quelle: Christian Ullenboom: Java ist auch eine Insel, 

Galileo Computing, 8. Auflage, 2009, ISBN 3-8362-1371-4 

96 

40

Einfache Datentypen in Java (3) 

Quelle: http://de.wikipedia.org/wiki/Java-Syntax 

97 

Konventionen bei der Deklaration von Namen 

• Variablen und Methoden beginnen 

mit einem Kleinbuchstaben 

• int i, j, meinZaehler; 

• public ausgabe (…) 

• Klassennamen beginnen mit 

einem Grossbuchstaben 

• class Person {…} 

Wir halten uns im 

Folgenden aber nicht 

immer an diese 

Konventionen… 

• Benannte Konstanten ganz mit 

Grossbuchstaben 

• MAX_SIZE 

98 

41

Arrays 

• Arrays sind („mathematisch betrachtet“) endliche Folgen 

Grösse, d.h. Anzahl 

int [] x; // array of int 

der Elemente 

x = new int[7]; // Grösse 7 (Indexbereich 0..6) 

for (int i=0; i < x.length; i++) x[i]=17; 

int [] x = new int[7]; // so ginge es auch 

int [] y; 

y = x; // y zeigt auf das gleiche Objekt 

y[3] = 9; // x[3] ist daher jetzt auch 9 

Arrays sind Referenzen auf (Speicher)- 

Objekte: Vorsicht bzgl. der Kopiersemantik 

(„Aliaseffekt“) und beim 

Vergleich zweier Array-Variablen! 

99 

Arrays (2) 

• Mehrdimensionale Arrays: 

float [][] matrix = new float [4][4]; 

matrix[0][3] = 2.71; 

• Da Arrays mit „new“ dynamisch erzeugt werden, kann 

die Grösse eines Arrays zur Laufzeit festgelegt werden: 

int n; 

... 

n = … // Wert berechnen oder einlesen 

int [] tabelle = new int [n]; 

• Einmal angelegt, kann sich die Grösse aber nicht mehr ändern! 

100 

42

Typkonversion 

• Java ist eine streng typisierte Sprache 

• Compiler kann viele Typfehler entdecken 

Keine automatische Typkonversion 

wie bei C++ 

• Gelegentlich muss dies jedoch durchbrochen werden 

• So geht es nicht ( Fehlermeldung durch Compiler): 

int myInt; 

float myFloat = -3.14159; 

myInt = myFloat; 

• Statt dessen explizite Typumwandlung („type cast“): 

int myInt; 

float myFloat = -3.14159; 

myInt = (int)myFloat; 

101 

Typkonversion (2) 

• Umwandlung hin zu einem grösseren Wertebereich 

(z.B. int → float) geht allerdings auch implizit 

float d = 5 + 3.2; 

• Typumwandlung ist gelegentlich 

sinnvoll bei Referenzen: 

Hund h; Tier fiffi; 

... 

if (fiffi instanceof Hund) 

h = (Hund)fiffi; 

Wenn das Tier mit dem Namen „fiffi“ hier ein 

Hund ist, dann betrachte fiffi als einen Hund 

Später mehr dazu („type cast“ bei Polymorphie) 

Das Problem inkompatibler Typen 

102 

43

Hüllenklassen 

• Einfache Datentypen (int, float,...) sind a priori keine 

echten Objekte (zu grosser Aufwand ineffizient!) 

• Für diese gibt es bei Bedarf sogenannte Hüllenklassen 

• Objekte davon können überall dort verwendet werden, 

wo eine Objektreferenz verlangt wird 

103 

Hüllenklassen (2) 

• Beispiel 

int x = 5; // normaler "int" 

Integer iob = x; // Instanz der Klasse "Integer" 

if (iob == 5) then ... // sind typkompatibel 

• Hüllenklassen bieten einige nützliche Methoden und Attribute 

• Vgl. dazu Dokumentationen im Web oder geeignete Java-Bücher 

• Z.B. bei Integer: 

floatValue () 

toString () 

• Beispiele: float f; … f = iob.floatValue(); 

104 

44

Ein- und Ausgabe 

int count = 0; 

while (System.in.read() != -1) count++; 

System.out.println("Eingabe hat " + 

count + "Zeichen."); 

• System.in: Standard-Eingabestrom 

• System ist eine Klasse mit Schnittstellenmethoden zum 

ausführenden System (Betriebssystem, Computer) 

• System.in ist der Standard-Eingabestrom (vom Typ InputStream) 

• read liest ein einzelnes Zeichen; liefert -1 bei Dateiende 

• Es gibt noch einige weitere Methoden (skip, close,...) 

• Erst abgeleitete Typen von InputStream enthalten Methoden, 

um ganze Zeilen etc. zu lesen (z.B. Klasse DataInputStream) 

105 

Ein- und Ausgabe (2) 

Konkatenation 

von strings 

int count = 0; 

while (System.in.read() != -1) count++; 

System.out.println("Eingabe hat " + 

count + "Zeichen."); 

• System.out: Standard-Ausgabestrom 

• print gibt das übergebene Argument (auf einem Display) aus 

• println erzeugt zusätzlich danach noch einen Zeilenumbruch („newline“) 

• Es können u.a. int, float, string, boolean... ausgegeben werden 

106 

45

Einlesen von Zahlen – ein Beispiel 

import java.io.* 

class X { 

Der Eingabestrom muss 

public static void main(String args[]) beim Aufruf des Konstruktors 

angegeben werden 

throws java.io.IOException { 

int i=0; String zeile; 

DataInputStream ein = new DataInputStream(System.in); 

} 

} 

... 

} 

... 

In diesem Paket stehen die 

Ein-Ausgabe-Methoden 

while(true) { 

zeile = ein.readLine(); 

i = i + Integer.parseInt(zeile); 

System.out.println(i); 

„parseInt“ ist eine Methode 

der Klasse „Integer“, die 

einen string in einen int- 

Wert konvertiert (analog 

kann man auch Gleitpunktzahlen 

einlesen) 

Die auftretbaren Exceptions 

müssen nach throws am Anfang 

einer Methode genannt werden 

Die Klasse DataInputStream 

enthält die Methode readLine, 

welche alle Zeichen bis 

Zeilenende liest und daraus 

einen string konstruiert 

Beachte: Die Methode readLine 

kann eine IOException auslösen! 

Man könnte hier auch 

ein.readLine() für 

zeile substituieren 

107 

Zeichenketten (strings) 

• Zeichenketten werden mit der Standardklasse String realisiert 

• Achtung: Strings sind im Unterschied zu C++ keine char-Arrays! 

String msg = "Die"; // String-Objekt wird 

int i = 7; 

// automatisch erzeugt 

msg = msg + " " + i; // Konkatenation 

msg = msg + " Zwerge"; 

Alternativ zur 

ersten Zeile geht 

es auch so: 

msg = new 

String("Die"); 

System.out.println(msg); // Die 7 Zwerge 

System.out.println(msg.length()); // 12 

String b = msg; 

msg = null; 

System.out.println(b); // Die 7 Zwerge 

109 

46

Zeichenketten (strings) (2) 

• Vergleich von strings: 

• Vergleich mit == ist oft nicht sinnvoll (Referenzvergleich) 

• Stattdessen Wertevergleich: s1.equals(s2) 

u 

y 

x B a u m 

Referenz 

z 

Wert 

V o g e l 

B a u m 

• x == u ist „false“ 

• x.equals(u) ist „true“ 

• u.equals(x) ist „true“ 

• y==z ist „true“ 

• y.equals(z) ist „true“ 

• Lexikographischer Vergleich mit s1.compareTo(s2) 

(liefert einen int-Wert 0) 

„Lexikographisch“: Wie im Lexikon – also alphabetisch; bei gleichen Präfixen kommt 

es auf das erste unterschiedliche Zeichen an („Zucker“ < „Zug“); ganze Wörter kommen 

vor Präfixen anderer Wörter („Kuh“ < „Kuhle“); wo „ü“ angeordnet wird (bei 

/ vor / nach „u“, oder erst nach „z“), wie Gross-/Kleinbuchstaben, Ziffern, Sonderzeichen 

angeordnet werden, ist durch das Alphabet bestimmt (hier: Unicode). 

110 

Zeichenketten (strings) (3) 

• Es gibt eine Vielzahl von Methoden und Konstruktoren 

• Länge („length“) 

• Teilstrings („substring“) 

• Umwandlung von Zeichen (z.B. Gross- / Kleinschreibung) 

• Umwandlung von char- und byte-Arrays in strings 

• Umwandlung von anderen Datentypen in strings (und umgekehrt) 

• ... 

• Mehr dazu in der „Java Platform API Specification“: 

http://java.sun.com/reference/api/ ( „core API“ java.lang String) 

111 

47

Auszug aus der API-Beschreibung 

(API = „Application Programming Interface“) 

compareTo 

public int compareTo(String anotherString) 

Compares two strings lexicographically. 

Parameters: 

anotherString - the String to be compared. 

Die einzelnen Zeichen werden 

entsprechend ihrer Reihenfolge 

im Unicode-Zeichensatz verglichen. 

Möchte man Grossund 

Kleinbuchstaben gleich 

behandeln, dann verwende 

man compareToIgnoreCase 

statt dessen. 

Returns: 

The value 0 if the argument string is equal to this string; a value less 

than 0 if this string is lexicographically less than the string argument; 

and a value greater than 0 if this string is lexicographically greater than 

the string argument. 

112 

Auszug aus der API-Beschreibung (II) 

concat 

public String concat(String str) 

Concatenates the string argument to the end of this string. 

Parameters: 

str - the String which is concatenated to the end of this String 

Returns: 

A string that represents the 

concatenation of this object's 

characters followed by the 

string argument's characters. 

Beispiele: 

"Zeit".concat("geist"); 

String s = "Drei"; 

s.concat(" Millionen"); 

113 

48

Auszug aus der API-Beschreibung (III) 

copyValueOf 

public static String copyValueOf(char data[]) 

Parameters: 

data - the character array 

Returns: 

A String that contains the characters of the array. 

114 

3. 

Klassen und 

Referenzen 

Konzepte sind aus Teil I der Vorlesung aus C++ im Wesentlichen bekannt! 

Buch Mark Weiss „Data Structures & Problem Solving Using Java“ siehe 

Seiten: 115-122 (this, static); 66-70 (Referenzen); 69 (Gleichheit) 

117 

49

118 

Ein Datentyp für Datumsangaben 

Diese drei private-Attribute 

sind von ausserhalb der 

Klasse nicht sichtbar. 

Eine Methode mit dem gleichen 

Namen wie die Klasse 

stellt einen "Konstruktor" dar. 

Er wird beim Erzeugen eines 

Objekts automatisch aufgerufen; 

man kann (nur) damit 

die neuen Objekte (deren 

Variablen) initialisieren. 

Konstruktoren haben keinen 

Rückgabetyp. 

Diese Klasse hat einen 

zweiten Konstruktor mit einer 

unterschiedlichen Signatur. 

Welcher Konstruktor genommen 

wird, richtet sich nach 

der Signatur beim new-Aufruf. 

class Datum { 

private int Tag, Monat, Jahr; 

public Datum() { 

System.out.println("Datum mit Wert 

0.0.0 gegründet"); 

} 

public Datum(int T, int M, int J) { 

Tag = T; Monat = M; Jahr = J; 

} 

Man hätte hier auch 

präziser sein können: 

public void Drucken() { this.Tag...; this.Monat etc. 

System.out.println(Tag + "." + Monat 

+ "." + Jahr); 

} 

public void Setzen(int T, int M, int J) { 


} 

} 

119 

50

Ein Datentyp für Datumsangaben (2) 

„Accessor“-Methode: 

liefert Werte privater 

Attribute nach aussen 

„Mutator“-Methode: ändert 

Werte privater Attribute 

Da man auf die Attribute 

Tag, Monat und Jahr von 

aussen nicht zugreifen 

kann, wird zum Setzen 

des Datums eine Methode 

bereitgestellt. 

class Datum { 


public Datum() { 

System.out.println("Datum mit Wert 

0.0.0 gegründet"); 

} 

public Datum(int T, int M, int J) { 


} 

public void Drucken() { 

System.out.println(Tag + "." + Monat 

+ "." + Jahr); 

} 

public void Setzen(int T, int M, int J) { 


} 

} 

120 

Verwendung des Datum-Typs 

class Beispiel { 

public static void main (String args[]) { 

Datum Ostermontag = new Datum(); 

/* ==> Datum mit Wert 0.0.0 gegründet */ 

} 

} 

Ostermontag.Drucken(); 

Ostermontag.Setzen(01,04,2013); 

Ostermontag.Drucken(); 

... 

• „Ostermontag“ ist eine Variable vom Typ „Datum“ 

• Genauer: eine Referenz, die auf Datum-Objekte zeigen kann 

• Ostermontag hat (als Datum-Objekt) auch einige Methoden 

• Hier: „Drucken“ und „Setzen“ (Zugriff mit Punktnotation) 

• Sowie zwei Konstruktoren (Aufruf bei new) 

Hier wird der erste 

Konstruktor aufgerufen 

Liefert 0.0.0 

Liefert 1.4.2013 

121 

51

Verwendung des Datum-Typs (2) 

• Eigentlich sollte „Setzen“ zumindest einen Plausibilitätstest 

machen (Monat ≤ 12, Tag ≤ 31 etc.) 

• Gleiches gilt für den zweiten Konstruktor 

• Auf diese Weise könnte garantiert werden, dass 

illegale Datumsangaben weitgehend vermieden werden 

• Der Zugriff auf private Attribute von ausserhalb der 

Klasse „Datum“ wird vom Compiler nicht zugelassen: 

Ostermontag.Jahr = 1789; 

liefert die Fehlermeldung: 

Variable Jahr in class Datum not 

accessible from class Beispiel. 

122 

Datumsvergleich 

• Wir fügen zu „Datum“ eine neue Methode hinzu, mit der ein 

Datum-Objekt entscheiden kann, ob es selbst früher als ein 

anderes (als Parameter übergebenes) Datum-Objekt ist: 

class Datum { 

... 

public boolean frueher_als(Datum d) { 

return Jahr < d.Jahr || 

Jahr == d.Jahr && Monat < d.Monat || 

Jahr == d.Jahr && Monat == d.Monat 

&& Tag < d.Tag; 

} 

true oder false 

d ist ein formaler Parameter 

vom Typ „Datum“ 

Man kann auf d.Jahr, d.Monat, d.Tag zugreifen, obwohl 

diese Attribute als „private“ deklariert sind, da es sich 

um die gleiche Klasse (aber eine andere Instanz) handelt 

123 

52

Datumsvergleich (2) 


... 

Datum d1 = new Datum(23,03,56); 


System.out.println(d1.frueher_als(d2)); 

// true 

System.out.println(d2.frueher_als(d1)); 

} 

// false 

... 

Hier wird die Methode „frueher_als“ 

aus dem Objekt d2 aufgerufen, und 

zwar mit Objekt d1 als Parameter. 

• Durch diese in der Klasse „Datum“ definierten Methoden kann man nun 

Datum-Objekte bezüglich früher / später vergleichen – ganz analog, 

wie man z.B. ganze Zahlen mit dem Operator ’

Gleichheit und „this“ 

class Datum... 

boolean frueher_als... 

boolean gleich(Datum d) { 

return !frueher_als(d) && !d.frueher_als(this); 

} 

... 

class Beispiel ... 

... 



System.out.println(d1.gleich(d2)); // false 


System.out.println(d1.gleich(d3)); // true 

... 

Beachte: „this“ ist ein Schlüsselwort, mit dem stets eine 

Referenz auf das eigene, aktuelle Objekt zurückgeliefert wird 

Hier wird die Funktion 

„frueher_als“ aus dem 

Objekt d aufgerufen, 

und zwar mit „einem 

selbst“ als Parameter! 

„gleich“ liesse sich 

natürlich auch direkter, 

ohne Rückgriff auf 

„frueher_als“ realisieren 

126 

Klassen- und Instanzenmethoden 

• Klassenmethoden bekommen (im Unterschied zu 

Instanzenmethoden) das Attribut „static“ vorangestellt 

• Klassenmethoden werden nicht für spezifische Objekte, 

sondern für die Klasse als Ganzes aufgerufen 

• Klassenmethoden lösen somit allgemeine Aufgaben 

für alle Objekte einer Klasse gemeinsam, z.B.: 

class Datum { 


static String Monatsname(Datum d) 

{if (d.Monat == 1) return "Januar"; 

} 

if ... 

... 

} 

... 

"Februar"; 

Auf eigene Instanzenvariablen 

(z.B. Monat 

bzw. this.Monat) kann 

Monatsname nicht 

zugreifen, wohl aber 

auf d.Monat aus der 

per Referenzparameter 

d übergebenen 

Instanz 

127 

54

Klassenmethoden und klassenbezogene 

Variablen („static“) 

• Klassenmethoden können nur auf klassenbezogene 

Variablen (d.h. mit „static“ deklarierte Variablen) oder 

andere Klassenmethoden zugreifen 

• Nicht auf eigene Instanzenvariablen (= Deklaration ohne static) 

• Nicht auf „this“ (da kein spezifisches Objekt existiert) 

• Auf Klassenmethoden wird von ausserhalb i.Allg. durch 

Angaben des Klassennamens (statt über eine Referenz 

auf ein Objekt der Klasse) zugegriffen 

• Also z.B.: System.out.print(Datum.Monatsname(Ostermontag)); 

• Klassenbezogene Variablen werden von allen Instanzen 

einer Klasse geteilt – Änderung bei einer Instanz wirkt 

sich auf alle anderen Instanzen der Klasse aus 

• Sind damit eine Art globale Variablen 

128 

Information Hiding („Geheimnisprinzip“) 

Verborgene Interna 

Schnittstelle mit 

Zugriffsmethoden 

130 

55

Information Hiding („Geheimnisprinzip“) 

• Kapselung aller relevanten Daten und Methoden 

• Kein direktes Lesen oder Schreiben (interner, d.h. 

„privater“) Daten, sondern nur über Zugriffsmethoden 

• Interne Repräsentation nach aussen unsichtbar machen 

• Verhindert inkompetenten Missbrauch garantiert Integrität 

• Klasse „Datum“ kann z.B. selbst prüfen, ob es mit einem illegalen 

Wert gesetzt werden soll (statt dass jeder Aufrufer immer prüft) 

• Dabei geht es nicht um „Datenschutz“, sondern um Abstraktion 

(von der Implementierung und Datenrepräsentation) 

• Konsequente Realisierung von sogenannten „abstrakten Datentypen“ 

• Klare Schnittstelle (nämlich Zugriffsmethoden) 

• Änderungsfreundliche Software (da seiteneffektfrei) 

131 


class Person { 

String name; 

int geburtsjahr; 

int groesse; 

Person vater, mutter; 

} 

Kein "static"! 

Das sind Platzhalter für 

Referenzen auf andere 

Personen (genauer: auf 

Instanzen bzw. Objekte 

des Typs „Person“) 

p1 ist eine „Referenzvariable“ 

class Geburt { 

public static void main (String[] args) { 

Person p1; 

// p1.name = "Hugo"; geht nicht! 

p1 = new Person(); // erst erzeugen! 

p1.name = "Hugo"; 

System.out.println(p1.name); 

} 

} 

132 

56

Dynamische Klassen und Referenzen (2) 

• Erzeugen von dynamischen Klassen geschieht mit 

new x(); 

„Konstruktor“ 

• Es wird eine Instanz bzw. Objekt der Klasse x erzeugt 

und eine Referenz („Zeiger“) darauf zurückgeliefert 

• Am besten die Referenz gleich „abspeichern“ : p1 = new x(); 

• Referenzen sind implementierungstechnisch Adressen 

• Für Referenzvariablen gibt es eine einzige Konstante: 

null – diese gehört zum Wertebereich aller Referenztypen 

133 

Verändern von Referenzvariablen 

Hätte man vor p = null dagegen q = p ausgeführt: 

Endgültig verlorene Objekte 

werden vom Garbage-Collector 

automatisch eingesammelt 

Recycling von Speicher 

dann wäre das Objekt über q noch zugreifbar! 

134 

57

Zuweisung von Referenzen 

• Einzige Operation auf Referenzvariablen ist die Zuweisung 

p = new Person(); q = new Person(); 

p.groesse = 186; p.name = "Mike"; 

q.groesse = 170; q.name = "Sandra" 

• Zunächst die Situation nach diesem Programmstück: 

135 

Zuweisung von Referenzen (2) 

Zuweisung an Referenzvariable p: 

Hiernach gilt p==q ( Alias-Effekt!) 

System.out.println(p.name); 

System.out.println(q.name); 

p.groesse = 200; 

System.out.println(q.groesse); 

ergibt dann jeweils „Sandra“ 

ergibt auch 200 

136 

58

Vergleich von Referenzen 

• Referenzvariablen können auf Gleichheit / Ungleichheit 

(mit ‘==’ bzw. ‘!=’) verglichen werden 

• p == q ist true genau dann, wenn die beiden 

Referenzvariablen auf das selbe Objekt zeigen 

(z.B. nach p = q) oder wenn beide null sind 

• aber nicht, wenn zwei verschiedene Objekte, auf die 

p bzw. q verweisen, die gleichen Werte haben! 

137 

Vergleich von Referenzen (2) 



q.groesse = 170; q.name = "Sandra"; 

if (p == q)... → liefert false 

p = q; 

if (p == q)... → liefert true 



q.groesse = 186; q.name = "Mike"; 

if (p == q)... → liefert false 

138 

59

4. 

Syntaxanalyse 

und Compiler 

Buch Mark Weiss „Data Structures & Problem Solving Using Java“ siehe Seiten: 

294-297 (Stacks); 473-502 (Stacks und Compiler); 625-629 ; 635-639 (Stack- 

Implementierung); 681 und folgende Seiten (Bäume); 697-708 

(Baumtraversierung) 

Aus der Übungen zu Informatik I ist bekannt: postfix („UPN“), inorder, postorder 

139 

Bäume in der Informatik 

• Bestehen aus Knoten und Kanten (d.h., sind „Graphen“) 

(1) Jede Kante verbindet genau 2 Knoten 

(2) Zwischen je 2 Knoten gibt es höchstens eine Kante 

(3) Anzahl der Knoten = 1 + Anzahl der Kanten 

(4) Sind „zusammenhängend“, d.h. von jedem Knoten kann 

man jeden anderen (evtl. indirekt) über Kanten erreichen 

Für jeden Baum gilt: 

• Zwischen je 2 verschiedenen 

Knoten gibt es genau einen „Weg“ 

(Folge von „benachbarten“ Knoten 

bzw. Kanten) 

• Es gibt keine „Zyklen“ (Weg mit 

Anfangsknoten = Endknoten) 

140 

60

Fräulein, bitte einen 

Baum mit 4 Knoten! 

Wirbeltiere 

Bitteschön! 

Fische 

Säugetiere 

Noch einen 

anderen, bitte! 

Affen 

Wie wäre es damit? 

Und noch einen! 

• Ja, aber wie viele wirklich verschiedene Bäume gibt es? 

In welchem Sinne? 

142 

16 

Beispiel: Alle 16 verschiedenen Bäume mit 4 Knoten 

1 2 3 4 5 6 7 8 9 10 11 12 

Und was 

ist damit? 

Bei solchen sogen. 

labeled trees werden 

alle jew. Knoten als 

verschieden angesehen 

13 14 15 16 

• Vgl. auch die beiden (!) Isomere 

des Camping-Gases Butan C 4 H 10 : 

• n-Butan und 

• Isobutan 

x 

x 

x 

Baumgenerierung: 

3 geeignete Kästchen 

ankreuzen 

Adjazenzmatrix 

„unlabeled trees“: 

Keine individuell verschiedenen 

Knoten 

143 

61

Beispiel: Verschiedene Bäume der Grösse 1 bis 6 

1 

2 

3 

4 

5 

6 

Hier: „unlabeled trees“ 

CH 3 

CH 2 

CH 2 

CH 2 

CH 2 

CH 3 

CH 3 

CH CH 2 

CH 2 

CH 3 

CH 3 

CH 3 

CH 2 

CH CH 2 

CH 3 

CH 3 

CH 3 

CH 3 

C CH 2 

CH 3 

CH 3 

Denkübung: 

Wieso aber gibt es 

nicht 6 (sondern nur 5) 

Isomere des Hexans? 

CH 3 

CH CH CH 3 

CH 3 

CH 3 

• Die Anzahl der Bäume bei n Knoten entspricht der Folge 1, 1, 1, 2, 3, 6, 

11, 23, 47, 106, 235, 551, 1301, 3159, 7741, 19320, 48629, 123867, … 

(wächst grössenordnungsmässig exponentiell mit n) 

144 

Sind Stammbäume wirklich „Bäume“? 

145 

62

Wurzelbäume 

• Ein bestimmter Knoten wird als „Wurzel“ ausgezeichnet 

• Bäume sind in der Informatik meist Wurzelbäume; daher 

meint man oft „Wurzelbaum“, wenn man einfach „Baum“ sagt 

• Werden i.Allg. „umgekehrt“ gezeichnet (Wurzel oben!) 

Knoten mit nur einer einzigen 

„inzidenten“ Kante heissen Blatt 

Jeden Knoten eines Baums kann man als 

Wurzel eines „Unterbaums“ auffassen 

Ausgehend von der Wurzel kann man die 

Knoten in Ebenen (Niveau, Level) einteilen 

gleiche Entfernung von der Wurzel 

Wurzelbäume eignen sich gut zur 

Darstellung hierarchischer Strukturen 

146 

147 

63

Wurzelbäume mit bis zu vier Blättern 


Bäume als mathematische 

Strukturen wurden 

1857 von 

Arthur Cayley 

eingeführt. 

Auszug aus: 

Arthur Cayley: 

On the Theory 

of Analytical 

Forms called 

Trees. 2 nd Part. 

Philosophical 

Magazine, Vol. 

17, 374-378, 

1859. 

148 

Darstellung von Wurzelbäumen 

Alles sind (nur) unterschiedliche 

Darstellungen 

des gleichen 

„abstrakten“ Baums! 

Als (gerichteter) Graph 

Als Mengendiagramm 

(zeigt „Verschachtelung“) 

In eingerückter 

Form 

(„indentation“) 

A 

B 

D 

C 

E 

F 

A ( B ( D ) , C ( E , F ) ) 

In Klammerdarstellung 

Name der Wurzel, dahinter in 

Klammern die Unterbäume, 

jeweils durch Komma getrennt 

Lineare Darstellung ist 

sehr kompakt, geeignet 

z.B. zur Ein- / Ausgabe 

150 

64

Binärbaum 

• Wurzelbaum, bei dem jeder Knoten höchstens zwei 

Nachfolger hat 

• Oft differenziert man dann zwischen dem linken und 

rechten Nachfolger (bzw. Unterbaum), so dass z.B. die 

folgenden Bäume als verschieden angesehen werden: 

W 

W 

X 

Y 

Y 

X 

Z 

Z 

Die Pfeilspitzen 

lässt man oft weg 

151 

Binärbäume in Arrays 

Die Idee besteht darin, die 

Wurzel an Stelle 1 eines 

Arrays zu speichern, und die 

beiden direkten Nachfolger 

von Stelle i an den Stellen 2i 

(Wurzel des „linken" Unterbaums) 

und 2i+1 (Wurzel 

des „rechten“ Unterbaums) 

Veranschaulichung 

durch Binärdarstellung 

der Indexnummer 

Konvention nötig für 

"leeren" Unterbaum 

152 

65

Binärbäume in Arrays (2) 

String [] Baum = new String [n+1]; 

Baum[1] = "Katja"; 

Baum[2] = "Eva"; 

Baum[3] = "Stephan"; 

Baum[4] = "Dirk"; 

... 

→ „Niveauweise“ Speicherung 

der Baumknoten 

→ Verweise nur noch implizit 

153 

Syntaxbaum 

Der Syntaxbaum (oder: 

Ableitungsbaum) spiegelt 

die Struktur eines 

Programmtextes wider 

Die Konstruktion eines 

Syntaxbaums zu einem 

Programmtext nennt 

man Syntaxanalyse 

Dies ist das, was ein 

Compiler zunächst mit 

einem Programm tut, 

bevor er es in Maschinensprache 

(bzw. 

Bytecode) übersetzt 

154 

66


• Zweck: nur syntaktisch korrekte Programme generieren 

• Überprüfen, ob ein Programm syntaktisch korrekt ist: 

Versuchen, es mit einem Syntaxdiagramm zu generieren 

• Ein (sehr einfaches) Beispiel: 

Zuweisung: 

Variablenname = Variablenname 

; 

bezeichnet einen 

syntaktischen Begriff 

(„Nicht-Terminalsymbol“), 

welcher seinerseits weiter 

expandiert werden muss 

+ 

Variablenname 

bezeichnet ein 

„Terminalsymbol“, welches 

so „wörtlich“ in einem Programm 

vorkommen kann 

156 

Durchlaufen von Syntaxdiagrammen 

• Vorgehensweise: 

• In Pfeilrichtung durchlaufen 

• Bei Verzweigungen „beliebige“ Richtung wählen 

• Durchlaufene Terminalsymbole aufschreiben 

• Wenn ein Nicht-Terminal getroffen wird, in das zugehörige 

Teildiagramm „abtauchen“ und nach dem „Auftauchen“ weitermachen 


; 

Das Nicht-Terminalsymbol 

„Variablenname“ muss in 

diesem Beispiel entsprechend 

„expandiert“ werden 

+ 

Variablenname 

157 

67

Syntaktisch korrekte Ausdrücke 

• Falls a, b, c gültige Variablennamen sind entsprechend 

diesem Syntaxdiagramm 

• Korrekt 

• a=b; 

• a=b+c; 

• b=b+c; 

• a=a+a; 

• Inkorrekt 

• a=b 

• a=b-c; 

• b=; 

• b=a+b+c; 

Was ändert sich, wenn 

diese Kante im Syntaxdiagramm 

hinzukommt? 

Zuweisung: 


; 

+ 

Variablenname 

158 

Ein Syntaxdiagramm-Beispiel: 

Klammerdarstellung eines Baums 

Baum: 

Knoten 

( Unterbäume ) 

Beispiel: A ( B ( D ) , C ( E , F ) ) 

Knoten: 

A 

B 

Unterbäume : 

Baum 

, 

Z 

Wie könnte man Binärbäume durch 

ein Syntaxdiagramm darstellen? 

159 

68

Syntax von arithmetischen Ausdrücken 

Term 

Term 

Faktor Faktor Faktor 

1 + 2 * 3 

Ausdruck 

Das ist übrigens ein Baum (in 

Mengendiagrammschreibweise) 

Ausdruck 

Term 

Faktor 

+ 

Faktor 

Term 

* 

Faktor 

160 

Syntax von arithmetischen Ausdrücken (2) 

Faktor 

Term 

Ausdruck 

Faktor 

( 1 + 

2) 

* 3 

„Ausdruck“ ist (indirekt) rekursiv; die Aufspaltung 

in Term und Faktor ermöglicht die 

Darstellung der Bindungspriorität 

Vgl. die beiden nachfolgenden Beispiele: wie 

geht daraus die Priorität, also die (evtl. implizite) 

„Klammerung“ der Teilausdrücke hervor? 

161 

69

Syntaxdiagramme und Syntaxbäume 

• Durch eine Baumdarstellung 

(der Terminale und Nicht- 

Terminale zu einem Ausdruck) 

kann der im Syntaxdiagramm 

durchlaufene Weg dargestellt 

werden: 

Term 

Faktor 

Term 

Faktor Faktor 

1 + 2 * 3 

Ausdruck 

Faktor 

Faktor 

( 1 + 2 

) * 3 

Term 

Ausdruck 

(1+2)*3 

Übung: Die Bäume „mit Knoten und 

Kanten“ zeichnen und sich die Bindungspriorität 

von +, *, () in dieser 

Graphdarstellung bewusst machen. 

163 

Syntaxanalyse 

• Problem: Gegeben ein Stück Text, welches so aussieht, 

als wäre es ein Teil eines Java-Programms 

• Ist dieses wirklich syntaktisch korrekt, d.h. nach den 

Syntaxregeln (= Syntaxdiagramm) gebildet worden? 

• „Lösung“: Man versucht, das Syntaxdiagramm mit 

„Spürsinn“ so zu durchlaufen, dass man am Ende 

das gegebene Textfragment erzeugt hat 

• Wenn dies gelingt → Textfragment syntaktisch korrekt 

• Wenn dies nicht gelingt: 

(a) → Textfragment syntaktisch nicht korrekt 

(b) → man hat sich nicht geschickt genug angestellt 

168 

70

Syntaxanalyse und Syntaxchecker 

• Problem: Einen Algorithmus angegeben, der für 

- ein beliebiges Syntaxdiagramm und 

- einen beliebigen Text 

eindeutig entscheidet, ob sich der Text mit dem 

Diagramm generieren lässt (→ Syntaxchecker) 

→ Theorie der Syntaxanalyse → formale Sprachen, Compilerbau 

for(int i=1; 

i


(am Beispiel von Infix-Ausdrücken) 

• Wiederholungen (z.B. am 

Ende von „Ausdruck“ und 

„Term“) werden durch 

while-Schleifen realisiert 

• Verzweigungen (z.B. in 

„Faktor“) werden durch 

if-Anweisungen realisiert 

171 

Ein Parser als Java-Programm 

(Parser = „Zerteiler“, 

Syntaxanalyseprogramm) 

Bemerkung: KbdInput ist eine Klasse mit 

Methoden (wie z.B. „getc“), die nicht zum 

Standard-Java gehört. Die Funktionalität 

(Zeichen vom Keyboard lesen) davon lässt 

sich aber leicht mit Methoden aus dem 

Paket java.io.* nachbilden (Übung!) 

//Anfangsteil kommt später 

... 

void int_const(){ 

c = KbdInput.getc(); 

} 

void Ausdruck(){ 

Term(); 

while (c == '+') { 


Term(); 

} 

... 

Integer-Konstanten 

bestehen bei uns 

nur aus einem 

einzigen Zeichen 

Verarbeitetes 

Zeichen „weglesen“; 

nachfolgendes 

Zeichen einlesen 

172 

72

Ein Parser als Java-Programm (2) 

//Anfangsteil kommt später 

... 

void int_const(){...} 

void Ausdruck(){...} 

void Term() { 

Faktor(); 

while (c == '*') { 


Faktor(); 

} 

} 

void Faktor() { 

if ((c >='0') && (c

Erzeugen eines Syntaxbaums 

• Man möchte i.Allg. nicht 

nur einen Syntaxchecker 

mit dem Resultat 

„syntaktisch korrekt / 

falsch“, sondern zur 

weiteren Bearbeitung den 

zugehörigen Syntaxbaum 

• Dazu erweitern wir das 

Analyseprogramm so, dass 

eine Baum-Ausgabe in der 

„eingerückten Darstellung“ 

erzeugt wird 

175 

Erzeugen eines Syntaxbaums (2) 

• Idee: Jede Methode, die für ein Terminal oder Nicht- 

Terminal steht, gibt ihren eigenen Namen aus 

• Und zwar eingerückt um eine Länge, die proportional zur 

Tiefe (= Abstand zur Wurzel) des Knotens ist 

• Jede Methode bekommt dazu die momentane Tiefe als 

int-Parameter übergeben 

• Dafür nutzen wir eine Hilfsprozedur „out“: 

void out(int t, String x) { 

System.out.println(); 

for(int i=1;i

Erzeugen eines Syntaxbaums (3) 

void Ausdruck(int t) { 

out(t,"Ausdruck"); 

Term(t+1); 

while (c == '+') { 

out(t+1,"+"); 


Term(t+1); 

} 

} 

"out" gibt den Namen entsprechend 

eingerückt aus 

"Term" und "+" haben als 

Nachfolger von Ausdruck 

eine um 1 grössere Tiefe 

void int_const(int t) { 

out(t,"int_const: " + c); 


} 

Um den Wert 

der Konstanten 

zu erfahren 

// Entsprechend werden "Term" 

// und "Faktor" ergänzt 

177 

Binäre Operatorbäume 

• Entstehen durch Kompaktifizierung aus den 

eigentlichen Syntaxbäumen 

• Drücken aber noch gleichermassen die wesentliche 

Struktur eines Ausdrucks aus 

• Unwesentliches entfernen 

• Namen von Nicht-Terminalen und Klammer-Knoten 

• Operator zur Wurzel des Teilbaums hochziehen 

• Stellt damit ein sogenanntes Attribut des Knotens dar 

• Sind Binärbäume 

• Ein Knoten (≠ Blatt) hat nur zwei Nachfolger 

• Dazu Teilausdrücke evtl. klammern: 2*3*4 (2*3)*4 

178 

75

Auswertung binärer Operatorbäume 

• Wenn der Baum keine Unterbäume 

hat, dann ist der Wert des Baums 

das Attribut der Wurzel (= Blatt) 

• Ansonsten existiert ein linker und 

rechter Unterbaum. Berechne (in 

rekursiver Weise!) „so“ den Wert 

des linken Unterbaums, dann 

„genauso“ den Wert des rechten 

Unterbaums und wende die 

Operation (= Attribut der Wurzel) 

auf die beiden Werte an 

→ 2*3=6 → 7-6 

= 1 → 1+2 = 3 

→ 3+...12 = 15 

179 

Auswertung des Ausdrucks durch 

Schrittweise Reduktion des Operatorbaums 

1 

6 

15 

3 3 12 

180 

76

Symmetrisches Traversieren eines 

Binärbaums („inorder“) 

• Prinzip: Zuerst den linken Unterbaum traversieren, 

dann den Wert der Wurzel ausgeben, anschliessend 

den rechten Unterbaum traversieren 

• Beispielhafte Anwendung: Rückgewinnung 

des Ausdrucks in Infix-Notation („vollständig 

geklammert“) aus einem Operatorbaum: 

• Falls die Wurzel kein Blatt ist: 

• Ausgabe von ‘(‘ und wende Algorithmus 

auf linken Unterbaum an 

• Ausgabe des Attributs der Wurzel 

• Falls die Wurzel kein Blatt ist: 

• Wende Algorithmus auf rechten 

Unterbaum an und Ausgabe von ‘)‘ 

Denkübung: Wie kann 

man die überflüssigen 

Klammern sparen? 

(Beachte auch den Fall, 

wo ’*’ und ’+’ im Baum 

vertauscht sind!) 

(((7-(2*3))+2)+(4*3)) 

181 

Postfix-Ausdrücke 

• Bei Postfix-Ausdrücken kommt der Operator nach den 

zugehörigen Operanden, nicht dazwischen (infix) 

• Wird auch als „umgekehrte polnische Notation“ (UPN) bezeichnet 

• Entspr. Präfix-Ausdrücke: Operator vor seinen beiden Operanden 

• Bsp: 2 3 + 4 5 * + entspricht infix (2 + 3) + (4 * 5) 

Die Präfix-Notation („polnische 

Notation“) wurde 

in den 1920er-Jahren 

vom polnischen 

Mathematiker 

Jan 

Lukasiewicz 

(1878–1956) 

entwickelt. 

182 

77

Postfix-Ausdrücke (2) 

• Postfix-Ausdrücke sind für die maschinelle Verarbeitung 

besser geeignet als Infix-Ausdrücke (dazu später mehr) 

• Sie enthalten z.B. keine Klammern und sind dennoch eindeutig! 

• Problem also: Automatische Umwandlung infix → postfix 

• Idee am Beispiel 2 + 3 → 2 3 + 

• D.h. von links nach rechts lesen und den Operator 

für den späteren Gebrauch zwischenspeichern 

• Entsprechend: 2 + Ausdruck → 2 Ausdruck + 

• auch wenn „Ausdruck“ sehr lang ist, der selbst 

wieder nach dem gleichen Prinzip übersetzt wird! 

• Konkreter (rekursiver?) Algorithmus hierfür? 

183 

Baumtraversierung in „postorder“ 

• Zuerst linken Unterbaum traversieren (falls vorhanden) 

• Dann rechten Unterbaum traversieren (falls vorhanden) 

• Dann die Wurzel „betrachten“ 

• Z.B. das bei einem Operatorbaum vorhandene Attribut ausgeben 

Lässt sich daraus der Operatorbaum 

wieder eindeutig rekonstruieren? 

7 2 3 * - 2 + 4 3 * + 

Das ist offenbar 

der Infix-Ausdruck 

((7-(2*3))+2)+(4*3) 

in Postfix-Notation! 

184 

78

Umwandlung infix postfix 

• Eine erste Idee: 

• Infix-Ausdruck mit einem Parser analysieren 

• Dabei Operatorbaum aufbauen 

• Operatorbaum dann in postorder durchlaufen 

• Es geht aber auch ohne expliziten Operatorbaum! 

185 

Umwandlung infix postfix (2) 

• Wir kommen ohne expliziten Baum aus, wenn wir beim 

zeichenweisen Lesen von links nach rechts einen Operator 

für den späteren Gebrauch zwischenspeichern 

⇒ 

 

⇒ 

 

• Daher: 

• Operator in einen Stack; dort ruhen lassen 

• Inzwischen den Ausdruck2 bearbeiten 

• Nach Ende von Ausdruck2: Operator aus dem Stack herausholen 

• Aber wie erkennt man das Ende? Wir machen es uns zunächst 

einfach und fordern, dass jeder (Teil)ausdruck geklammert ist; 

dann erkennt man das an einer schliessenden Klammer „)“ 

186 

79

Ein Stack („Keller“, „Stapel“) 

Bereits aus Teil I der 

Vorlesung bekannt 

• Für einzelne Zeichen 

(„character-Stack“) 

• Realisiert als Klasse, 

die ein Array enthält 

• Array-Grenzen sind durch 

0 und length-1 abgesteckt 

• p „zeigt“ immer schon auf 

das nächste freie Element 

class Stack { 

int p; 

char [] st; 

Stack(int size) { 

p = 0; 

st = new char[size]; 

} 

void push(char c) { 

if (p >= st.length) 

System.out.println 

("Stack Overflow"); 

else 

st[p++] = c; 

} 

char pop() { 

return st[--p]; 

} 

} 

Stackpointer 

Konstruktor 

Sonst Fehler 

bei Zugriff auf 

st[st.length] 

Ein „Stack Underflow“ 

sollte eigentlich auch 

überprüft werden! 

187 

Postfix-Umwandlung mittels Stack 

• Wir beschränken uns hier auf die beiden Operatoren 

+ und * sowie einziffrige Operanden 

• Lösungsidee: 

• Operanden (d.h. Zahlen) werden sofort ausgegeben 

• Operatoren kommen in den Stack 

• Bei jeder schliessenden Klammer „pop“: auf den obersten 

Operator anwenden (d.h. aus dem Stack holen) und ausgegeben 

• Offenbar spielen öffnende Klammern keine Rolle, daher ’(’ 

genauso wie Leerzeichen etc. einfach überlesen! 

188 

80

Postfix-Umwandlung mittels Stack (2) 

class Stack //Wie gehabt... 

class InfToPost { 

Stack stk = new Stack(1000); 

char c; 

boolean eof(char c) { 

return (c == (char) -1); 

} 

void convert() { 

while (!eof(c = KbdInput.getc())) { 

if ((c=='+') || (c=='*')) 

stk.push(c); 

if ((c >= '0') && (c

Auswertung mittels Operandenstack 

Beispiel: 5 1 2 + 3 4 * * 6 + * 

191 

Ein Postfix-Auswerter in Java 

public static main void(String []) 

Stack stk = new Stack(1000); // hier: int-Stack (für Operanden) 

char c = ' '; int x; 

while (!eof(c)) { 

if (!(c == '+' || c == '*' || c >= '0' || c = '0' && c

Umwandlung von Ziffernfolgen in Zahlen 

• Verschiedene Operanden sind durch 

Leerzeichen getrennt; mehrstellige 

Operanden enthalten keine Leerzeichen! 

while (c>='0' && c 1 und Ziffern 0 c i < b) ergibt sich aus 

Z = Σ c i b i = (…(c n )b+c n-1 )b+…+c 1 )b+c 0 Hornerschema für Polynome 

• Wir verwenden Dezimalzahlen mit b = 10 

• Beim Berechnen der Operanden wird die Tatsache ausgenutzt, 

dass mit char-Werten wie mit int-Werten gerechnet werden kann 

(c-’0’) und die Ziffern 0 bis 9 im Zeichensatz hintereinander stehen 

• Ganz ähnlich könnte man z.B. auch binäre (b = 2) oder hexadezimale 

(b = 16) Operanden zulassen und nach int konvertieren 

• Statt (c-’0’) ginge weniger trickreich auch Character.digit(c,10) 

193 

Stellenschreibweise laut Adam Riese (AD 1550) 


Zehen sind figurn / darmit ein jede zal geschrieben wirt / 

sind also gestalt. 1. 2. 3. 4. 5. 6. 7. 8. 9. 0. Die ersten neun 

bedeuten / die zehent als 0 gibt in fursetzung mehr 

bedeutung / gilt aber allein nichts / wie hie 10. 20. 30. 40. 

50. 60. 70. 80. 90. als Zehen, Zwentzig, Dreissig / etc. 

Werden zwey 0 furgesatzt / so hastu hundert vorhanden / 

also 100. 200. 300. 400. 500. 600. 700. 800. 900. Werden 

drey 0 furgesatzt / so hastu tausent / nemlich 1000. 2000. 

3000. Ein jede figur vnder den obgeschrieben zehen / gilt an 

der ersten stat gen der rechten handt sich selbst / an der 

anderen gen der lincken handt so vil zehen / an der dritten 

so offt hundert / Und an der vierden stat so vil tausent. Der 

halben zele von der rechten handt gen der lincken / eins 

zehen hundert tausent. 

194 

83

Adam Ries erklärt die Stellenschreibweise in seinem 

dritten Rechenbuch („Rechenung nach der lenge / 

auff den Linihen und Feder“) 1550 unter der 

Überschrift „Numerirn / Zelen“ wie folgt: 

Zehen sind figurn / darmit ein jede zal geschrieben 

wirt / sind also gestalt. 1. 2. 3. 4. 5. 6. 7. 8. 9. 0. 

Die ersten neun bedeuten / die zehent als 0 gibt in 

fursetzung mehr bedeutung / gilt aber allein nichts / 

wie hie 10. 20. 30. 40. 50. 60. 70. 80. 90. als 

Zehen, Zwentzig, Dreissig / etc. Werden zwey 0 

furgesatzt / so hastu hundert vorhanden / also 100. 

200. 300. 400. 500. 600. 700. 800. 900. Werden 

drey 0 furgesatzt / so hastu tausent / nemlich 1000. 

2000. 3000. Ein jede figur vnder den obgeschrieben 

zehen / gilt an der ersten stat gen der rechten handt 

sich selbst / an der anderen gen der lincken handt 

so vil zehen / an der dritten so offt hundert / Und an 

der vierden stat so vil tausent. Der halben zele von 

der rechten handt gen der lincken / eins zehen 

hundert tausent. 

http://dx.doi.org/10.3931/e-rara-81 

Man kann übrigens vermuten, dass die sprachliche Verwandtschaft des 

Zahlwortes „zehn“ mit „Zehen“ kein Zufall ist, vgl. die Abstammung des 

englischen Wortes „digit“ für „Ziffer“ vom lateinischen digitus (Finger). 

195 

Klammerchecker für Java-Programme 

• Eine weitere Anwendung für Stacks: Analyse 

der durch „{ ... }“ definierten hierarchischverschachtelten 

Blockstruktur von Programmen 

• Bei Beginn eines Blocks (bei ’{’) wird die gegenwärtige 

Zeilennummer in den Stack geschrieben 

• Nach Abarbeitung aller inneren Blöcke wird sie 

bei Blockende (d.h. ’}’) aus dem Stack geholt 

1 { … 

2 … 

3 { … 

4 { … 

5 } 

6 { … 

7 } 

8 } 

9 } 

Einen solchen Kommentar wollen 

wir automatisch erzeugen 

Block von Zeile 4 endet in Zeile 5 




196 

84

Klammerchecker für Java-Programme (2) 

class Stack //hier auch wieder int-Stack 

class KlammerChecker { 

static boolean eof(char c) { return (c == (char) – 1); } 

public static void main(String[] args ) { 

int zeile = 1; 

Stack stk = new Stack(1000); 


if (c == '\n') zeile++; 

if (c == '{') stk.push(zeile); 

if (c == '}') 

if (stk.empty()) 

System.out.println("*** Fehlt: {"); 

else 

System.out.println("Block von zeile " + stk.pop() + 

"endet in Zeile" + zeile); 

} //end while 

if (!stk.empty()) 

System.out.println("*** Fehlt: }"); 

} //end Methode main 

} 

Bei 'newline' wird der 

Zeilenzähler erhöht 

Wenn am Ende der 

Stack nicht leer ist, 

war etwas falsch! 

197 

Ein rekursiver Klammerchecker 

class KlammerChecker { 

//c und zeile sind global für alle Methoden 

char c; int zeile = 1; 

static boolean eof(char c) { return c == (char) – 1; } 

} 

void block(int z) { 


switch(c) { 

case '\n': 

zeile++; 

break; 

case '}': 

System.out.println("Block von zeile " + z + 

"endet in Zeile" + zeile); 

return; 

case '{': 

block(zeile); 

} // end switch 

} //end while 

} 

Ginge auch 

continue? 

Rekursiver 

Aufruf! 


KlammerChecker kc = new KlammerChecker(); 

kc.block(0); 

} 

Übung: Wie könnte man Fehler der Klammerstruktur 

(zu viele bzw. zu wenige ’{’ oder ’}’) melden? 

Erzeugt gleiches Ergebnis 

wie vorheriges Programm 

Implizite Nutzung des 

Laufzeitstacks (statt 

explizitem Stack) 

Die Zeilennummer wird 

dabei auf dem jeweiligen 

Exemplar der Variablen z 

der einzelnen Methodeninstanzen 

gespeichert 

Nach Rückkehr aus einem 

rekursiven Methodenaufruf 

befindet man sich wieder 

in einer Instanz mit 

dem „alten“ Wert von z 

198 

85

Codegenerierung für Infix-Ausdrücke 

• Aufgabe eines Compilers ist nicht nur die Syntaxprüfung, 

sondern auch „Code“ für eine Zielsprache zu erzeugen 

• Wir postulieren hier eine Stackmaschine als Zielmaschine 

mit folgenden drei Operationen: 

• push(i): Int-Wert i auf den Stack schreiben 

• plus: Oberste beiden Stackelemente durch ihre Summe ersetzen 

• mult: ... Produkt ersetzen 

202 

Codegenerierung für Infix-Ausdrücke (2) 

• Wir wollen das Analyseprogramm an den „richtigen“ 

Stellen so mit Codeerzeugungsanweisungen ausstatten, 

dass Folgendes generiert wird: 

Die Zielmaschine kann in Hardware 

realisiert sein, oder als 

virtuelle Maschine durch ein 

Laufzeit- oder Betriebssystem 

simuliert werden. 

Oder der generierte Code wird 

weiter in Code für eine echte 

Zielmaschine transformiert. 

Das ist eigentlich eine 

Übersetzung nach Postfix! 

203 

86

Der Parser mit Codeerzeugung 

void int_const(){ //hier nur einziffrig 

System.out.println("push(" + c + ")"); 


} 


Term(); 

while (c == '+') { 


Term(); 

System.out.println("plus"); 

} 

} 

void Term() { 

Code-Generierung für 

Faktor(); 

die Stackmaschine 

while (c == '*') { 


Faktor(); 

System.out.println("mult"); 

} 

} 

Auch bei dieser Infix zu 

Postfix-Übersetzung wird 

(implizit) ein Stack benutzt: 

Der Laufzeitstack von Java, 

in dem die Rücksprungadressen 

abgelegt sind! 

204 

Ein Interpreter für Infix-Ausdrücke 

• Statt die Operationen einer Stackmaschine 

auszugeben, also etwa in eine Datei zu schreiben, 

und diese anschliessend von einer Stackmaschine 

ausführen zu lassen, können wir 

auch gleich push, plus, mult etc. auf einem 

Stack ausführen und so schritthaltend zur 

Analyse den Ausdruck („on the fly“) auswerten 

• Wir bekommen damit statt eines Compilers 

(=Übersetzer) einen Interpreter für Infix-Ausdrücke 

• Zur Realisierung dieses „Taschenrechners“ verwenden 

wir wieder unserer Service-Klasse „Stack“ 

5*(((1+2)*(3*4))+6) 

push(5) 

push(1) 

push(2) 

plus 

push(3) 

push(4) 

mult 

mult 

push(6) 

plus 

mult 

205 

87

Ein Interpreter für Infix-Ausdrücke (2) 

class Stack // wie gehabt int-Stack 

class Parser { 

Stack stk = new Stack(100); char c; 

void int_const() { 

stk.push(Character.digit(c,10)); 

c.KbdInput.getc(); 

} 


Term(); 

while (c == '+') { 

c = KbdInput.getc(); Term(); 

stk.push(stk.pop() + stk.pop()); 

} 

} 

void Term() { 

Faktor(); 

while (c == '*') { 

c = KbdInput.getc(); Faktor(); 

stk.push(stk.pop() * stk.pop()); 

} 

} 

... main ... 

Parser p = new Parser(); 

p.c = KbdInput.getc(); 

p.Ausdruck(); 

System.out.println(p.stk.pop()); 

} 

Umwandlung eines char 

in eine Zahl zur Basis 10 

Was wäre bei '-' zu beachten? 

Die obersten beiden Stackelemente 

werden durch deren Summe ersetzt 

Hier wird das Resultat ausgegeben 

206 


207 

88

Bem.: Die klassische deutsche Bezeichnung 

für „Stack“ lautet „Keller“ (oder „Stapel“) 

208 

209 

89

210 

Wie kam es zu diesem Patent? 

Friedrich L. Bauer erinnert sich: 

• „Im Jahr 1951 erschien eine bahnbrechende, aufregende Zürcher Publikation 

von Heinz Rutishauser – ein Programm, das Programme produziert: 

• Über automatische Rechenplanfertigung bei programmgesteuerten Rechenmaschinen. 

Z. Angew. Math. Mech. 31(8/9):255, Aug./Sept. 1951“ 

Friedrich Ludwig Bauer (*1924) ist ein deutscher 

Informatik-Pionier. Er konstruierte in 

den 1950er Jahren Verschlüsselungsmaschinen 

und eine elektromechanische „aussagenlogische 

Maschine“ (STANISLAUS). Ab 1956 

beteiligte er sich an der internationalen Zusammenarbeit 

zur Schaffung der Programmiersprache 

Algol 60, 1957 erfand er das 

Prinzip des Stacks. Er hielt 1967 an der TU 

München die erste offizielle Informatikvorlesung 

in Deutschland und prägte 1968 den 

Begriff „Software Engineering“. 

Friedrich Ludwig Bauer 

Heinz Rutishauser 

Aus: Friedrich L. Bauer: Über „Episoden aus den Anfängen der Informatik an 

der ETH“ von A. Speiser. Informatik-Spektrum 31(6), Dez. 2008, S. 600-612 

211 

90

H. Rutishauser: Automatische Rechenplanfertigung 

bei programmgesteuerten 

Rechenmaschinen. (Mitteilungen aus 

dem Institut für angewandte Mathematik 

an der ETH. Zürich Nr. 3.) 45 S. 

m. 8 Abb. und 3 Strukturdiagrammen. 

Basel 1952, Verlag Birkhäuser, 5,70 SFr 

214 

Auszug aus Rutishausers „Automatische 

Rechenplanfertigung“ 

Blätter 

Innere 

Baumknoten 

216 

91

Friedrich L. Bauer erinnert sich… 

„Konrad Zuse hatte 1944 die Idee eines ‚Planfertigungsgeräts‘ (er benützte 

den Ausdruck ‚Plan‘ statt ‚Programm‘) zur Erleichterung der Programmierung 

der Z4, die er aber in den Wirren des letzten Kriegsjahrs nicht 

mehr weiterverfolgen konnte. … Rutishauser hatte jedenfalls schon 1951 

den glänzenden Einfall, statt ein eigenes Gerät zu bauen, die Rechenanlage 

selbst zur Planfertigung zu benützen, also ein ‚programmierendes 

Programm‘, wie es Andrei Ershov bald darauf nannte, einzusetzen. … 

‚That the same computer that solved a problem could prepare its own instructions 

was a critical moment in the birth of software‘ (Paul E. Ceruzzi, 

1998). Rutishausers Algorithmus … bewirkt den Abbau der durch die Klammern 

geschachtelten Strukturen, wie sie beispielsweise in der üblichen 

Infix-Schreibweise arithmetischer oder logischer Ausdrücke vorkommen, 

von innen nach aussen. Aus der Formel wird bei Rutishauser ein dem 

Syntaxbaum und der Schachtelstruktur äquivalentes ‚Klammergebirge‘ 

hergestellt, das die vorgeschriebene Auswertungsreihenfolge eindeutig 

festlegt. Das zugehörige Programm … ist unmittelbar ablesbar beziehungsweise 

erzeugbar.“ 

217 

Friedrich L. Bauer erinnert sich… 

„Rutishauser nahm noch an, dass die Formel explizit geklammert ist, 

und unter dieser Annahme zeigte Corrado Böhm 1952, dass man die 

Auswertung auch sequentiell, normalerweise von links nach rechts, 

vornehmen kann. In üblicher Schreibweise wird jedoch unter Annahme 

einer Präzedenz der Multiplikation über der Addition und der Subtraktion 

auf die vollständige Klammerung verzichtet. In FORTRAN wurde 

ab 1954 (P.B. Sheridan) durch einen vorgeschalteten Durchlauf die 

Klammerung vervollständigt. L.KalmarmachtedazudenwitzigenVorschlag, 

das Multiplikationszeichen × überall durch die Folge )×( zu ersetzen 

(und die ganze Formel extra einzuklammern). Die entstehenden 

redundanten Klammern störten Kalmar nicht.“ 

218 

92

Friedrich L. Bauer erinnert sich weiter 

„Wir verbesserten das Programm von Rutishauser, das eine Springprozession 

über die Formel vollführte, zu einem streng sequentiellen Verfahren, 

das auch auf die vollständige Klammerung verzichtete unter 

Einführung von Operator-Rangordnungen. Das wurde die Grundlage 

unserer späteren Patentanmeldung von 1957, wobei es das ‚Kellerprinzip‘ 

verwendete, nämlich den im Rechner STANISLAUS eingeführten 

mehrgeschossigen Speicher vom (last in - first out)-Typus. 

Klaus Samelson hatte auch die Idee, neben dem ‚Zahlkeller‘ fürZwischenergebnisse 

des STANISLAUS auch einen ‚Operationskeller‘ zu 

verwenden, um die jeweils ihres Ranges wegen ‚zurückgestellten‘ 

Operationen zu kellern.“ 

„Wie sehr das Kellerprinzip inzwischen die Informatik durchdrungen hat, zeigt 

folgender kleiner Vorfall: Als ich kürzlich einem jungen Mitarbeiter gegenüber 

äusserte, Prof. Bauer habe den Kellerspeicher erfunden, fragte er: ‚Was gab 

es denn da zu erfinden? Das ist doch einfach ein Stack!‘ “ -- Fritz Lehmann 

219 

Friedrich L. Bauer schrieb schon 1960… 

Auszug aus: K. Samelson, F. L. Bauer: Sequential Formula Translation, 

Communications of the ACM 3(2), pp. 76-83, Feb. 1960 

220 

93

Rutishauser (li.) und Speiser (re.) an 

der Zuse Z4-Rechenanlage der ETH 

221 

Heinz Rutishauser (1918-1970) 

• 1942 Diplom ETH in Mathematik 

• 1948 Dissertation ETH 

• 1949-1955 ERMETH-Entwicklung 

(mit Ambros Speiser bei Prof. Stiefel) 

• 1951 Habilitation „Automatische 

Rechenplanfertigung“, ETH 

• Ab 1955 Professor an der ETH 

• Entscheidende Beiträge zur 

Programmiersprache ALGOL 

(Bild: ETH-Bibliothek, Com_M04-0265-0002) 

Ambros Speiser (li.) und Heinz Rutishauser (re.) 

an der Konsole von Zuses Z4-Rechenanlage, 1955. 

(Mit der Z4 hatte die ETH ab 1950 als erste Universität 

Kontinentaleuropas einen Computer) 

222 

94

223 

Heinz Rutishauser 

„1968 war Rutishauser im Besitz eines Rufes 

nach München auf eine Professur, die 

mit der Leitung des Leibniz-Rechenzentrums 

verbunden war. Es gelang mir im 

Mai 1968 nicht, ihn zu überreden, den Ruf 

anzunehmen; er nannte mir damals gesundheitliche 

Gründe und seine Befürchtungen 

waren, wie sich leider herausstellte, nicht 

grundlos. Dass er in Zürich verblieb, hat 

dann dem Aufbau der zunächst Computerwissenschaften 

genannten Informatik sehr 

geholfen.“ 

Aus F.L. Bauer „Computer und Algebra“ (in: Zwanzig Jahre Institut für 

Informatik , Bericht des Instituts für Informatik, ETH Zürich, 1988) 

224 

95

Konrad Zuse (1910-1995) präsentiert seinen Z4-Computer. 

„Immerhin besass das verschlafene Zürich durch die ratternde Z4 ein, wenn auch bescheidenes, 

Nachtleben. Ich selbst besass einen Schlüssel zum Hauptgebäude der ETH, und manches 

Mal bin ich spät in der Nacht durch die einsamen Züricher Gassen gegangen, um nach 

der Z4 zu sehen. Es war ein eigenartiges Gefühl, in die menschenleere ETH einzutreten und 

bereits im Parterre zu hören, dass die Z4 im obersten Stock noch einwandfrei arbeitete.“ 

225 

Die Z4 an der ETH Zürich 

HG G 39 

226 

96

Der elektromechanische 

Computer Z4 von Zuse 

• Konstruiert 1942-1945 in Berlin 

• 2200 Telefonrelais, Gewicht ca. 1 t 

• 64 mechanische Speicherplätze für Zahlen 

• Aber kein Speicher für Befehle 

• Programme („Rechenpläne“) wurden auf 

Lochstreifen gestanzt 

• Hierzu dienten gebrauchte 35-mm-Kinofilme 

• Im Bild rechts: Lochstreifenstanzer sowie Lochstreifenabtaster 

für das Hauptprogramm, links: 

Abtaster für ein Unterprogramm als Schleife 

• Rechenwerk im Dualsystem, Zahlen 

in Gleitpunktdarstellung 

• Ca. 1 s pro Befehl, ca. 3 s pro 

arithmetischer Operation 

Bildquellen: www.spiegel.de/fotostrecke/fotostrecke-56183-3.html, 

www.ethistory.ethz.ch/rueckblicke/departemente/dinfk/bilder/1951_z4-lochstreifen.jpg 

228 

Die Z4 

„Kommandostand“ 

Relais-Schränke 

Schaltpult 

Lochstreifenabtaster 

Mechanischer Speicher 

http://farm3.staticflickr.com/2208/1814569165_5348377b80_o_d.jpg 

230 

97

Die Z4, beschrieben von Eduard Stiefel 

„Im Vordergrund steht das Schaltpult; es enthält in seinem Mittelstück zwei Abtaster und einen 

Locher für die Lochstreifen, links die Tastatur zum Eingeben von Zahlen und ein Lampenfeld 

zum Ablesen von solchen. Der rechte Teil dient der Herstellung von Programmen; durch 

Betätigung der unten sichtbaren Tasten werden die Befehle auf einen Filmstreifen gelocht. 

Hinter der elektrisch gesteuerten Schreibmaschine ist das Speicherwerk angebracht […]. 

Rechts und im Hintergrund stehen die Schränke für Rechenwerk und Speicherwerk; die Z 4 

verwendet als Schaltelemente gewöhnliche Telefon-Relais und Schrittschalter. 

[…] zeigt die beiden Abtaster während des Durchrechnens eines mathematischen Problems. 

Im rechten Abtaster liegt das Hauptprogramm, auf welchem etwa ein Integrationsschritt zur 

Lösung einer Differentialgleichung programmiert ist. Der linke Abtaster verarbeitet ein Unterprogramm, 

und zwar das Ausziehen einer Wurzel auf iterativem Weg. Man beachte, daß 

dieses Programm eine endlose Schleife ist; ein einmaliger Umlauf desselben ergibt einen 

Iterationsschritt. Während die Rechnung automatisch abläuft, kann man nun folgendes Spiel 

beobachten. Sobald das Hauptprogramm an die Stelle kommt, wo eine Wurzel berechnet 

werden muß, bleibt es stehen und veranlaßt durch einen Sprungbefehl das Anlaufen des 

Unterprogramms. (Unbedingter Sprung.) Dieses macht so viele Umläufe, das heißt berechnet 

so viele immer bessere Annäherungen an den Wurzelwert, bis die Rechnung steht; dann 

nimmt das Hauptprogramm seine Arbeit wieder auf.“ 

In: Rechenautomaten im Dienste der Technik. Erfahrungen mit dem Zuse-Rechenautomaten Z4. 

Sonderdruck aus Arbeitsgemeinschaft für Forschung des Landes Nordrhein-Westfalen, Bd. 45, 

Köln 1954. 

231 

Der mechanische Speicher der Z4 

http://www.digitalbrainstorming.ch/weblog/Abb.%201%20Mechanischer%20Speicher%20Z4-pano.jpg 

233 

98

Konrad Zuse 

• Konrad Zuse (1910 - 1995) schloss 1935 sein Ingenieurstudium 

in Berlin ab. Danach arbeitete er 

zunächst als Statiker in der Flugzeugindustrie, 

gab diese Stelle jedoch bald auf und richtete eine 

Erfinderwerkstatt in der elterlichen Wohnung ein. 

• Mit seiner Entwicklung der Z3 im Jahre 1941 baute 

er den ersten vollautomatischen, programmgesteuerten 

und frei programmierbaren, in binärer Gleitkommarechnung 

arbeitenden Computer der Welt. 

• Zu Kriegsende 1945 Flucht aus Berlin über Göttingen in das Allgäu, 

wobei er den zuletzt entstandenen Rechner Z4 retten konnte. 

• 1949 spürte Prof. Eduard Stiefel von der ETH Zürich Zuse im 

Allgäu auf und liess sich die Z4 vorführen. Durch ihn kam ein 

grosszügiger Mietvertrag mit der ETH zustande, der Zuse die 

notwendigen Mittel verschaffte, um die Zuse KG zu gründen. 

• Zuse erhielt 1991 die Ehrendoktorwürde der ETH Zürich. 

Quelle u.a. Wikipedia 

Eduard Stiefel 

234 

Höhere Mathematik auf Knöpfen 

DER SPIEGEL 7. Juli 1949 (Auszug) 

Spiegel-Titel 28/1949 

Als er sich als Berliner TH-Student mit langen statischen Berechnungen 

herumquälte, kam ihm der Gedanke, „die geistigen 

Kräfte des Menschen zu verstärken, indem Maschinen 

zur Lösung von Aufgaben herangezogen werden, die bisher 

einen großen Teil der geistigen Arbeitskraft gebunden hatten“. 

„Ich war zu faul zum Berechnen“, interpretiert der lange Mann 

in den geflickten Mechanikerhosen heute seinen eigenen Broschürentext. 

Aus 15 000 Meter Draht, 20 000 Lötstellen, 2000 Telephonrelais, 

2500 kg Material, 250 000 Mark und 100 000 Arbeitsstunden 

entstand ein Gerät, das einen normalen Möbelwagen 

bequem ausfüllt. In diesem Möbelwagen fährt V 4 jetzt 

nach Hünfeld (Kreis Fulda). Dort soll sie 

Originalname der Z4 

der deutschen Wissenschaft rechnen helfen. 

In den USA existieren ähnliche Geräte wie V 4 unter dem Namen „Maschinen-Gehirn“. Sie arbeiten 

aber auf anderer Basis. Zuse ersetzte 18000 US-Elektronenröhren durch mechanische Einrichtungen. 

Die amerikanische Maschine kostet 400000 Dollar, wiegt 20 Tonnen und hat Stromlinienform. 

Auf den 149 Knöpfen und Tasten des V-4-Kommandostandes spielt Zuse höhere Mathematik. Daneben 

hängen unzählige verschieden gelochte Filmstreifen. Jede Lochung bedeutet eine mathematische 

Formel, von der einfachsten Wurzel bis zur schwierigsten Gleichung mit zehn Unbekannten. 

237 

99

Höhere Mathematik auf Knöpfen 

Um eine Rechenaufgabe zu lösen, wird der entsprechende Streifen in V 4 eingehängt. Paulas 

flinke Hände tippen auf der Tastatur die jeweiligen Zahlen, die je nach Bedarf von der V 4 

addiert, subtrahiert, multipliziert, dividiert oder gewurzelt oder alles auf einmal werden. 

Wenn die 60 Volt Gleichstrom durch die 20 Kilometer Draht gejagt sind, leuchtet das Ergebnis 

hinter weißen Glasscheiben auf. Eine schwierige Berechnung, zu der ein Stab von 

Wissenschaftlern Tage braucht, löst V 4 in Minuten. 

Zur V 4 gehört noch ein „mechanisches Gedächtnis“ in der Größe eines mittleren Kleiderschrankes. 

Dessen Einzelteile schnitt Zuse aus US-Konservenblech. Das Gedächtnis 

„notiert“ automatisch Zwischenergebnisse. 

Konrad Zuse braucht 20 000 DM, um der V 4 ein New-Look-Kleid zu geben. Im Augenblick 

sieht sie aus wie eine Großstadttelephonzentrale nach einem Erdbeben. Außerdem sucht 

er Geldgeber, um den Serienbau der Rechen- und der Problemmaschine zu beginnen. 

„20 000 DM zum Weiterexperimentieren täten es auch schon.“ 

Das Ausland zeigt sich an V 4 interessiert. Aber Zuse wartet ab. 

Der Mietvertrag mit der ETH wurde am 7.9.1949 in der Gaststätte des Bad. Bahnhofs 

in Basel unterzeichnet; ein ETH-Schulratsprotokoll vom 6.10.1949 vermerkt: 

„Im Juli 1949 erfuhr die Kommission von einer Rechenmaschine des deutschen 

Ingenieurs Zuse, die von der ETH zu aussergewöhnlich günstigen Bedingungen 

übernommen werden konnte. Prof. Stiefel und Dr. Lattmann besichtigten die 

Apparatur. Sie rühmten besonders deren mathematische Disposition…“ 

Bereits am 11.7.1950 wurde die generalüberholte Z4 an der ETH Zürich installiert. 

xx 

238 

ETH-Schulratsprotokoll vom 8.10.1949 zur Z4 

239 

100


240 


241 

101

ERMETH - Elektronische Rechenmaschine der ETH 

"Bereits kurz nach der Gründung des Instituts 

für angewandte Mathematik im Jahr 

1948 begann die Planung zum Bau eines 

eigenen Computers. Zu Beginn der 1950er 

Jahre waren auf kommerzieller Basis noch 

keine programmierbaren Rechner mit Speicher 

erhältlich, die für wissenschaftliches 

Rechnen geeignet gewesen wären. Deshalb 

auch die Idee zu einer Eigenentwicklung von 

Grund auf… " 

www.ethistory.ethz.ch/rueckblicke/departemente/dinfk/weitere_seiten/ermeth/index_DE 

ERMETH („Elektronische Rechenmaschine der 

ETH“), gebaut 1948-1957 an der ETH Zürich 

und genutzt bis 1963, Nachfolgesystem der Z4. 

242 

ERMETH 

• 1500 Elektronenröhren 

• Arbeitsspeicher: Magnettrommel 

mit Platz für 10000 

Wörter zu 14 Dezimalziffern 

• 1,5 Tonnen schwer 

• 6000 Umdrehungen pro Minute 

• Entwicklung kostete eine Million Franken 

• Ca. 100 Mal schneller als die Z4 

• Leistungsaufnahme von 30 kW 

• Die ERMETH reagierte empfindlich auf Schwankungen der Netzspannung, 

etwa wenn morgens die Trams den Betrieb aufnahmen 

• Wesentliche Teile im Museum für Kommunikation in Bern 

243 

102

Ambrosius Speiser (1922 – 2003) 

• Studium der Elektrotechnik an der ETH 

• 1950 Dissertation bei Eduard Stiefel 

• Entwurf eines elektronischen Rechengerätes unter besonderer 

Berücksichtigung der Erfordernis eines minimalen Materialaufwandes 

bei gegebener mathematischer Leistungsfähigkeit 

• Technische Leitung der ERMETH-Entwicklung 

• Gründungsdirektor (ab 1955) des IBM- 

Forschungslabors in Rüschlikon 

• Gründungsdirektor (ab 1966) des Forschungszentrums 

von Brown, Boveri & Cie. (später: 

ABB) in Dättwil bei Baden 

• 1986 Ehrendoktorwürde der ETH Zürich 

244 

Z4 und ERMETH – Heinz Waldburger erinnert sich 

Quelle: Herbert Bruderer: Konrad Zuse und die Schweiz. Oldenbourg-Verlag, 2012 

• Studium an der ETH, ab 1953 Hilfsassistent von Rutishauser und Stiefel, 

später Informatikchef der Firma Nestlé 

• „Im ETH-Vorlesungsverzeichnis des Sommersemesters 1952 wurde angekündigt: 

Praktikum an der programmgesteuerten Rechenmaschine 

Z4 (Zuse) am Institut für angewandte Mathematik. Prof. Stiefel, Dr. 

Rutishauser, Dr. Speiser. […] Wir waren wenige Hörer, vielleicht ein 

Dutzend Mathematiker aus der Industrie: BBC, Sulzer usw. […] Meine 

Vorlesungsnotizen zeigen, dass Stiefel nicht in Erscheinung trat. Rutishausers 

56 Seiten betrafen folgende Themen: Struktur einer programmgesteuerten 

Rechenmaschine, externes Rechenprogramm, Rechenbefehle, 

Flussdiagramm, numerische Anwendungen, sauber strukturiertes 

Programmieren, Rechnen mit Befehlen. Hinzu kamen die 16 Seiten der 

‚Bedienungsanweisung Z4‘. […] Die 20 Seiten Notizen zu Speisers Vorträgen 

erklärten das Funktionieren von elektrischen und elektronischen 

digitalen Schaltungen und deren Kombinationen für die Rechen- und 

Datenübertragungsfunktionen…“ 

245 

103

Z4 und ERMETH – Heinz Waldburger erinnert sich 

• „Das Wechselbad von Theorie und Praxis an der ETH war äusserst 

anregend. Rutishauser war dabei ein echter Meister, zurückhaltend, 

zusammenführend, stets hilfsbereit. Zuses geniale Erfindungen und 

sein einzigartiger Rechenautomat liessen an der ETH dank Stiefel, 

Rutishauser und Speiser eine eigenständige schweizerische lnformatikkultur 

wachsen. Nicht die beim Bau von Prozessoren und Magnetspeichern 

erworbenen technischen Kenntnisse überlebten, sondern Rutishausers 

Programmiergrundsätze. Sie flossen in die von ihm geschaffene 

Programmiersprache Algol ein. […] Die Studierenden in den ersten 

Z4- und ERMETH-Jahren waren sich wohl nicht bewusst, dass 1952 in 

Zürich meines Wissens die erste Informatikvorlesung auf dem 

europäischen Kontinent stattfand.“ 

Ende der historischen Notiz 

Zum Weiterlesen der Geschichte der Computer und der Informatik an der ETH Zürich: Andreas Nef, Tobias 

Wildi: Informatik an der ETH Zürich 1948–1981, Preprints zur Kulturgeschichte der Technik / 2007 / 21, 

ETH Zürich, Institut für Geschichte / Technikgeschichte. Auch in: Peter Haber (Hrsg.): Computergeschichte 

Schweiz – eine Bestandesaufnahme, Zürich, 2009. www.tg.ethz.ch/dokumente/pdf_Preprints/Preprint21.pdf 

246 

Compiler 



• Übersetzt ein Programm einer (höheren) Programmiersprache 

(z.B. C++) ganz in Maschinensprache 

Ein Prozessor kann keine 

Programme einer höheren 

Sprache ausführen, sondern 

nur Maschinenprogramme 

Maschinensprache ist 

Menschen nicht zumutbar 

Transformation muss bedeutungsäquivalent 

sein! 

247 

104

Interpreter 

• Programm, welches ein Programm einer anderen 

Programmiersprache Anweisung für Anweisung 

nur intern „übersetzt“ und diese jeweils unmittelbar 

ausführt (im Gegensatz zu einem Compiler) 

• Typisch für Dialog-, Skriptund 

Kommandosprachen 

• z.B. Perl, Python, oder Ruby 

• Vorteil: Einfaches Testen, 

da Programm sofort (weiter) 

ausführbar nach Änderung 

Eingabe- 

Daten 



Java- 

Programm 

Java 

Interpreter 

Maschine 

M 

Resultat des 

Java- 

Programms 

• Nachteil: Programmausführung dauert länger als die 

Ausführung übersetzter (compilierter) Programme 

• Analyse, Adressberechnung etc. wird in einer Schleife 

z.B. jedes Mal (statt einmalig) gemacht! 

248 

Java-Bytecode 

• Bytecode ist die Maschinensprache der Java-VM 

• Bytecode ist ziemlich kompakt: Die meisten Instruktionen 

(„Operationen“) sind nur 1 Byte (= 8 Bit) lang 

• Kennzeichnung durch einen 8-Bit-Operationscode 

• Haben zusätzlich auch eine „symbolische“ Bezeichnung, z.B.: 

• add mit Operationscode 01100000 

(dezimal 96, hexadezimal 0x60) 

• iconst_3 mit Operationscode 00000100 

• pop mit Operationscode 01010111 

249 

105

Übersetzung in Java-Bytecode 

static int p1(int p) { 

int i; 

i = 5; 

int j = 7; 

int k = j+i+j+i+3; 

return k; 

} 

• Die Speicherplätze für Variablen werden 

vom Compiler durchnummeriert 

• p auf Platz 0, i auf 1, j auf 2, k auf 3 

• Diese Nummern werden dann bei istore 

und iload als „Adressen“ verwendet 

250 

Übersetzung in Java-Bytecode (2) 

static void q() { 

int i=0, j=0; 

boolean b = false; 

b = (4*i + (3+j)*2) > j+7*i; 

b = b & (33 > 2+j); 

} 

Mit dem Konsolen-Kommando 

javap -c xx 

kann man sich den Java-Bytecode der 

Klasse xx in symbolischer Form anzeigen 

lassen, den der Java-Compiler (z.B. in 

der Datei xx.class) generiert hat. 

Tipp: Dieses ausprobieren, man 

macht interessante Entdeckungen! 

0 iconst_0 

1 istore_0 

2 iconst_0 

3 istore_1 

4 iconst_0 

5 istore_2 

6 iconst_4 

7 iload_0 

8 imul 

9 iconst_3 

10 iload_1 

11 iadd 

12 iconst_2 

13 imul 

14 iadd 

15 iload_1 

16 bipush 7 

18 iload_0 

i 

j 

b 

19 imul 

20 iadd 

21 if_icmpgt 28 

24 iconst_0 

25 goto 29 

28 iconst_1 

29 istore_2 

30 iload_2 

31 iconst_2 

32 iload_1 

33 iadd 

34 bipush 33 

36 if_icmplt 43 

39 iconst_0 

40 goto 44 

43 iconst_1 

44 iand 

45 istore_2 

251 

106

Eine Auswahl von VM-Instruktionen 

• Instruktionen operieren i.Allg. auf dem Operandenstack 

• Aber einige dienen auch nur der Steuerung des Kontrollflusses 

• Instruktionen werden durch einen Operationscode 

gekennzeichnet (1 Byte, daher max. 256 Instruktionen) 

• Evtl. enthalten nachfolgende Bytes auch Operanden (z.B. Index 

einer Variablen oder einen direkten Wert, wie z.B. bei bipush); 

Instruktionen können daher auch zwei oder mehr Byte lang sein 

• Neben nachfolgenden Instruktionen gibt es noch weitere 

• Siehe dazu z.B. Tim Lindholm, Frank Yellin: The Java Virtual Machine 

Specification, Addison-Wesley, 1999 (ISBN 0-201-43294-3), online bei: 

http://docs.oracle.com/javase/specs/jvms/se5.0/html/VMSpecTOC.doc.html 

• Zur Java-VM generell (und Bytecode) siehe auch Bill Venners: 

Inside the Java Virtual Machine, 2000 (ISBN 0-07-135093-4) , 

insbes. Kapitel 5, online bei www.artima.com/insidejvm/ed2/jvm.html 

252 

Eine Auswahl von VM-Instruktionen (2) 

iconst_m1 

Push the integer -1 onto the stack. 

iconst_0, ... iconst_5 

Push the integer 0,..., 5 onto the stack. 

iload_vindex 

The value of the local variable at 

vindex in the current Java frame is 

pushed onto the operand stack. 

istore_vindex 

Local variable vindex in the current 

Java frame is set to value. 

bipush byte 

Push one-byte signed integer. 

pop 

Pop top stack word from the stack. 

iadd 

Value1 and value2 must be integers. 

The values are added and replaced 

on the stack by their integer sum. 

imul 

...replaced on the stack by their 

integer product. 

nop 

Do nothing 

vindex: die Variablen eines „frames“ sind durchnummeriert; 

vindex ist dabei die Nummer („index“) einer Variablen 

253 

107

5. 

Pakete in Java 


- 126-131 (Pakete) 

- 635-639 (Stack als Liste) 

- 122-126 („BigRational class“) 

254 

Pakete in Java 

• Paket = (zusammengehörige) Menge von Klassen 

• Sowie Unterpakete und Interfaces 

• Hierarchischer Aufbau 

• Paket „xyz“ im Paket „java“ → „java.xyz“ 

• Wichtig für Strukturierung und Zugriffskontrolle 

• Klassen und Methoden (bzw. Attribute von Klassen) sind (ohne 

weitere Angaben) nur im eigenen Paket sichtbar und zugreifbar 

• Klassen befinden sich (logisch) immer in Paketen 

• Paketdeklaration direkt am Anfang einer Quelldatei, z.B. 

package abc; 

• Konvention: kleingeschriebene Namen 

• Falls package-Deklaration fehlt: „unnamed package“ 

255 

108

Pakete in Java (2) 

• Attribute bzw. Methoden von Klassen können vollqualifiziert 

(d.h. mit dem Paketnamen) benannt werden 

• Z.B.: java.lang.String.substring 

Paket Klasse Methode 

• Importieren von Klassen (als Namensabkürzung) 

• Z.B. import java.util.Random 

(es wird diese Klasse importiert; kann mit Name „Random“ benutzt werden) 

• Oder import java.util.* 

(es wird alles aus diesem Paket importiert) 

• Das Java-System bietet eine Reihe von Standardpaketen 

mit nützlichen Klassen und Methoden für fast jeden Zweck an 

• Z.B. java.lang, java.io, java.net, java.applet, java.util,... 

256 

257 

109

Eigene Pakete 

Beispiel.java: 

import myPack.*; 


...main...{ 

Stack S; 

... 

Queue Q; 

} 

} 

Alternativ zu „import“: jew. 

vollqualifizierter Zugriff, 

also z.B. myPack.Queue 

Stack.java: 

package myPack; 

public class Stack 

{...} 

class Hilfselement 

{ void setzen() 

{...} 

} 

Queue.java: 

package myPack; 

public class Queue 

{...} 

class x 

{ private void y() 

{...} 

} 

Gemeinsames Paket (aber getrennte Dateien, da jede 

Datei nur eine einzige public-Klasse enthalten darf) 

• Die Klasse Stack in der Datei Stack.java (bzw. Queue in Queue.java) muss 

mit dem Zugriffsmodifikator „public“ qualifiziert werden, da diese Klassen 

ausserhalb des Paketes MyPack (in Beispiel.java) verwendet werden 

• Entsprechendes würde für öffentl. Methoden / Attribute von Stack und Queue gelten 

• Die Methode „setzen“ ist innerhalb von myPack (also z.B. von Queue aus) 

zugreifbar, nicht aber von ausserhalb des Paketes (z.B. von Beispiel aus) 

• y ist nur von Methoden der Klasse X aus zugreifbar (da „private“) 

258 

Beispiel 1: Ein Paket für int-Listen 

• Es geht um verkettete Listen der folgenden Art: 

25 

17 39 

• Nutzer unseres Paketes sollen „Listenelemente“ am Anfang 

(am Listenkopf: „head“) hinzufügen und entfernen können 

• add_head, remove_head 

• Ausserdem sollen sie weitere nützliche Methoden bekommen: 

• Feststellen, ob die Liste leer ist 

• Wie viele Elemente sie enthält 

259 

110

Beispiel 1: Ein Paket für int-Listen (2) 

package listPack; 

class ListElem { 

int val; 

ListElem next; 

ListElem ist ausserhalb 

des Paketes 

nicht sichtbar 

39 

} 

public ListElem(int i, ListElem e) { Konstruktor 

val = i; 

next = e; 

} 

Hierauf soll das neue 

Listenelement zeigen 

public class List { 

... 

} 

Nur eine einzige Klasse 

pro Datei darf public sein 

Fortsetzung des Paketes „listPack“ 

auf der nächsten slide 

260 

public class List { 

private ListeElem first = null; 

private int size = 0; 

private boolean empty() { 

return (size == 0); 

} 

public int size() {return size;} 

public void add_head(int i) { 

first = new ListElem(i,first); 

size++; 

} 

public int remove_head() { 

int i = first.val; 

first = first.next; 

size--; 

return i; 

} 

// evtl. weitere Methoden 

} 

Kein Zugriff von aussen 

Methode liefert den 

Wert der gleichnamigen 

privaten Variablen 

Neues Element vorne 

einketten 

Grösse auf privater 

Variablen mithalten 

Ausketten 

Wert des (ehemaligen) 

vordersten Elements 

zurückliefern 

261 

111

Ein Stack aus einer int-Liste 

Bereits als Übung in 

Teil I der Vorlesung 

• Unter Verwendung realisierter Datentypen (z.B. List) 

können neue Datentypen konstruiert werden, z.B. ein 

Stack mit push, pop (ohne Wertrückgabe) und top 

• Interne Realisierung von push bzw. pop (nach aussen 

nicht sichtbar): 

262 

import listPack.List; 

public class Stack { 

private List L; 

public Stack() { 

L = new List(); 

} 

public boolean empty() { 

return (L.size() == 0); 

} 

public void push(int i) { 

L.add_head(i); 

} 

public void pop() { 

// Test, ob !empty()... 

L.remove_head(); 

} 

public int top() { 

// Test, ob !empty()... 

int i = L.remove_head(); 

L.add_head(i); 

return i; 

} 

} 

Im Konstruktor des Stacks muss 

eine (leere) Liste erzeugt werden! 

Der zurückgelieferte Wert wird 

einfach ignoriert! 

Da List keinen direkten Zugriff auf 

die Listenelemente gestattet und 

die Werte nicht direkt ermittelt 

werden können, verwenden wir 

diesen Trick 

263 

112

Stack: Implementierungsmöglichkeiten 

• Wir wissen bereits von früher, 

wie ein Stack mit einem Array 

implementiert werden kann: 

• Dagegen Implementierung 

mit verketteter Liste wie eben: 

] 

Array-Implementierung: effizient, 

aber der Stack ist a priori begrenzt. 

Der Stack ist so potentiell unbegrenzt, 

wegen „new“ jedoch etwas aufwendiger 

(langsamer) und hat Speicher- 

Overhead durch die next-Referenzen. 

264 

Austausch von Klassen als 

Dienstleistungsanbieter 

• Eine Klasse als „Dienstleistungsanbieter“ kann „rücksichtslos“ gegen 

eine mit gleicher Schnittstelle (public-Variablen und -Methoden) 

sowie gleicher externer Wirkung ausgetauscht werden 

• Aber kann ein Array-basierter Stack (feste Maximalgrösse!) wirklich 

exakt das gleiche Verhalten aufweisen wie ein listenbasierter Stack? 

265 

113

Beispiel 2: Paket „Bruchrechnen“ 

Bruch = Zähler 

Nenner 

• Paket, um mit rationalen Zahlen in Bruchform zu rechnen 

• Vermeidet so evtl. Rundungsfehler, die bei float zu erwarten 

sind (hier nur für nicht-negative Brüche realisiert) 

package bruchPak; 

public class Bruch { 

private long Zaehler = 0; 

private long Nenner = 1; 

public Bruch(long z, long n) {setzen(z,n);} 

public Bruch(long z) {setzen(z,1);} 

public Bruch() {setzen(0,1);} 

public void setzen(long z, long n) { 

if (z < 0 || n

Paket „Bruchrechnen“ (3) 

public Bruch plus(Bruch y) { 

long n = kgV(Nenner, y.Nenner); 

long z = (n/Nenner)*Zaehler + (n/y.Nenner)*y.Zaehler; 

} 

Bruch t = new Bruch(z,n); 

t.kuerzen(); 

return t; 

public Bruch mult(Bruch y) { 

return new Bruch(Zaehler*y.Zaehler,Nenner*y.Nenner); 

} 

private void kuerzen() { 

if (Zaehler == 0) 

Nenner = 1; 

else { 

long g = ggT(Zaehler,Nenner); 

Zaehler = Zaehler/g; 

Nenner = Nenner/g; 

} 

} 

} // Ende der Klasse Bruch 

Das Ergebnis einer Addition 

ist ein neuer Bruch 

Durch die Multiplikationen kann es 

leicht zu einem Überlauf kommen 

besser: Faktoren frühzeitig kürzen, 

um das Probelm zu minimieren 

'kuerzen' ist als eine 

instanzenbasierte Funktion 

realisiert, die aber von 

aussen nicht zugänglich ist 

268 

Nutzung des Pakets „Bruchrechnen“ 

import bruchPak; 

... 

Bruch a = new Bruch(); 

Bruch b = new Bruch(1,2); 

Bruch c = new Bruch(5); 

a.drucken(); 

a.setzen(2,3); 

a.drucken(); 

b.drucken(); 

c.drucken(); 

c = a.mult(b); 

c.drucken(); 

(a.plus(b)).drucken(); 

c = a.plus(b.plus(a)); 

c.drucken(); 

c = c.plus(new Bruch(1,8)); 

c.drucken(); 

public Bruch(long z, long n) 

{ setzen(z,n); } 

public Bruch(long z) 

{ setzen(z,1); } 

public Bruch() { setzen(0,1); } 

0/1 = 0 

2/3 = 0.666667 

1/2 = 0.5 

5/1 = 5 

1/3 = 0.333333 

7/6 = 1.16667 

11/6 = 1.83333 

47/24 = 1.95833 

270 

115

Nutzung des Pakets „Bruchrechnen“ (2) 

c = (new Bruch(7,12)).plus(new Bruch(1,6)); 

c.drucken(); 

2/3 1/2 

System.out.println(a.kleiner(b)); 

System.out.println(b.kleiner(a)); 

c = a; 

System.out.println(a.identisch(c)); 

System.out.println(a.identisch(b)); 

a.setzen(0,3); 

b.setzen(0,4); 

c = a.plus(b); 

c.drucken(); 

c.setzen(3,0); 

3/4 = 0.75 

false 

true 

true 

false 

0/1 = 0 

*** Fehler Wertebereich 

• Die interne Repräsentation von Zähler und Nenner durch „long“ ist 

beschränkt; man könnte sich andere Realisierungen vorstellen; 

z.B. bei der die einzelnen Ziffern von Zähler und Nenner in 

(potentiell beliebig langen) verketteten Listen gehalten werden. 

• Analoge Pakete auch für andere mathem. Objekte, z.B. Polynome, Matrizen... 

271 

Themen der Vorlesung 








7. Exceptions 








Algorithmen 


15. Heaps 


und Threads 

273 

116

Resümee (5) 

• Arithmetische Infix-Ausdrücke 

• Codegenerierung für eine Stackmaschine 

• Interpreter für Infix-Ausdrücke ( „Taschenrechner“) 

• Übersetzung von Java nach Bytecode 

• Java-VM als Bytecode-Interpreter 

while (c == '+') { … 

stk.push(stk.pop() 

+ stk.pop()); } 

• Pakete in Java 

• Beispiel verkettete Liste / Stack 

• Beispiel Bruchrechnung 

import bruchPak; … 

a = b.plus(new Bruch(1,8)); 

276 

6. 

Objektorientierung 

Aus Teil I der Vorlesung und aus C++ teilweise bekannt! 

Insbesondere wurde dort behandelt: 

- Basisklasse, abgeleitete Klasse, Vererbung („is-a“, „has-a“ etc.) 

-Dynamicbinding 


- 105-109 (Objektorientierung) 

- 145-204 (Vererbung) 277 

277 

117

Objektorientiertes Programmieren 

• Weltsicht: Die Welt besteht aus verschiedenen 

interagierenden „Dingen“, 

welche sich klassifizieren lassen 

Simulationssprache SIMULA 

war die erste objektorientierte 

Programmiersprache (1967) 

• Ziel: Betrachteten Weltausschnitt 

strukturkonform mit kommunizierenden 

Objekten abbilden und modellieren 

278 

Objekte 

• Sind autonome, gekapselte Einheiten 

eines bestimmten Typs 

• Haben einen eigenen Zustand 

(= lokale Variablen) 

• Besitzen ein Verhalten 

(wenn sie aktiviert werden) 

• Bieten anderen Objekten Dienstleistungen an 

• Durchführung von Berechnungen 

• Änderungen des lokalen Zustandes 

• Zurückliefern von Variablenwerten oder 

Berechnungsergebnissen 

• Allgemein: „Reaktion“ auf Aufruf einer Methode 

279 

118

Objektorientierter Softwareentwurf 

• Strukturierung der Problemlösung als eine Menge 

kooperierender Objekte 

• Entwurf der Objekttypen, dabei ähnliche Objekte zu 

Klassen zusammenfassen 

• Herausfaktorisierung gemeinsamer Aspekte verschiedener 

Klassen ⇒ Hierarchie festlegen, Klassenbibliothek 

• Festlegung einzelner Dienstleistungen (→ Methoden) 

• Entwurf der Objektbeziehungen 

• Feinplanung der einzelnen Methoden, Festlegung der 

Klassenattribute etc. 

• Implementierung der Methoden 

(d.h. klassisches Programmieren im Kleinen) 

280 

Konzepthierarchie 

• Spezialisierung, Verallgemeinerung 

• Ein Rennfahrer ist ein spezieller Sportler 

• Ein Informatikstudent ist ein Mensch (mit Programmierkenntnissen) 

283 

119

Vererbung („inheritance“) 

• Alle Merkmale, Eigenschaften... des umfassenderen 

Begriffs werden an den Unterbegriff vererbt 

• Ein Rennfahrer hat mehr Eigenschaften als ein (allgemeiner) Sportler 

• Ein Rennfahrer erbt von zwei Oberkonzepten (Mehrfachvererbung) 

(Bemerkung: Mehrfachvererbung ist bei Java allerdings nicht möglich) 

284 

Vererbung („inheritance“) (2) 

• Ein Objekt (als „Begriffsinstanz“) ist oft polymorph 

• Ein Rennfahrer kann je nach Zweckmässigkeit auch 

nur als Sportler bzw. als Geschäftsmann oder schlicht 

einfach als Mensch betrachtet werden 

Vererbungsrelation 

ist transitiv: ein 

Bäcker hat alle Eigenschaften 

eines 

(„generischen“) 

Menschen 

285 

120

Klassenhierarchie als Konzeptbaum 

Basisklasse 

abgeleitete Klassen 

• Ein VW ist ein Personenwagen ist ein Auto ist ein Fahrzeug 

• Eine Trompete ist ein Blasinstrument ist ein Musikinstrument 

• Ein Fahrzeug hat Räder ⇒ ein Personenwagen hat Räder 

„is-a“-Relation 

286 

Abgeleitete Klassen, Redefinition 

• Eine abgeleitete Klasse besitzt automatisch alle 

Eigenschaften der zugehörigen Basisklassen 

• Konkret: besitzt alle Attribute und Methoden der Basisklassen 

• Ausser: Es werden explizit einige davon unsichtbar 

gemacht oder einige Methoden redefiniert 

• Redefiniert: heissen noch genauso, verhalten sich aber etwas anders 

• Eine abgeleitete Klasse kann zusätzliche Attribute und 

Methoden definieren ( Spezialisierung) 

287 

121

Abgeleitete Klassen, Redefinition – Beispiel 

• Eine Methode „berechneSteuer“ lässt sich nicht für alle 

Fahrzeuge gleichermassen definieren 

• Man würde z.B. in „Auto“ eine Standardmethode vorsehen 

(Benutzung von „Hubraum“), jedoch für spezielle Fahrzeuge 

(z.B. Elektroautos) diese Methode anders definieren 

288 

Ein Beispiel in Java 

class Fahrzeug{ 

public int Radzahl; 

} 

class Auto extends Fahrzeug { 

public int PS; 

public float Hubraum; 

} 

class PW extends Auto { 

public int Beifahrerzahl; 

} 

void print() { 

System.out.println("Radzahl: " + Radzahl + 

", Beifahrerzahl: " + 

Beifahrerzahl); 

} 

class LW extends Auto { 

public float Zuladung; 

} 

Vorfahre weiss nicht von den 

Erben; Erbe muss sich seinen 

Vorfahren aussuchen! 

Erweiterung der Klasse 

"Fahrzeug": Alles, was in 

"Fahrzeug" deklariert ist, 

gehört damit auch zur "Auto" 

(sowohl Attribute als auch 

Methoden) – mit gewissen 

Einschränkungen (→ später) 

Auf "weiter oben" 

definierte Attribute 

kann ohne weiteres 

zugegriffen werden 

– diese sind Teil der 

abgeleiteten Klasse! 

Fahrzeug 

Auto 

PW LW 

289 

122

Ein Beispiel in Java (2) 

class Beispiel{ 


Fahrzeug f = new Fahrzeug(); 

Auto a = new Auto(); 

PW p = new PW(); 

LW l = new LW(); 

Hier werden Instanzen (also Objekte) der 

verschiedensten Hierarchiestufe erzeugt 

p.Beifahrerzahl = 5; 

p.PS = 70; 

p.Hubraum = 1794; 

p.Radzahl = 4; 

p.print(); 

} 

} 

Zugriff auf Variablen und Methoden des 

mit 'p' bezeichneten PW-Objektes 

p.Zuladung geht 

natürlich nicht! 

Idee: Gemeinsame Aspekte 

herausfaktorisieren und in eine 

übergeordnete Klasse einbringen 

290 

Zuweisungskompatibilität 

• Objekte von abgeleiteten Klassen können an Variablen 

vom Typ der Basisklasse zugewiesen werden 

Fahrzeug 

• Fahrzeug f; Auto a; ... f = a; 

• Variable f kann Fahrzeugobjekte speichern 

• Ein Auto ist ein Fahrzeug 

Auto 

• Daher kann f auch Autoobjekte speichern 

• Die Umkehrung gilt jedoch nicht! 

• d.h. a = f; ist verboten! 

PW 

• Variable a kann Autoobjekte speichern 

• Ein Fahrzeug ist aber kein Auto (jedenfalls nicht immer)! 

LW 

• „Gleichnis“ zur Zuweisungskompatibilität: Auf einem 

Parkplatz für Fahrzeuge dürfen Autos, Personenwagen, 

Fahrräder... abgestellt werden. Auf einem Parkplatz für 

Fahrräder jedoch keine beliebigen Fahrzeuge! 

291 

123

Zuweisungskompatibilität (2) 

• Merke also: Eine Variable vom Typ „Basisklasse“ darf 

auch ein Objekt der abgeleiteten Klasse enthalten 

• Man nennt diese Eigenschaft auch Polymorphie, da eine 

Referenz auf Objekte verschiedenen Typs zeigen kann 

(bzw. eine Variable Werte unterschiedlichen Typs haben kann) 

• Beispiel: Eine Variable vom Typ „Referenz auf 

Fahrzeug“ kann zur Laufzeit sowohl zeitweise auf 

PW-Objekte, als auch zeitweise auf LW-Objekte zeigen 

292 

Ein Java-Beispiel zur Zuweisungskompatibilität 

class Fahrzeug {... int Radzahl;} 

class Auto extends Fahrzeug {... float Hubraum;} 

class PW extends Auto ... 

Fahrzeug f; Auto a; PW p; LW l; 

... new ... 

p.Hubraum = 1702; 

p.Radzahl = 4; 

Ein PW ist ein Auto 

und ein Fahrzeug 

a = p; 

f = p; 

f = a; 

/* a = f; */ 

/* ERROR: Incompatible types */ 

Ein Fahrzeug-Variable darf PW- 

Objekte und Auto-Objekte speichern 

a.Hubraum = 1100; 

f = a; 

System.out.println(f.Radzahl); 

System.out.println(f.Hubraum); 

ERROR: No variable Hubraum defined in Fahrzeug 

Fahrzeug 

Radzahl 

Auto 

Hubraum 

PW 

Es wurde zwar Hubraum und 

Radzahl zugewiesen; Hubraum 

ist aber über f nicht zugreifbar 

293 

124

Typkonversion („type cast“) 

• Aus gutem Grund ist f.Hubraum verboten: Auf f könnte 

ja zufällig ein Fahrrad (ohne Hubraum!) „parken“! 

• Durch Typkonversion kommt man aber notfalls auch 

über f an den Hubraum des Auto-Objektes: 

System.out.println(((Auto)f).Hubraum); 

• Aber wenn dort derzeit kein Auto (sondern ein Fahrrad) 

parkt? Das gibt einen Laufzeitfehler „ClassCastException“! 

• Dem kann man wie folgt vorbeugen: 

if (f instanceof Auto) 

System.out.println(((Auto)f).Hubraum); 

else System.out.println("kein Auto, kein Hubraum!"); 

294 

Polymorphie 

• Polymorphie („Vielgestaltigkeit“) 

• Eine Variable kann Werte unterschiedlichen Typs annehmen 

• Bzw.: eine Referenz kann auf Objekte unterschiedlichen 

(aber „verwandten“) Typs verweisen 

• Objekte verwandten Typs können gleichnamige 

Methoden haben 

Beispiel: 

Methode „Flächenwert“ 

ist für alle Objekttypen 

realisiert, jedoch unterschiedlich 

je nach Typ! 

Geometrisches 

Objekt 

Ellipse Rechteck Dreieck 

Kreis 

Quadrat 

295 

125

Abstrakte Methoden und Klassen 

• Abstrakte Methoden werden von den abgeleiteten Klassen 

jeweils spezifisch implementiert 

• Eine Klasse mit abstrakten Methoden muss selbst als 

„abstract“ deklariert werden 

• Beispiel: 

abstract class GeomObj { 

GeomObj next; 

public abstract float flaechenwert();} 

} 

Anker 

next 

Diese Methode muss 

für jede abgeleitete 

Klasse mit sinnvoller 

Semantik implementiert 

werden! 

296 

Polymorphe Liste 

class Dreieck extends GeomObj { 

// Koordinaten etc. als Attribute 

public float flaechenwert() { 

... // bekannte Formel anwenden 

System.out.print("Dreiecksfläche:..."); 

} 

} 

class Kreis extends GeomObj { 

... ...flaechenwert() ... 

} 

• Eine polymorphe Liste kann man dann z.B. so durchlaufen: 

for (GeomObj z = Anker; z != null; z = z.next) 

f = f + z.flaechenwert(); 

Anker 

next 

297 

126

Verarbeitung polymorpher Objekte 

• Die Verarbeitung der einzelnen Objekte kann 

unabhängig von ihrem eigentlichen Typ geschehen 

• In der Praxis wird eine solche „Verarbeitung“ i.Allg. wesentlich 

komplexer sein, als in obigem Beispiel angedeutet 

• Es können, ohne den Verarbeitungsalgorithmus 

anzupassen, neue Objekttypen als Unterklassen von 

„GeomObj“ eingeführt werden (z.B. „Quadrat“) 

• Nur hinzufügen, aber (im Idealfall) nichts verändern, vermindert 

den Wartungsaufwand beträchtlich! 

• Late binding: Es wird zur Laufzeit berechnet, welche 

konkrete Methode „angesprungen“ wird; dies steht zur 

Übersetzungszeit ( „early binding“) noch nicht fest! 

298 

Generische Methoden und abstrakte Klassen 

abstract class Sort { 

abstract boolean kleiner (Sort y); 

static void sort(Sort[] Tab) { 

for (int i=0; i

Generische Methoden und abstrakte Klassen (2) 

• Unabhängig davon, wie die Relation „kleiner“ konkret 

definiert ist, funktioniert unser Sortierverfahren! 

• Das Sortierverfahren kann also bereits implementiert (und 

getestet) werde, bevor überhaupt die Daten selbst bekannt sind 

• Einmal entwickelt, kann man den Algorithmus auch zum 

Sortieren anderer Datentypen verwenden 

• int, float, Brüche als rationale Zahlen, Zeichenketten... 

300 

Anwendung des Sortierverfahrens 

• Es sollen zunächst einfache int-Werte sortiert werden, 

und zwar unter Benutzung der existierenden generischen 

Sortierroutine (ohne diese kennen zu müssen!): 

class IntSort extends Sort { 

int w; 

IntSort(int i) { Konstruktor 

w = i; 

} 

boolean kleiner(Sort y) { 

return w < ((IntSort)y.w); 

} 

} 

Hier wird die Relation 

"kleiner" definiert 

und implementiert 

Dies ist die vom Anwender bereitgestellte 

Klasse (aufbauend 

auf der Basisklasse Sort) 

301 

128

Anwendung des Sortierverfahrens (2) 

class ... { 

... 

IntSort[] Tabelle = new IntSort[12]; 

} 

Diese Klasse verwendet 

beispielhaft IntSort 

Füllen mit Zufallszahlen 

for (int i=0; i

Eine andere Sortieranwendung (2) 

class ... 

... 

Studi[] Tab = new Studi[8]; 

Tab[0] = new Studi(10,"Bio","Hase"); 

Tab[1] = new Studi(8,"Mathe","Oberzahl"); 

... 

Tab[7] = new Studi(6,"Physik", "Kraft"); 

Studi.sort(Tab); 

for (int i=0; i

Sortieren geometrischer Objekte nach ihrer Fläche 

abstract class GeomObj extends Sort { 

public abstract float flaeche(); 

boolean kleiner (Sort y) { 

GeomObj x = (GeomObj)y; 

return flaeche() < x.flaeche();} 

} 

class Quadrat extends GeomObj { 

float laenge; 

public float flaeche() { 

return (laenge*laenge); 

} 

Quadrat() { 

laenge = KbdInput.readInt("Länge? "); 

} 

} 

class Kreis extends GeomObj { 

float radius; 

public float flaeche() { 

return (3.1415926536*radius*radius); 

} 

Kreis() { 

radius = KbdInput.readInt("Radius? "); 

} 

} 

Abstrakte 

Klassen 

Quadrat 

laenge 

Sort 

GeomObj 

abstract 

kleiner 

abstract 

flaeche 

Kreis 

radius 

Die Fläche wird jeweils 

typspezifisch berechnet 

307 

Das zugehörige Testprogramm 


GeomObj[] Tabelle = new GeomObj[3]; 

} 

for (int i=0; i

Mehrfachvererbung 

• Zweck: „mix in“; Verheiraten mehrerer Konzepte 

• Beispiel: geometrische Formen eines Zeichenprogramms: 

• Dabei soll „gefülltes Quadrat“ Methoden und Attribute von 

mehreren Klassen erben können 

• Ist keine Baumstruktur, sondern ein gerichteter azyklischer Graph! 

311 

Probleme der Mehrfachvererbung 

• Gleich benannte Attribute in verschiedenen 

Vorgängerklassen: welches davon wird geerbt? 

• Problem oft nicht zu vermeiden, da Vorgängerklassen von 

verschiedenen Entwicklern realisiert wurden 

• Daher Mechanismen zur „Konfliktauflösung“ notwendig 

(z.B. beim Erben umbenennen; Angabe, welche davon man 

erben möchte; Vorrangregeln für den Konfliktfall etc.) 

• Keine Mehrfachvererbung bei Java! (Im Gegensatz zu C++) 

• Um Sprache einfach zu halten 

• Als teilweisen Ersatz dafür dienen bei Java die „Interfaces“ 

312 

132

Schnittstellen („Interfaces“) 

• Interface = (abstrakte) Klasse, die alle Methoden nur 

deklariert, aber nicht implementiert 

• Enthält also nur (implizit) abstrakte Methoden (und evtl. Konstanten) 

interface Menge { 

int cardinal(); 

void insert (Object x); 

void remove (Object x); 

} 

Alle Methoden sind automatisch 

public abstract 

Alle „Variablen“ sind automatisch 

public static final (d.h. „Konstanten“) 

• Interface muss von anderen Klassen implementiert werden: 

class S implements Menge { 

public int cardinal(); { 

... 

while ... i++ ...; 

return i; 

} 

} 

implements hat die gleiche Rolle 

wie extends bei „echten“ Klassen 

Es kann auch eine entsprechende 

Hierarchie entstehen 

313 

Mehrfacherweiterungen 

• Interfaces dürfen mehrere andere erweitern, z.B.: 

interface A {...} 

interface B {...} 

interface I extends A, B {... 

int m(); ... 

} 

A 

I 

B 

• I umfasst alle (abstrakten) Methoden von A und B (und zusätzlich m) 

• Eine Klasse dagegen kann nur eine einzige Klasse erweitern 

(aber gleichzeitig mehrere Interfaces implementieren): 

class P extends Q 

implements A,B,... 

A 

Q 

P 

B 

314 

133

„Diamond Inheritance“ 

• Das sogen. „diamond inheritance problem“ 

ist damit entschärft: 

interface W {...} 

interface X extends W {...} 

class Y implements W {...} 

class Z extends Y implements X {...} 

X 

W 

Z 

Y 

• Die von Z geerbten Attribute und Methodenimplementierungen 

können nur aus Y (und 

nicht indirekt doppelt aus W stammen) 

315 

7. 

Exceptions 


- 83-87 

- 173-174 

320 

134

Exceptions – „offizielle“ Erläuterungen 

• “An exception is an event, which occurs during the 

execution of a program, that disrupts the normal 

flow of the program's instructions." 

• "When an error occurs within a method, the 

method creates an object and hands it off 

to the runtime system. The object, called an 

exception object, contains information about 

the error, including its type and the state of 

the program when the error occurred." 

• "Creating an exception object and handing it to the 

runtime system is called throwing an exception." 

Source: http://download.oracle.com/javase/tutorial/essential/exceptions/ 

321 

Ausnahmeereignisse (Exceptions) 

• Ausnahmeereignisse 

als Fehlerereignisse 

• Werden oft vom System 

ausgelöst („throw“) 

• Können aber auch explizit im 

Programm ausgelöst werden 

• Sollten abgefangen und 

behandelt werden („catch“) 

• Programmstrukturierung 

durch „try“ und „catch“: 

• Fehlerbehandlung muss auf 

diese Weise nicht mit dem 

„normalen“ Programmcode 

verwoben werden 

readFile() { 

try { 

// open the file; 

// determine its size; 

// allocate that much memory; 

// read the file into memory; 

// close the file; } 

catch (FileOpenFailed) { 

// doSomething; } 

catch (SizeDeterminationFailed){ 


catch (MemoryAllocationFailed){ 


catch (ReadFailed){ 


catch (FileCloseFailed){ 


} 

von Exceptions: 

Weitere Nutzen von Exceptions: 

http://tinyurl.com/5t9uesp 

322 

135

Fehlerarten 

• Typ. Situationen, in denen Ausnahmen auftreten können: 

• Ein- / Ausgabe (z.B. IOException) 

• Netz (z.B. MalformedURLException) 

• Erzeugen von Objekten mit „new“ 

• Typkonvertierung 

(z.B. NumberFormatException) 

Ob ein Fehler auftritt, hängt 

vom Kontext ab, den man 

oft nicht selbst kontrolliert 

• Wichtige Fehlerklasse: Laufzeitfehler, z.B.: 

• Zugriff über Null-Referenz 

try { 

• Division durch 0 

value = value / x; 

• Array-Indexfehler 

} 

catch (ArithmeticException e){ 

Solche „Programmierfehler“ können, 

System.out.println 

aber müssen nicht abgefangen werden 

("Division durch 0?"); 

} 

323 

Ausnahmen: Hierarchie 

Throwable 

Die Klasse Throwable enthält 

umfangreiche Methoden zur 

Behandlung von Fehlern, z.B.: 

getStackTrace, 

printStackTrace, ... 

Error 

Exception 

RunTimeException 

... 

IOException 

324 

136

Fehler abfangen / weiterleiten 

• Alle Fehler (ausser Laufzeitfehler) müssen von einer Methode 

entweder selbst abgefangen oder explizit weitergeleitet werden 

• Entweder durch try / catch in der Methode 

• Oder durch Angabe (mittels „throws“), dass die Methode diese Ausnahme 

evtl. auslöst (und damit dem „Aufrufer“ weiterreicht), z.B.: 

import java.io.*; 

public eine_methode (...) throws java.io.IOException { 

... read ... 

} Der Aufrufer muss dann mit 

dieser Exception „rechnen“ 

325 

Ausnahmen: E/A-Beispiel 

Eingabe / Ausgabe 

import java.io.*; 

public class EA_Beispiel { 

//print "Hello World" to a file specified by the first input parameter 


FileOutputStream out = null; 

//try opening the file; if we can't, 

//display error and quit 

try { 

out = new FileOutputStream(args[0]); 

} 

catch (Throwable e) { 

System.out.println("Error in opening file"); 


} 

PrintStream ps = new PrintStream(out); 

try { 

ps.println("Hello World"); 

out.close(); 

} 

catch (IOException e) { 

System.out.println("I/O Error"); 


} 

} 

} 

Da wir Fehler selbst 

abfangen, können wir auf 

"throws…" verzichten 

Diese Fehlerklasse liegt 

ganz oben in die Hierarchie 

und fängt damit alles ab 

Z.B. Zugriffsrechte "falsch" 

Fehler hierbei würden 

nicht abgefangen 

Über diese Variable kann 

man mehr über den 

Fehler erfahren 

Notausstieg aus dem 

Programm 

326 

137

Definieren und Auslösen eigener Ausnahmen 

• Ausnahmen sind Objekte! 

• Eigener Ausnahmetyp 

muss von 

java.lang.Throwable 

abgeleitet sein 

• Kann mit „throw“ 

ausgelöst werden 

• „super“ ruft 

Konstruktor 

der Basisklasse 

Fehlerhaftes Datum 

ist: 47.3.97 at Datum. 

Setzen(Datum.java:27) 

at Beispiel.main 

(Datum.java:39) 

class IllegalesDatum extends Throwable { 

IllegalesDatum(int Tag, int Monat, int Jahr) { 

super("Fehlerhaftes Datum ist: " 

Tag + "." + Monat + "." + Jahr"); 

} 

Der Konstruktor von Throwable erwartet einen String, der 

} 

als Fehlermeldung (mit dem Stack-Trace) ausgegeben wird 

class Datum { 

... 

void setzen(int T, int M, int J) 

throws IllegalesDatum { 


if (Tag > 31) throw new 

IllegalesDatum (Tag, Monat, Jahr); 

} 

} 


... 

d.setzen(47,03,1997); //Zeile 39 in der Datei 

... 

} 

327 

8. 

Binärbäume als 



- 695-697 (Rekursion und Bäume) 

Aus den Übungen von Teil I der Vorlesung 

- 715-725 (Suchbaum) 

sind binäre Suchbäume und rekursive 

- 697-709 (Baumtraversierung) 

Traversierung bereits bekannt 

328 

138

Zur Erinnerung: Binärbaum 

• Jeder Knoten hat höchstens zwei Nachfolger 

• Unterscheide linken und rechten Nachfolger / Unterbaum 

W 

W 

X 

Y 

Y 

X 

Z 

Z 

331 

Binärbäume als Referenzstrukturen 

• Bsp: die Knoten eines Binärbaums 

sollen folgende Struktur haben: 


String name; 

Person left, right; 

} 

"Katja" 

left 

right 

"Eva" 

left 

right 

"Stephan" 

left 

right 

332 

139

Binärbäume als Referenzstrukturen (2) 

• Ein wenig umständlich könnte man dann so den 

Baum aufbauen: 

Person Wurzel; 

Wurzel = new Person(); 

Wurzel.name = "Katja"; 

Wurzel.left = new Person(); 

Wurzel.left.name = "Eva"; 

Wurzel.right = new Person(); 

Wurzel.right.name = "Stephan"; 

Wurzel.left.left = new Person(); 

... 

• Es können dynamisch neue Knoten hinzugefügt werden 

• Im Unterschied zur früheren Array-Repräsentation eines Baums 

• Jedenfalls solange der Speicherplatz reicht… 

333 


• Oft wird man in den einzelnen Knotenobjekten auch eine 

Referenzvariable vorsehen, die auf den Vorgänger zeigt: 

info 

Knoten mit 

Rückverweis: 

Ohne Rückverweis: 

back 

info 


String name; 

Person left, right; 

Person back; 

} 

left 

right 

left 

right 

334 

140


• Ein Baum ist dann eine solche 

„verzeigerte“ Struktur aus 

dynamischen Objekten 

• Die rekursive Struktur von 

(Binär-)bäumen legt eine 

Reihe von rekursiven 

Algorithmen nahe, z.B.: 

• Anzahl der Knoten 

• Höhe des Baums 

• Suchen eines Elementes 

• Traversieren (inorder, postorder...) 

• … 

336 

Höhe eines Binärbaums 

• Die Tiefe eines Knotens ist sein Abstand 

(d.h. die Länge seines Weges) zur Wurzel 

• Die Wurzel hat also die Tiefe 0 

• Die Höhe eines Baums ist die maximale Tiefe 

• D.h. die Länge eines längsten Weges von 

der Wurzel zu einem Blatt (es kann mehrere 

solche – gleich langen – Wege geben!) 

• Mit anderen Worten: Der maximale Abstand 

zwischen einem Knoten und der Wurzel 

• Ein Baum, der nur aus einer Wurzel besteht, 

hat also die Höhe 0 

Höhe: 3 

337 

141

Beispiel: Alle 21 Binärbäume der Höhe 2 

„links“ / „rechts“ unterscheiden 

„unlabeled“ 

• Es gibt 651 Binärbäume der Höhe 3, 

• 457653 der Höhe 4, 

• 210065930571 der Höhe 5, 

• 44127887745696109598901 der Höhe 6, 

• 1947270476915296449559659317606103024276803403 der Höhe 7, 

• … 

338 

Höhe eines Binärbaums rekursiv 

• Als lokale Methode in einer Knoten-Klasse: 

int height() { 

if (left!=null && right!=null) 

return 1 + Math.max(left.height(), 

right.height()); 

else if (left!=null) 

return 1+left.height(); 

else if (right!=null) 

return 1+right.height(); 

else 

return 0; 

} 

339 

142

Höhe eines Binärbaums rekursiv (2) 

• Als globale Methode ausserhalb einer Knoten-Klasse: 

int height(Tree b) { 

if (b != null) 

return 1 + Math.max(height(b.left), 

height(b.right)); 

else 

return ...; 

} 

Denkübung: Was muss hier hin? 

0? Oder -1? Oder etwas anderes? 

340 

Binäre Suchbäume 

• Voraussetzung: 

• Jeder Knoten hat ein Schlüsselattribut 

• Die Menge der Schlüsselattribute ist total geordnet 

• Def.: Für jeden Knoten mit Schlüsselattribut s gilt: 

• Alle Schlüssel im linken Unterbaum sind kleiner als s 

• Alle Schlüssel im rechten Unterbaum sind grösser als s 

Zu den gleichen Schlüsselattributen 

gibt es verschiedene Suchbäume. 

Bsp: „Günter“ anstelle von „Jan“ 

mit „Jan“ als rechten Nachfolger 

von „Günter“. 

341 

143

Suchen in binären Suchbäumen 

• Suchen eines Elementes (für gegebenes 

Schlüsselattribut) ist sehr effizient 

• Suchpfad startet an der Wurzel 

• Dann jeweils links ode rechts weitersuchen, 

je nach Schlüsselwert des Knotens 

• Bei „gutartigen“ Bäumen (alle Niveaus 

gut gefüllt) kommt man schon nach 

etwa log(n) Schritten an ein Blatt! 

• n = Anzahl der Knoten 

• Hat man das gesuchte Element bis dahin 

nicht gefunden, ist es nicht im Baum! 

342 

Einfügen in Suchbäume 

static void insert (String n, int t, Person p) { 

if (n.compareTo(p.name) < 0) 

if (p.left != null) 

insert(n, t, p.left); 

else { 

p.left = new Person(); 

p.left.name = n; p.left.telnr = t; 

} 

else 

if (p.right != null) 

insert(n, t, p.right); 

else { 

p.right = new Person(); 

p.right.name = n; p.right.telnr = t; 

} 

} 


Person left; 

Person right; 

Person back; 

String name; 

int telnr; 

} 

Ein neuer Knoten 

wird immer als 

Blatt eingefügt 

Einfügen der 

back-Referenz auf 

den Vorgänger als 

Denkübung 

• Beachte: Der Aufruf der Methode setzt voraus, dass der dritte 

Parameter auf die Wurzel eines (nicht leeren) Suchbaums zeigt 

• Was geschieht eigentlich, wenn es im Baum den Namen schon gibt? 

343 

144

Eine kürzere, elegantere Lösung? 

insert(…,…,w) 

static void insert (String n, int t, Person p) { 

if (p == null) { 

p = new Person(); 

p.name = n; p.telnr = t; 

} 

else if (n.compareTo(p.name) < 0) 

insert(n,t,p.left); 

else 

insert(n,t,p.right); 

} 

• Würde funktionieren, wenn p nicht eine Kopie (!) der Referenz w wäre, 

die beim Aufruf von insert als aktueller Parameter angegeben wird 

• Veränderungen des formalen Parameters p innerhalb von insert wirken 

sich so nicht auf den aktuellen Aufrufparameter „nach aussen“ aus! 

• Schade – sonst könnte man so auch in den noch leeren Baum einfügen 

• Merke: bei Java gilt für Referenzen die Wertübergabe! 

• Reality check für Spezialisten: wie ist es bei C++ ? 

344 

Des Rätsels Lösung 

1) Der Aufruf insert(…,…,w) von void insert(…,…,Person p) 

bewirkt als erstes eine implizit Zuweisung p=w des Wertes 

des „aktuellen“ Parameters w an den „formalen“ Parameter p 

2) Obige erste Lösung: p.left.telnr = 32168 

ist nach p=w aufgrund des Aliaseffekts 

identisch zu w.left.telnr = 32168, d.h. 

die Zuweisung der Telefonnummer wirkt 

p w 

nach aussen, ins Hauptprogramm zurück 

telnr = 32168 

3) Situation der „kürzeren Lösung“ (im Fall von w == null) nach p=w: 

p 

Ø 

w 

Nach p = new… ergibt sich: 

Das heisst, w zeigt nach dem Aufruf weiter ins Leere, 

die Manipulationen über p wirken nicht auf w zurück 

p 

w 

Ø 

345 

145

Knoten in Suchbäumen löschen 

• Aufgabe: Einen Knoten mit einem bestimmten 

Schlüsselattribut so aus dem Suchbaum entfernen, 

dass der Rest ein Suchbaum bleibt 

• Trivial bei Blättern 

• Einfach bei Knoten mit 

einem einzigen Nachfolger: 

diesen Knoten „ausketten“ 

(Beispiel: Jan oder Kerstin) 

Man überlege sich, wieso das „Ausketten“ 

die Suchbaumeigenschaft invariant lässt 

346 

Löschen von Knoten mit zwei Nachfolgern 

• Ersetze das zu entfernende Element entweder durch 

• das grösste Element seines linken Teilbaums 

• (im linken Teilbaum ganz nach rechts laufen!) 

• oder das kleinste seines rechten Teilbaums 

• (im rechten Teilbaum ganz nach links laufen!) 

Das Ersatzelement 

ist immer entweder 

ein Blatt oder ein 

Knoten mit einem 

einzigen Nachfolger 

• Also durch den unmittelbaren Vorgänger 

bzw. Nachfolger entsprechend der Ordnung 

Beispiele: 

-Katja durch Jan 

-Katja durch Kerstin 

-Eva durch Dirk 

- Eva durch Günter 

- Stephan durch Stefanie 

- Stephan durch Tanja 

Man überlege sich wieder, 

wieso dies die Suchbaumeigenschaft 

invariant lässt 

347 

146

Inorder-Traversierung von Binärbäumen 

• Prinzip: Zuerst den linken Unterbaum traversieren, 

dann den Wert der Wurzel ausgeben, anschliessend 

den rechten Unterbaum traversieren 

• Bei einem Suchbaum werden dabei die Knoten in 

der Reihenfolge des Schlüsselattributs ausgegeben 

die Ausgabe ist aufsteigend sortiert! 

static void inorder(Person p) { 

if (p != null) { 

inorder(p.left); 

System.out.println(p.name); 

inorder(p.right); 

} 

} 

Dirk, Eva, Günter, Jan, 

Katja, Kerstin, Stefanie, 

Stephan, Tanja 

351 

Sortieren mit Suchbäumen 

• Prinzip: 

1. Unsortierte Eingabeliste in einen (anfangs leeren) 

Suchbaum überführen (d.h. „insert“ nacheinander 

auf alle Elemente der Eingabeliste anwenden) 

2. „inorder“ auf die Wurzel anwenden und beim 

rekursiven Traversieren die Werte ausgeben 

3 

3, 5, 2, 7, 1, 4, 8, 6 1, 2, 3, 4, 5, 6, 7, 8 

2 5 

1 

4 7 

6 

8 

352 

147

Zeitbedarf: Anzahl der Schritte als 

Funktion der Zahl der Elemente n 

• Methode „insert“ wird n Mal von aussen aufgerufen 

• Aber: Wie viele Schritte benötigt ein solcher insert-Aufruf? 

• jedes Mal wird (rekursiv) ein Ast ganz durchlaufen 

O(n log n) 

• Aber wie lange ist ein Ast (im Mittel, maximal...)? 

• Im Extremfall (Eingabe sortiert!): n (bzw. 0.5n „gemittelt“) 

• Im „Normalfall“, wenn gutartige Bäume entstehen: etwa log(n) 

• Methode „inorder“ wird 1 Mal von aussen und 2n Mal 

rekursiv aufgerufen – also linear zu n O(n) 

• O(n) ist klein gegenüber O(n log n); geht in O(n log n) auf 

• Eine genaue mathematische Analyse würde ergeben: 

Im häufigen Normalfall werden insgesamt nur ca. 

c n log(n) Schritte zum Sortieren benötigt 

kleine Konstante 

353 

9. 

Binärsuche 


- 244-248 

- 341-342 

354 

354 

148

Binärsuche auf Arrays 

• Problem: Feststellen, ob ein Element in einem 

sortierten Array vorkommt 

• Lösung durch Intervallhalbierung: 

• Prüfen, in welcher Hälfte der gesuchte Wert liegen muss 

(wenn man nicht zufällig genau in der Mitte auf ihn gestossen ist!) 

• Verfahren dann iterativ (oder rekursiv) auf die „richtige“ Hälfte 

anwenden → entweder linke oder rechte Grenze neu setzen 

• Stoppkriterien: 

• Wert gefunden → liefere Index des gesuchten Elements im Array 

• Restbereich „kollabiert“ → liefere ’-1’ als Fehl-Indikator 

355 

Binärsuche auf Arrays – Beispiel 

• Ist die 76 vorhanden? 

356 

149

Binärsuche auf Arrays in Java 

// A sei hier ein globales int array 

int binSearch (int s) { 

int m; 

int li = 0; int re = A.length-1; 

} 

while (re >= li) { 

m = (li+re)/2; 

if (s == A[m]) return m; 

if (s < A[m]) 

re = m - 1 ; 

else 

li = m + 1 ; 

} 

return (-1); 

Voraussetzung: A sei 

aufsteigend sortiert 

Was passiert wenn 

• li + re ungerade ist? 

• oder wenn li = re? 

Fragen: 

1) Dürfen gleiche Elemente 

mehrfach vorkommen? 

2) Was geschieht, wenn 

A doch nicht sortiert ist? 

(Wie könnte dies in linearer 

Zeit überprüft werden?) 

357 

Binärsuche – Anwendungen 

• Beispiele: 

• Ist diese Telefonnummer schon vergeben? 

• Gibt es einen Stern mit diesem Namen schon? 

• Oft hat man komplexere Datenstrukturen 

• Dann ist das Array nur bzgl. einer „Schlüsselkomponente“ sortiert 

• Beispiel: Wie lautet das Buch mit dieser ISBN-Nummer? 

ISBN = 3458342672 

Titel = Die Schatzinsel 

ISBN = 3723503871 

Titel = Kaspar Hauser 

ISBN = 3770123395 

Titel = Der Würger 

• Sucheffizienz: Anzahl der Schritte ist logarithmisch zur Array-Länge 

• Also O(log n); „naive“ sequentielle Suche wäre hingegen O(n) 

• Beachte: Einfügen neuer Elemente ist allerdings „teuer“, da das 

Array sortiert bleiben muss (→ Platz schaffen durch Verschieben) 

358 

150

Binärsuche – Terminierung 

// A sei hier ein globales int array 

int binSearch (int s) { 

int m; 

int li = 0; 

int re = A.length-1; 

} 


m = (li+re)/2; 


if (s < A[m]) 

re = m - 1; 

else 

li = m + 1; 

} 

return (-1); 

Wieso terminiert die 

Schleife in jedem Fall? 

Es ist nicht a priori klar, 

dass der Algorithmus 

nicht eventuell (in einer 

Endlosschleife) „stecken 

bleibt“! 

359 

Binärsuche – Terminierung (2) 


m = (li+re)/2 


if (s < A[m]) 

re = m - 1; 

else 

li = m + 1; 

} 

• Hätte man z.B. : ... re = m; else li = m; 

statt dessen, dann könnte folgendes geschehen: 

mit li = 4, re = 5 m = (li+re)/2 = 4 

(im Fall s > A[4]): li = 4, re = 5 Endlosschleife! 

• Wie können wir wirklich beweisen, dass so ein 

Problem bei unserer Lösung nicht vorkommt? 

• Korrektheitsbeweis (als Denkübung) muss bei re = m-1; 

li = m+1, aber darf nicht bei re = m; li = m funktionieren! 

(Unvollständiges) 

Testen hilft nicht 

immer! 

360 

151

OK, WE‘VE CHANGED 

">" TO ">=". BUT THAT 

DOESN‘T WORK EITHER. 

AND NOW? 

LET ’S TRY 

"

Lineare Interpolationssuche 

m = li + (s – A[li])*(re-li) / (A[re]-A[li]); 

if (m < li) m = li; Korrektur für den Fall, dass s 

if (m > re) m = re; ausserhalb des Bereichs liegt 


Und würde man so nicht 

if (s < A[m]) re = m-1; zu oft in der falschen 

else li = m+1; („grösseren“) Hälfte landen? 

Aber würde man nicht 

durch 0 dividieren, 

wenn A[re] = A[li] ist? 

• Wie viel besser als die „normale“ Binärsuche ist dies? 

• Typischerweise viel besser, wir analysieren das aber nicht weiter 

• Findet z.B. Anwendung bei Zugriff auf externe Dateien 

• Wo jeder Zugriff relativ lange dauert 

• Dafür weitere Optimierungen, z.B. Index im Hauptspeicher halten 

363 

Binärsuche rekursiv 

„Comparable“ sei ein Interface 

import ... 

mit der Methode „compareTo“ 

public class BinarySearch { 

public static int binarySearch(Comparable [] a, Comparable x) 

throws ItemNotFound { 

return binSearch(a, x, 0, a.length -1); 

} 

} 

... 

} 

// Verborgene rekursive Methode: 

private static int binSearch(Comparable [] a, Comparable x, 

int low, int high) 

throws ItemNotFound { 

if ( low > high ) 

throw new ItemNotFound("BinarySearch fails"); 

int mid = (low + high) / 2; 

if ( a[mid].compareTo(x) < 0 ) 

return binSearch(a, x, mid+1, high); 

else if (a[mid].compareTo(x) > 0) 

return binSearch(a, x, low, mid-1); 

else return mid; 

Aber lohnt 

sich Rekursion 

bei Binärsuche 

wirklich? 

364 

153

Binärsuche rekursiv (2) 

// Test-Programm 

public static void main(String [] args) { 

int SIZE = 8; 

Comparable [] a = new MyInteger [SIZE]; 

for ( int i = 0; i < SIZE; i++ ) 

a[i] = new MyInteger(i * 2); 

for ( int i = 0; i < SIZE * 2; i++ ) { 

try { 

System.out.println("Found " + i + " at " 

+ binarySearch(a, new MyInteger(i))); 

} 

catch(ItemNotFound e) { 

System.out.println(i + " not found"); 

} 

} 

} 

Deklaration des Arrays „a“ 

Füllen von „a“ mit Werten 

binarySearch für 

Testwerte i aufrufen 

Das Beispiel findet sich 

so ähnlich im Buch von 

Mark Weiss, Seite 342 

• Benötigt wird noch „MyInteger“, das das Interface „Comparable“ 

zusammen mit der Methode „compareTo“ implementiert ( als Übung) 

• „ItemNotFound“ sei kanonisch von java.lang.Exception abgeleitet 

365 

10. 

Backtracking 


- 367-370 

366 

154

Backtracking 

• Ziel: Systematisches Durchmustern eines grossen Zustandsraumes, 

um zu einem Problem eine Lösung zu finden 

• Systematisches „trial and error” 

Passende, gute, optimale; 

alle Lösungen... 

• Beispiel: Ausgang in einem Labyrinth suchen: 

• Sich für eine Richtung entscheiden 

• In diese Richtung weitergehen 

• Wenn „letztendlich“ erfolglos: 

zurückkehren und eine andere Richtung wählen 

Backtracking 

Falls bereits alle Richtungen ausprobiert 

noch weiter zurück 

367 

Durchmustern des Entscheidungsbaums 

• Idee: Den Baum aller möglichen Entscheidungen 

systematisch (rekursiv) durchlaufen: 

• Knoten = Entscheidungssituation („Zustand“) 

• Kante = Entscheidung 

• Nachfolgeknoten = Situation 

nach der Entscheidung 

X 

? 

A 

? ? 

Y Z 

• Blatt = Endsituation 

P Q 

• Nützliche Strategie: Sackgassen möglichst früh entdecken 

• Ist abhängig vom konkreten Problem 

• Spart evtl. viel Suchaufwand (ganze Unterbäume!) 

• Beispiel: Analyse eines Spielbaums: „Dieser Zug ist hoffnungslos“ 

gut 

schlecht 

Sackgasse 

368 

155

Eine schlechte Wahl 

Süddeutsche Zeitung, 9.3.2012 

Wer bei Entscheidungen zu früh manche Optionen ausschließt, 

landet oft bei einer unbefriedigenden Lösung 

Zu den Tragödien des Lebens gehört, dass man Entscheidungen treffen muss, von denen man 

nicht weiß, wo sie am Ende hinführen. Wer etwa einen Zug im Schachspiel ausführen will, kann 

nicht alle Optionen bedenken, die sich nach 30 weiteren Zügen ergeben könnten. Und wer eine 

Urlaubsreise plant, hat trotz Google Earth nicht die Zeit, alle in Frage kommenden Ziele ordentlich 

zu prüfen. Um dennoch rechtzeitig zu Ferienbeginn gebucht zu haben, beschneiden die 

meisten Menschen den Entscheidungsbaum schon beim ersten Schritt: Sie entschließen sich 

zum Beispiel aus Gründen der Bequemlichkeit, nur Ziele in Betracht zu ziehen, für die sie bei der 

Anreise nicht umsteigen müssen. Ein solches Vorgehen kann aber dazu führen, dass sie letztlich 

eine schlechte Entscheidung fällen: eine, die sie im Ergebnis unglücklicher macht als die Variante 

mit Umsteigen. Diese könnte nämlich andere, insgesamt größere Vorteile bieten. Dies zumindest 

meinen Forscher um Quentin Huys vom University College London belegen zu können (PLoS 

Computational Biology, Bd. 8, S. e1002410, 2012). 

In ihrer Studie mussten 46 Versuchsteilnehmer einen Weg durch verschiedene Entscheidungsbäume 

planen, bei dem sie an jeder Abzweigung Geld verlieren oder gewinnen konnten. Dabei 

zeigte sich, dass fast alle Probanden Wege vermieden, bei denen sie bereits beim ersten Schritt 

viel Geld verloren hätten. Dies war selbst dann der Fall, wenn sie an nur drei Abzweigungen je 

zwei Optionen bedenken mussten, sie sich also recht einfach hätten ausrechnen können, ob der 

Anfangsverlust am Ende wieder kompensiert wird. „Die Probanden tendierten dazu, Entscheidungsäste 

zu ignorieren, die auf größere Verluste folgen“, schreiben die Autoren. 

369 

Ein Puzzle 

• Gegeben seien 9 derartige Quadrate 

mit verschiedenen Hälften von Figuren 

• Aufgabe: Diese so zu einem 3×3-Feld zusammensetzen, 

dass die Ränder „passen“ 

370 

156

371 

Ein Puzzle (2) 

• Schwierig (frustrierend und reizvoll zugleich!), da man evtl. 

erst recht spät merkt, dass das Puzzle nicht „aufgeht“ und 

man grosse Teile zurückbauen muss! 

• Der Puzzle-Designer hat es wohl absichtlich so gestaltet, dass 

viele partielle und wenig vollständige Lösungen existieren 

• Naiver Ansatz („brute force“): Es gibt nur endlich viele verschiedene 

Anordnungen der Quadrate in einem 3×3-Feld; 

also generiere alle und teste jeweils auf Korrektheit 

Davon gibt es 9 ×4 ×8 ×4 ×7 ×4 × 

... 1 × 4 9 = 4 9 ×9! ≈ 100 000 000 000 

Aber sollte das nicht 

effizienter gehen? ? 

Das ist einfach! (Für die Kryptographie 

ist es übrigens entscheidend, dass es 

kombinatorische Probleme gibt, für die 

man nur sehr schwer Lösungen findet, 

diese aber einfach überprüfen kann) 

372 

157

Ein rekursiver Ansatz 

1 2 3 

4 5 6 

7 8 9 

Problem: 

- Gibt es eine Lösung? 

- Wenn ja, wie lautet sie? 

1) Bestimme zunächst (rekursiv) die Lösungen für 

ein Spielfeld, das um 1 Einzelfeld kleiner ist 

2) Versuche für eine solche Lösung (falls existent) das 

zusätzliche Einzelfeld so mit einem der restlichen Spielsteine 

zu besetzen, dass eine Gesamtlösung entsteht 

373 

Oder andersherum? 

• Solange noch nicht alle Spielsteine (in allen 4 Orientierungen) 

für Position 1 ausprobiert worden sind: 

1) Belege Position 1 auf eine neue Weise 

2) Löse rekursiv das einfachere Problem „Gibt es mit 

den restlichen Spielsteinen eine dazu passende 

Lösung für das Spielfeld der Positionen 2,...,9 ?“ 

3) „ja“: → Gesamtlösung zurückliefern 

1 4 7 2 5 8 3 

6 

9 

• „Nein“ melden, wenn erfolglos alle Möglichkeiten probiert 

• Welcher der beiden Ansätze ist besser? 

• Sollte man nicht die Mitte (Position 5) recht früh belegen? 

• Diese induziert sehr viele „Constraints“ Sackgassen früh erkennbar? 

374 

158

Der Backtracking-Baum 

Je nach Problem kann man einem 

Zwischenzustand (= Teilproblem) 

eventuell ansehen, dass er keinesfalls 

zu einer Gesamtlösung 

beitragen kann „tree pruning“. 

• Der Baum wird „depth first“ durchlaufen: 

Zunächst wird ganz links abgestiegen... 

Gelegentlich wird ein Unterbaum 

auch dann gekappt, wenn man 

zwar nicht sicher ist, aber vermutet, 

dass sich in ihm keine (gute) Lösung 

befindet. Hierfür verwendet 

man problembezogene Heuristiken. 

• Illegale partielle Anordnungen werden 

nicht weiter ausgebaut ( Sackgasse) 

• Im Gegensatz zum „brute force“-Ansatz, der alle Situationen betrachtet 

• Wenn nicht frühzeitig viele Alternativen ausgeschlossen werden können, 

entsteht aber dennoch ein (abgeschwächter) exponentieller Aufwand 

375 

Das n-Damen-Problem 

Das 8-Damen-Problem: 

Es handelt sich um ein Problem, 

das erstmals von Max 

Bezzel 1845 in einer Schachzeitung 

veröffentlicht wurde 

(„Wieviel Steine mit der Wirksamkeit 

der Dame können 

auf das im übrigen leere 

Brett…“), aber zunächst unbeachtet 

blieb. Erst als die 

Aufgabe 1850 vom blinden 

Schachexperten Dr. Nauk erneut 

zur Diskussion gestellt 

wurde, fand sie breites Echo. 

Als Nauk 3 Monate später alle 

92 Lösungen publizierte, hatte 

der berühmte C.F. Gauss erst 

72 Lösungen gefunden! 

(Quelle: Wolfgang Urban, Wien) 

376 

159

Das n-Damen-Problem 

• Keine der n „Damen“ auf dem n×n 

Schachbrett darf eine andere bedrohen 

• d.h. keine zwei Damen stehen in der 

selben Zeile, Spalte, Diagonale 

• Wie viele Lösungen gibt es für n=8? 

x 

377 

Repräsentation der Spielsituation 

dia1[10] 

dia2[5] 

• Darstellung der Spielsituation durch 

ein (globales) int-Array dame[0..n]: 

x 

1 

2 

3 

4 

5 

6 

7 

8 

Spalte x 

dame[x] 

1 

5 

8 

6 

3 

7 

2 

4 

y-Koordinate 

x 

Man braucht also gar kein (aufwendiges) 

2-dimensionales Array für den Spielzustand! 

• Zweckmässig sind ferner 3 (globale!) 

boolean-Arrays als „abgeleitete 

Grössen“ aus der Spielsituation: 

• zeile[y] == true: Zeile y ist bedroht 

• dia1[k] == true: Hauptdiagonale 

mit x+y=k ist bedroht (k=2,…,16) 

• dia2[k] == true: Nebendiagonale 

mit x-y+7=k ist bedroht (k=0,…,14) 

379 

160

Eine Lösung mit Backtracking 

Ansatz: 

Setze eine (einzige) Dame in 

Spalte x. 

Löse dann das Problem 

rekursiv für das Brett aus 

den Spalten x+1,..., n. 

x 

Dabei die Bedrohungen der 

Damen aus Spalten 1,...,x 

berücksichtigen! 

380 

Eine Lösung mit Backtracking (2) 

static void setze(int x) { 

for (int y=1; y

Eine Lösung mit Backtracking (3) 

• Der Aufruf erfolgt in main mit setze(1); dies erzeugt (in wenigen 

Millisekunden) 92 Lösungen (viele davon symmetrisch): 

• 15863724 

• 16837425 

• 17468253 

• 17582463 

• 24683175 

• ... 

• 84136275 

Positionen (1,1), (2,5), (3,8), 

(4,6), (5,3), (6,7), (7,2), (8,4) 

n Lösungen 

1 1 

2 0 

3 0 

4 2 

5 10 

6 4 

7 40 

8 92 

9 352 

10 724 

11 2680 

12 14200 

382 

Programm mit Demo-Ausgabe 

static void setze(int x) { 

for (int y=1; y

Backtrack- 

Beispiel 

für n=4 

384 

Backtrack-Beispiel für n=4 

Übung: Backtracking- 

Baum dazu skizzieren 

Dame gesetzt auf (4,3) 

Lösung gefunden: 2431 

http://ktiml.mff.cuni.cz/~bartak/ 

constraints/images/backtrack.gif 

386 

163

11. 

Spielbäume, 

„game playing“ 

Buch Mark Weiss „Data Structures & Problem Solving Using Java“ siehe: 459-469 

Literaturhinweis: Alexander Reinefeld: Entwicklung der Spielbaum-Suchverfahren: 

Von Zuses Schachhirn zum modernen Schachcomputer. In: W. Reisig, J.C. Freytag: 

Informatik – Aktuelle Themen im historischen Kontext, S. 241-273, Springer 2006 

388 

1949: Relais-basierte 

Tic-Tac-Toe-Maschine 


Auf einem 3×3 Felder grossen 

Spielfeld machen die beiden 

Spieler abwechselnd ihre Zeichen 

(ein Spieler Kreuze, der andere 

Kreise). Der Spieler, der als erstes 

drei seiner Zeichen in eine Reihe, 

Spalte oder eine der beiden 

Hauptdiagonalen setzen kann, 

gewinnt. Wenn allerdings beide 

Spieler optimal spielen, kann 

keiner gewinnen, und es kommt 

zu einem Unentschieden. 

http://de.wikipedia.org/wiki/Tic_Tac_Toe 

389 

164

1949: Relais-basierte 

Tic-Tac-Toe-Maschine 

Donald Davies (1924-2000) war 

britischer Physiker und Informatiker; 

er konstruierte um 1950 

den „Pilot ACE-Computer“ (nach 

Plänen des ACE-Computers 

von Alan Turing), ab 1955 von 

English Electric weiterentwickelt 

zum ersten kommerziellen britischen 

Computer (DEUCE – 

„Digital Electronic Universal 

Computing Engine“). 1960 erfand 

er die Paketvermittlung 

(engl. „packet switching“), die 

grundlegend für den Internet- 

Datenverkehr wurde. 

1949: Davies führt seine Maschine für Tic-Tac-Toe (bzw. „noughts and crosses”) vor 

„The noughts and crosses display worked absolutely beautifully – until 

some schoolchildren came along and pressed all the buttons at once!” 

390 

A Machine Using Post Office Relays 

• “A by-product of my electromechanical work was to finalise my 

quest for a machine to play noughts and crosses. In the evenings 

I built a machine using Post Office relays. NPL * put it forward as 

an exhibit at the Royal Society Soirée in 1949. Its clicking noise 

and nice display attracted people, so it received more attention 

than it deserved. I felt rather bad for the other exhibitors with 

real scientific achievements to show. Next day I was on the Daily 

Express front page and much more publicity followed…” 

• “This machine did not use the whole strategy, so I built a second 

model which was partly electronic, with a wire threaded through 

magnetic cores to represent each rule. This machine was a 

regular feature of the NPL children’s party.“ 

* ) NPL = National Physical Laboratory (UK) 

Biogr. Mems Fell. R. Soc. 2002 48, 87-96; doi: 10.1098/rsbm.2002.0006 

391 

165

The Sydney Morning Herald – 12. Juni 1949 

Electric Brain to Play Noughts and Crosses 

392 

393 

166

Tic-Tac-Toe auf dem DEUCE-Computer (Davies) 

Focus 

Brilliance 

Focus 

Select DL 

Brilliance 

Vielleicht das erste interaktive Computerspiel (ca. 1952)… „the program enables 

the operator to compete with DEUCE at the game of Noughts and Crosses“ 

394 

Die Konsole des DEUCE-Computers 

The control panel carries a row of 32 keys for the 

input of single numbers and a row of 32 lamps for 

the output of single numbers, an alarum buzzer and 

lamp to indicate the failure of an internal check in 

the program, two monitor cathode-ray tubes for displaying 

the contents of the various delay line storage 

positions, and keys for imitating almost everything 

that the DEUCE normally does automatically. 

395 

167

Die Konsole des DEUCE-Computers 

Single shot 

396 

60 Jahre später passt das 

als App in eine Smartwatch 

397 

168

Optimale Strategie für Tic-Tac-Toe 

“Optimal strategy for 

player X. In each grid, the 

shaded red X denotes the 

optimal move, and the 

location of O's next move 

gives the next subgrid to 

examine. Note that only 

two sequences of moves 

by O (both starting with 

center, top-right, left-mid) 

lead to a draw, with the 

remaining sequences 

leading to wins from X.” 

http://en.wikipedia.org/wiki/Tic-tac-toe 

398 

1951: Der NIM-Spielcomputer – 

Ein „Elektronengehirn“ von Ferranti 


Das NIM-Spiel: Gegeben sei 

ein Haufen von n Zündhölzern. 

Die Spieler entfernen abwechselnd 

jeweils 1, 2, oder 3 Zündhölzer. 

Wer das letzte Hölzchen 

entfernt, hat verloren. 

It is not that the games … are chosen 

because they are clear and simple; rather it 

is that they give us, for the smallest initial 

structures, the greatest complexity, so that 

one can engage some really formidable 

situations after a relatively minimal diversion 

into programming. Marvin Minsky, 1968 

399 

169

Computerschach 

• Schach ist prominentester Vertreter des „automatischen 

strategischen Spielens“ 

• Faszination: Verbindung von uraltem Spiel und moderner Technik 

• Herausforderung: Eine „intelligente“ Maschine bauen 

• Reiz: kleine, abgeschlossene Welt (klare Spielregeln) 

• Hoffnung (trügerisch!): Wenn man ein Spiel wie Schach 

beherrscht, dann auch viele andere Probleme (aus Wirtschaft, 

Politik...), zu deren Lösung „Intelligenz“ nötig ist 

• Es sind (nur noch) einige wenige menschliche Spieler 

(manchmal) besser als die besten Schachprogramme 

• Es gibt aber andere strategische Spiele, wo Maschinen 

den Menschen noch nicht ganz so überlegen sind 

400 

Der Schachtürke 

(Wolfgang von Kempelen, 1769) 

401 

170

Der Schachtürke 

Kupferstiche von Racknitz, 1789 

402 

Geschichtliches zum Computerschach 

• 1770: Baron von Kempelen baut einen „Türken“ als Schachmaschine 

(u.a. verliert Napoleon dagegen; E.A. Poe beschreibt den Betrug) 

• 1890: Torres y Quevedo baut ein mechanisches Gerät für Endspiel 

Turm und König gegen König 

• 1928: John von Neumann veröffentlicht einen Artikel „Zur Theorie der 

Gesellschaftsspiele“ 

• 1944: Alan Turing versucht sich an handsimulierten Programmen 

• 1949: Claude E. Shannon (Bell Labs) verwendet das Minimax-Prinzip 

in einer Arbeit „Programming Computer for Playing Chess“ 

• 1956: John McCarthy veröffentlicht den α-β-Algorithmus 

• ab 1957: Erste echte Schachprogramme 

(auf dem Elektronenröhren-Computer IBM 704) 

403 

171

“Mechanischer Apparat aus Spanien, 1911 konstruiert, setzt mit Turm und König 

matt, was eine krächzende Stimme von einer Schallplatte auf Spanisch verkündet.” 

404 

Paul Stern (links) und Nick 

Metropolis (rechts) am MANIAC- 

Computer in Los Alamos, ca. 1951 

405 

172

Dietrich Prinz (Ferranti), 1955 

Alex Bernstein an einer IBM 704-Konsole, 1958 

406 

Herbert Simon (1916–2001), 

Sozialwissenschaftler und Pionier 

der künstlichen Intelligenz, 

Turing-Preis 1975, Wirtschaftsnobelpreis 

1978, hier mit einem 

IBM 650-Computer (1958) 

408 

173

John McCarthy (1927-2011), 

Pionier der künstlichen Intelligenz, 

spielt Schach an der 

IBM 7090 in Stanford, ca. 1967 

409 

410 

174

George Arnold, Columbia University, 1972 

411 

Chris Daley (NASA), 1970 

412 

175

Alex Bell, Peter Kent, 

John Birmingham und 

J. Waldron an einer 

IBM 360/195, 1974 

413 

Northwestern University, CDC 6400 

414 

176

David Slate und Larry Atkin, 1975, 

via Teletype-Terminal mit Akustik- 

Koppler verbunden mit einem 

Mainframe-Computer an der 

Northwestern University 

415 

Geschichtliches zum Computerschach (2) 

• 1960er: Verbesserte Suchverfahren (z.B. Varianten von α-β), Bibliotheken 

für Eröffnungen und Endspiele, spezielle Schach-Hardware 

• 1968: „Levy-Wette“: Levy (internationaler Meister) wettet 250 Pfund, 

dass innerhalb von 10 Jahren kein Computer ihn im Schach schlägt 

• 1970: ACM first computer chess tournament 

• 1974: First world computer chess championship 

wird von KAISSA (UdSSR) gewonnen 

• 1978: Levy gewinnt seine Wette 

• 1979: Schaukampf im Fernsehen „Levy – chess 4.8“ geht 

unentschieden aus (Levy verlängert seine Wette um nur 2 Jahre) 

• Ende der 1970er Jahre tauchen die ersten 

Hobby-Schachcomputer im Spielwarenhandel auf 

418 

177

Hobby-Schachcomputer 

419 


• 1987: Programm HITECH 

schlägt einen Schachgrossmeister 

(HITECH 

generiert ca. 10 Millionen 

Stellungen pro Sekunde) 

• 1990: „Deep Thought“ 

(IBM; später in „Deep 

Blue“ umbenannt) generiert 

ca. 500 Millionen Stellungen pro Sekunde und 

erreicht damit eine „Denktiefe“ von ca. 11 Zügen 

• 1995: Beste Schachprogramme werden nur noch 

von ca. 100 menschlichen Spielern übertroffen 

• 1996: Turnier „Kasparov - Deep Blue“ endet 4:2 für den Schach- 

Weltmeister Kasparov (darunter zwei Spiele unentschieden) 

420 

178


• 1997: Zweites Turnier „Kasparov - 

Deep Blue“ mit 6 Spielen endet 

3,5:2,5 für Deep Blue 

“In a shocking finale that lasted 

barely more than an hour, World 

Champion Garry Kasparov resigned 

19 moves into Game 6, handing a 

historic victory to Deep Blue.” 

• 2003: Deep Junior (Gewinner der World Computer Chess 

Championships in 2002) spielt gegen Kasparov 3:3 unentschieden 

• 2006: Deep Fritz 10 (auf Intel Core 2 Duo-Prozessor) gewinnt 4:2 

gegen Schach-Weltmeister Wladimir Kramnik (2 Siege, 2 Remis) 

421 

Sensation: Schach-Rechner schlägt Grossmeister 

Erstmals gewinnt ein Computer gegen einen Weltmeister 

12. Mai 1997 (tk) 

Der Supercomputer Deep Blue von IBM (Branchenspitzname: Big Blue) schlägt 

den Schach-Grossmeister Garry Kasparov. Damit gewinnt erstmals ein Computer 

nicht nur über einen amtierenden Weltmeister. Experten halten Kasparov für den 

derzeit besten lebenden Schachspieler überhaupt. Hatte die Schach-Ikone noch im 

letzten Jahr die Auseinandersetzung gegen die Maschine gewonnen, musste sich 

der Russe nun geschlagen geben. 

Das über sechs Partien gehende Match (dauerte eine Woche; komplette Dokumentation 

unter www.chess.ibm.com/home/b.html) endete 3,5 zu 2,5 für Deep Blue. 

Zwei der Partien gewann der auf Schach getrimmte Super-Rechner, drei endeten 

Unentschieden und nur eine Partie verlor Deep Blue. Die letzte und entscheidende 

Partie eröffnete Kasparov mit einer Caro-Kann-Verteidigung. Zwar verlor Deep 

Blue dadurch einen Springer, trotzdem war der Schach-Grossmeister mit dieser 

Strategie chancenlos. Nach Verlust eines eigenen Springers, Läufers, Bauers und 

der Königin gab Kasparov auf. Die Spieldauer: Knapp eine Stunde oder 19 Züge. 

„Ich muss mich für die heutige Leistung entschuldigen“, so der 34jährige Kasparov in der Pressekonferenz. 

„Ich hatte keine richtige Energie für die Auseinandersetzung.“ Laut Beobachtern hatte der IBM-Rechner mit 

den ersten fünf Partien (bis dahin eine Niederlage, ein Sieg, drei Unentschieden) Kasparov‘s unerschütterliches 

Selbstbewusstsein der beste Schachspieler aller Zeiten zu sein, erschüttert. So gab Kasparov nach der 

mit einem weiteren Unentschieden endenden fünften Partie auch zu: „Ich muss mich vorsehen, denn ich kann 

jeden Spieler der Welt ausrechnen, aber ich kann nicht diese Maschine ausrechnen.“ 

Deep Blue ist ein Computer der IBM-RS/6000-SP-Reihe. Seine Parallel-Prozessor-Architektur (Taktrate von 

130 Megahertz) mit für Schach optimierten Mikrochips kann zwei Millionen Positionen pro Sekunde errechnen. 

Verlor Deep Blue noch im letzten Jahr die erste Auseinandersetzung mit Kasparov (damals gewann der 

Grossmeister drei Partien, verlor eine und zwei endeten unentschieden), verdoppelten IBM-Techniker in den 

letzten Monaten die Rechenleistung des Computers auf den heutigen Stand. © 1997 by Ziff-Davis-Verlag GmbH 

179

2010 + : Mit neue Interaktionsmöglichkeiten 

425 

The Thinking Table 

“The Thinking Table, a work in 

progress, is a physical installation 

in which two people can play a 

game of chess. As they play, the 

table illuminates the board with 

thoughts of the future as seen by 

the artificial intelligence engine of 

the Thinking Machines. The board 

is both the arena in which the two 

players act, and a thought space 

in which their linked choices, deliberations 

and hostilities are made 

visible.” 

Martin Wattenberg, Marek Walczak 

http://mw2mw.com/thinking-table 

426 

180

„The machine's thoughts“ 

“Thinking Machine 4 explores 

the invisible, elusive nature 

of thought. Play chess against 

a transparent intelligence, its 

evolving thought process visible 

on the board before you. 

A map is created from the 

traces of thousands of possible 

futures as the program 

tries to decide its best move. 

Those traces become a key 

to the invisible lines of force 

in the game as well as a window 

into the spirit of a thinking 

machine.” 

http://mw2mw.com/25 

427 

Zukunft? 

181

Spieltheorie 

„Spiele haben die Wissenschaft oft befruchtet: Glücksspiele inspirierten die 

Wahrscheinlichkeitstheorie, Gesellschaftsspiele die mathematische Spieltheorie. 

Die Frage, ob Computer Schach spielen könnten, dient der Informatik 

seit ihrer Frühzeit als Messlatte für die Wirksamkeit von heuristischen 

Suchverfahren und der Formalisierung von Wissen.“ (Jürg Nievergelt) 

• Untersuchung des rationalen / optimalen Verhaltens bei 

Konflikt- und Konkurrenzsituationen mehrerer Parteien 

• Optimierungstheorie (Gewinnmaximierung) 

• Operations Research 

• Wirtschaftstheorie (Kampf um Marktanteile) 

• Konflikttheorie (Politik, Militär) 

• Grundannahme: Jeder Spieler verhält sich „rational“ und 

ist bestrebt, seinen Gewinn zu maximieren 

• Meilenstein 1928 mit John von Neumanns 

Artikel „Zur Theorie der Gesellschaftsspiele“ 

• In: Mathematische Annalen 100, pp. 295 - 320 

432 

433 

182

Endliche rein strategische 2-Personen-Spiele 

• Endlich: 

• Durch Sonderregeln (z.B. Verbot von Zugwiederholung) 

werden Spiele oft künstlich endlich gemacht 

• Bei endlichen Spielen ist vor allem das Ergebnis am Ende interessant 

(ob „das Spiel an sich“ reizvoll ist, ist mathematisch unerheblich) 

• Rein strategisch: 

• Spieler selbst treffen alle Entscheidungen 

• Zufall spielt keine Rolle 

• Gegenbeispiel: Roulett, Würfelspiele und viele Kartenspiele 

• 2-Personen: 

• Einfacher als n-Personen (keine Koalitionsbildung) 

• Kooperation, Überredung, Täuschung, List, Bluff, Belohnung, 

Bestrafung... bei 2 Personen i.Allg. weniger sinnvoll / notwendig 

als bei n Personen (insbes. bei Nullsummenspielen) 

437 

Nullsummenspiel; 

vollständige Information 

• Nullsummenspiel: 

• So hoch wie ein Spieler gewinnt, verlieren andere 

• Eigener Vorteil ist Nachteil des Gegners 

• Mit den Endsituationen ist für jeden Spieler eine 

Gewinnauszahlungsfunktion definiert; Summe 

aller Funktionswerte = 0 für jede Endsituation 

(z.B. +1, -1, 0 bei Gewinn, Verlust, Unentschieden) 

• Bei 2-Personen-Spielen handelt der Gegner den 

eigenen Interessen entgegengesetzt (unter der 

Grundannahme der Spieltheorie) 

Im folgenden interessieren uns nur: 

Endliche rein strategische 2-Personen- 

Nullsummenspiele mit vollständiger 

Information 

Bsp: Schach, Reversi, 

Dame, Mühle, Go und 

viele andere Brettspiele 

Gegenbeispiel: 

Erschliessen neuer Märkte 

durch Koalitionsbildung 

oder Kartelle (bei diesen 

Spielen gewinnen evtl. 

alle: „Win-Win-Situation“) 

• Vollständige Information: 

• Alle Spieler wissen (prinzipiell) gleich viel 

• Keiner hat einen verdeckten Informationsvorsprung 

• Jeder kann sich ganz in die Rolle des anderen 

hineinversetzen 

Gegenbeispiele: viele Kartenspiele 

(damit Spielwiederholung 

nicht langweilt, 

ist die verdeckte 

Information dann i.Allg. 

vom Zufall abhängig 

→ Karten mischen!) 

438 

183

Spielbäume 

Kann Max einen Sieg 

(positiv. Auszahlungswert) 

erzwingen? 

Spieler „Max“ und „Min“ 

ziehen abwechselnd 

- Konvention: Max beginnt 

- Niveauweise abwechselnd 

Max-Knoten / Min-Knoten 

• Blätter beschreiben eine Endsituation 

• Sind mit dem Wert der Auszahlungsfunktion für Max markiert 

• Max ist bestrebt, ein Blatt mit hohem Wert zu erreichen 

• Entsprechend strebt Min einen möglichst kleinen (evtl. neg.) Wert an 

439 

Spielbäume (2) 

Echte Spielbäume sind 

sehr gross (Damespiel ca. 

10 78 Knoten, Schach ca. 

10 120 , Go ca. 10 761 ), daher 

vollständige Enumeration 

aller Zustände und Spielabläufe 

i.Allg. unmöglich 

• Ein Spiel ist vollständig durch den Baum beschrieben! 

• Abstrahiert von Spielregeln, vom ästhetischen Reiz des Spiels,... 

• In verschiedenen Knoten kann die gleiche Spielsituation auftreten 

• Jedem Ast entspricht ein möglicher Spielverlauf 

440 

184

Strategie 

• = Vollständiger Verhaltensplan: Handlungsvorschrift (d.h. 

Zug) für jede Situation, in die der Spieler kommen könnte 

• In der Praxis aber meist zu 

viel, um alles im Voraus zu 

berechnen 

• Daher oft nur kompakte, 

heuristische Regeln (z.B.: 

„wenn zwei Steine in einer 

Reihe stehen, dann...“) 

441 

Visualisierung einer Strategie σ für Max 

Strategie (für Max) dargestellt als 

Graph, der aus dem Spielbaum 

entsteht, indem man alle Kanten 

streicht und nur für jeden Max- 

Knoten eine einzige ausgehende 

Kante übrig lässt 

Das ist nur eine einzige von 

vielen denkbaren Strategien 

- Offenbar gibt es sehr viele Strategien 

- Welche Strategie wählt man? 

442 

185

Eine Strategie σ´ für Min 

Wie viele Strategien hat eigentlich 

ein Schachcomputer? Vielleicht 

nur eine einzige? Oder 

eine pro einstellbarer Spielstärke? 

Oder würfelt er heimlich? 

Damit ist der Spielverlauf (als „Überlagerung“ 

der beiden Strategien σ und σ’) klar! 

Und es ist auch von vornherein 

klar, wer gewinnt! 

443 

Strategiewahl 

• In der Praxis wird ein Spieler i.Allg. vor jedem Zug neu 

nachdenken und die aktuelle Situation evaluieren 

• Rein theoretisch („mathematisch“) lässt sich ein Spiel 

aber auch so auffassen: 

• Σ = {σ 1 , σ 2 , ..., σ n } Strategiemenge für Max 

• Σ’ = {σ’ 1 , σ’ 2 , ..., σ’ m } Strategiemenge für Min 

• Max und Min wählen vor dem Spiel (in verdeckter Weise) je eine 

Strategie σ bzw. σ’ (ein Wechsel der Strategie im Laufe des Spiels 

ist bei dieser Auffassung sinnlos)! 

• Der Spielverlauf ist dadurch vollständig determiniert: Folgt man 

dem eindeutigen Ast, landet man bei einem Blatt, das mit dem 

Gewinn (bzw. „Verlust“, wenn negativ) markiert ist! 

444 

186

Auszahlungsmatrix 

• Für die Strategien Σ und Σ’ gibt es eine n×m-Matrix A 

(die „Auszahlungsmatrix“), die an der Stelle A[σ,σ’] den 

Gewinn (für Max) bzgl. des Strategiepaares (σ,σ’) angibt 

• Formal ist ein Spiel dann sogar alleine durch das Tripel 

(Σ, Σ’, A) definiert! 

445 

Beispiel: Das Spiel „Schere, Stein, Papier“ 

(auch bekannt als „Schnick, Schnack, Schnuck“) 

• Zwei Spieler formen gleichzeitig (d.h. ohne Kenntnis der 

Entscheidung des Gegners) mit einer Hand ein Symbol 

• Spiel besteht nur aus einem einzigen (Doppel)-Zug 

• Gewinnregel: 

• Stein schlägt Schere (macht sie stumpf) 

• Schere schlägt Papier (schneidet es) 

• Papier schlägt Stein (wickelt ihn ein) 

Papier 

Stein 

• Auszahlungsmatrix: 

Schere Stein Papier 

Schere 0 1 -1 

Stein -1 0 1 

Papier 1 -1 0 

Schere 

Jeder Spieler kann zwischen 3 

Strategien Schere, Stein, Papier 

(für seinen einzigen Zug!) wählen 

Gibt es eine „beste“ Strategie? 

449 

187

Testspiel 

Schere Stein Papier 

Schere 0 1 -1 

Stein -1 0 1 

Papier 1 -1 0 

450 

Schnick, Schnack, Schnuck 

„Schnick, Schnack, Schnuck ist das Schach des kleinen Mannes: Fast alle 

essentiellen Mini-Konflikte (Wer bringt den Müll raus? Wer wechselt die 

vollen Babywindeln?) lassen sich über das Spiel entscheiden.“ 

Mike Hanke (li.) und 

Marco Reus von Bor. 

Mönchengladbach 

knobeln per Schnick- 

Schnack-Schnuck, wer 

den Freistoss schiesst 

451 

188

Schnick, Schnack, Schnuck-Roboter 

„Schnick, Schnack, Schnuck ist das Schach des kleinen Mannes: Fast alle 

essentiellen Mini-Konflikte (Wer bringt den Müll raus? Wer wechselt die 

vollen Babywindeln?) lassen sich über das Spiel entscheiden. 

Jetzt haben japanische Forscher an einer 

Universität in Tokio die ultimative Siegesgarantie 

entwickelt: Eine Roboterhand gewinnt 

jeden Schnick-Schnack-Schnuck- 

Zweikampf. 

Nun ist der Knobel-Roboter kein Deep Fritz, 

er berechnet nicht aus Millionen von Möglichkeiten 

den besten Zug, sondern nutzt 

schlicht seine Schnelligkeit: Über die Handstellung 

erkennt seine Kamera innerhalb 

einer Millisekunde, ob sein menschliches 

Gegenüber Schere, Stein oder Papier zeigen 

wird. Der Roboter wählt daraufhin innerhalb 

einer weiteren Millisekunde seine Siegerstellung 

aus.“ 

www.sueddeutsche.de/digital/maschine-vs-mensch-knobel-roboter-auf-siegeszug-1.1399531 

452 

Superspiel aus Spielfolgen 

• „Superspiel“: n-malige Wiederholung des einfachen Spiels 

• Denkübung: Wie sieht dann bei unserem Knobelspiel 

„Schere, Stein, Papier“ eine Strategie aus? 

• Ist diese einfach eine Folge von Symbolen 

„Schere“, „Stein“, „Papier“ der Länge n? 

• Gibt es gute und weniger gute Strategien? 

453 

189

Beste Strategie? 

• Zurück zu den „endlichen rein strategischen 2-Personen- 

Nullsummenspielen mit vollständiger Information“: 

• Annahme: Gegner spielt optimal 

• Nutzt jeden Fehler schonungslos aus 

• Lässt sich nicht bluffen 

• Weiss bestens Bescheid 

• Was ist dann die beste eigene „Strategie“? 

• Möglichst vorsichtig und risikolos spielen! 

Ist in der Praxis vielleicht 

eine übertrieben 

pessimistische Annahme! 

454 

Maximierung des Minimalgewinns 

• Betrachte alle Strategiepaare (σ,σ’): 

• Für festes σ von Max würde der Gegner Min 

ein solches σ’ wählen, das A[σ,σ’] minimiert 

• Diesen durch Min (potentiell) minimierten Gewinnwerten sollte Max 

diejenige eigene Strategie σ* entgegensetzen, die bezüglich der 

Auszahlungsmatrix den dann noch höchst möglichen Gewinn bringt 

σ* 

455 

190

Garantierter Mindestgewinn 

• Der garantierte Mindestgewinn G für Max beträgt also 

G = max i min j A[σ i ,σ’ j ] 

• Hierzu gehört für Max eine Strategie σ* 

Informatiker denken dabei 

an eine doppelte for-Schleife 

• Entsprechend ermittelt Min für sich einen garantierten 

Mindestgewinn G’ = min j max i A[σ i ,σ’ j ] 

• Hierzu gehört für Min eine Strategie σ’* 

(beachte: Matrix A gibt stets den Gewinn in Bezug auf Max an) 

• Wenn sowohl Max als auch Min ihren jew. Mindestgewinn 

garantiert haben wollen, wird sicherlich (σ*,σ’*) gespielt 

Fragen: - Erhält Max immer nur den Gewinn G oder evtl. sogar mehr? 

- Wie hängen G und G’ zusammen? 

456 

Optimale Strategien 

• Satz (o. Bew.): Für endliche rein strategische 2-Personen 

Nullsummenspiele mit vollständiger Information gilt G = G’ 

In Von Neumanns Artikel: 

• Die zugehörigen Strategien σ* bzw. σ’* heissen 

optimale Strategien (für Max bzw. Min) 

• Das Paar (σ*,σ’*) bildet einen Gleichgewichtspunkt: 

• Es gilt: A[σ*,σ’*] ≥ A[σ,σ’*] für alle σ von Max 

• D.h.: wenn Min seine optimale Strategie σ’* anwendet, kann Max 

nichts sinnvolleres tun, als ebenfalls seine optimale Strategie σ* 

anzuwenden – entsprechendes gilt auch umgekehrt 

Eine Situation, bei der sich kein Spieler verbessern kann, indem (nur) er von 

der Strategiekombination abweicht, heisst auch Nash-Gleichgewicht (Theorie 

1951 von John Nash, dafür 1994 Nobelpreis für Wirtschaftswissenschaften) 

457 

191

Vernünftig aber langweilig… 

• Optimale Strategien wirken stabilisierend: Für keinen 

Spieler besteht Veranlassung, davon abzuweichen 

• Risiko würde steigen; Mindestgarantie würde verschlechtert 

• Weicht der Gegner von seiner optimalen Strategie ab, ist dies 

zum eigenen Vorteil 

• In diesem Sinne („optimaler“ Gegner!) sind die Strategien 

σ* und σ’* das Vernünftigste, was die Spieler tun können 

• Wenn es für Max das Vernünftigste ist, σ* zu spielen, dann weiss Min 

aber schon, dass Max diese Strategie wählen wird (und umgekehrt)! 

• So betrachtet ist Spielen „langweilig“ (risikolos!): 

• Für das Spiel (Σ, Σ’, A) bestimme σ* ∈ Σ sowie σ’* ∈ Σ’ 

und streiche sodann den Gewinn A[σ*,σ’*] ein... 

459 

Gewinnstrategie und Gewinnstellung 

• Die Blätter des Spielbaums seien mit >0 („Max gewinnt“) 

bzw. 0 erreichbar ist: 

A[σ*,σ’*] 

>0 → σ* ist Gewinnstrategie für Max 

Minimax-Algorithmus 

• Eine optimale Strategie kann effizienter als nach der Definition 

(Enumeration aller Strategien) gefunden werden: 

• Sei γ die Auszahlungsfunktion für Blätter; dann definiere 

den Minimaxwert v(k) eines Knotens k so: 

γ k 

, falls k ein Blatt ist 

 

max v n | n ist direkter Nachfolger von k , falls k innerer MaxKnoten ist 

min v n | n ist direkter Nachfolger von k , falls k innerer MinKnoten ist 

• Die rekursive Definition lässt sich direkt in einen 

entsprechenden rekursiven Algorithmus umsetzen 

Minimax- 

Algorithmus 

Es wird von zwei Seiten am Werte … hin und her gezerrt, nämlich durch S1, 

der ihn möglichst groß, und durch S2, der ihn möglichst klein machen will. 

John von Neumann, 1928 

462 

Bottom-up-Minimax-Algorithmus 

Alternativ zum rekursiven 

Top-down-Ansatz können 

die Werte auch von den 

Blättern in Richtung Wurzel 

propagiert werden 

(„bottom up“) 

Blätter 

• Interpretation: 

• Die Wurzel erhält den Wert, den Max mindestens erreichen kann 

• Max wählt Alternative zum grössten direkten Nachfolger 

• Min wählt Alternative zum kleinsten direkten Nachfolger 

Optimale 

Strategie 

463 

193

Spielbäume mit binärem Gewinn 

• Verwende für die binären Werte „gewonnen“ / „verloren“ 

die booleschen Werte ’true’ (’1’) bzw. ’false’ (’0’) 

• ’min’ und ’max’ ’und’ (’&’) bzw. ’oder’ (’|’) 

• Spielbaum entspricht damit einem Operatorbaum 

(für boolesche Ausdrücke!) 

Booleschen Ausdruck 

einfach ausrechnen! 

((0|1) & (1|0)) | ((0|0) & (1|0)) 

Ermittlung der optimalen 

Strategie ist nun eine algebraische 

Rechenaufgabe! 

465 

Auswertung boolescher 

Operatorbäume / Spielbäume 

• Auswertung des Baums z.B. rekursiv und von links nach rechts: 

• Dabei Java-Shortcut-Operatoren ’&&’ bzw. ’||’ (statt ’&’ bzw. ’|’) anwenden: diese 

werten nur so viele Operanden aus wie nötig (’&’ bzw. ’|’ wertet dagegen alle aus)! 

• Führt zu Schnitten: Sobald ein |-Operator (Max-Knoten) den Wert ’1’ (bzw. 

’true’) von einem Nachfolger gemeldet bekommt, brauchen dessen restlichen 

Geschwister nicht mehr ausgewertet werden (analog für &-Operator) 

Denkübung: Wie müssen die direkten Nachfolger 

eines Knotens „sortiert“ sein, um möglichst 

viele Schnitte zu erzeugen? Und wie viele 

Blattauswertungen spart man so maximal? 

466 

194

467 

NO! 

./ . 

(Shortcut) 

468 

195

Auswerten von Spielbäumen 

• Man wird i.Allg. einen Spielbaum nicht erst ganz aufbauen 

und dann auswerten, sondern dynamisch nach Bedarf Knoten 

„expandieren“ und schritthaltend den Baum auswerten 

• Dazu existieren verschiedene Methoden: 

• Tiefensuche 

• Breitensuche 

• Bestensuche 

• ... 

469 

Tiefensuche („depth-first“) 

• Ein Knoten wird erst erzeugt, wenn alle „linken“ 

Geschwister und alle deren (direkte und indirekte) 

Nachkommen erzeugt (und evtl. bewertet) wurden 

• z.B. L erst nach Z, P, B, K 

470 

196

Breitensuche („breadth-first“) 

• Knoten einer tieferen Ebene 

werden erst dann in Betracht 

gezogen, wenn alle Knoten 

der darüber liegenden Ebene 

bearbeitet wurden 

• Speicheraufwand zum 

Aufbewahren der Ebenen! 

471 

Bestensuche („best-first“) 

• Knoten bekommen einen „Schätzwert“; dann wird unter 

allen Geschwistern derjenige zuerst expandiert (d.h. alle 

dessen direkten Nachfolger ermittelt), der den besten 

Schätzwert hat 

• Man erzeugt damit Teilniveaus, steigt aber schnell in die 

Tiefe ab; wenn man aus der Tiefe wieder auftaucht, 

nimmt man als nächsten Knoten zum Expandieren 

denjenigen mit dem zweitbesten Wert etc. 

• Man hofft, so schnell zu einem guten Blatt zu kommen 

• Dann kann man sich evtl. damit zufrieden geben, ohne zu viele 

andere Teilbäume auswerten zu müssen 

• Ist aber nur nützlich, wenn der Schätzwert eines 

Knotens das Minimax-Resultat gut prognostiziert 

Heuristik: Wähle die Alternative 

mit den besten 

Erfolgsaussichten 

472 

197

Schlanke Spielbäume 

• Man versucht möglichst, Spielbäume 

schlank zu halten 

• Erlaubt eine grössere Tiefe 

bzgl. der interessanten Knoten 

• Erfordert aber eine Bewertung 

aller „Geschwister“ oder Nachkommen, 

bevor man tiefer absteigt, 

um nur die interessantesten 

weiterzuverfolgen 

( Bestensuche) 

• Menschen spielen offenbar sehr stark selektiv 

• Vorsicht: man kann sich bei der Bewertung täuschen 

und damit interessante Züge „irrtümlich“ abschneiden! 

473 

Beschränkung der Suchtiefe 

• Spielbäume sind i.Allg. zu gross, um sie bis zu den 

tatsächlichen Blättern durchlaufen zu können 

• Ausnahme: „Endspiel“ mit einigen wenigen Zügen 

• Man wird daher den Baum nur bis zu einer gewissen Tiefe 

aufbauen und dort die Suche abbrechen 

• Für die künstlichen Blätter schätzt man dann den Minimaxwert 

(d.h. man führt eine „statische“ Stellungsbewertung durch) 

• Die Bewertungsfunktion sollte „gut“ sein und effizient zu berechnen 

sein; sie ist oft entscheidend für gutes Spielverhalten! 

• Abbruchtiefe ist i.Allg. nicht fest 

• Hängt u.a. von der zur Verfügung stehenden Zeit ab 

• Kritische Situationen wird man tiefer analysieren als „stabile“ 

474 

198

Baumschnitte 

• Man kann oft einige Knoten / Unterbäume abschneiden, 

die den Minimaxwert garantiert nicht beeinflussen 

• Ziel: Möglichst früh solche verzichtbaren Unterbäume 

erkennen und möglichst viele davon abschneiden 

Begründung für den Schnitt: Max 

wird von rechts einen Wert ≤ 2 

erhalten und daher sowieso den 

linken Zug (5) wählen; den Wert 

des abgeschnittenen Unterbaums 

braucht man also nicht zu kennen! 

Wie erkennt man Schnittmöglichkeiten 

systematisch? 

Wie maximiert man die Zahl der Schnitte? 

475 

Der Alpha-Beta-(„α-β“)-Algorithmus 

• Reduziert den Spielbaum systematisch durch Schnitte, 

aber liefert den gleichen Minimaxwert der Wurzel wie 

der eigentliche Minimax-Algorithmus 

• Tiefensuche, wobei Knoten nur dann expandiert werden, 

wenn sie (nach bisheriger Information) den Minimaxwert 

beeinflussen können 

• Analog zur Shortcut-Auswertung 

boolescher Operatorbäume 

476 

199

Der Minimax-Algorithmus (Pseudocode) 

eval sei die statische 

int maxValue(Gamestate g) { 

Bewertungsfunktion 

für Spielstellungen 

if cutofftest(g) return eval(g); 

for (GameState s=g.firstsucc; s!=g.lastsucc; s=s.nextsucc) { 

α = max(α, minValue(s) ); 

} 

} 

return α; 

int minValue(Gamestate g) { 

} 



β = min(β, maxValue(s) ); 

} 

return β; 

Bei (künstlichen) 

Blättern liefere 

cutofftest „true“ 

477 

Der α-β-Algorithmus (Pseudocode) 

Bei (künstlichen) 

Blättern liefere 

cutofftest „true“ 

eval sei die statische 

int maxValue(Gamestate g, int α, int β) { 

Bewertungsfunktion 

für Spielstellungen 



α = max(α, minValue(s, α, β) ); 

if (α >= β) break; // β-Schnitt 

} 

return α; 

} 

int minValue(Gamestate g, int α, int β) { 

} 



β = min(β, maxValue(s, α, β) ); 

if (β

Der α-β-Algorithmus 


β = min(β, maxValue(s, α, β) ); 

if (β

α-β-Schranken: Beispiel 

Bei Knoten X: α=2 

nach Auswertung 

von Blatt „2“; aber 

α=5 nach Auswertung 

von Blatt „5“ 

α=9 

≥β=5 


α = max(α, minValue(s, α, β) ); 

if (α >= β) break; // β-Schnitt 

} 

481 

Tiefe α-β-Schnitte 

• Der α- bzw. β-Wert einer 

bestimmten Ebene kann 

(weiter rechts) Schnitte 

auf einer viel tieferen 

Ebene bewirken 

• Interpretation: Man braucht sich als 

Min-Spieler bei x keine Hoffnungen 

auf einen besseren Wert (

Übungsbeispiel α-β-Algorithmus 

• Illustriert auf 75 slides Schritt für Schritt 

den Ablauf des α-β-Algorithmus 

• Homepage der Vorlesung 

www.vs.inf.ethz.ch/edu/ 

483 

Effizienz des α-β-Algorithmus 

• Wie viele Blätter ausgewertet werden, hängt von der 

Reihenfolge der Knoten einer Ebene ab: 

• Nachfolger von Min-Knoten sollten aufsteigend sortiert 

sein, Nachfolger von Max-Knoten absteigend, damit 

maximal viele Schnittmöglichkeiten gegeben sind 

(d.h. bester Zug sollte jeweils links stehen) 

484 

203

Wie viel spart α-β gegenüber Minimax? 

• Annahme: Tiefe d, jeder innere Knoten hat w direkte Nachfolger 

• Schlechtester Fall: es sind w d Blätter auszuwerten (wie Minimax) 

• Bester Fall (ohne Beweis): es sind ca. w d/2 Blätter auszuwerten 

• Das sind nur „√-soviele“ und erlaubt viel tiefere Bäume! 

• Wo zwischen w d/2 und w d liegt der „Normalfall“? 

• Wenn man die inneren Knoten entsprechend einer statischen Bewertungsfunktion 

sortiert, die eine gute Prognose für den tatsächlichen 

Wert darstellt, erhöht man die Chance auf Schnitte 

• Eine statische Bewertung wird man i.Allg. sowieso vornehmen, um die 

Bestensuche anwenden zu können bzw. den Baum schlank zu halten 

• Experimentelle Untersuchungen zeigen, dass (schon bei unsortierten 

Knoten), der effektive Verzweigungsgrad bei ca. 3/4 w im Durchschnitt 

für typische Spielbäume liegt bei gleichem Zeitaufwand kann die 

Suchtiefe etwa um 33% erhöht werden 

485 

Der α-β-Algorithmus 


One of the inventors the alpha-beta algorithm was Arthur Samuel (1901–1990). He made the first 

checkers program on IBM’s first commercial computer. Since he had only a very limited amount of 

available computer memory, he implemented what is now called alpha-beta pruning. The program 

was a sensational demonstration of the advances in both hardware and skilled programming and 

caused IBM's stock to increase 15 points overnight. [From Wikipedia] 

486 

204

Spekulative Suchfenster 

• Idee: langsame Schrumpfung des Suchfensters vorwegnehmen 

• Dadurch bereits früh die Schnittmöglichkeiten erhöhen 

• Also: mit einem Suchfenster (α,β) ≠ (-∞,+∞) starten! 

• Was tun, wenn man sich „verspekuliert“ hat? 

• Wie stellt man das fest? 

• Bei einem Suchfenster (a,b) wird ein „Minimaxwert“ a geliefert 

→ tatsächlicher Minimaxwert ist ≤ a (also vermutlich < a) 

• Es wird der Wert b geliefert → analog (d.h. vermutlich > b) 

• Man wiederholt dann notgedrungen das ganze mit einem 

halbseitig erweiterten Suchfenster, z.B. (-∞,a) bzw. (b,+∞) 

• Denkübung: und wenn dabei wieder genau a bzw. b geliefert wird? 

487 

Last Move Improvement 

• Es kommt i.Allg. nicht auf den genauen Minimaxwert an, 

sondern nur auf den besten Zug aus der ggw. Stellung 

! 

• Skizze des Algorithmus: 

• Untersuche alle direkten Nachfolger 

eines Knotens wie gehabt, 

bis auf den letzten 

• Sei v der dabei ermittelte 

Minimaxwert 

• Für den Unterbaum des 

letzten Nachfolgers verwende 

das Suchfenster (v, v+1) 

488 

205

Last Move Improvement (2) 

• Beachte: (v, v+1) ist ein sogen. Nullfenster, es ist von vornherein 

klar, dass das Ergebnis ausserhalb des Suchfensters liegt 

• Es werden ganzzahlige Werte vorausgesetzt; die 

Randwerte führen schon Schnitte herbei 

• Von Bedeutung ist nur, ob das Ergebnis 

(bzgl. Max) ≤ v oder ob es ≥ v+1 ist 

• ≤ v → rechtester Zug ist uninteressant, 

da schlechter als einer der anderen Züge 

• ≥ v+1 → bester Wert liegt im rechtesten Unterbaum (genaue 

Lage und Wert allerdings unbekannt!), daher wähle diesen Zug 

• Vorteil: Durch das enge Fenster kommt es im rechtesten 

Unterbaum zu viel mehr Schnittmöglichkeiten 

Denkübung: Idee rekursiv auf den 

vorletzten Zug anwenden etc.? 

489 

Nullfenster-Suchverfahren 

• Im linksten Unterbaum den Minimaxwert v als Referenzwert ermitteln 

• Mit dem Nullfenster (v, v+1) zu „beweisen“ versuchen, dass alle 

anderen Unterbäume keinen besseren Wert ≥ v+1 (bei Max) liefern 

Falls der Beweis für einen Unterbaum nicht gelingt, 

abwarten, ob noch ein anderer Unterbaum einen 

Wert >v liefert; dann mit wiederholter Suche dessen 

genauen Minimaxwert ermitteln und als neuen Referenzwert 

für weiter rechts stehende Unterbäume 

verwenden (sonst ist der beste Zug eindeutig!) 

• Von Vorteil, wenn der linkeste Zug der beste oder zweitbeste ist 

• Ist oft der Fall, da man (z.B. für Bestensuche oder α-β) die Nachfolger 

einer statischen Bewertung unterzieht und entsprechend anordnet 

• Viele Schnitte durch das enge Suchfenster bei einem Reversi-Spielprogramm 

wurde so ca. 63% der Zeit gegenüber Standard-α-β gespart! 

490 

206

Das Horizont-Problem 

• Typisch für Spielprogramme: Eine unausweichliche 

Katastrophe wird nur um einige Züge hinausgeschoben 

• Über den Horizont (= maximale Suchtiefe), dadurch sieht die 

Zukunft zunächst wieder einigermassen rosig aus 

• Z.B. durch irrelevanten Zug, 

der mit der Vermeidung 

der Katastrophe nichts 

zu tun hat, aber den 

Gegner zunächst zu 

einer unmittelbaren 

Antwort zwingt 

Horizont 

491 

Iterative Vertiefung 

• Der Spielbaum wird zunächst bis zu 

einer Tiefe n ausgewertet; wenn 

dann noch genügend Zeit bleibt, 

wird er wiederholt ausgewertet, 

dann aber bis zur Tiefe n+1 

• Auswertung bis zur Tiefe n ist 

billig im Vergleich zur Auswertung 

bis zur Tiefe n+1 (Wiederholung 

kostet nicht viel) 

• Bei der früheren Iteration wird Information bzgl. der statischen 

Bewertung von Stellungen gewonnen – diese kann bei der n+1-ten 

Iteration als Sortierkriterium für den α-β-Algorithmus dienen 

• Um Mehrfachauswertungen von Knoten zu vermeiden, könnten evtl. 

einige Information aus früheren Auswertungen aufbewahrt werden 

492 

207

Endspielanalyse 

• Wenn man weiss, dass das Spiel nur noch einige wenige 

Züge dauert: 

• Evtl. kann dann der Baum vollständig analysiert werden 

• Falls es auf die Höhe des Gewinns nicht ankommt, genügt dafür 

die zweiwertige Menge {gewonnen, verloren-oder-unentschieden} 

• Bei zweiwertigen Knoten gibt es mehr Schnitte, daher wird man 

das Endspiel zunächst damit analysieren; wenn man dann noch 

näher am Spielende ist, wird auch die Gewinnhöhe maximiert 

• Zweiwertige Bäume können durch boolesche Operatoren 

besonders effizient analysiert werden 

493 

Weitere Spielaspekte 

• Zeitmanagement 

• Die zur Verfügung stehende Zeit (Gesamtzeit oder Zeit pro Zug) sollte 

bestmöglich genutzt, aber nicht überschritten werden 

• Andere Spielbaumsuchverfahren: 

• Neben den besprochenen Algorithmen gibt es noch andere Verfahren 

• Lernende Spielprogramme: 

• Was soll gelernt werden? 

• Beispiel: Optimierung der Gewichtung einzelner Merkmale, die in die 

statische Bewertung einer Stellung einfliessen 

• Kann ein Programm lernen, indem es gegen sich selbst spielt? 

• Literaturhinweise: 

• C.G. Diderich: A bibliography on minimax trees, ACM SIGACT News 24(4), 82-89 

• Alexander Reinefeld: Spielbaum-Suchverfahren. Springer, 1989 

(Informatik-Fachberichte 200, Subreihe Künstliche Intelligenz) 

494 

208

Kritik 

• Gegnermodell: Ist es realistisch, dass der Gegner 

• das Minimax-Prinzip anwendet? 

(und bis zu welcher Tiefe?) 

• rational spielt und unfehlbar ist? 

(sollte man auf Nachlässigkeit spekulieren?) 

• Schätzfehler: Bei den Werten künstlicher Blätter handelt 

es sich nur um Schätzwerte des echten Minimax-Wertes 

• Ist es in diesem Beispiel klug, den rechten Zug zu wählen? 

• Helfen Wahrscheinlichkeitsüberlegungen? 

Minimax zeigt sogar oft ein pathologisches 

Verhalten („Fehlerverstärkung“): Wenn die 

Genauigkeit der statischen Bewertungsfunktion 

nach unten hin nicht deutlich zunimmt, wird – 

mathematisch beweisbar – der nach oben 

propagierte Wert zunehmend ungenauer 

(kurz: je tiefer man analysiert, desto 

schlechter spielt man!) 

495 

Reversi 

• In den Übungen wird das Spiel „Reversi“programmiert 

• Auch unter „Othello“ bekannt 

• Gelegenheit, Teile der Theorie anzuwenden ( Turnier!) 

• Um 1880 von Lewis Waterman 

bzw. John Mollet erfunden 

• Die beiden haben sich deswegen 

heftig gestritten 

• Erste deutsche Version 1907 

bei Ravensburger 

• Ältere chinesische Vorläufer? 

• Spielregeln sind einfach, gute Strategien aber schwierig 

496 

209

Japperflocky 

’Twas logic, and the slippy lops 

Did gyre and rattle on the board: 

All ordered were the flippy flops, 

And the corner guards on toward. 

"Beware the Japperflock, my son! 

The end-game slip, the Stoner trap! 

Beware the frontier wall, and shun 

The nimble turning back." 

He took his Tower clock in hand; 

Tsukuda board for the tournament. 

So chatted he with the players, and 

to the proper table went. 

And, as in nervous thought he sat, 

The Japperflock began the game, 

Then whiffled through Rotating Flat, 

With furbled hands of flame. 

One, two! One, two! And follow through! 

His foe was in a Boscov Swindle! 

He kept him dead, and well ahead, 

The other’s discs did dwindle. 

"And hast thou wiped the Japperflock? 

Come to my arms, my counting boy! 

O fliptious snare! Stored move! X-Square!" 

He chortled in his joy. 

’Twas logic, and the slippy lops 

Did gyre and rattle on the board: 

All ordered were the flippy flops, 

And the corner guards on toward. 

– Hugo Calendar 

(Inspired by Othello and Jabberwocky, by Lewis Caroll) 

http://hugocalendar.com/documents/japperflocky.html 

498 

Literatur zu Reversi-Spielstrategien 

• K.-F. Lee , S. Mahajan: The Development of a World Class Othello Program, 

Artificial Intelligence 43, pp. 21-36, 1990 (empfehlenswert!) 

• A. Kierulf: New Concepts in Computer Othello: Corner Value, Edge Avoidance, 

Access and Parity; in: "Heuristic Programming in Artificial Intelligence: The 

First Computer Olympiad", ed.: D.N.L. Levy and D.F. Beal, pp. 225-240, Ellis 

Horwood, 1989 

• Dorrit Billman, David Shaman: Strategy Knowledge and Strategy Change in 

Skilled Performance: A Study of the Game Othello, American Journal of 

Psychology, Summer 1990, Vol. 103, No. 2, pp. 145-166 

• Michael Buro: Techniken für die Bewertung von Spielsituationen anhand von 

Beispielen, Dissertation der Uni-GH Paderborn, 1994, 

www.cs.ualberta.ca/~mburo/ps/mics_dis.pdf (beschreibt u.a. das Reversi- 

Spielprogramm "LOGISTELLO", eines der weltweit besten Spielprogramme) 

• Michael Buro: An Evaluation Function for Othello Based on Statistics, 

NEC Research Institute Technical Report #31, 1997, 

www.cs.ualberta.ca/~mburo/publications.html 

499 

210

Literatur zu Reversi-Spielstrategien (2) 

• Michael Buro: How Machines have Learned to Play Othello", IEEE Intelligent 

Systems J. 14(6) 1999, 12-14, 

www.cs.ualberta.ca/~mburo/publications.html 

• Mark G. Brockington: Keyano Unplugged - The Construction of an Othello 

Program, Technical Report 97-05, Department of Computing Science, 

University of Alberta, 1997, 

www.cs.ualberta.ca/~games/articles/keyanotr.ps.gz 

• Hugo Calendar (Editor): Othello Strategy and Tactics. Referenz bei 

www.andreazinno.it/orules.html (dort weitere Hinweise zu Reversi) 

• Michael Buro: The Evolution of Strong Othello Programs, Proc. IWEC-2002 

Workshop on Entertainment Computing (2002), 

www.cs.ualberta.ca/~mburo/ps/compoth.pdf 

500 

Internet-Ressourcen zu Reversi 

• http://home5.swipnet.se/~w-50714/othello/tutorial/intro.htm 

• http://home5.swipnet.se/~w-50714/othello/tutorial/tutorial.htm 

• Othello Gateway http://othellogateway.com/ 

• http://www.othello.org.hk/tutorials/eng-tu2.html 

• broken link 

• http://www.othello.org.hk/tutorials/eng-tu3.html 

• broken link 

• Nethello ist ein Reversi-Programm, das direkt von einem 

WWW-Browser aus aufgerufen werden kann und gegen 

das man interaktiv spielen (und verlieren...) kann: 

• broken link: http://cgi.student.nada.kth.se/cgi-bin/d95-mih/nethello.pl 

501 

211

12. 

Rekursives 

Problemlösen 


- 327-363 (rek. Problemlösen) 

- 393-396 (Mergesort) 

504 

Rekursion 

505 

212

506 

508 

213

511 

512 

214

513 

Ein Beispielproblem: die Türme von Hanoi 

Bildquelle: Wikipedia 

514 

215

Türme von Hanoi 

• Ein buddhistischer Mönchsorden versucht sich der 

Legende nach seit vielen Jahren an folgendem Problem: 

• 64 goldene Scheiben verschiedener 

Grösse sind aufeinander gestapelt 

• Es darf immer nur eine kleinere Scheibe 

auf einer grösseren liegen, nie umgekehrt 

• Scheiben dürfen nur einzeln von einem 

„Turm“ zu einem anderen gebracht werden 

• Am Ende sollen alle Scheiben korrekt auf 

Turm 3 liegen 

• Gesucht ist ein Algorithmus, 

der angibt, wann welche Scheibe 

von wo nach wo zubewegen ist 

(falls das Problem überhaupt lösbar ist!) 

Ein Problem, das sich relativ leicht 

rekursiv lösen lässt, aber nicht so 

einfach ohne Rekursion 

1883 vom französischen Mathematiker 

Eduard Lucas beschrieben 

515 

Türme von Hanoi – Animation 

516 

216

Türme von Hanoi – Animation mit Roboter 

Video [2:21] by Yanyu Su and Kyuhwa Lee, Imperial College London, http://vimeo.com/41611733 or 

http://www.youtube.com/watch?v=KOgmSpfcxCY (“iCub Block Manipulation”) 

517 

Türme von Hanoi – Lösungsidee 

• Die einzige Möglichkeit, die unterste (grösste) Scheibe von 

Turm 1 nach Turm 3 zu bewegen: 

(a) Auf Turm 1 befindet sich nichts sonst 

(b) Turm 3 ist leer 

• Aus (a) und (b) folgt: 

(c) Alle anderen Scheiben 

befinden sich auf Turm 2! 

• → Es müssen zunächst die n-1 anderen Scheiben von 

Turm 1 nach Turm 2 gebracht werden 

518 

217

Rekursionsansatz 

• „Es müssen zunächst die n-1 anderen Scheiben von 

Turm 1 nach Turm 2 gebracht werden“ 

• Dies ist das gleiche Problem in kleinerer Dimension 

(denn offenbar behindert die hier nicht betrachtete unterste 

Scheibe auf Turm 1 nicht die Lösung des Teilproblems) 

• Lösungsansatz für das Gesamtproblem: 

• Bringe den „n-1 Turm“ von 1 nach 2 

• Bewege die Scheibe von 1 nach 3 

• Bringe den „n-1 Turm“ von 2 nach 3 

• Wieso ist folgende ähnliche Überlegung falsch? 

• Bewege die oberste (kleinste) Scheibe von 1 nach 2 

• Bringe den restlichen „n-1 Turm“ von 1 nach 3 

• Bewege die eine (kleinste) Scheibe von 2 nach 3 

 

 

 

519 

Das rekursive Java-Programm 

class Hanoi { 

} 

Das ist ein Programm ohne Zuweisung! 

(→ funktionaler Programmierstil) 

void bewege(int von, int nach) { 

System.out.println("Eine Scheibe von Turm " + 

von + " nach Turm " + nach); 

} 

void hanoi(int groesse, int von, int nach) { 

if (groesse == 1) 

Könnte man die Rekursion nicht bei 0 statt 1 

bewege(von, nach); aufhören lassen? Wie sieht das dann aus? 

else { 

hanoi(groesse-1, von, 6-von-nach); 

bewege(von, nach); 

hanoi(groesse-1, 6-von-nach, nach); 

} 

} 

Der "andere" Turm 

520 

218

Die Programmausgabe von „hanoi(4,1,3)“ 




else { 




} 

} 

0) 

1) 

2) 

3) 

Eine Scheibe von Turm 1 nach Turm 2 



521 

Die Programmausgabe von „hanoi(4,1,3)“ 




else { 




} 

} 

0) 

1) 

2) 

3) 

4) 

5) 

6) 

7) 








522 

219

Dynamische Aufrufkette 

hanoi(4,1,3) 

if … bewege … 

hanoi(3,1,2) 

bewege(1,3) 

hanoi(3,2,3) 

hanoi(3,2,3) 


hanoi(2,2,1) 

bewege(2,3) 

hanoi(3,1,3) 

Tiefe der 

dynamischen 

Aufrufkette 

Schnappschuss des 

Berechnungszustandes 

hanoi(2,2,1) 


hanoi(1,2,3) 

bewege(2,1) 

hanoi(1,3,1) 

hanoi(1,2,3) 

bewege(2,3) 

hanoi(0,2,1) 

bewege(2,3) 

hanoi(0,1,3) 




else { 




} 

} 

bewege(2,3) 

println(2,3) 

Es existieren gleichzeitig mehrere Instanzen 

der hanoi-Methode 

Jede wartet auf Fertigstellung der von ihr 

gerufenen Methode an der Aufrufstelle 

Mit der eigenen Instanz wird fortgefahren, 

wenn die Aufrufkette wieder bis dorthin 

abgebaut worden ist 

523 

Zeitkomplexität des Hanoi-Algorithmus 

• Nach der Legende ist das Ende der Welt erreicht, 

wenn die Mönche ihre Aufgabe ganz gelöst haben 

• Wann ist das bei unserem Algorithmus der Fall? 

• n = 64 Scheiben 

• Eine Scheibe / Minute 

• „Anfangsverdacht“ für die Zeitkomplexität (= Anzahl 

der Elementarschritte, hier: „bewege“) empirisch: 

n 

1 

2 

3 

4 

: 

t(n) 

1 

3 

7 

15 

: 

- Vermutung: t(n) = 2 n -1 

- Rekursionsformel: t(n) = 

1 für n=1 

2 t(n-1) + 1 sonst 

Korrektheit der Rekursionsformel ist klar, aber 

was ist mit der geschlossenen Formel 2 n -1? 

Beweis: zeige induktiv: 2 n -1erfüllt die Rekursionsformel 

524 

524 

220

Zum Weltuntergang 

• Da haben wir noch einmal Glück gehabt! 

• t(64) = 2 64 -1 min ≈ 10 19 min ≈ 10 14 Tage ≈ 3×10 11 Jahre 

• Die Welt existiert aber erst seit ca. 1.37×10 10 Jahren 

• Der Weltuntergang steht also noch nicht unmittelbar bevor... 

• Algorithmen exponentieller Zeitkomplexität t(n)= c n lassen 

sich in der Praxis oft selbst für „vernünftige“ Problemgrössen n 

auch auf sehr schnellen Computern kaum (jemals!) ausführen 

• Sie sind inhärent ineffizient 

525 

Effizientere und einfachere Algorithmen 

für das Problem? 

• Sind die Mönche vielleicht schlecht beraten? 

• D.h.: gibt es einen effizienteren Algorithmus (der 

die geforderten Nebenbedingungen des Problems einhält)? 

• Ja? (→ Algorithmus angeben!) 

• Nein? (→ Beweis, dass nicht!) 

• Oder: weiss vielleicht niemand, ob „ja“ oder „nein“ gilt? 

• Noch eine Frage: Gibt es einen (einfachen) 

nicht-rekursiven Algorithmus für das Problem? 

• Antwort: Ja, aber dieser wird hier nicht verraten 

• Tipp: Man betrachte 6-x-y für die Folge der Protokollzeilen bei 

Eine Scheibe von Turm x nach Turm y 

526 

221

Divide et impera – Ein interessantes Paradigma 

• Grundprinzip zur Problemlösung in der Informatik 

• Ursprung der Redewendung in der praktischen Politik 

• „Feinde“ (bezüglich Religion, Ethnie etc.) in 

Untergruppen aufspalten 

• Einzelne Untergruppen „besiegen“ oder 

„unter Kontrolle halten“ 

• Evtl. Untergruppen gegeneinander anstiften 

• Von den alten Römern bis zur Kolonialzeit 

und darüber hinaus angewendet 

• Oft mit langwierigen Konsequenzen 

antiquitatis.com 

527 

Beispiel: Minimum einer geordneten Menge 

Nach dem Prinzip „divide et impera“ („ divide and conquer“): 

(1) Teile die Menge P in 2 Teilmengen P1, P2 („Partition“), so dass: 

• P1 P2 = P 

• P1 P2 = Ø 

(2) Löse das Problem für die beiden 

jew. kleineren Mengen P1 und P2 

• Sei p’ das Minimum von P1 

• Sei p” die entspr. Lösung für P2 

(3) Vergleiche p’ mit p” und liefere 

den kleineren der beiden Werte 

als Ergebnis p zurück 

• Also: p = min(p’,p”) 

• Ist das gemogelt? 

• Geht das auch immer gut? 

(Für bel. Teilmengen P1,P2,…) 

• Lässt sich dieses Paradigma auch 

auf andere interessante algorithmische 

Probleme anwenden? 

528 

222

„Visualisierung“ der rekursiven 

Minimumbestimmung einer Menge 

Das ist ein Baum 

(in Darstellung als 

Mengendiagramm) 

529 

Eine andere Darstellung des Rekursionsbaums 

530 

223

Divide et impera: Voraussetzungen 

• Das Problem muss beim Partitionieren „einfacher“ / kleiner werden 

• Man muss richtig partitionieren: 

• Keine der beiden Teilmengen darf leer werden 

• Man kann nur richtig partitionieren, wenn die Ausgangsmenge zwei 

oder mehr Elemente enthält 

• Man muss also die Lösung für eine einelementige Menge anders bestimmen 

(aber: leere Menge?) 

• Man muss aus den Teillösungen die Gesamtlösung einfach 

zusammenbauen können 

• Die beiden Teilprobleme lassen sich u.U. sogar gleichzeitig bearbeiten 

(„Parallelisierung“) 

• Wieso eigentlich nicht gleich in mehr als 2 Teilprobleme aufspalten? 

531 

Beispiel: Mergesort 

• „Merge“ = Zusammenfassen von zwei sortierten Folgen 

zu einer einzigen sortierten Folge durch 

einfädeln, 

verflechten, 

verschmelzen 

fortgesetzte Auswahl des kleineren der 

beiden Anfangselemente 

532 

224

Mergesort – Prinzip 

Unsortierte Daten 

aufteilen 

Teil 1 Teil 2 

rekursiv sortieren 

Teil 1 sortiert Teil 2 sortiert 

merge 

Sortierte Daten 

muss nicht genau 

halbiert werden 

1) Sortiere die erste Hälfte der 

Daten mit Mergesort 

2) Sortiere die zweite Hälfte der 

Daten mit Mergesort 

3) Beide Hälften „mergen“ 

• Rekursion abbrechen bei 

einer Folge der Länge 1 

533 

Mergesort – rekursiver Ansatz 

• Typische Anwendung des Divide-et-impera-Prinzips 

• Der rekursive top-down Mergesort-Algorithmus in Java: 

void mergesort(int li, re){ 

... 

if (...) { 

m = (li+re)/2; 

mergesort(li,m); 

mergesort(m+1,re); 

... 

Denkübung: ist die Bestimmung von m korrekt, 

auch wenn li+re eine ungerade Zahl ergibt? 

534 

225

Mergesort – ein Beispiel 

535 

Mergesort mit verketteten Listen 

Sofern die Liste mehr als 

ein Element enthält: 

→ Aufspalten der Liste 

in zwei Teillisten (Durchlaufen 

und abwechselnd 

in L1 oder L2 einfügen): 

Die Listen L1 und L2 

jeweils rekursiv sortieren: 

L1 und L2 durchlaufen 

und das jeweils kleinere 

Objekt in eine neu aufgebaute 

Liste hinten anfügen 

(„merge“): 

537 

226

Variante: Bottom-up-Mergesort 

• Nicht rekursiv! 

1) Durchlaufe die Liste der Elemente und erzeuge geordnete Paare 

durch Mergen benachbarter sortierter Teillisten der Länge 1 

• Es werden sortierte Teillisten der Länge 2 erzeugt 

2) Durchlaufe die Liste und erzeuge geordnete Quadrupel 

durch Mergen benachbarter sortierter Teillisten der Länge 2 

• Es werden sortierte Teillisten der Länge 4 erzeugt 

3) … 

• → Bis eine sortierte Liste der Länge n erzeugt wird 

538 

Sortieren einer zufälligen Folge 

539 

227

Umgekehrt sortierte Ausgangsfolge 

540 

Bottom-up-Mergesort – Effizienz 

• Nach k Durchläufen hat man sortierte Teillisten der Länge 2 k 

• Nach log n Durchläufen hat man die Länge n ( fertig!) 

• Ein Durchlauf erfordert jeweils n „Schritte“ 

• Pro Schritt: Vergleichen zweier Werte, Erhöhen eines Index... 

• Mergesort benötigt also (grössenordnungsmässig) n log n „Schritte“ 

• Top-down- und Bottom-up-Mergesort führen i.w. die gleichen 

Merge-Operationen aus, allerdings in unterschiedlicher Reihenfolge! 

• Beim rekursiven Top-down-Mergesort gibt es folgenden 

Zwischenzustand: sortiert unsortiert 

• Dieser Zustand kann beim Bottom-up-Mergesort nicht 

auftreten, dort sind alle Teile stets etwa „gleich weit“ 

541 

228

13. 

Komplexität von 

Algorithmen 


- 223-227, 237-243, 248-250 

542 

Aufwand von Algorithmen 

• Algorithmen verbrauchen Rechenzeit 

• Benutzte Datenstrukturen benötigen Speicher 

• Wichtiges Ziel: Ressourcenverbrauch minimieren 

• Bsp. einer typ. Frage: Wie hoch ist der Ressourcenverbrauch beim 

Sortieren von n Elementen (bei einem konkreten Algorithmus)? 

• Frage präzisieren! (Im Durchschnitt? Im worst-case? Unter 

welchen Bedingungen?) 

• Es gibt Probleme, wo jeder mögliche Lösungsalgorithmus 

eine gewisse Mindestmenge von Ressourcen benötigt 

• Anwendung z.B.: sichere kryptographische Verfahren 

543 

229

Begriffe bei der Aufwandsanalyse 

• Problemumfang bzw. -grösse wird meist mit n bezeichnet 

• Oft: Anzahl der Eingabewerte 

• Manchmal aber auch: Anzahl der Bits der Eingabe 

• Der Aufwand (Bedarf an Zeit bzw. Speicherplatz in sinnvollen 

Einheiten) ist typischerweise von n abhängig 

• Wird daher als Funktion f(n) angegeben 

• Beim Zeitaufwand wird i.Allg. von konstanten Faktoren 

(und additiven Termen) abstrahiert 

• Also z.B.: f(n) = n log (n) statt genauer 3 + 7 n log (n) 

• Beim Speicheraufwand (bzgl. der Implementierung eines Algorithmus) 

abstrahiert man aber meist nicht von konstanten Grössen 

544 

Begriffe bei der Aufwandsanalyse (2) 

• Oft ist der Aufwand eines Algorithmus nicht nur von der 

Problemgrösse n, sondern von den konkreten Eingabewerten 

(bzw. deren Reihenfolge) abhängig, daher unterscheidet man: 

• günstigster Aufwand („best case“) 

• mittlerer Aufwand („average case“) 

• ungünstigster Aufwand („worst case“) 

• Oft ist man nur am (i.Allg. leichter zu bestimmenden) asymptotischen 

Aufwand (für n→∞) als Funktion von n interessiert 

• Achtung: für „kleine“ n kann ein Algorithmus mit schlechterem 

asymptotischen Aufwand besser sein (→ break even points)! 

• Komplexität eines Problems = geringstmöglicher Aufwand, der 

mit dem dafür besten Lösungsalgorithmus erreicht werden kann 

• Manche Probleme sind inhärent aufwendig / schwierig / „komplex“ 

545 

230

Komplexitätsgrössenordnung 

• Zweck: Angabe der Grössenordnung der (Zeit)komplexität 

eines Algorithmus als Funktion der Eingabegrösse („n“) 

• Zeitkomplexität wird typw. als Anzahl der Schritte aufgefasst 

• Idee: Von unwesentlichen Konstanten abstrahieren 

• Technologieparameter, Implementierungsdetails 

• Schreibweise: 

• O(log n) logarithmische Komplexität 

• O(n) lineare Komplexität 

• O(n 2 ) quadratische Komplexität 

• O(c n ) exponentielle Komplexität 

• O(1) konstante Komplexität (d.h., unabhängig von n) 

546 

Die O-Notation 

• Man sagt, die Komplexität eines Algorithmus ist 

von der Grössenordnung O(f(n)), wenn für die 

„wirkliche“ Komplexität g(n) des Algorithmus gilt: 

∃ 

∀ 

∃n 0 , c>0 : ∀n ≥ n 0 : g(n) ≤ c f(n) 

• Beispiel: Für 7 + 1.5 n + 3n 2 schreibe O(n 2 ) 

• Informelle Interpretation: Die Laufzeit wird „im 

wesentlichen“ durch O(...) beschränkt (oder oft 

auch unpräziser: „ist etwa proportional zu“) 

O(n 3 ) oder O(2 n ) 

wäre auch richtig, 

aber „übertrieben“ 

Interessant ist 

i.Allg. die „kleinste“ 

Funktion f, die g 

majorisiert 

• Oft kann man die Grössenordnung in O-Notation angeben, 

ohne die wirkliche Komplexität exakt zu kennen! 

547 

231

Laufzeiten und Problemgrössen 

Laufzeit für kleine 

Problemgrössen bei 

Beispielalgorithmen 

548 

Laufzeiten und Problemgrössen (2) 

Laufzeit für grosse 

Problemgrössen 

549 

232

Beispiele aus der Vorlesung 

• Asymptotische Zeitkomplexität: 

• ägypt_mult(m,n): O(log n) 

• hanoi(n): O(2 n ) 

• insertion sort, deletion sort: O(n 2 ) 

aver. 

case 

worst 

case 

• Sortieren mit Suchbäumen: O(n log n) ... O(n 2 ) 

• Mergesort: O(n log n) 

• Binärsuche: O(log n) 

average und worst case 

550 

Maximaler Problemumfang bei gegebener Zeit 

• Beispiel: Bei Zeitbedarf von 10 μs für n=1: 

551 

233

Zeitbedarf bei vergrössertem Problemumfang 

• Beispiel: Bei 1 μs für n=1: 

552 

Bewältigbarer Problemumfang bei 

schnellerer Maschine 

Wenn „jetzt“ Problemumfang M bewältigbar ist, dann 

kann in gleicher Zeit eine 10 Mal schnellere Maschine 

folgenden Problemumfang M' bewältigen: 

f(n) 

M' 

Anzahl Berechnungsschritte 

(„Laufzeit“) bei Problemumfang n 

Beispiel: In 2 M Berechnungsschritten wird ein 

Problem der Grösse M bewältigt. Mit der 

schnelleren Maschine kann man (in gleicher 

Zeit) 10 Mal mehr Schritte, also 10 × 2 M 

Schritte, ausführen. Welche Problemgrösse M' 

kann mit so vielen Schritten bewältigt werden? 

Wir setzen M' als unbekannte, zu bestimmende 

Variable in die Laufzeitformel f(n) = 2 n ein: 

2 M' = 10 × 2 M . Logarithmieren (zur Basis 2) 

beider Seiten liefert M' = log 2 10 + M ≈ 3.3 + M. 

553 

234

Komplexitätsklassen O(f) 

• Mit O(f) wird jeweils eine ganze Funktionsklasse bezeichnet 

• Genauer: O(f(n)) = { g(n) | ∃ n 0 , c > 0: ∀n ≥ n 0 : g(n) ≤ c f(n) } 

• Statt g ∈ O(f) schreibt man oft salopper: g = O(f) 

• Notation dann z.B.: g(n) = O(n 2 ) 

oder kürzer g = O(n 2 ) 

• Interpretation: g wächst 

höchstens so schnell wie f 

• f = O(1) bedeutet: f ist beschränkt 

• Überschreitet einen bestimmten konstanten Wert nicht 

• Wichtig ist auch die Klasse der polynomiellen Funktionen: 

POLY(n) =∪p>0 O(n p ) 

• Falls f ∈ POLY(n), dann spricht man von polynomiellem Aufwand 

(wesentlicher Unterschied dazu: exponentieller Aufwand O(c n )) 

n 0 

n 

554 

Die Ω-Notation 

• Für untere Schranken verwendet man die Ω-Notation: 

• Ω(f(n)) = { g(n) | ∃ n 0 , c > 0: ∀n ≥ n 0 : c f(n) ≤ g(n) } 

• Interpretation von g = Ω(f): 

• g wächst mindestens 

so schnell wie f 

n 0 

n 

555 

235

Beispiel: Komplexität von Mergesort 

• Behauptung: Die Zeitkomplexität beträgt O(n log n) 

Beweisansatz: 

Anzahl der Schritte 

der rekursiven 

Top-down-Lösung 

mittels einer Rekursionsgleichung 

556 

Beispiel: Komplexität von Mergesort 

• Oder einfacher: Wir zeigen, dass die „vom Himmel gefallene“ 

Formel t(n) = n + n log n die Zahl der Schritte angibt 

• Beweis induktiv mit dem Rekursionsansatz 

t(n) = n + 2 t(n/2) 

= n + 2 (n/2 + n/2 log (n/2)) 

= n + n + n log (n/2) 

= n + n - n + n log n 

= n + n log n 

∈ O(n log n) 

n = Aufwand für „merge“ 

von n Elementen 

Induktionsannahme für n/2 

wg. log (n/2) = (-1 + log n) 

[Logarithmus zur Basis 2] 

Denkübung: 

Induktionsanfang? 

557 

236

Komplexität von Sortieren 

• Es gilt (hier ohne Beweis), dass das Sortieren von n 

Elementen ein Problem mit Zeitkomplexität O(n log n) ist 

• Unter gewissen allgemeinen Bedingungen (dass z.B. über 

den Wertebereich der Elemente a priori nichts bekannt ist) 

• Das heisst, dass Mergesort (grössenordnungsmässig) 

ein optimaler Algorithmus für das Sortierproblem ist 

• Es gibt keinen „wesentlich“ besseren Sortieralgorithmus! 

• Aber vielleicht hilft ja Parallelität? 

• Z.B. mit Mehrkernprozessoren („multicore“) 

558 

Laufzeitvergleich von drei 

O(n log n)-Sortierverfahren 

Sekunden 

Abhängig von der konkreten 

Implementierung können die 

Ergebnisse allerdings etwas 

unterschiedlich ausfallen 

Heapsort 

Mergesort 

Heapsort besprechen wir 

später; Quicksort behandeln 

wir in dieser Vorlesung nicht 

Quicksort 

O(n 2 )-Sortierverfahren 

benötigen hier bereits 

hunderte von Sekunden 

n 

559 

237

14. 

Simulation 


- 543-555 (ereignisgesteuerte Simulation) 

567 

Zedlers „grosses vollständiges Universal- 

Lexicon aller Wissenschafften und Künste,“ 

…welche bißhero durch menschlichen Verstand 

und Witz erfunden und verbessert worden,… 

1732 bis 1754 erschienenen; rund 284 000 Artikel auf 

ca. 63 000 Seiten; 64 Bände und 4 Supplementbände 

Historische 

Notiz 

Simulare 

„Stellen“ im Sinne von „einen Zustand vortäuschen“ bzw. „sich 

verstellen“ (sich krank stellen; er stellte sich, als ob er schliefe) 

568 

238

Meyers Konversations-Lexikon 1885 – 1892 

• 

571 

Brockhaus-Lexikon 1895 

Simulation (lat. „Erheuchelung“, „Vorspiegelung“) 

ein Verhalten, welches einen dem wirklichen Sachver≈ 

halt nicht entsprechenden Schein eines anderen Sach≈ 

verhalts hervorruft, meistens in der Absicht zu täu≈ 

schen. Juristisch kommt in Betracht die Simulation 

von Geisteskrankheiten, namentlich zur Vermeidung 

einer dem Simulanten drohenden strafrechtlichen Ver≈ 

folgung, die Vorschützung von Gebrechen oder körper≈ 

lichen Krankheiten, um vermögensrechtliche Vorteile zu 

erlangen, beim Militär, um sich der Dienstpflicht zu 

entziehen. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 

572 

239

Simulation – neuere Begriffsbestimmung 

Brockhaus 1983: Darstellung oder Nachbildung physikalischer, 

technischer, biologischer, psychologischer oder 

ökonomischer Prozesse durch mathematische oder physikalische 

Modelle, die eine wirklichkeitsnahe, jedoch einfachere, 

billigere oder ungefährlichere Untersuchung als das 

Objekt erlauben. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 

was 

wie 

wozu 

VDI-Richtlinie 3633: Nachbildung eines dynamischen 

Prozesses in einem Modell, um zu Erkenntnissen zu gelangen, 

die auf die Wirklichkeit übertragbar sind. xxxxxxxx 

574 

Simulation als Problemlösungstechnik 

• Kurze Definition: Experimente an einem Modell 

• „Simulationsmodell“ 

• Simulation ist ein „Modellexperiment“ 

• Soll Rückschlüsse auf das reale System ermöglichen 

• Prinzip: „Wenn dies so wäre, dann würde folgendes geschehen“ 

• Simulation ist also eine Problemlösungstechnik 

• Warum Simulation? 

• Für reale, komplexe Probleme / Abläufe gibt es oft keine „Lösungsformel“ 

• Simulationen sind i.Allg. aufwendig 

• Oft muss man einen Ablauf in vielen verschiedenen Varianten untersuchen 

• Für statistisch Relevanz stochastische Simulationen mehrfach wiederholen 

• Hoher Detailierungsgrad benötigt lange Laufzeit 

575 

240

Modelle und Modellierung 

• Modell = Vereinfachtes Abbild der komplexen Realität 

• Soll sich bzgl. relevanter Aspekte (=?) aber analog zur Realität 

darstellen oder verhalten 

Reduktion, 

Vergröberung! 

Modelle dienen u.a. dem Begreifen 

der Wirklichkeit als Voraussetzung 

für planvolles Handeln 

- In diesem Sinne evtl. auch bereits 

prähistorische Höhlenmalereien 

- Spielen von Kindern 

„Dass die Folgen der Bilder stets 

wieder die Bilder seien von den 

naturnotwendigen Folgen der 

abgebildeten Gegenstände“ 

(Heinrich Hertz) 

Simulation = Durchspielen am Modell 

576 

Zweck und Anwendung von Simulation 

• Zweck von Modellierung und Simulation 

• Optimierung (z.B. Wirkung der Beseitigung von Engpässen) 

• Entscheidungshilfe (Auswahl von Entwurfsalternativen) 

• Prognose (z.B. Wetter) 

• Validierung (z.B. Schaltplan eines neuen Mikroprozessors) 

• Theorienbildung (z.B. kognitive Vorgänge) 

• Animation, Erklärung (pädagogische Hilfsmittel, „Demonstrationsmodell“) 

• Anwendungsgründe für Simulation 

• Rein mathematische Analyse nicht möglich 

• Reales System liegt nicht vor (ist z.B. erst geplant) 

• Realität erträgt Experiment nicht (Ökologie, Militär) 

• Realität zu schnell (chemische Reaktionen) 

• Realität zu langsam (Entstehung von Galaxien) 

• Reales Experiment zu teuer 

577 

241

Ursprünge von Modellierung und Simulation 

• Landkarten, Globus 

• Sandkastenspiele der Militärs 

• Formalisierung der Physik 

• Differentialgleichungen 

• Digitale Computer ab ca. 1945 

• Zunächst militärische und ökonomische Anwendungen 

578 

Einsatzbereiche von Simulation 

• Meteorologie, Klima 

• Verkehrsplanung 

• Industrielle Fertigung, Logistik 

• Militär 

• Volkswirtschaft 

• Ökologie, Biologie 

• Architektur 

• Grundlagenforschung (z.B. Physik, Chemie) 

• … 

579 

242

Beispiel: Klimasimulation 

http://www.bgc-jena.mpg.de/~martin.heimann/vorlesung/Animations/tmp2m_web.gif 

580 

Beispiel: Klimasimulation (Niederschlagsmenge 2100) 

http://www.noaanews.noaa.gov/stories2007/images/global-precip-end-21st-century2.jpg 

581 

243

Beispiel: Simulation eines Tornados 

582 

Beispiel: Strömungssimulation 

583 

244

Beispiel: Strömungssimulation (2) 

587 


589 

245


590 

Beispiel: Simulation von Verbrennungsvorgängen 

593 

246

Beispiel: Simulation von Luftkühlung 

http://static.datacenterdynamics.com/assets/image/0004/235147/Simulation-of-thermal-flows-in-datacenter.jpg 

594 

Beispiel: Simulation von Schmelzvorgängen 

http://gtresearchnews.gatech.edu/wp-content/uploads/2009/12/dancing-atoms-simulation.jpg 

595 

247

Beispiel: Protein-Simulation 

596 

Beispiel: Supernova-Simulation 

598 

248

Beispiel: Simulation virtueller Welten 

Stage Space AG 

Linden Research (second life) 

600 

Beispiel: Produktionssimulation 

Plan B Automatisierung GmbH 

602 

249

Beispiel: Montagesimulation 

http://www.ea-online.de/xml-import/bilder/ia/2007-52/600x/thumb_ia52070184_tif.jpg 

603 

Beispiel: Verkehrssimulation 

http://gamma.cs.unc.edu/DCrowd/images/crosswalkUserInput.jpg 

604 

250

Beispiel: Verkehrssimulation 

www.ib-hurrle.de/Simula_Bild.jpg 

605 

Beispiel: Crash-Simulation 

606 

251

Beispiel: Simulation einer Autosteuerung 

Analog-Computer mit Servo-Motoren (General Motors, 1958) 

607 

Beispiel: Fahrsimulator (1950er-Jahre) 

608 

252

Beispiel: Fahrsimulator (1950er-Jahre) 

609 

Beispiel: Flugsimulator (1950er-Jahre) 

612 

253


http://www.historyofpia.com/forums/viewtopic.php?f=8&t=13664 

613 


615 

254


http://www.planetds.de/screens.php?typ=spiel&code=airds&shot=1 

616 


Max-Planck-Institut für biologische Kybernetik 

617 

255

Simulatoren für alles… 

618 

Noch ein wichtiges Beispiel: 

Simulationsmodelle für die Wetterprognose 

www.wetter3.de 

619 

256

Historische Vision der Wettervorhersage 

mittels numerischer Simulation 


Mehrere 10000 menschliche 

Rechner in einer kugelförmigen 

Galerie um einen Dirigenten 

berechnen die Wettervorhersage. 

Eine auf die 

Wände gemalte Erdkarte definiert 

das Rechengitter, das 

eine räumliche Auflösung 

von einem Grad hat. Die Ergebnisse 

der Berechnung 

werden in einem Eimer zu 

einem Telegraphen herabgelassen, 

der die Wetterprognose 

verbreitet. 

Nach L.F. Richardson, Weather 

Prediction by Numerical Process, 

1922 

620 

Historische Vision der Wettervorhersage 

mittels numerischer Simulation 

621 

257

L.F. Richardson über seine 

Central Forecast-Factory for the Whole Globe 

622 



623 

258



“Imagine a large hall like a theatre, except that the circles and galleries go right round 

through the space usually occupied by the stage. The walls of this chamber are painted 

to form a map of the globe. The ceiling represents the north polar regions, England 

is in the gallery, the tropics in the upper circle, Australia on the dress circle and the 

Antarctic in the pit. A myriad computers are at work upon the weather of the part of 

the map where each sits, but each computer attends only to one equation or part of an 

equation. The work of each region is coordinated by an official of higher rank. Numerous 

little ‘night signs’ display the instantaneous values so that neighboring computers can 

read them. Each number is thus displayed in three adjacent zones so as to maintain 

communication to the North and South on the map. From the floor of the pit a tall pillar 

rises to half the height of the hall. It carries a large pulpit on its top. In this sits the 

maninchargeofthewholetheatre;heissurroundedbyseveralassistantsandmessengers. 

One of his duties is to maintain a uniform speed of progress in all parts of the 

globe. In this respect he is like the conductor of an orchestra in which the instruments 

are slide-rules and calculating machines. But instead of waving a baton he turns a 

beam of rosy light upon any region that is running ahead of the rest, and a beam of 

blue light upon those who are behindhand. 

Four senior clerks in the central pulpit are collecting the future weather as fast as it is 

being computed, and dispatching it by pneumatic carrier to a quiet room. There it will 

be coded and telephoned to the radio transmitting station.” 

624 

625 

259

Als „Computer“ noch Menschen waren… 

626 

Lewis Fry Richardson, 1881-1953 

Perhaps some day in the dim future it 

will be possible to advance the computations 

faster than 

the weather advances 

and at a 

cost less than the 

saving to mankind 

due to the information 

gained. But 

that is a dream. 

1922 

627 

260

Wettervorhersage ab ca. 1850 

Synoptische Wetterbeobachtungen 

(und 

Prognosen mittels einfacher 

Modelle) bald 

nach der Erfindung des 

Telegraphen ab Mitte 

des 19. Jahrhunderts. 

Wetterkarte der 

deutschen Seewarte 

von 1887 

628 

Wettervorhersage ab ca. 1850 

629 

261

Wetterwarte auf dem Säntis-Gipfel ab 1882 

„Zehn vollamtliche Säntisbeobachter, 

mehrheitlich mit ihren Ehegattinnen, 

haben von 1882 bis 1969 ihre 

anspruchsvolle Aufgabe immer wieder 

auch unter schwierigsten Wetterbedingungen 

wahrgenommen. Kennzeichnend 

waren wochenlange Einsamkeit 

mit zeitweise fehlendem 

Nahrungsmittelnachschub im Winter 

(bis 1935), stundenlange Enteisungsaktionen 

vor allem am Windmesser, 

ermüdendes Schneeschaufeln, Reparieren 

von Instrumenten.“ [Thomas 

Gutermann, DMG-Mitteilungen 4/2000] 

632 

Wetterwarte auf dem Säntis-Gipfel (1922) 

Der Wetterwart hatte täglich 

dafür zu sorgen, dass sich 

das Windmesserrad frei drehen 

kann und nicht vereist. 

Säntisträger brachten Brennholz 

und Essen zum Gipfel. 

Telefon und Morseapparat 

im Arbeitszimmer des Observatoriums. 

633 

262

Wettervorhersage im Fernsehen 

635 

Erste Wettervorhersage am 17. Dez. 1946 

im französischen Fernsehen 

637 

263

Wettervorhersage ab 1951 im deutschen TV 

Meteorologen erklären 

live mit Kohlestift und 

grossen Gesten dem 

abendlichen Fernsehpublikum 

das Wetter. 

638 

Wettervorhersage ab 1951 im deutschen TV 

639 

264

Animierte Wetterkarten ab 1960 

„Automatisches Wetter“ 

mit Trickfilmtechnik 

(jeweils 

rund 35 Meter Film 

aus ca. 4000 Einzelbildern, 

produziert 

in drei Stunden) – 

Computergraphik 

und -animation oder 

Satelittenbilder gab 

es noch nicht. Die 

Karte zeigt Deutschland 

„dreigeteilt“, 

in den Grenzen von 

1937. 

641 

Ab dem Millennium wird die Wetterprognose 

zum Entertainment – mit Weather Girls & Boys 

Numerische Wettermodelle 

werden jetzt weitgehend 

automatisch mit 

aktuellen Daten gefüttert 

– die Prognosekunst 

ist so einfacher 

und die Wetterkarte 

sowieso computergeneriert. 

Fast wichtiger als 

die Vorhersage ist nun 

die Frage, von wem sie 

präsentiert wird (und 

welcher Sponsor die Wettermenschen 

kleidet). 

Wettervorhersage ist in 

der Schweiz auch keine 

Nachricht mehr, die auf 

Hochdeutsch präsentiert 

wird, sondern Infotainment, 

wo Mundart üblich 

ist. 

644 

265

Jeder kann jetzt das Wetter ansagen – somit 

sind andere Präsentationseigenschaften gefragt! 

Private TV-Programme 

ermöglicht durch Fortschritte 

in der Kommunikationstechnik 

645 

“Why is the weather so often presented by 

attractive women?” 

“Are weather presenters chosen primarily for their expert knowledge of meteorology or just 

for their looks? Is the weather forecasting game more about being good with figures or is 

it real about having a figure that looks hot in shorts? […] Northern countries tend towards 

more serious weather presenting while countries further south go for weather glamour. It 

also appears, the hotter the climate the less clothing weather girls seem to wear. 

BBC Serious Weather. In the UK, BBC weather presenters are highly professional 

meteorologists from the UK Met Office, a government sponsored organisation with links 

to the Ministry of Defence. […] While the BBC weather presenter Laura Tobin is pretty and 

personable, the emphasis is firmly on the weather and the camera 

view is of the weather animation not the presenter's body. 

Greek Weather. Mapia, the leggy weather presenter and weather 

girl […] frequently strides in front of the map, swinging her hips. 

Look at her body language. Her body is talking but not about the 

weather! 

Italy. Gabbi is clearly top of the class 

as far as attractiveness goes but her presenting skills need 

considerable improvement. Reading the weather from a 

clipboard is certainly not appealing and she clearly has no 

interest whatsoever in the chart behind her. How on earth 

did she get the job?” 

http://rikravado.hubpages.com/hub/Weather-Girls 

646 

266

Wetterfee in Klatschmedien und auf Facebook 

„Jetzt hat doch das SF tatsächlich 

eine neue Wetterfee – vermutlich als 

Ersatz für Neo-Mama Sandra Boner. 

Daniela Schmuki heisst sie. Ist nicht 

unsympathisch, die junge Dame, 

obwohl ihr Auftritt eher an eine 

Schülertheater-Inszenierung von 

Grimms ‚Vom Fischer und seiner 

Frau‘ erinnert … Susanne, du bist 

doch viel natürlicher, charmanter. 

Du lullst uns ein mit deiner weichen Stimme. Was ihr Wetterfeen erzählt, glauben 

wir eh nicht, aber angenehm rüberkommen soll’s wenigstens. Und in dich, Susanne, 

in dich habe wir doch schon so viel Zeit und Energie investiert. Richtig gross machen 

wollten wir dich. Haben eigens eine Facebook-Gruppe lanciert…“ 

www.klatschheftli.ch/tag/susanne-aeschlimann 

647 

Das Weather Girl als Traumjob 

“The weather 

girl position is a 

dream job for a lot 

of women. You get 

to look great, styled 

for the camera, and 

have fun makeovers 

every season. Even 

if it’s raining, her 

fans will love to 

see whatever new 

fashion she’s 

wearing!” 

651 

267

Reality Check: Weather Girl 1981 

652 

Zurück zum Ernst der Dinge: 

Simulationstechnik 

653 

268

Zeitgesteuerte („synchrone“) Simulation 

• Entwicklung eines Systems in der Zeit untersuchen 

• Modellzustand Schritt für Schritt („Zeitschritt“) fortschreiben 

• Kontinuierlicher Ablauf wird „diskretisiert“ zeitdiskrete Simulation 

(„diskret“: abgegrenzt, getrennt, vereinzelt; lat. discernere unterscheiden) 

• Zum simulierten Modell gehört auch eine Simulationsuhr, 

die die aktuelle Zeit des Modells („Simulationszeit“) angibt 

• Abbild der realen Zeit im Modell, aber „gerastert“ (d.h. diskretisiert) 

• Pro Simulationsschritt: Erhöhe Simulationsuhr um festes ∆t 

• ∆t zu klein → langsam 

Diskretisierungsproblem 

• ∆t zu gross → ungenau / falsch 

• Mögliche „Totzeiten“ → Verschwendung von Rechenzeit 

Das ist etwas anderes 

als die Simulationszeit! 

654 

[T, T+Δt]-Epochen 

• Was real in [T, T+∆t] geschieht, wird erst am Ende der 

Epoche, zum Zeitpunkt T+∆t, in der Simulation wirksam 

• Ungenauigkeiten / Fehler insbes. bei kontinuierlichen Abläufen 

• Zustandsänderung eines Objektes wirkt sich frühestens 

in der nächsten Epoche auf die anderen Objekte aus 

• Falls ∆t ausreichend klein: quasi-kontinuierliche Simulation 

(vgl. Film aus vielen Einzelbildern pro Sekunde) 

• Auf allen Objekten sollte die jew. Zustandsänderung der 

Epoche [T, T+∆t] unabhängig ausgeführt werden können 

• „Gleichzeitig“ in Simulationszeit, d.h. in beliebiger Reihenfolge bei 

der Simulation einer Epoche 

Denkübung: Wie hängen die Begriffe „unabhängig“, 

„gleichzeitig“, „beliebige Reihenfolge“ zusammen? 

655 

269

Ein Beispielproblem 

• Dorfbewohner bauen Weizen an 

• Ernte im Juli beträgt 2 000 000 kg 

• Wird in einer Scheune gelagert 

• Pro Monat werden 100 000 kg verbraucht 

• Mäuse in der Scheune fressen auch Weizen 

• Aber Katzen fressen Mäuse 

• Die Dorfbewohner sorgen (monatlich) dafür, dass 

der Katzenbestand nicht unter ein Minimum fällt 

Erntemenge sollte also 

eigentlich ausreichen… 

• Typische Frage: Wie gross ist die Weizenmenge nach 

n Jahren, wenn der minimale Katzenbestand k beträgt? 

→ Werden mehr Katzen benötigt? 

→ Kann man Anbauflächen stilllegen? 

McAdvisor&Co mit einem 

Gutachten beauftragen! 

656 

Abhängigkeiten in der Miniwelt 

• Komplexe kausale 

Abhängigkeiten 

• Rückkoppelungen, 

Regelkreise 

• Zeitliche Fernwirkungen 

→ „Regelkatastrophen“ 

• Dennoch stark vereinfacht 

gegenüber der Realität 

• Bevölkerungswachstum 

• Anbautechnik 

• Ernteschwankungen 

• Marktpreise 

• Essgewohnheiten 

• Gentechnik 

• Biosprit 

• … 

657 

270

Abhängigkeiten in der Miniwelt 

• Hier ist die Semantik der 

Pfeile noch etwas „diffus“ 

• Ist also keine vollständige 

Problemspezifikation! 

• In analytisch-mathematischer 

Weise lassen sich solche 

Probleme kaum oder gar 

nicht mehr behandeln 

• Simulation ist die geeignete 

Problemlösungstechnik 

658 

Das Modell 

Ein Unternehmensberater von 

McAdvisor&Co analysiert das 

Weizenproduktionssystem und 

führt in seinem management 

summary sieben key findings auf: 

a) Jede Maus frisst monatl. 15 kg Weizen. 

b) 1/12 aller Mäuse und 1/120 aller 

Katzen sterben jeden Monat an 

Altersschwäche. 

c) Wenn die Scheune leer ist, sterben 

alle Mäuse; allerdings wandern dann 

20 neue von aussen ein. 

d) Falls mehr als 100 kg Weizen pro 

Maus vorhanden ist, verdoppelt sich 

deren Anzahl monatlich. Ansonsten 

beträgt die Anzahl der monatlichen 

Geburten: Weizenmenge/100. 

e) … 

659 

271

Das Modell (2) 

d) … 

e) Falls mehr als 50 Mäuse/Katze 

existieren, frisst jede Katze 30 Mäuse 

pro Monat. Sonst werden monatlich 

30×Mäusezahl/50 gefressen. 

f) Bei < 25 Mäuse/Katze verhungern 

(25×Katzen - Mäuse) /50 Katzen. 

g) Falls mehr als 50 Mäuse/Katze existieren, 

produziert jede (weibliche!) 

Katze im März und September 6 

Junge. Bei weniger als 25 

Mäuse/Katzen werfen die Katzen 

nicht. Ansonsten werden 

3×(Mäuse/25 - Katzen) Junge 

geboren. 

660 

Zeitgesteuerte Simulation des 

Weizen-Mäuse-Katzen-Problems 

• Diskretes Zeitraster, d.h. die Simulationszeit „springt“ 

• Wie gross sollte man ∆t wählen? 

• Ist ∆t = 1 Monat vernünftig? 

• Aber ist der Weizenverbrauch 

nicht nahezu kontinuierlich? 

• Bei jedem Zeitschritt ∆t 

ändern sich die Grössen 

• Weizenmenge (∆ weiz) 

• Mäusezahl (∆ maus) 

• Katzenzahl (∆ katz) 

T = T + ∆t 

• Verlauf der drei Kenngrössen als Funktionsgraph darstellen 

661 

272

Monatliche Änderung der Weizenmenge 

a) Jede Maus frisst 15 kg 

Weizen pro Monat. 

662 

Änderung der Mäusezahl 

Annahme: Nur 

ganzzahlige 

Werte (d.h. 

„integer“) für 

dmaus etc. 

b) 1/12 aller Mäuse … sterben jeden 

Monat an Altersschwäche. 

c) Wenn die Scheune leer ist, 

sterben alle Mäuse … 

d) Falls mehr als 100 kg Weizen 

pro Maus vorhanden ist, 

verdoppelt sich deren Anzahl 

monatlich. Ansonsten beträgt 

die Anzahl der monatlichen 

Geburten: Weizenmenge/100. 

e) Falls mehr als 50 Mäuse/Katze 

existieren, frisst jede Katze 30 

Mäuse pro Monat. Sonst werden 

monatlich 30×Mäusezahl/50 

gefressen. 

663 

273

Änderung der Katzenzahl 

f) Bei < 25 Mäuse/Katze verhungern 

(25×Katzen - Mäuse)/50 Katzen. 

b) … 1/120 aller Katzen sterben 

jeden Monat an Altersschwäche. 

Random[i:j] sei eine Zufallszahl zwischen i und j. 

Eine Interpretation von Modelleigenschaft b): 

Auch bei weniger als 120 Katzen stirbt gelegentlich eine davon 

„zufällig“ (aber warum eigentlich nicht mehr?). Dies ist 

umso wahrscheinlicher, je grösser die Zahl der Katzen ist. 

Oder sollte man das Modell „verstetigen“ und mit 

Bruchteilen von Katzen (und Mäusen) rechnen? 

664 

Änderung der Katzenzahl (2) 

g) Falls mehr als 50 Mäuse/Katze 

existieren, produziert jede 

(weibliche!) Katze im März und 

September 6 Junge. Bei weniger 

als 25 Mäuse/Katzen werfen 

die Katzen nicht. Ansonsten 

werden 3×(Mäuse/25 - Katzen) 

Junge geboren. 

Stellen die Flussdiagramme eine 

„perfekte“ Implementierung der 

Modellbeschreibung dar? 

Gibt es wesentlich andere Interpretationen 

der Spezifikation? 

Spiegelt das Modell die Realität 

ausreichend genau wider? 

665 

274

Das Steuerprogramm 

a) Wert von minkatzen eingeben (z.B. 10) 

b) Initialisieren: 

• weizen = 0; katzen = minkatzen; mäuse = 20; jahr = 1; monat = 6; 

c) In einer Schleife (bis z.B. jahr==10): 

• monat++ ; falls monat==13: {monat=1; jahr++} 

• Methoden („Unterprogramme“) aufrufen zur Bestimmung von: 

• dweiz 

• dmaus 

• dkatz 

• weizen = max(0, weizen+dweiz) 

• mäuse = max(20, mäuse+dmaus) 

• katzen = max(minkatzen, katzen+dkatz) 

wieso? 

Ist hier eigentlich die Reihenfolge 

der Neuberechnung der drei 

Kenngrössen entscheidend? 

Könnte weizen+dweiz < 0 sein? 

Was bedeutet das? 

• Ergebnis ausgeben (z.B. Kurvenverlauf oder Balkendiagramme) 

• Versuch evtl. wiederholen mit anderem minkatzen-Wert 

Sensitivitätsanalyse: Reagiert das Modell empfindlich auf kleine Änderungen? 

666 

Simulationsergebnis 

• Jedes dritte Jahr eine 

Hungersnot 

• Exponentielle Mäusevermehrung 

im Vorjahr 

• Erst kein Weizen, dann keine 

Mäuse, dann keine Katzen 

• Einfluss der Katzen (bei minkatzen=10) 

auf die Mäuseplage 

ist nicht ausreichend 

• Ohne Katzen wäre aber alle 

2 Jahre eine Hungersnot 

• Wie kann man Hungersnöte 

ganz vermeiden ? 

667 

275

Die Grenzen des Wachstums 


Standardlauf des Weltmodells 

von J.W. Forrester und 

D. Meadows (Die Grenzen 

des Wachstums, 1972) 

668 

Weltmodell von Forrester/Meadows (Ausschnitt) 

Quelle: Meadows, 

Abb. 26, pp. 88-91 

und François Cellier 

670 

276

671 

Ölkrise 1973 

• Schon ein Jahr später bekam man einen Vorgeschmack… 

– die Ölverknappung war allerdings nur politisch motiviert, 

und schon bald floss das Öl wieder in ausreichendem Masse 

277

Deutschland 

USA 

278

„Mit ‚Die Grenzen des Wachstums‘ legte der Club of Rome 1972 die heilige Schrift aller 

Zukunftsskeptiker vor. Die Computersimulation in Buchform war der erste Öko-Megaseller 

überhaupt und prägte das gesellschaftliche Klima der Siebziger wie kein anderes Werk. … 

Eine Publikation mit 160 Seiten und 48 Kurvendiagrammen, die zum erfolgreichsten und 

einflussreichsten Umwelt-Buch nach der biblischen Schöpfungsgeschichte wurde. … Die 

Hochrechnungen des MIT reichen von 1900 bis 2100 und untersuchen das Auf und Ab von 

fünf Werten: Erdbevölkerung, Industrieproduktion, Nahrungsversorgung, Rohstoffvorräte 

und Umweltverschmutzung. Aus vielen Einzelstudien schält sich eine Erkenntnis heraus: 

Nur wenn Pro-Kopf-Produktion und Bevölkerungszahl konstant bleiben und der Ressourcenverbrauch 

auf ein Viertel schrumpft, kann die Menschheit 

der Katastrophe entgehen. In allen anderen Fällen drohen im 21. 

Jahrhundert globale Hungersnöte und der Zusammenbruch der 

Industriekapazität. … Am 2. März 1972 erscheint in den USA 

‚The Limits to Growth‘, die 160 Seiten starke Vorabversion des 

Projektberichts. Die deutsche Fassung ‚Die Grenzen des Wachstums‘, 

die zwei Monate nach der amerikanischen herauskommt, 

wird ... ein Bestseller. Die Botschaft vom ‚Nullwachstum‘ verbreitet 

sich rasant, und im Oktober 1973 erhält der Club of Rome 

den Friedenspreis des deutschen Buchhandels. … Weltweit wird 

‚The Limits to Growth‘ in 37 Sprachen übersetzt und mehr als 12 

Millionen mal verkauft. Zum einen trifft das Werk den Zeitgeist: 

... im Juni 1972 tagte in Stockholm die erste Umweltkonferenz 

der Vereinten Nationen. Zum anderen verknüpfte es den Mythos 

vom allwissenden Computer mit der Aura des Zirkels weiser 

Männer, als den man den Club of Rome wahrnimmt.“ 

(Ralf Bülow: Apokalypse aus dem Computer, einestages.spiegel.de) 

675 

Die Grenzen des Wachstums 

„Warten wir nicht seit 30 Jahren, bequem in den Fernsehsessel gelümmelt, auf die 

Katastrophe? Seit 1972 sagen der Wissenschaftler Dennis Meadows und seine 

Kollegen Schlimmstes vorher. Dabei ist das Bier hierzulande immer noch schön kühl, 

und die Erde dreht sich… 

Damals stürmte die These vom nahen, selbstverschuldeten 

Untergang der Menschheit die Bestsellerlisten… Zum ersten 

Mal hatten Autoren den Mut und die argumentative Stärke, 

um mit Vehemenz auf die Endlichkeit der Erde aufmerksam 

zu machen. Und das zeigte glücklicherweise Wirkung: Sie 

verstärkten die Aufbruchsstimmung der 1980er Jahre, in 

denen sich die Grünen gründeten. Sie bereiteten den Boden 

für den internationalen Umweltschutz. Und sie brachten die 

Ökonomen dazu, über Wirtschaften ohne Wachstum 

nachzusinnen.“ 

Petra Pinzler in „Die Zeit“ Nr. 19 vom 30. April 2008 

676 

279

Eine weitere Simulationsanwendung 

Systemspezifikation der telefonischen Ticketreservierung 

eines Reisebüro-Call-Centers: 

677 




678 

280




1) 5 Angestellte nehmen Buchungen entgegen 

2) 18 Telefonleitungen (d.h. max. 13 Anrufer warten) 

3) „Bitte warten“, wenn alle Angestellten belegt 

4) Angest. wird frei → am längsten wartenden Anrufer bedienen 

5) Wartebereitschaft normalverteilt mit Mittel 4 Minuten 

6) Endgültiger Verzicht eines Kunden, wenn keine Leitung frei 

oder wenn Wartebereitschaft überschritten 

7) Zwischenankunftszeiten exponentialverteilt (20 Sek.) 

8) Bedienzeit exponentialverteilt 

(mit Mittel 1 Min. bei „one way“, 2 Min. bei „round trip“) 

9) Wahrscheinlichkeit für round trip = 0.75 

679 

Systemspezifikation 

Warteschlange der Anrufer 

18 Telefonleitungen 

Anruf 

(alle 20s 

im Mittel) 

Wartegeduld 

begrenzt 

(4 Min im Mittel) 

5 Angestellte 

(Bedienzeit pro Kunde im 

Mittel 1 Min oder 2 Min) 

680 

281

Typische Fragestellungen für 

Simulationsexperimente 

1) Mehr Angestellte → Kosten / Nutzen? 

2) Ausfall von Angestellten → Konsequenzen? 

3) Wie wirkt sich eine Verkürzung der Bedienzeiten 

von 60 Sek. auf 55 Sek. aus? 

4) Musik in der Warteschleife lässt Kunden 25% länger 

warten; Konsequenzen für die Systemleistung? 

5) Bei einer 50%igen Steigerung der Anrufrate: 

Wie wirkt sich das auf Auslastung, Anzahl bedienter 

und Anzahl verärgerter Kunden aus? 

681 

Simulationsexperiment zur 

Analyse der Systemleistung 

• Zu bestimmende Leistungsparameter: 

• Mittlere Wartezeit der Anrufer? ( ca. 70 Sekunden) 

• Auslastung der Angestellten? 

( ca. 91%) 

• Auslastung der Leitungen? 

( ca. 45%) 

• Anteil sofort bedienter Anrufe? 

( 15800 = 88%) 

• Anzahl „verzichtender“ Kunden? 

( 2160) 

• Anteil der „besetzten“ Anrufe? 

( 161 von ca. 18000) 

Ergebnis nach 100 Stunden Simulationszeit 

(= simulierter Zeit) 

682 

282

Call-Center zeitgesteuert simulieren? 

• Prinzip: 

• Simulationsuhr pro Simulationsschritt um ∆t erhöhen 

• Alle „realen“ Zustandsänderungen im Intervall 

[T, T+∆t] zum simulierten Zeitpunkt T+∆t nachbilden 

• Bei jedem einzelnen Schritt prüfen und (mit Simulationszeitpunkt) 

für die Auswertung festhalten: 

• Sind „zwischenzeitlich“ Anrufe gekommen? 

• Sind Bediener freigeworden? 

• … 

683 

Wahl von Δt? 

• ∆t = 1 μs (Simulationszeit, nicht Rechenzeit!) 

→ Zustandsänderung ist sehr unwahrscheinlich 

→ Viele nutzlose Schritte 

→ 100 Stunden → 360 000 000 000 Schritte 

• ∆t = 1000 s 

→ Warteschlange hat „plötzlich“ ca. 50 Kunden! 

→ Alle Angestellten sind am Anfang lange unbeschäftigt 

→ Fehlerhafte Statistiken! 

• ∆t = 1 s 

→ Nur etwa in jedem zehnten Schritt geschieht etwas 

→ Wie „genau“ und gut ist dieser Kompromiss? 

Ereignisgetrieben geht dies 

genauer und effizienter! 

Überspringt automatisch Zeitintervalle, 

in denen nichts Relevantes geschieht. 

684 

283

Ereignisgesteuerte Simulation 

• Grundannahme: Zustand bleibt abschnittsweise 

konstant; es passiert nichts zwischen zwei Ereignissen 

• Zeit springt von Ereignis zu Ereignis 

• Nur Ereignisse ändern den Zustand 

• Typische Ereignisse 

bei Simulationen: 

„event 

• Anruf eines Kunden driven“ 

• Betreten eines Aufzuges 

• Anstellen an die Warteschlange 

• Bearbeitungsende eines Werkstücks 

Der Fortschritt der Simulation wird 

also nicht durch Ändern einer Simulationsuhr 

getrieben; statt dessen 

wird umgekehrt die Simulationsuhr 

und die Welt von den stattfindenden 

Ereignisse vorangetrieben 

Vgl. sehr schnelles „Vorspulen“ 

eines Videos bis zum nächsten 

Ereignis (z.B. Fussballtor) 

• Ereignis: 

• Hat einen Eintrittszeitpunkt 

• Bewirkt beim „Eintreten“ eine schlagartige Zustandsänderung 

685 

Was treibt die Welt voran? 

Raffael stellt in einem Eckfresko 

der Gewölbedecke 

der Stanza della Segnatura 

(Apostolischer Palast, Vatikan, 

Rom) einen „unbewegten 

Beweger“ (primus motor) 

dar, der nach der Metaphysik 

von Aristoteles die 

Welt antreibt. 

686 

284

Modellentwurf Reisebüro 

• Zustand des Modells („als Schnappschuss“): 

• Status (frei / beschäftigt) jedes Angestellten 

• Anzahl der freien Leitungen 

• Liste derzeit wartender Anrufer 

• Ereignisbedingte Zustandsübergänge 

• Aus Sicht eines individuellen Kunden: 

Oder genügt 

hier die Zahl der 

freien Angestellten? 

Ereignistypen: 

- Beginn Bedienung / Beginn Warten 

(nach Anruf) 

- Ende Warten 

(freie Bediener / abgelaufene Geduld) 

- Ende Bedienung 

690 

Der ereignisgesteuerte Simulationsablauf 

Der Initialzustand 

Ein erster „vorhergesehener“ 

Kundenanruf 

Zeit springt, getrieben 

durch das nächste Ereignis 

„Ereignisliste“: 

Menge der z.Z. 

vorgemerkten 

Ereignisse in Form 

von sogenannten 

„Ereignisnotizen“ 

Bedienungsende-Ereignis wird 

bereits bei Bedienstart vorgemerkt! 

691 

285

Der ereignisgesteuerte Simulationsablauf (2) 

Modellierung: Jeder 

erfolgte Anruf plant 

bereits den nächsten 

Kundenanruf ein 

Es gibt immer mind. 

ein vorgemerktes 

Anruf-Ereignis! 

Etc., bis zu folgendem Zustand: 

692 


Wartende Kunden 

Warteschlange wird 

durch das „Eintreten“ 

eines Anrufes erzeugt, 

falls der Kunde nicht 

sofort bedient wird, 

sondern warten muss 

693 

286


Warteschlange 

(verkettete Liste) 

Frühester Kunde (44) 

kommt als nächster dran 

Kunde 46 hat 

aufgegeben 

694 

Ereignisroutine 

„Kundenanruf“ 

Ereignisroutinen werden bei 

„Eintreten“ von Ereignissen 

des entsprechenden Typs 

ausgeführt 

Mit diesem „Trick“ wird 

das System am Leben 

gehalten: Immer wenn 

ein Kunde anruft, wird 

schon der nächste 

Anrufwunsch generiert 

Hier werden die relevanten 

Zustandsänderungen am 

Modell vorgenommen 

Mehr oder weniger viel 

Simulationszeit des Kunden 

und des Bedieners 

verbrauchen (d.h. „Bedienungsende-Ereignis“ 

für einen späteren Zeitpunkt 

vormerken) 

695 

287

Ereignisroutine 

„Bedienungsende“ 

Freigabe der 

Betriebsmittel 

696 

Ereignisroutine „Geduld-Ende“ 

697 

288

Methode „Bedienung“ 

Keine eigene Ereignisroutine; 

die Methode wird in den Ereignisroutinen 

„Kundenanruf“ und 

„Bedienungsende“ aufgerufen 

„Cancel“-Operation 

(vgl. Abstellen des 

Weckers, weil man 

schon vorzeitig 

aufgewacht ist) 

698 

Statistik und Animation 

• Evtl. weitere Aktionen in den Ereignisroutinen 

durchführen, um Statistikdaten sammeln 

• Evtl. auch „Animation“ durch Ausgabeanweisungen 

in den Ereignisroutinen, z.B.: 

• 08:17, Kunde 29 ruft an 

• 08:19, Kunde 26 wird bedient 

• 08:20, Bediener 3 beendet Bedienung von Kunde 24 

• 08:27, Kunde 28 gibt nach 5 Minuten entnervt auf 

Beachte, dass in einem so erzeugten „Ereignisprotokoll“ 

die Zeit monoton steigend ist! 

699 

289

Der Simulatorzyklus 

Mindestens eine erste 

Ereignisnotiz in die 

Ereignisliste einfügen 

Oder: UHR < Endezeitpunkt? 

Prinzip: 

• Führe die Aktion des 

jeweils (chronologisch) 

nächsten eingeplanten 

Ereignisses aus 

• Dabei können neue 

Ereignisse „entstehen“ 

Dies kann u.U. eine umfangreiche Manipulation 

von Datenstrukturen bedeuten! 

Evtl. neu einzuplanende 

Ereignisse in die 

Ereignisliste einfügen! 

700 

Ereignisgesteuerter Simulator 

Simulator enthält ausserdem noch 

Programmcode (Ereignisroutinen, 

Steuerung des Simulatorzyklus, 

Ausgabestatistik...) 

Ereignisnotizen in der Ereignisliste 

enthalten einen Eintrittszeitpunkt 

Simulationszeit („Uhr“) springt zum jew. nächsten Ereignis 

• Ausführung der zugehörigen Ereignisroutine, dabei: 

• Änderung des (globalen) Zustands 

• Evtl. Einplanen neuer Ereignisse (in der „Zukunft“) 

Simulatorzyklus 

701 

290

Quasi-Parallelismus 

• In der Realität gleichzeitig ablaufende Aktivitäten 

werden in der Simulation „stückweise“ sequentialisiert 

• Durch die Auflösung in Ereignisse (am Anfang und Ende 

von Teilaktivitäten) werden Aktivitäten zeitlich verzahnt 

• Beispiel: Zwischen Ankunftsereignis und Abgangsereignis 

eines Supermarktkunden (also während 

dieser mit Einkaufen als „Aktivität“ beschäftigt ist) 

betreten weitere Kunden den Supermarkt 

702 

Quasi-Parallelismus: Beispiel 

Kunde 1 

Eintritt 

Supermarkt 

Anstellen 

Käsetheke 

Verlassen 

Käsetheke 

Anstellen 

Kasse 

Verlassen 


Zeit in der 

Simulation 

Kunde 2 

Eintritt 


Anstellen 

Kasse 

Verlassen 


Kunde 3 

Eintritt Anstellen 

Supermarkt Käsetheke 

Verlassen 

Käsetheke 

Anstellen 

Kasse 

Verlassen 


Dauer der Simulation hängt vom 

Zeitbedarf der Ereignisroutinen ab 

Ausführungszeit („cpu“) 

der Ereignisroutinen 

des Simulators 

Ende der Simulation 

703 

291

Modellierung paralleler Aktivitäten 

• Die Modellierungskunst besteht darin, die Aktivitäten 

der Realität so in Ereignisse aufzulösen, dass 

• die Wechselwirkung zwischen den Aktivitäten auf die Ereignisse 

beschränkt bleiben; 

• die Ereignisse sich korrekt gegenseitig einplanen; 

• die zugehörigen Ereignisroutinen die Zustandsänderung des 

Modells korrekt wiedergeben; 

• das Gesamtverhalten die Realität adäquat widerspiegelt. 

Gibt es Ereignisse mit exakt gleichem Eintrittszeitpunkt? Soll es sie geben? 

(Wenn ja, dann sollte die Reihenfolge ihrer Bearbeitung keine Rolle spielen.) 

704 

Beispiele für das Einplanen von Ereignissen 

• Abfahren eines Autos an einer Kreuzung bewirkt 

Einplanung des Ankunftsereignisses zu einem 

späteren Zeitpunkt bei einer anderen Kreuzung 

• Ein Kassierer „würfelt“ das Bedienungsende des Kunden 

aus, sobald er einen Kunden anfängt zu bedienen 

• Ein beim Supermarkt eintreffender Kunde „würfelt“ den 

Ankunftszeitpunkt des nächsten Kunden aus 

Das ist ein sehr effektiver Trick: Auf diese 

Weise muss man nicht initial alle jemals 

eintreffenden Kunden als vorgemerkte 

Ereignisse in die Ereignisliste einfügen; 

es ist statt dessen immer nur der jeweils 

nächste eintreffende Kunde vorgemerkt! 

⇒ „Scheinkausalität“: 

In Wirklichkeit ist das Eintreffen 

eines Kunden nicht 

die Ursache für das Eintreffen 

eines weiteren Kunden! 

705 

292

Ereignisverwaltung 

Hier dargestellt als 

verkettete Liste, 

die nach Eintrittszeitpunkt 

sortiert ist 

Ereignisnotizen benennen 

den Eintrittszeitpunkt und 

die Ereignisroutine (d.h. 

den Ereignistyp) eines eingeplanten 

(d.h. noch auszuführenden) 

Ereignisses 

Die Ereignisliste speichert 

alle Ereignisnotizen und 

liefert auf Anforderung 

die früheste 

Ereignisroutinen enthalten Anweisungen zur Änderung des 

Modellzustands (und evtl. zum Einplanen weiterer Ereignisse, 

d.h. Einfügen neuer Ereignisnotizen in die Ereignisliste) 

706 

Ereignisliste als abstrakter Datentyp 

• Die Ereignisliste muss man nicht 

als verkettete Liste realisieren: 

Definiert durch die Wirkung 

der Operationen, nicht durch 

eine Implementierung 

• Insert fügt eine Ereignisnotiz in 

einen „abstrakten Behälter“ ein 

• Get_min soll die Ereignisnotiz mit 

kleinstem Zeitstempel der im Behälter 

z.Z. gespeicherten zurückliefern 

und diese aus dem Behälter 

entfernen (Exception falls Behälter leer) 

Eine Datenstruktur mit 

diesen beiden Operationen 

heisst „priority queue“ 

• Beispiel: Die Folge von Operationen 

insert(5); insert(2); insert(8); get_min; insert(4); insert(7); get_min; 

liefert: 2, 4 

707 

293

Auch ein abstrakter Behälter… 

„Der Kunde bedient hierbei einen zentralen 

Abgabe- und Abholautomaten. Nach Entrichten 

des Mietbetrags am Automaten wird 

durch ein automatisches Fördersystem ein 

leerer Behälter zur Aufnahme des Gepäcks 

bereitgestellt, in den der Reisende sein Gepäck 

einstellt. Nachdem dies erfolgt ist, 

fährt der Behälter ebenfalls automatisch in 

ein zentrales automatisiertes Lager, wo er 

für die Dauer der Aufbewahrung verbleibt. 

Für den Kunden ist dieser Vorgang nicht zu 

bemerken, was häufig zu Irritationen und 

Missverständnissen führt.“ de.wikipedia.org 

708 

Implementierung von priority queues 

1. Implementierung: Sortierte verkettete Liste 

• → insert benötigt O(n) Schritte 

(richtige Stelle finden und dort einfügen) 

• → get_min benötigt O(1) Schritte 

(vorderstes Element zurückliefern) 

Für ein „zufälliges“ 

Element (bei 

Gleichverteilung) 

n = Anzahl der Elemente 

in der Liste 

709 

294

Implementierung von priority queues 

2. Implementierung: Unsortierte verkettete Liste 

• → insert benötigt O(1) Schritte 

(z.B. vorne anfügen) 

• → get_min benötigt O(n) Schritte 

(kleinstes Element suchen und ausketten) 

3. Implementierung: Heap-Datenstruktur 

„partiell“ 

sortiert 

• → insert und get_min benötigen beide nur O(log n) Schritte 

! 

710 

15. 

Heaps 


- 833-852 (Heap, Heapsort) 

711 

295

Die Heap-Datenstruktur 

• Heap = Binärbaum mit 

• Alle Niveaus (bis evtl. auf das letzte) sind vollständig besetzt 

• Für alle Knoten k ≠ Wurzel: Wert(Vorgänger(k)) < Wert(k) 

(alternative Def. mit ≤, >, ≥ auch möglich) 

Min-Heap 

• Zwei Operationen: get_min und insert 

712 

Heaps vs. Suchbäume 

Ich 

< > 

kleiner 

als ich 

Suchbaum 

grösser 

als ich 

kleiner 

als ich 

Ich 

< < 

Max-Heap 

auch 

kleiner 

als ich 

grösser 

als ich 

Ich 

> > 

Min-Heap 

auch 

grösser 

als ich 

713 

296

Heap: get_min und insert 

Man überlege sich 

genau, dass das 

der Fall ist! 

6 

16 

12 

Für get_min und insert gilt: 

- Lässt Heap-Eigenschaft invariant 

-Benötigt O(log n) Schritte 

19 

get_min: 

• Wurzel entfernen 

• Letzten Knoten des untersten Niveaus 

an die Wurzelposition setzen 

• Neue Wurzel so weit wie möglich nach 

unten sinken lassen: Mit kleinerem der 

beiden Nachfolger vertauschen; dies 

rekursiv (oder iterativ) auf entsprechenden 

Unterbaum anwenden 

insert: 

Im Unterschied zur Implementierung 

von priority 

queues als sortierte / unsortierte 

verkettete Liste! 

• Als neues Blatt auf unterstem 

Niveau einfügen 

• Soweit wie möglich nach oben 

wandern lassen: Iterativ mit 

Vorgänger vertauschen, wenn 

dieser grösser 

714 

Heaps niveauweise als Array 

• Wurzel hat Array-Index 1 

• Direkte Nachfolger eines Knotens mit Index i haben 

die Indizes 2i und 2i+1 (sofern vorhanden) 

Beispiel für einen Heap, der so 

„niveauweise“ gespeichert ist 

Niveau 1 2 3 4 … 

• Dadurch ist Aufsteigen / Absteigen entlang eines 

Pfades bei get_min / insert besonders einfach! 

• Halbieren / Verdoppeln von Indizes 

715 

297

Heap: Implementierung von „insert“ 

Als neues Blatt auf 

unterstem Niveau 

einfügen. 

Soweit wie möglich 

nach oben wandern 

lassen: Iterativ mit 

Vorgänger vertauschen, 

wenn dieser 

grösser. 

void insert (int x) { 

int k = ++N; 

a[0] = -1; 

while (a[k/2] >= x) { 

a[k] = a[k/2]; 

k = k/2; 

} 

a[k] = x; 

} 

N bezeichnet die Anzahl der 

gespeicherten Elemente 

Ein „Trick“, damit die Schleife 

immer verlassen wird 

Wird evtl. abgerundet 

Pfad hochwandern… 

• Trick a[0]=-1 klappt nur, wenn keine negativen Werte eingefügt werden! 

• Beachte: Bei Ersetzen von k/2 durch k-1 erhält man insertion-sort 

⇒ Interpretation: Beim Heap wird insertion-sort entlang eines einzigen Pfades 

angewandt; dieser hat nur eine Länge von O(log n) 

Denkübung: Was geschieht, wenn man ein schon gespeichertes Element noch mal eingefügt? 

716 

Heap: „get_min“ 

int get_min() { 

int k = 1; int j; int x = a[1]; 

} 

a[1] = a[N--]; 

int w = a[1]; 

while (k

Weitere Anwendungen von Heaps 

• Betriebssysteme 

• Job-Scheduling: Job mit höchster Priorität zuerst 

• Suchverfahren 

• Aussichtsreichstes Teilproblem zuerst bearbeiten 

• Spielbaumanalyse 

• Besten Zug zuerst analysieren 

• Codierungstheorie / Dateikomprimierung 

• Kurze Codewörter für häufigste Zeichen („Huffman-Code“) 

718 

Heapsort 

• Sortieren mit einem Heap: 

1) n Elemente (der unsortierten Folge) einzeln einfügen 

2) danach n mal get_min auf den Heap anwenden 

⇒ Sortierverfahren mit O(n log n) Worst-Case-Zeitkomplexität! 

• Man kann den Heap im Array selbst („in place“) aufbauen, indem der 

Heap von links heranwächst, während nacheinander Elemente des 

unsortierten Teils entfernt werden: 

Phase 1 

Heap aus bereits bearbeiteten Elementen 

Unsortierte Resteingabe 

• Anschliessend wird der Heap schrittweise abgebaut und das jeweils 

entfernte Element an eine im freigeräumten Bereich heranwachsende 

sortierte Folge angefügt: 

Phase 2 

Rest-Heap (mit get_min abgebaut) 

Bereits sortierter Teil 

721 

299

Animation ► 

722 

Animation 

http://de.wikipedia.org/wiki/Image:Sorting_heapsort_anim.gif 

723 

300

Heapsort-Beispiel – Phase 1 

1 2 

Ausgangszustand: unsortiertes Array 

Nach Phase 1: der aufgebaute Heap 

(hier: grösstes Element an der Wurzel links) 

724 


1 2 

Ausgangszustand: unsortiertes Array 

Nach Phase 1: der aufgebaute Heap 

(hier: grösstes Element an der Wurzel links) 

725 

301


Neue Wurzel so 

weit wie möglich 

nach unten 

sinken lassen 

Letzten Knoten des 

untersten Niveaus 

an die 

Wurzelposition 

setzen 

3 4 

bereits 

sortierter 

Bereich 

Schnappschuss: Abbau des Heaps 

durch wiederholtes Entfernen der 

Wurzel (mit „Heap-Reparatur“) und 

Anfügen an den sortierten Bereich 

Das Endergebnis 

726 

Animation ► 

727 

302

Animation 

http://de.wikipedia.org/wiki/Image:Sorting_heapsort_anim.gif 

728 

Heapsort im Jahre 1974 

(Aus: Creative Computing Magazine) 


Heapsort wurde 

1964 entdeckt 

Die folgenden vier 

slides stellen lediglich 

eine „historische 

Kuriosität“ dar. 

Interessierte mögen 

aber Spass am „reverse 

engineering“ 

des Programms haben 

und nebenbei 

einen Eindruck der 

seinerzeit populären 

Programmiersprache 

„Basic“ bekommen. 

729 

303

010 REM. KNUTH/WILLIAMS/FLOYD HEAPSORT ALGORITHM. 

020 ! PAS '74 

030 DIM N(150),C$(150) 

040 PRINT 

050 PRINT 

060 PRINT "TYPE C FOR CHARACTER STRING SORT," 

070 PRINT "TYPE N FOR NUMBER SORT."; 

080 INPUT W$ 

090 N=0 ! START COUNT=N AT 0 

100 PRINT 

110 IF W$="N" THEN 480 

120 IF W$ "C" THEN 60 ! BAD REPLY 

130 REM ********* CHARACTER STRING SORT ROUTINE: ********* 

140 GOSUB 770 ! ASK FOR STOP CODE 

150 INPUT S$ ! GET STOP CODE 

160 PRINT 

170 N=N+1 ! INPUT LOOP: 

180 INPUT C$(N) 

190 IF C$(N)S$ THEN 170 

200 N=N-1 ! END OF INPUT... 

210 PRINT 

220 L=INT(N/2)+1 ! HEAPSORT PROPER: 

230 N1=N ! PRESERVE N, USE N1 

240 IF L=1 THEN 280 

250 L=L-1 

260 A$=C$(L) 

270 GOTO 320 

730 

280 A$=C$(N1) 

290 C$(N1)=C$(1) ! MOVE TOP OF HEAP TO END 

300 N1=N1-1 ! HEAP IS ONE SMALLER NOW 

310 IF N1=1 THEN 430 ! ONLY ONE LEFT? THEN WE'RE DONE. 

320 J=L ! NO, CONTINUE 

330 I=J 

340 J=2*J ! LOOK FOR "SONS" OF I 

350 IF J=N1 THEN 390 

360 IF J>N1 THEN 420 ! "N1" IS SIZE OF ACTIVE LIST 

370 IF C$(J)>=C$(J+1) THEN 390 ! CHOOSE LARGER "SON" 

380 J=J+1 

390 IF A$>=C$(J) THEN 420 

400 C$(I)=C$(J) 

410 GOTO 330 ! LARGER SON REPLACES PARENT 

420 C$(I)=A$ 

425 GOTO 240 ! END OF SORT... 

430 C$(1)=A$ 

440 FOR I=1 TO N 

450 PRINT C$(I) ! OR REVERSE ORDER: I=N TO 1 STEP -1 

455 NEXT I 

460 GOTO 60 

unwesentliche Teile hier weggelassen 

760 REM **********SUBROUTINE TO INPUT STOP CODE********** 

770 PRINT "PLEASE INDICATE A STOP CODE--SOMETHING NOT IN YOUR" 

780 PRINT "LIST, WHICH WILL ACT AS AN 'END OF LIST' SIGNAL: "; 

790 RETURN 

800 END 

731 

304

Hobby-Programmierer und Home-Computer- 

Nutzer der 1970er Jahre 

4 kB RAM; 

8-Bit cpu; 

1,77 MHz 

Stolze Mutter mit 

Kunsthaar-Perücke 

Regular coffee 

Kitchen TV (b&w) 

1249 BYTES FREE 

READY. 

? LOAD "HEAPSORT" 

PRESS PLAY ON TAPE 

SEARCHING 

FOUND HEAPSORT 

? LOAD 

READY. 

? LIST 280 

280 A$=C$(N1) 

290 C$(N1)=C$(1) Keine Kleinbuchstaben 

300 N1=N1-1 

310 IF N1=1 THEN 430 

320 J=L 

330 I=J 

340 J=2*J 

350 IF J=N1 THEN 390 

360 IF J>N1 THEN 420 

370 IF C$(J)>=C$(J+1) THEN 

380 J=J+1 

390 IF A$>=C$(J) THEN 420 

400 C$(I)=C$(J) 

Kassettenrekorder 

als Speicher 

Kein Drucker 

Kein Netzanschluss 

732 

Magnetband-Kassettenrekorder 

als Speichermedium 

733 

305

Heapsort Dance 

www.youtube.com/watch?v=ZbUbCe0WpBE 

734 

16. 

Parallele Prozesse 

und Threads 

The Java Tutorial (http://docs.oracle.com/javase/tutorial/), 

Lesson “Concurrency” (“Doing Two or More Tasks At Once”): 

http://docs.oracle.com/javase/tutorial/essential/concurrency/ 

742 

306

Prozesse 

Abstrakter: „Vorgang einer 

algorithmisch ablaufenden 

Informationsverarbeitung“ 

• Prozess = Programm in Ausführung 

• „Instanz“ eines Programms 

• Programm selbst ist passives Ding auf Papier oder in einer Datei 

• Es kann gleichzeitig mehrere Prozesse als verschiedene 

Instanzen des selben Programms geben 

• Z.B. mehrere aktive Web-Browser 

• Kontext eines Prozesses (zu einem Zeitpunkt) umfasst u.a.: 

• Aktuelle Position („Befehlszähler“) 

• Inhalt der CPU-Register 

Kontext wird oft einfach 

als Zustand bezeichnet 

• Werte aller Variablen 

• Inhalt des Laufzeitstacks (dynamische Aufrufsequenz) 

• Zustand zugeordneter Betriebsmittel (z.B. geöffnete Dateien) 

743 

Prozessverwaltung und Betriebsmittel 

• Ein Prozess benötigt Betriebsmittel („Ressourcen“) 

• CPU-Zeit, Hauptspeicher (RAM), Dateien... 

• Prozesse werden durch das Betriebssystem verwaltet 

• Gründen (z.B. im Auftrag anderer Prozesse) 

• Terminieren (dann Freigabe aller belegten Betriebsmittel) 

• Kontrolle des Ressourcenverbrauchs (Schranken, Monopolisierung) 

• Scheduling („suspend“, „resume“ etc. zum Multiplexen der CPU) 

• Mechanismen zur Synchronisation 

• Vermittlung von Kommunikation zwischen den Prozessen 

(z.B. Signale, Ereignisse oder Nachrichten) 

744 

307

Multitasking 

• Mehrere Aufgaben (tasks) quasi-gleichzeitig ausführen 

745 

Multitasking 

Hier: Prozesse, daher 

auch „Multiprocessing“ 


• Prozess unterbrechen; später fortsetzen 

• Multiplexen der CPU: time-sharing 

durch Zeitscheiben (Interrupt durch 

„timer“ erzwingt Freigabe der CPU) 

Prozesse in so kurzen Abständen 

immer abwechselnd aktivieren, 

dass der Eindruck 

der Gleichzeitigkeit entsteht 

747 

308

Multitasking 

Hier: Prozesse, daher 

auch „Multiprocessing“ 


• Prozess unterbrechen; später fortsetzen 

• Multiplexen der CPU: time-sharing 

durch Zeitscheiben (Interrupt durch 

„timer“ erzwingt Freigabe der CPU) 

Schnelles Hin- und Herschalten geht dann 

gut, wenn sich mehrere Prozesse bereits 

im Hauptspeicher befinden (und nicht 

erst jedes Mal geladen werden müssen) 

• Zweck: 

• Mehrere Abläufe der realen Welt gleichzeitig „kontrollieren“ 

• Bessere CPU-Nutzung: Während ein Prozess auf ein device wartet, 

kann ein anderer ausgeführt werden (in 10 ms Plattenzugriffszeit 

sind z.B. ca. 10 7 Maschineninstruktionen anderer Prozesse möglich) 

748 

Echt und quasi-gleichzeitige Abläufe 

(Nebenläufigkeit, „concurrency“) 

E/A-Geräte können 

meist „echt“ parallel 

zur CPU arbeiten 

• Optimierungsziel: 

möglichst alle Geräte 

(und die CPU) ständig 

beschäftigen bzw. einen 

möglichst hohen Überlappungsgrad 

erzielen 

749 

309

Prozesszustände 

• Von aussen gesehen kann ein Prozess in 2 Zuständen sein: 

resume 

läuft 

suspend 

wait 

Prozess wird von 

einem anderen 

Prozess suspendiert 

Ein Ereignis von 

aussen reaktiviert 

den Prozess 

blockiert 

Prozess versetzt 

sich selbst in den 

Wartezustand 

Z.B. Warten auf Fertigwerden der E/A 

oder Warten auf ein Synchronisationssignal 

eines anderen Prozesses 

750 

Prozesszustände: Verfeinerung 

• Bild verfeinern, wenn mehrere Prozesse quasi-gleichzeitig 

laufen: 

Von aussen (z.B. „kill 

interrupt“) kann ein 

Prozess von jedem 

Zustand in den 

„beendet“-Zustand 

versetzt werden 

• Zu einem Zeitpunkt ist stets nur ein einziger Prozess tatsächlich laufend; 

die lauffähigen warten darauf, ein bisschen CPU-Zeit zu bekommen 

• Zustandswechsel lauffähig („ready“) / laufend („running“) wird vom Betriebssystem 

(„Scheduler“) vorgenommen (ohne dass der Prozess selbst 

dies merkt: aus seiner Sicht geht es nur mal wieder sehr langsam voran) 

• Unterscheide „blockiert“ (fehlende Ressourcen zum Weiterlaufen) und 

„lauffähig“ (könnte, aber darf nicht weitermachen – wartet nur auf CPU) 

751 

310

Prozesskontrollblock 

• Prozesse werden durch das Betriebssystem verwaltet 

• Multiplexen der CPU („Scheduling“) 

• Überwachung des Ressourcenverbrauchs 

• Dazu wird für jeden Prozess ein Prozesskontrollblock (PCB, 

„Process Control Block“) angelegt, der alle notwendige 

Verwaltungsinformationen enthält 

• Eindeutige Prozessnummer 

• Scheduling-Zustand (blockiert, lauffähig...) 

• Programmzähler 

• Inhalt der Register 

• Priorität 

• Maximal erlaubte Hauptspeichernutzung 

• Zeiger auf verwendete Speicherbereiche und eigene Kind-Prozesse 

• Zeiger auf Betriebsmittel-Listen (z.B. geöffnete Dateien) 

• Rechte und Schutz-Information (z.B. zugehöriger „User“) 

• Abrechnungsinformation (Zeitlimit, verbrauchte Zeit, Startzeit,...) 

• ... 

752 

Prozesstabelle 

• Alle Prozesskontrollblöcke zusammen werden in einer 

Prozesstabelle gehalten 

PID 

1 

PCB 


Programmzähler 

2 

… 

n 

… 



Register 

Zustand 

Priorität 

Offene Dateien 

Adressraum 



Register 

Zustand 

Priorität 


Adressraum 

Benutzer 

… 

Register 

Zustand 

Priorität 


Adressraum 

Benutzer 

… 

Benutzer 

… 

753 

311

Kontextsicherung 

„laufend“ 

„lauffähig“ / „blockiert“ 

• Wird der laufende Prozess unterbrochen, muss der 

aktuelle Kontext des Prozesses gesichert werden; 

hierzu dienen diverse Felder im Prozesskontrollblock 

• Der Prozesskontrollblock enthält u.a.: 

• … 

• Programmzähler 

(wenn nicht laufend) 

• Inhalt der Register 

• … 

Wenn der Prozess wieder 

laufend wird, lädt 

das Betriebssystem 

dies in die CPU zurück 

754 

Kontextwechsel 

Prozess P 1 Betriebssystem Prozess P 2 

Interrupt 

Zustand in PCB 1 retten 

blockiert / 

lauffähig 

Zustand von PCB 2 laden 

laufend 

Zustand in PCB 2 retten 

Interrupt 

Zustand von PCB 1 laden 

755 

312

Kosten eines Kontextwechsels 

• Der zu sichernde Prozesszustand ist recht umfangreich 

• Hinzu kommen diverse Verwaltungsaktionen, die das 

Betriebssystem bei einem Kontextwechsel durchführt 

• Speicherbereich des neuen Prozesses vor Zugriffen 

anderer abschotten 

• Zugriffsberechtigung auf Ressourcen prüfen 

• … 

• Kontextwechsel ist daher relativ teuer 

• Kostet typischerweise einige zehntausend Instruktionen 

• Man kann sich nicht viele „Prozesswechsel“ pro Sekunde erlauben 

756 

Leichtgewichtsprozesse (Threads) 

• Threads („of control“) sind parallele Aktivitätsträger, 

die nicht gegeneinander abgeschottet sind 

• Laufen innerhalb eines gemeinsamen Adressraumes 

• Teilen sich gemeinsame Ressourcen 

• Kontextwechsel zwischen den Threads ist viel 

effizienter als Kontextwechsel zwischen Prozessen 

• Kein Adressraumwechsel 

• Kein automatisches Scheduling 

• Kein Retten / Restaurieren des Kontextes (Ausnahme: Register, 

Programmzähler etc. analog zu Unterprogrammaufruf) 

Dadurch anfällig 

gegenüber Programmierfehlern! 

Instruktionsteil 

gemeinsame 

Daten 

3 Threads in unterschiedlichen 

Stadien 

(Programmzähler) 

• Pro Zeiteinheit viel mehr Threadwechsel als Prozesswechsel möglich 

• Wichtig für Server (z.B. Datenbanken oder Suchmaschinen), die pro 

Sekunde tausende von Anfragen quasi-gleichzeitig bearbeiten müssen 

757 

313

Multithreading 

• Quasi-gleichzeitig mehrere Vorgänge innerhalb einer 

einzigen Anwendung erledigen 

• Oft angewendet bei 

interaktiven Programmen 

• Z.B. „endlose“ Animation, wobei Interaktion 

jederzeit möglich sein soll 

• Lösung: Zwei Threads (Animation 

und Verwalter der input buttons) 

Andere typische Anwendung: 

Window-Manager, der mehrere 

Fenster auf dem Display verwaltet 

• Ohne Multithreading müsste der einzige Kontrollfluss selbst 

schnell genug zwischen den Aufgaben hin- und herschalten 

• Dies dann entweder aktiv durch regelmässiges Nachfragen 

(„liegt jetzt eine Anforderung vor?“) 

• Oder durch Interrupts („bei Mausklick kurz mal etwas anderes machen“) 

• Dies ist i.Allg. ineffizient, komplex und fehleranfällig 

758 

Klasse java.lang.Thread 

• Konstruktor: public Thread() 

Hier nur ein Auszug; zu 

weiteren Aspekten vgl. 

die Java-Dokumentation 

(online bzw. in Büchern) 

• Methoden: 

- void start() 

- void suspend() 

- void stop() 

- void resume() 

- void wait() 

- void yield() 

- void sleep(int millis) // blockiert einige ms 

- void join() // Synchronisation zweier Threads 

- int getPriority() 

- void setPriority(int prio) 

- void setDaemon(boolean on) 

„Hintergrundprozess“: terminiert 

nicht mit dem Erzeuger 

759 

314

Programmstruktur eines Thread 

• Jeder Thread (genauer: jede von „Thread“ abgeleitete 

Klasse) muss eine void-Methode run() enthalten 

• Diese macht die eigentlichen Anweisungen des Thread aus! 

• „run“ ist in „Thread“ selbst nur abstrakt definiert 

• Ein typisches Gerüst für einen Thread: 

class Beispiel_Thread extends Thread { 

int myNumber; 

public Beispiel_Thread(int number) { // Konstruktor 

myNumber = number; 

} 

public void run() { 

// hier die Anweisungen des Thread 

} 

// hier weitere Methoden 

} 

760 

Erzeugen eines Thread 

(aus einem anderen Thread heraus) 

761 

315

Erzeugen eines Thread 

Beispiel_Thread m = new Beispiel_Thread(5); 

m.start(); 

Damit kann man auf den Thread zugreifen 

und diesen kontrollieren (z.B. m.suspend();) 

Mit dieser Nummer identifizieren 

wir einen Thread individuell; jeder 

Thread kennt „seine“ Nummer 

m = new... 

m.start() 

Kontrollfluss des Erzeugers 

Thread m (Methode „run“) 

• „Anonyme“ Erzeugung als Alternative: 

new Beispiel_Thread(5).start(); 

• Zusammenfassen der beiden Anweisungen (Gründen & Starten) 

• Dann aber keine Kontrolle möglich, da kein Zugriff auf den Thread 

762 

Ein Thread-Beispiel („Hin-Her“) 

• ***************** 

• Ein Thread „Hin“ schreibt Sterne; ein anderer Thread 

„Her“ löscht Sterne; beide arbeiten (quasi)parallel 

• Wer gewinnt den Sternenkrieg? 

767 

316


Nach einer Idee von 

Ralf Kühnel („Die Java- 

Fibel“, Addison-Wesley) 

• **************** **************** 

• Ein Thread „Hin“ schreibt Sterne; ein anderer Thread 

„Her“ löscht Sterne; beide arbeiten (quasi)parallel 

• Wer gewinnt den Sternenkrieg? 

public class HinHer { 

public static void main (String args[]) { 

System.out.print("********************"); 

} 

System.out.flush(); 

new Hin().start(); 

new Her().start(); 

} 

Ausgabe des durch „print“ gefüllten Puffers 

Kommt es dazu überhaupt noch? Oder behält 

„Hin“ die ganze Zeit über die Kontrolle? 

768 


class Hin extends Thread { 

} 

public void run() { 

try { 

while(true) { 

sleep((int)(Math.random() * 1000)); 

paint(); 

System.out.flush(); 

} 

} 

catch (InterruptedException e) {return;} 

} 

public void paint() { // Sterne hinzufügen 

System.out.print("****"); 

} 

class Her extends Hin { 

public void paint() { 

System.out.print("\b\b\b\b \b\b\b\b"); 

} 

} 

4 Leerzeichen („space“) 

Denkübung: Was geschieht, 

wenn ein Thread aufwacht, 

während der andere gerade 

mitten in „paint“ ist? 

Exception, falls während 

des sleep ein Interrupt 

ausgelöst wird 

Methode „run“ und damit 

den Thread beenden 

„Her“ erbt die Methode 

„run“ von „Hin“ 

Redefinition von „paint“: 

Sterne mittels backspace 

löschen 

769 

317

Das Backspace-Steuerzeichen \b 

Als „Steuerzeichen“ bezeichnet man diejenigen Zeichen eines Zeichensatzes, 

die keine darstellbaren Zeichen repräsentieren. Ursprünglich wurden sie zur 

Ansteuerung von Fernschreibern oder Textdruckern (analog zu elektrischen 

Schreibmaschinen) verwendet. Durch Steuerzeichen ist es möglich, Steuerungsbefehle 

für die Ausgabegeräte – z.B. Zeilenvorschub („line feed“), Wagenrücklauf 

(„carriage return“), Klingel – innerhalb des Zeichenstroms selbst zu übertragen. 

Steuerzeichen werden in Zeichenketten durch ein vorangestelltes „\“ codiert, z.B. 

\n („line feed“ bzw. „new line“) oder \b („backspace“). Letzteres bewegte bei 

klassischen Textdruckern den Druckkopf eine Position zurück; bei Displays soll 

der Cursor um ein Zeichen nach links rücken. 

Ob die Steuerzeichen allerdings durch das jeweilige Ausgabegerät (bzw. die 

Systemroutinen des Betriebssystems) wirklich „korrekt“ interpretiert werden und 

damit der gewünschte Effekt auftritt, kann Java nicht garantieren. Insbesondere 

dann, wenn nicht die Systemkonsole als Ausgabe verwendet wird, kann es daher 

geschehen, dass ein \b als „nicht druckbares Zeichen“ interpretiert wird und auf 

dem Display als □ dargestellt wird. 

770 

Thread-Steuerung 

• Ein Thread läuft (d.h. ist laufend oder lauffähig) so lange, bis 

• seine run-Methode zu Ende ist 

• er mit stop() abgebrochen 

wird (von aussen 

oder durch sich selbst) 

• Ein laufender Thread kann sich selbst 

• die CPU entziehen: yield() 

(Übergang in den Zustand „lauffähig“; wird automatisch wieder 

„laufend“, wenn keine wichtigeren Threads mehr laufen möchten) 

• schlafen legen: sleep(…) (wie suspend, aber 

automatisches resume nach gegebener Zeit) 

• anhalten: suspend() bzw. wait() 

• beenden: stop() 

• in der Priorität verändern: setPriority(…) 

Prioritäten: normal 5, 

minimal 1, maximal 10 

(anfangs: Priorität des 

erzeugenden Threads) 

771 

318

Thread-Steuerung (2) 

• Ein Thread kann einen anderen Thread t 

• starten: t.start() 

• anhalten: t.suspend() 

• fortsetzbar machen: 

t.resume(); 

• beenden: t.stop() 

• in der Priorität verändern: t.setPriority(…) 

hierzu ist eine 

Referenz auf den 

Thread notwendig 

• Beachte: stop, suspend und resume führen, unbedacht 

angewendet, zu unsicheren Programmen und sollte daher 

möglichst vermieden werden 

Vgl. auch: http://tinyurl.com/3dhrgfr 

772 

Stop is Being Deprecated 

Thread.stop is being deprecated because it is inherently unsafe. Stopping a 

thread causes it to unlock all the monitors that it has locked. (The monitors 

are unlocked as the ThreadDeath exception propagates up the stack.) If any 

of the objects previously protected by these monitors were in an inconsistent 

state, other threads may now view these objects in an inconsistent state. 

Such objects are said to be damaged. When threads operate on damaged 

objects, arbitrary behavior can result. This behavior may be subtle and difficult 

to detect, or it may be pronounced. Unlike other unchecked exceptions, 

ThreadDeath kills threads silently; thus, the user has no warning that the 

program may be corrupted. The corruption can manifest itself at any time 

after the actual damage occurs, even hours or days in the future. 

If you have been using Thread.stop in your programs, you should substitute 

that use with code that provides for a gentler termination. Most uses of stop 

can and should be replaced by code that simply modifies some variable to 

indicate that the target thread should stop running. The target thread should 

check this variable regularly, and return from its run method in an orderly 

fashion if the variable indicates that it is to stop running. 

773 

319

Stop is Being Deprecated (2) 

Thread.suspend is inherently deadlock-prone so it is also being deprecated, 

thereby necessitating the deprecation of Thread.resume. If the target thread 

holds a lock on the monitor protecting a critical system resource when it is 

suspended, no thread can access this resource until the target thread is resumed. 

If the thread that would resume the target thread attempts to lock 

this monitor prior to calling resume, deadlock results. Such deadlocks typically 

manifest themselves as "frozen" processes. 

As with Thread.stop, the prudent approach is to have the "target thread" poll 

a variable indicating the desired state of the thread (active or suspended). 

When the desired state is suspended, the thread waits using Object.wait. 

When the thread is resumed, the target thread is notified using Object.notify. 

http://docs.oracle.com/javase/1.5.0/docs/guide/misc/threadPrimitiveDeprecation.html 

774 


Auszug aus: Guido Krüger: Handbuch der Java-Programmierung. 

Addison-Wesley, 2004, ISBN 3-8273-2201-4 

Mit dem JDK 1.2 wurde die Methode stop als deprecated markiert, d.h., sie 

sollte nicht mehr verwendet werden. Der Grund dafür liegt in der potentiellen 

Unsicherheit des Aufrufs, denn es ist nicht voraussagbar und auch nicht definiert, 

an welcher Stelle ein Thread unterbrochen wird, wenn ein Aufruf von 

stop erfolgt. Es kann nämlich insbesondere vorkommen, dass der Abbruch 

innerhalb eines kritischen Abschnitts erfolgt (der mit dem synchronized- 

Schlüsselwort geschützt wurde) oder in einer anwendungsspezifischen Transaktion 

auftritt, die aus Konsistenzgründen nicht unterbrochen werden darf. 

775 

320


Die alternative Methode, einen Thread abzubrechen, besteht darin, im Thread 

selbst auf Unterbrechungsanforderungen zu reagieren. So könnte beispielsweise 

eine Membervariable cancelled eingeführt und beim Initialisieren des 

Thread auf false gesetzt werden. Mit Hilfe einer Methode cancel kann der 

Wert der Variable zu einem beliebigen Zeitpunkt auf true gesetzt werden. 

Aufgabe der Bearbeitungsroutine in run ist es nun, an geeigneten Stellen 

diese Variable abzufragen und für den Fall, dass sie true ist, die Methode run 

konsistent zu beenden. 

Dabei darf cancelled natürlich nicht zu oft abgefragt werden, um das Programm 

nicht unnötig aufzublähen und das Laufzeitverhalten des Thread nicht 

zu sehr zu verschlechtern. Andererseits darf die Abfrage nicht zu selten erfolgen, 

damit es nicht zu lange dauert, bis auf eine Abbruchanforderung reagiert 

wird. Insbesondere darf es keine potentiellen Endlosschleifen geben, in den 

cancelled überhaupt nicht abgefragt wird. Die Kunst besteht darin, diese gegensätzlichen 

Anforderungen sinnvoll zu vereinen. 

776 

Thread-Steuerung mittels stop und resume 

• Trotzdem sind stop, suspend und resume aber ganz bequem: 

class Spinner extends Thread // "endloser" Thread 

... 

void HitCancel() { 

Spinner.suspend(); // anhalten 

if (askYesNo("Wirklich abbrechen?","ja","nein")) 

Spinner.stop(); // abbrechen 

else 

Spinner.resume(); // weiter 

} 

... 

777 

321

Thread-Ende 

• Ein Thread ist beendet, wenn seine run-Methode 

beendet wird oder er durch „stop“ abgebrochen wird 

• Das Objekt eines beendeten Thread existiert weiter 

• Auf dessen Zustand kann also noch zugegriffen werden 

• Ein beendeter Thread kann mit start wieder neu loslaufen 

• Die run-Methode wird dann erneut ausgeführt 

• Methode join verwenden, wenn auf die Beendigung 

eines anderen Thread gewartet werden soll 

• Z.B. weil man auf die von ihm berechneten Daten zugreifen will 

778 

Warten auf einen Thread („join“) 

• Beispiel: Thread s wartet so lang, bis t beendet ist: 

• Alternativer Fall: Thread t ist zuerst fertig: 

In diesem Fall ist 

t.join bedeutungslos 

• Nach t.join ist in jedem Fall garantiert, dass t beendet ist 

779 

322

Wie lange ist ein Thread laufend? 

• Bis er sich beendet 

• „stop“ oder Ende von „run“ 

• Bis ein Thread höherer 

Priorität lauffähig wird 

• Übergang nach „lauffähig“ 

• Sofortiger Threadwechsel ist aber nicht garantiert! 

• Bis er in den „blockiert“-Zustand übergeht 

• Explizit mit „suspend“, „wait“, „sleep“ etc. 

• Evtl. implizit durch E/A (es ist aber nicht garantiert, dass ein auf 

E/A-wartender Thread die CPU tatsächlich für andere freigibt!) 

• Bis er mit „yield“ die Kontrolle dem Scheduler übergibt 

• Oder vom Scheduler zwangsweise die CPU entzogen bekommt 

Vom Lateinischen „schedula“, Diminutiv von „scheda“ (bzw. 

„scida“) für einen abgespalteten Streifen der Papyrusstaude, 

woraus dann auch das deutsche Wort „Zettel“ entstand 

Ein laufender thread wird 

von der CPU ausgeführt 

780 

Thread-Scheduling 

• Scheduling: Planvolle Zuordnung der CPU an 

die einzelnen Threads (jeweils für einige Zeit) 

• Genaue Scheduling-Strategie ist in Java nicht standardisiert 

• Kann jede VM-Implementierung für sich festlegen (und damit 

Eigenheiten des zugrundeliegenden Betriebssystems effizient nutzen) 

• Man darf sich daher nicht auf „Erfahrungen“ verlassen 

(konkret: nicht auf die Wirkung von Zeitscheiben oder Prioritäten) 

• Scheduling mit Zeitscheiben kann von 

der VM realisiert sein, muss aber nicht 

sonst sind Programme 

nicht deterministisch 

und nicht portabel! 

• Thread läuft dann längstens bis zum Ablauf der Zeitscheibe (i.Allg. 

zyklisches Scheduling unter Threads gleicher maximaler Priorität) 

781 

323

Prinzip eines zyklischen Zeitscheiben-Schedulers 

… 

while (true){ 

if (current != last) 

next = current + 1; 

else 

next = 1; 

threadlist[current].suspend(); 

threadlist[next].resume(); 

current = next; 

sleep(TIMESLICE); 

} 

Der „System Idle“-Prozess nutzt die CPU am meisten 

• Der Scheduler selbst sollte mit höchster Priorität laufen 

• Der „System Idle“-Prozess mit niedrigster Priorität 

• Was ist bei Endlosschleifen in anderen Threads? 

• Ist generell garantiert, dass der Scheduler nach Ablauf 

der Zeitscheibe wieder die Kontrolle erhält? 

782 

Prioritäten 

• Implementierungsvorgabe: Ein Thread-Scheduler 

soll Threads mit höherer Priorität bevorzugen 

• Priorität entspricht initial der des Erzeuger-Thread 

• Priorität kann verändert werden (setPriority) 

• Wenn ein Thread mit höherer Priorität als der gegenwärtig ausgeführte 

lauffähig wird, wird der gegenwärtige i.Allg. unterbrochen 

• Typische Verwendung von Prioritäten: 

• Niedrige Priorität für dauernd laufende „Hintergrundaktivitäten“ 

• Höhere Priorität für seltene aber wichtige Ereignisse 

(Benutzereingaben, Unterbrechungen...) 

• Prioritäten sollten besser nicht als Synchronisationsmittel 

(Erzwingen einer bestimmten Reihenfolge etc.) eingesetzt werden 

783 

324

Threads: Schwierigkeiten 

• Ein Thread mit Endlosschleife kann u.U. das ganze System 

blockieren (so dass andere Threads „verhungern“) 

• Daher eventuell rücksichtsvoll mit „yield“ dem Scheduler helfen 

• Ist insbesondere bei Systemen ohne Zeitscheiben wichtig 

• Bei Prozessoren mit mehreren CPUs bzw. Rechenkernen 

(„multicore“) könnten entsprechend viele Threads „echt 

gleichzeitig“ ausgeführt werden („multiprocessing“) 

• Schon deswegen kein Verlass, dass Synchronisation bzw. wechselseitiger 

Ausschluss, realisiert mittels Prioritäten, funktioniert! 

• Böses Erwachen, wenn ein solches Programm dann irgendwann 

einmal auf einem Multicore-Prozessor ausgeführt wird... 

784 

Threads: Schwierigkeiten (2) 

• Programmieren und „Debugging“ von Threads ist schwierig 

• Alle denkbaren verzahnten Abläufe („interleavings“) berücksichtigen 

• Menge der verzahnten Abläufe durch geeignete Synchronisation 

einschränken (nur „korrekte“ Abläufe zulassen) 

• Finden von Synchronisationsfehlern ist besonders mühsam 

(schlecht reproduzierbar; evtl. „Heisenberg-Effekt“!) 

• Portabilität ist bei dilettantischer Thread-Nutzung gefährdet 

• “The setPriority and yield methods are advisory. They constitute 

hints from the application to the JVM. Properly written, robust, 

platform-independent code can use setPriority() and yield() to 

optimize the performance of the application, but should not depend 

on these attributes for correctness.” 

785 

325

Parallele Threads auf dem Mars 


Mars Pathfinder Mission 1997 

786 

The Lander’s Computer Appeared to Reset Itself 

JET PROPULSION LABORATORY 

CALIFORNIA INSTITUTE OF TECHNOLOGY 

NATIONAL AERONAUTICS AND SPACE ADMINISTRATION 

PASADENA, CALIF. 

MISSION STATUS - 14 July 1997, 10:00 am PDT 

Mars Pathfinder's lander sent about an hour's worth of data to Earth last night – 

including portions of a 360-degree color panorama image – before the lander's 

computer appeared to reset itself, terminating the downlink session. 

787 

326

Software that Manages a Number of Different 

Activities Simultaneously 

MISSION STATUS - 14 July 1997, 10:00 am PDT 

Engineers are continuing to debug the 

reset problem, which appears to be related 

to software that manages how the 

lander's computer handles a number 

of different activities simultaneously. 

“Saturday night, we ‘serialized’ activities 

by having the lander do one thing at 

a time, whereas last night the lander 

was handling a number of activities 

when the reset occurred,” said Brian 

Muirhead, Mars Pathfinder flight system 

manager. “Tonight we will return to 

a ‘serialized’ approach to try to avoid 

the possibility of a reset.” The reset occurred 

at 1:06 a.m. PDT, about halfway 

through a planned two-hour downlink 

session. 

788 

Handle One Activity at a Time! 

MISSION STATUS - 15 July 1997, noon PDT 

Recent incidents in which the 

Pathfinder lander's computer reset 

itself were discussed by Glenn 

Reeves, flight software team leader. 

According to him, computer resets 

have occurred a total of four times 

duringthemission–onJuly5,10, 

11 and 14. The flight team has 

attempted to avoid future resets by 

instructing the computer to handle 

one activity at a time – ‘serializing’ 

activities – rather than juggling a 

number of activities at once. 

789 

327

Considering Changes in the Flight Software 

MISSION STATUS - 15 July 1997, noon PDT 

The team continues to trouble-shoot the 

problem by testing all of the sequences 

leading up to reset in JPL's Mars Pathfinder 

testbed; considering changes in 

the flight software that would allow for 

immediate recovery if the flight computer 

were to reset itself; and modifying 

operational activities to minimize data 

loss if a reset should occur again. “In a 

sense, the reset itself is not harmful 

because it brings us back into a safe 

state,” said Reeves. “But it does cause a 

disruption of the operational activities.” 

790 

The Task Had Not Been Given High Enough Priority 

MISSION STATUS - July 17, 1997, 11 am PDT 

Mars Pathfinder engineers... also noted that they have found and are in the 

process of fixing a software bug that had caused the lander's computer to 

reset itself four times in recent days. 

“The resets on the lander computer 

were caused by a software task that 

was unable to complete the task in the 

allotted time,” said Flight Director 

Brian Muirhead. “We found that the 

task was being cut short because it had 

not been given high enough priority to 

runthroughtocompletion.Basically, 

we just need to add one instruction to 

the computer software to raise the 

priority of that task.” 

791 

328

The Problem was Reproduced and Isolated 


The problem was reproducedandisolatedintesting 

at JPL. Further tests 

and verification will be 

completed today and tomorrow, 

with radio transmission 

of a software patch 

to change the lander's software 

scheduled for Saturday, 

Muirhead said. 

792 

Sent a Software Update to Mars 


The team... also sent a software 

update to correct sequences onboard 

the flight computer which 

have caused it to automatically reset 

itself. 

MISSION STATUS – 

July 24, 1997, 2:30 pm PDT 

Flight Director Dave Gruel reported 

that no further flight software resets 

have occurred since the team sent 

modified flight software... 

793 

329

Andere Softwarefehler im Weltraum 

• 22. Juli 1962, Cape Canaveral / Florida: 

Start der ersten amerikanischen 

Venussonde „Mariner 1“ 

• Ausschnitt aus dem FORTRAN- 

Programm zur Steuerung der 

Flugbahn der Trägerrakete 

• Der Start scheiterte. Die Trägerrakete 

Atlas Agena B kam vom Kurs ab und 

wurde 290 Sekunden nach dem Start 

durch Funkbefehl gesprengt. Wer erkennt 

den simplen Programmierfehler? 

IF (TVAL .LT. 0.2E-2) GOTO 40 

DO 40 M = 1, 3 

W0 = (M-1)*0.5 

X = H*1.74533E-2*W0 

DO 20 N0 = 1, 8 

EPS = 5.0*10.0**(N0-7) 

CALL BESJ(X, 0, B0, EPS, IER) 

IF (IER .EQ. 0) GOTO 10 

20 CONTINUE 

DO 5 K = 1. 3 

T(K) = W0 

Z = 1.0/(X**2)*B1**2+3.0977E- 

4*B0**2 

D(K) = 3.076E- 

2*2.0*(1.0/X*B0*B1+3.0977E- 

4**(B0**2-X*B0*B1))/Z 

E(K) = 

H**2*93.2943*W0/SIN(W0)*Z 

H = D(K)-E(K) 

5 CONTINUE 

10 CONTINUE 

Y = H/W0-1 

40 CONTINUE 

DO 5 K = 1.3 (statt 1,3) wurde vom 

Compiler als Zuweisung von 1.3 an 

die Variable DO5K verstanden! 

794 

Race conditions [Wettlaufsituationen] 

802 

330

Race conditions bei Threads 

• Threads kommunizieren über gemeinsame Variablen 

• „shared variables“ 

• Dabei kann es zu unterschiedlichen Ergebnissen kommen, 

je nachdem, welcher Thread zuerst bzw. zuletzt auf eine 

Variable zugreift 

• „race condition“ bzw. „hazard“ 

A 

B 

Wer hat das letzte Wort? Welcher Effekt ist hier wirksam? 

Wer zuerst kommt, mahlt zuerst – aber wer zuletzt lacht, lacht am besten 

Unbeabsichtigte Wettlaufsituationen 

sind ein häufiger 

Grund für schwer auffindbare 

Programmfehler; bezeichnend 

für solche Situationen 

ist nämlich, dass bereits die 

veränderten Bedingungen 

zum Programmtest zu einem 

völligen Verschwinden der 

Symptome führen können. 

de.wikipedia.org 

803 

Ein Beispiel für race conditions 

int x = 5; // initial 

Thread 1: 

{ y=x; y=y+1; x=y; } 

Thread 2: 

{ y=x; } 

Thread 3: 

{ y=x; y=y+5; x=y; } 

• Welches Ergebnis ist das richtige? 

• Ablauf ist nicht-deterministisch es gibt 

mehrere „gleich richtige“ (wie viele?) 

• Oder ist richtig nur das, was der Programmierer 

„eigentlich“ gemeint hat? 

Denkübung: was könnte bei 

echter Parallelität mit 2 oder 

3 CPU-Kernen passieren? 

804 

331

Race conditions bei Kontobuchung 

• Bsp.: Zwei parallele Threads nehmen Kontobuchung vor: 

Zeit 

• Kontobuchung des linken Threads geht verloren! 

• „lost update problem“ 

• Lösung? 

805 

Race conditions bei Kontobuchung (2) 

• Wie wäre es damit?: 

... 

Konto.Update(Betrag1+ 

Konto.Stand()); 

... 

... 

Konto.Update(Betrag2+ 

Konto.Stand()); 

... 

• Oder vielleicht jeweils Aufruf einer Methode „Buchung“?: 

void Buchung (... Konto, float Betrag) { 

float a = Konto.Stand(); 

Konto.Update(a + Betrag); 

} 

ist das eigentlich 

kommutativ? 

... 

Buchung(k, 300.00); 

... 

... 

Buchung(k, -154.23); 

... 

806 

332

Atomarität 

• Ist eine Java-Anweisung „atomar“? 

• Z.B.: Konto.Update(Betrag + Konto.Stand()); 

• Oder zumindest: Buchung(k, …); 

Auch dann gäbe es aber 

zwei mögliche Abläufe: 

Konto würde bei „unglücklicher“ 

Reihenfolge evtl. 

kurzzeitig überzogen! 

• Atomare Folge von Operationen 

• Während die Folge ausgeführt wird, werden keine anderen 

Operationen (quasi) gleichzeitig ausgeführt 

• Wenn die CPU mit der ersten Operation der atomaren 

Folge beginnt, arbeitet sie diese bis zur letzten ab, 

ohne zwischendrin etwas anderes („störendes“) zu tun 

• Unterbrechungen sind höchstens zwischen atomaren Folgen erlaubt 

807 

Relative Atomarität 

• Aber: „unkritische Dinge“ könnten eigentlich doch 

parallel zu einer atomaren Folge ausgeführt werden 

• Quasi „heimlich“? 

• Und was genau ist (in welchem Sinne?) unkritisch? 

• Teile eines ganz anderen Programms? 

• Auf den Kontostand nur lesend zugreifen? 

• Leere Schnittmenge bzgl. gemeinsamer / veränderter Variablen? 

„Atomar“ ist ein interpretationsbedürftiger relativer Begriff! 

808 

333

Inkonsistenzen 

• Durch die Nicht-Atomarität von Anweisungsfolgen kommt es 

bei paralleler Ausführung leicht zu unerwünschten Effekten 

• Z.B. inkonsistente Zustände, 

die widersprüchlich sind und 

nicht auftreten dürften 

Inkonsistenz [de.wikipedia.org]: Ein Zustand, in dem zwei Dinge, die beide 

als gültig angesehen werden sollen, nicht miteinander vereinbar sind. 

809 

Bauanleitung für Selbstbaumöbel? 

810 

334

811 

Inkonsistenzen: Beispiel 

(Animation einer Teilchenbewegung) 

Animationsthread: 

Eventthread: 

Objekt springt bei „reset“ (manchmal!) an eine 

falsche Stelle (x-Koordinate ist dann nicht Null) 

812 

335

Lieber Thread-Scheduler! 

Wie kann man Atomarität von Anweisungsfolgen erreichen? 

… 

x = 0; 

y = 0; 

… 

„Lieber Thread-Scheduler, bitte 

unterbrich mich jetzt nicht!“ 

… 

write(x,0) 

write(y,0) 

… 

„Danke, lieber Thread-Scheduler, du darfst 

mich jetzt gerne wieder unterbrechen!“ 

813 

Unterbrechungssperren auf 

Java-Ebene mittels Prioritäten? 

… 

int p = getPriority(); 

setPriority(Thread.MAX_PRIORITY); 

x = 0; y = 0; // kritischer Abschnitt 

setPriority(p); 

Ist das eine 

funktionierende 

und gute Lösung 

für Unterbrechungssperren? 

• Beachte: Auch bei einer „Unterbrechungssperre“ können 

durchaus andere Dinge parallel ablaufen 

• Der Systemprozess, wo der Thread-Scheduler eingebettet ist (z.B. die 

Java-VM), kann vom Betriebssystem zeitweise suspendiert werden 

• Ein Mehrkernprozessor könnte andere Threads „echt“ parallel ausführen 

• Die „Umwelt“ ändert sich auch während einer Unterbrechungssperre 

• Es kommt also darauf an, in welcher „Hinsicht“ 

Atomarität gewährleistet werden soll / kann! 

814 

336

Java: Nicht-Atomarität von double und long 

• Double- und long-Variablen sind 64 Bit lang 

• Auf 32-Bit-Prozessoren sind beim Schreiben bzw. 

Lesen jeweils zwei Speicherzugriffe nötig; diese 

sind zwischendrin unterbrechbar! 

• Bei zwei Threads, die auf die gleiche Variable 

zugreifen, kann es zu Inkonsistenzen kommen: 

Ergebnis entspricht nicht unbedingt einem 

möglichen Interleaving auf Sprachebene 

815 

Java: Nicht-Atomarität von double und long (2) 

"Programmers are 

cautioned always to 

explicitly synchronize 

access to shared double 

or long variables“ 

(The Java Virtual 

Machine Specification) 

Wie erreicht man Konsistenz, wenn es hardwaremässig 

keine atomaren Befehle zum Zugriff auf 64 Bits gibt? 

816 

337

Kritischer Abschnitt 

• Kritischer Abschnitt = Folge von Anweisungen, die 

bezüglich anderen „entsprechenden“ kritischen 

Abschnitten wechselseitig ausgeschlossen ist 

• D.h. während ein Thread im kritischen Abschnitt ist, darf kein anderer 

Thread einen entsprechenden kritischen Abschnitt betreten 

• Höchstens einer hat also die Erlaubnis 

• In einem kritischen Abschnitt werden diejenigen elementaren 

Operationen ausgeführt, die ungestört als 

Ganzes ausgeführt werden müssen 

• Z.B. Einfügen eines Elementes in den nächsten freien Array- 

Platz und Hochzählen der Variablen, die diesen Platz anzeigt 

• Oder: Zugriff auf ein exklusives Betriebsmittel in Konkurrenz 

zu anderen Prozessen (z.B. zu beschreibende Datei) 

817 

Kritischer Abschnitt: Anforderungsspezifikation 

• Das Problem besteht darin, ein „Protokoll“ zu entwerfen, 

an das sich dann alle Prozesse halten, und das die 

Semantik des kritischen Abschnitts (kA) realisiert 

• Was gehört zur Semantik des kA? 

• 3 Anforderungen: 

• Safety 

• Liveness 

• Fairness 

818 

338

Safety, Liveness, Fairness 

(1) Safety („nothing bad will ever happen“) 

Wenn ein Prozess im kA ist, dann kein anderer 

Das alleine genügt aber nicht; 

sonst wäre ein Protokoll, das 

keinem Prozess je den Zutritt 

erlaubt, korrekt! (Alle Verkehrsampeln 

auf Dauerrot 

machen Zürich sicher!) 

(2) Liveness („something good will eventually happen“): 

Wenn kein Prozess im kA ist, aber einige 

sich „bewerben“, dann kommt einer von 

diesen schliesslich in den kA 

Liveness ohne Safety 

ist auch wieder trivial! 

Gesucht ist eine Lösung, 

die Safety und zugleich 

Liveness erfüllt 

(3) Fairness 

Ein sich bewerbender Prozess darf 

nicht beliebig oft von anderen 

Prozessen übergangen werden 

Sonst könnten sich etwa 

zwei Prozesse abwechselnd 

das Recht zuspielen und 

einen dritten Prozess verhungern 

lassen 

819 

Java: das Synchronized-Konstrukt 

• Bei Java wird ein kritischer Abschnitt durch eine in 

{...}-geklammerte Anweisungsfolge mit vorangestelltem 

Schlüsselwort „synchronized“ spezifiziert: 

synchronized (xxx) { 

// Anweisung 1 

... 

// Anweisung n 

} 

Hier steht xxx für irgendeine 

Objektreferenz 

(„Sperrobjekt“; „lock“) 

• Meist wird xxx innerhalb der Anweisungsfolge verwendet 

• D.h. es handelt sich um das „kritische Objekt“, bezüglich 

dessen der wechselseitige Ausschluss realisiert sein soll 

• Es kann sich aber auch um irgendein stellvertretendes Sperrobjekt 

handeln, z.B. so deklariert: 

Object Sperre = new Object; 

820 

339

Wirkung von „synchronized“ 

• Alle bezüglich des gleichen Sperrobjektes synchronisierten 

kritischen Abschnitte schliessen sich wechselseitig aus 

• Wird automatisch durch die Java-VM garantiert 

• Beispiel: 

synchronized (Konto) { 

float a = Konto.Stand(); 

a = a + Betrag; 

Konto.Update(a); 

} 

Man versuche herauszufinden, 

was die Java- 

Sprachbeschreibung 

zur Fairness aussagt 

• Beachte: unkooperative Threads können aber weiterhin z.B. 

über die Objektreferenz (hier: „Konto“) auf das „gesperrte“ 

Objekt zugreifen und es „parallel“ manipulieren 

• Die richtige Verwendung des Sperrmechanismus 

liegt in der Verantwortung des Programmierers! 

821 

Beispiel für „synchronized“ 

Initial: int a = 1, b = 2; 

Thread 1: a = b; 

Thread 2: b = a; 

• Zuweisung ist nicht atomar! 

1. Lesen aus dem Hauptspeicher in 

In the absence of explicit synchronization, 

a Java implementation is free 

to update the main memory in an 

order that may be surprising. Therefore 

the programmer who prefers to 

avoid surprises should use explicit 

synchronization. 

(Java Language Specification) 

den Arbeitsbereich des Thread (u.a. Stack, CPU-Register...) 

2. Schreiben aus dem Arbeitsbereich in den Hauptspeicher 

• Daher sind drei Ergebnisse möglich: 

• a = 2, b = 2 (Thread 1 ganz vor Thread 2) 

• a = 1, b = 1 (Thread 2 ganz vor Thread 1) 

• a = 2, b = 1 (vertauschte Werte durch Interleaving!) 

iload_1 

istore_0 

iload_0 

istore_1 

822 

340

Beispiel für „synchronized“ (2) 

• Durch „synchronized“ kann der 3. Fall vermieden werden: 

Thread 1: synchronized(Sperre) {a = b;} 

Thread 2: synchronized(Sperre) {b = a;} 

• Synchronisation schränkt die Anzahl möglicher Abläufe ein 

• Auch bei Atomarität gibt es aber noch zwei unterschiedliche Abläufe 

• Denkübung: wie könnte man erzwingen, dass auf 

alle Fälle erst Thread 1 und dann Thead 2 läuft? 

Best practice is that if a variable is ever to be assigned 

by one thread and used or assigned by another, then 

all accesses to that variable should be enclosed in 

synchronized methods or synchronized statements. 

(Java Language Specification) 

823 

Synchronized-Methoden 

• Ganze Methoden können mit dem Attribut 

„synchronized“ gekennzeichnet werden: 

synchronized void Update (int betrag) { 

konto = konto + betrag; 

System.out.println(konto); 

} 

• Synchronized-Methoden wirken wie Synchronized- 

Anweisungsfolgen, die bzgl. „this“ als Sperrobjekt 

wechselseitig ausgeschlossen sind 

824 

341

Eine Denkübung zu Synchronized-Methoden 

public class … { 

int z = 0; 

public synchronized void Incr() { 

println(z++); 

} 

// Gründen von zwei parallelen Threads, 

// welche beide fortlaufend Incr aufrufen; 

} 

1) Ist ausser der Ausgabefolge 0,1,2,3,4,… noch 

eine andere möglich? 

2) Bei Weglassen von „synchronized“: 

a) Ist die Ausgabe dann immer aufsteigend sortiert? 

b) Können Werte doppelt ausgegeben werden? 

c) Können Werte dreifach ausgegeben werden? 

825 

Das Deadlock- 

Problem 

830 

342

831 

Deadlock („Verklemmung“) durch „synchronized“ 

 

 

 

 

Mit „Glück“ hätte das 

Scheduling der Threads 

so ausgesehen: 

(1) ; (4) ; Freigabe 

von A ; (2) ; (3) 

Auf Glück ist aber leider 

kein Verlass… 

Synchronisationsfehler 

sind schwer zu finden! 

• Thread 1 wartet auf Freigabe von B durch Thread 2 

• Thread 2 wartet auf Freigabe von A durch Thread 1 

Deadlock 

832 

343

Ein weiteres Problem: 

Der atomare Kontrolltransfer 

• Bei Nutzung von Threads taucht oft folgendes Problem auf: 

• Es soll („abwechselnd“) immer nur einer von n Threads laufen 

• Jeder Thread soll an einer gewissen Stelle die Kontrolle an 

einen bestimmten anderen Thread transferieren 

• Wenn die Kontrolle zurücktransferiert wird, dann soll genau an 

dieser Stelle weitergemacht werden 

• Wie implementiert man dies? 

833 

Lösung mit suspend / resume? 

• Idee: Alle bis auf jeweils einen Thread blockieren 

• Problem: T2 könnte unmittelbar nach T2.resume() loslaufen 

• T1.resume() würde dann verpuffen, da T1 noch nicht blockiert ist 

• T2 würde sich mit suspend() blockieren; 

• T1 läuft weiter und blockiert sich dann ebenfalls sofort mit der 

nächsten Anweisung Deadlock! 

834 

344

Lösung mit „synchronized“? 

Man hätte also gerne einen Mechanismus, 

der in atomarer Weise 

suspendiert und zugleich die 

Sperre freigibt (und damit einen 

anderen Thread lauffähig macht) 

wait / notify-Konzept von Java 

• Problem: Bei Blockierung durch suspend behält ein Thread alle Sperren 

• Nach suspend von T1 würde also T2 vor seinem „synchronized“ warten 

• Sowohl T1 als auch T2 warten aufeinander Deadlock! 

835 

Lösung mit wait / notify 

• Wait: passives Warten auf das Eintreffen einer Bedingung 

• Und in atomarer Weise gleichzeitig Freigabe der Sperre! 

• Notify: Benachrichtigen vom Eintreffen einer Bedingung 

• Dient neben der Synchronisation von Threads damit auch 

der Kommunikation zwischen Threads (in primitiver Form) 

• Wir diskutieren dieses Java-Konzept (und das generelle 

Synchronisationsproblem paralleler Prozesse) hier nicht 

genauer; in anderen Systemen gibt es für diesen Zweck 

noch eine Reihe weiterer Mechanismen 

! 

Moral: Umgang mit Parallelität 

erfordert mächtige und adäquate 

Konzepte (und grösste Sorgfalt!) 

836 

345

Das Ringen mit der Parallelität 

837 

Das Ringen mit der Parallelität 

838 

346

Das Bezwingen der Parallelität – 

eine Herkulesaufgabe 

839 

Resümee 

der Vorlesung 

844 

347

Resümee – Ziele der Vorlesung 

• Primär: Informatik-Grundbegriffe 

• Konzepte, Modelle, Problemlösungstechniken 

• Algorithmen und Datenstrukturen 

• Sekundär: Programmieren 

• Java 

• Auch: Techniken für qualitativ hochwertige Software 

• Strukturen (Objektorientierung...) 

• Qualitätsmerkmale 

• Korrektheit 

845 

Konzepte 

Java 

Korrektheitsnachweis (Invarianten und vollst. Indukt.) 

Robustes Programmieren 

Bäume 



Infix, Postfix, Operatorbaum, Stack 

Codegenerierung, Compiler, Interpreter 

Verzahnte und verwobene Einführung konzeptioneller 

Aspekte und programmiersprachlicher Konstrukte 

Polymorphie 

Suchbäume, Sortieren 

Backtracking 

Spieltheorie, Minimax, AlphaBeta 

Rekursives Problemlösen 

Effizienz, O-Notation 

Simulation (zeitgesteuert, ereignisgesteuert) 

Heap, Heapsort 

Pseudoparallelität 

Java: C-Level 

Java-Klassen als Datenstrukturen 


Java-VM als Bytecode-Interpreter 

Pakete 

Klassenhierarchie 

Abstrakte Klassen 

Exceptions 

Programmbeispiele dienen gleichzeitig der 

Einführung programmiersprachlicher Konstrukte 

und der Illustration von Informatikkonzepten 

Threads in Java 

847 

348

Anhang 

• In den ersten Übungen wird das „3n+1“-Problem erwähnt. 

Es stammt von Lothar Collatz (1910-1990). 

853 

Anhang 

854 

350

Anhang 

855 

Anhang 

856 

351

Anhang 

http://xkcd.com/ 

857 

GLAUBEN SIE ABER JA NICHT, 

DASS DAS SKRIPT ALLEIN ZUM 

BESTEHEN DER PRÜFUNG 

AUSREICHT! 

http://page.math.tu-berlin.de/~scherfne/Bilder/studium1.jpg 

937 

352

Informatik II 

(Studiengang Informationstechnologie und Elektrotechnik) 

Vorlesung FS 2013 

Friedemann Mattern 

Departement Informatik, ETH Zürich 

© F. Mattern, 2013 

353

2-up - ETH Zürich

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

Template löschen?

Als Template speichern?