Informatik I+II 001 - PDF Free Download

Informatik I+II, Vorlesungen im WS’04/05, SS’05 Barbara Hammer 11. Januar 2006 Inhaltsverzeichnis 1 Was ist Informatik?...

30 downloads 1351 Views 1MB Size Report

This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!

Report copyright / DMCA form

DOWNLOAD PDF

Informatik I+II, Vorlesungen im WS’04/05, SS’05 Barbara Hammer 11. Januar 2006

Inhaltsverzeichnis 1 Was ist Informatik? 1.1 Gebiete der Informatik 1.2 Algorithmen . . . . . . 1.3 Darstellung . . . . . . 1.4 Eine kurze Historie . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

1 . 2 . 3 . 6 . 10

2 Erste Schritte in Java 10 2.1 Hello World! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.2 Elementare Datenstrukturen und Operationen . . . . . . . . . . . . . . . . . . . . 14 2.3 Elementare Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 3 Eigenschaften von Algorithmen 22 3.1 Syntax und Semantik von Programmen . . . . . . . . . . . . . . . . . . . . . . . 22 3.2 Korrektheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.3 Komplexit¨at . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 4 Datenstrukturen 4.1 Boolesche Werte . . . 4.2 Ganze Zahlen . . . . . 4.3 Floating point . . . . . 4.4 Klassen und Methoden

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

37 38 42 46 53

5 Algorithmen fur ¨ abstrakte Datentypen 5.1 Arrays . . . . . . . . . . . . . . . . 5.2 Listen . . . . . . . . . . . . . . . . 5.3 B¨aume . . . . . . . . . . . . . . . . 5.4 Graphen . . . . . . . . . . . . . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

68 69 78 87 106

6 Algorithmenentwurf 6.1 Divide and Conquer . . . . . . 6.2 Dynamische Programmierung 6.3 Greedy-Verfahren . . . . . . . 6.4 Backtracking . . . . . . . . . 6.5 Randomisierte Verfahren . . . 6.6 Nebenl¨aufigkeit . . . . . . . . 6.7 Fehler . . . . . . . . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

126 126 127 131 132 133 135 147

. . . . . . .

. . . . . . .

. . . . . . .

7 Programmierstile 149 7.1 Imperativ – deklarativ – objektorientiert . . . . . . . . . . . . . . . . . . . . . . . 150 7.2 Ein paar Schlagworte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 7.3 Prolog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 8 Information 8.1 Entropie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2 Kodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.3 Kompression und Kryptographie . . . . . . . . . . . . . . . . . . . . . . . . . . .

168 168 170 176

9 Informationsverarbeitung im Rechner 9.1 Prozesse . . . . . . . . . . . . . . 9.2 Speicher . . . . . . . . . . . . . . 9.3 Filesystem . . . . . . . . . . . . . 9.4 IO . . . . . . . . . . . . . . . . . 9.5 Kern . . . . . . . . . . . . . . . . 9.6 Good bye! . . . . . . . . . . . . .

177 179 180 181 182 183 184

10 Literatur

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

186

1

1 Was ist Informatik? Informatik ist ein Kunstwort, das in den 60er Jahren f¨ur eine sich neu entwickelnde Disziplin geschaffen wurde: Informatik = Information + Automatik Es geht also um die automatische Verarbeitung von Information. Mit Hinblick auf den englischen Begriff Computer Science, also Computerwissenschaften, f¨ugen wir hinzu: es geht um die automatische Verarbeitung von Information mithilfe von Rechnern. Diese Erl¨auterung ist noch ziemlich abstrakt. Informatik umfaßt in diesem Zusammenhang tats¨achlich verschiedenste Bereiche. Anstelle einer Pr¨azisierung geben wir einige Beispiele an, die unterschiedliche Aspekte der Informatik beleuchten: • Ein handels¨ublicher Arbeitsplatzrechner basiert im Kern auf elektronischer Datenverarbeitung, d.h. auf der Festplatte oder im Arbeitsspeicher sind Informationen in sogenannten Bits, bin¨aren 0/1-Werten gespeichert. Die elektronischen Signale werden mithilfe elementarer Schaltungen, die auf den Computerchips angesiedelt sind und die elementaren Signale geeignet kombinieren, verarbeitet. Im Kern eines Computers steht also der Entwurf geeigneter elektronischer Schaltungen und Speicherbausteine, ein Bereich der Hardwaretechnik. • Ein u¨ blicher Nutzer eines Computers arbeitet nicht auf der im Zentrum des Computers stehenden elementaren Ebene, sondern in einer f¨ur ihn komfortableren Umgebung. Er spricht in der Regel nicht einzelne Bits an, sondern er speichert Informationen in Dateien (files), die in Verzeichnissen (directories) organisiert werden k¨onnen. Abl¨aufe im Rechner werden durch Prozesse und geeignete Prozessteuerung realisiert. Verantwortlich f¨ur die komfortable Nutzung des Computers ist das auf dem Computer installierte Betriebssystem, meist Linux, Windows oder Mac OS X. • Normalerweise stehen Rechner nicht einzeln auf dem Arbeitsplatz, sondern sie sind mit weiteren Rechnern vernetzt. Spezielle Dienste wie etwa die Vorhaltung der Heimatverzeichnisse oder die Speicherung von Rechnernamen sind h¨aufig zentral auf einem daf¨ur eingereichteten Rechner angesiedelt, der die anderen Computer im Netz bedient. Rechner k¨onnen u¨ ber das Internet miteinander kommunizieren. Diese Aspekte reichen in den Bereich der verteilten Systeme und Netzwerke. • Im Zusammenhang mit dem Internet und seinen Diensten, die vielen durch e-mails oder Web-Browsing gel¨aufig sind, stehen Fragestellungen wie etwa spezielle Internet-Programme, Darstellung von Informationen auf Web-Seiten, Web-Suche, aber auch Sicherheit der einzelnen Systeme gegen Missbrauch von aussen im Mittelpunkt. • Bei der Vernetzung und Verarbeitung von Informationen braucht man sich nicht auf den engen Bereich handels¨ublicher PCs zu beschr¨anken. Hinzu kommen z.B. Audio- und Videodaten in Multimediapplikationen, oder eine Vernetzung mit weiteren elektronischen Ger¨aten wie einem Handy, MP3-Player, . . . Informatikkomponenten in Gebrauchsger¨aten werden in den Bereichen eingebettete Systeme und ubiquita¨ re Programmierung betrachtet. • In einer Bibliothek sind die vorhandenen B¨ucher, Zeitschriften und sonstigen Werke (in einer Universit¨atsbibliothek z.B. Dissertationen oder Technical Reports) in einem Rechner gespeichert. Man kann innerhalb dieser Information nach Titel oder Autor suchen, neue Werke einf¨ugen, aussortierte Werke l¨oschen, ausgeliehene B¨ucher vermerken, . . . . Es geht hier um das strukturierte Vorhalten der Information, so daß Operationen wie die Suche nach

1 WAS IST INFORMATIK?

2

verschiedenen Kriterien m¨oglichst effizient m¨oglich sind. In der Praxis wird f¨ur die Speicherung derartiger Information meist eine Datenbank eingesetzt. • Der Einsatz von Rechnern in unterschiedlichsten Bereichen mit unterschiedlichsten Nutzeranforderungen bedingt Forschungsarbeiten im Bereich der Mensch-Maschine Kommunikation, um den Umgang mit Rechnern m¨oglichst intuitiv, einfach und nat¨urlich zu machen. Fragestellungen sind dabei etwa die M¨oglichkeit, Rechner durch nat¨urlichsprachige Eingaben zu steuern. • Die allermeisten klassischen Arbeiten auf Rechnern im Bereich der Informatik geschehen auf der Basis von Programmen in einer gegebenen Programmiersprache. In diesem Kurs werden wir die Programmiersprache Java kennenlernen. Im Programmierkurs, der in diesem Semester angeboten wird, haben Sie die Gelegenheit, die sehr wichtige Programmiersprache C zu lernen. • Das Gebiet des Compilerbaus besch¨aftigt sich mit den Techniken, aus den meist in Hochsprachen formulierten Programmen durch den Computer ausf¨uhrbare Maschinenbefehle zu generieren. • Egal welche Programmiersprache benutzt wird, im Zentrum der Programme stehen Abl¨aufe, die die auszuf¨uhrenden Prozesse abstrakt formalisieren und die Durchf¨uhrung der Einzelschritte regeln. Dieses ist das Gebiet der Algorithmik. • Wichtige Eigenschaften von Algorithmen, die einer genaueren Untersuchung bed¨urfen, sind deren Komplexit¨at, d.h. deren Speicherplatzbedarf und Laufzeit. Interessant ist allgemeiner, welche Probleme effizient mit Algorithmen gel¨ost werden k¨onnen, und welche Probleme machen oder sogar u¨ berhaupt nicht durch Rechner l¨osbar sind, die Bereiche der Komplexit¨atstheorie und Rekursionstheorie. • Zu einem gegebenen Programm sollte sichergestellt sein, daß es auch wirklich implementiert, was es soll. Methoden, dieses nachzupr¨ufen, offerieren Programmtests und pr¨azise Verifikation der Algorithmen.

1.1 Gebiete der Informatik Klassischerweise unterteilt man die Informatik in vier verschiedene, teilweise u¨ berlappende Gebiete, die sich in die oben bereits angedeuteten (und weitere) Teilaspekte gliedern: • In der Technischen Informatik geht es darum, wie man Rechner und Automaten entwirft, vernetzt und steuert. Wesentliche Aspekte sind der Entwurf m¨oglichst effizienter Schaltkreise und Rechnerchips, Speichermedien und -formate, Schnittstellen der einzelnen Rechnermodule und Peripherie, Vernetzung und Kommunikation, Effektoren und Robotik. Da die technischen und physikalischen Gegebenheiten der verwendeten Materialien ber¨ucksichtigt werden m¨ussen, grenzt die technische Informatik an Elektrotechnik und Physik. • In der Praktischen Informatik geht es um die Bereitstellung von Methoden, die dem Menschen die Kommunikation mit dem Rechner vereinfachen und ein Arbeiten am Rechner, wie wir es kennen bzw. kennen lernen, erm¨oglichen. Typische Aspekte sind Compilerbau, Programmiersprachenentwicklung, Internetprotokolle, Betriebssysteme, Softwaretechnik, Datenbanken und Oberfl¨achenprogrammierung.

1.2 Algorithmen

3

• In der Theoretischen Informatik geht es um die Definition, Untersuchung, mathematische Fundierung und Entwicklung von Algorithmen und Konzepten f¨ur die Informatik. Typische Fragestellungen besch¨aftigen sich mit Berechenbarkeit, Komplexit¨at, Verifikation, Kodierungstheorie, Algorithmentheorie. Die Theoretische Informatik baut in vielen Bereichen auf Techniken der Mathematik und Logik auf. • In der Angewandten Informatik geht es um die Anwendung der Informatik f¨ur konkrete Probleme wie etwa Medizin- und Bioinformatik, Geographische Informationssysteme, Multimediaapplikationen. Dieses grenzt nat¨urlicherweise an das jeweilige Anwendungsgebiet an. Diese vier Bereiche sind nicht disjunkt; typischerweise startet man in der Praxis von einem konkreten Problem, etwa dem Auftrag einer Bank, eine Finanzsoftware zu entwickeln, und ist dann mit allen Aspekten der Informatik konfrontiert: Formalisierung der zu automatisierenden Abl¨aufe, Planen, Bereitstellen und Vernetzen der Hardwarekomponenten, Einrichten einer Datenbank, Implementation der Algorithmen- und Abl¨aufe, Verifikation, Test und Dokumentation. Es ist also essentiell, als Informatiker von allen Bereichen Kenntnisse zu besitzen. Nicht nur in der Industrie, auch an Universit¨aten besch¨aftigen sich Forscher mit Gebieten, die alle vier Bereiche ber¨uhren; etwa in der Robotik hat man es vom Design der Hardware, der Programmierung von Basisfunktionalit¨aten und Kommunikation der Einzelteile, bis hin zum Entwurf von komplexen Algorithmen etwa zum autonomen Zurechtfinden in neuen Umgebungen zu tun. Weitere Aspekte, die teilweise in anderen Disziplinen angesiedelt, aber wesentlich durch die Informatik gepr¨agt sind und deren man sich als Informatiker bewußt sein sollte, sollten hier erw¨ahnt werden: ein wichtiger Punkt ist die Auswirkung der Informatik auf die Gesellschaft. Sei es durch die Effekte auf Arbeitspl¨atze (Bildschirmarbeitspl¨atze, Rationalisierung, Fertigungsstraßen, Computer-unterst¨utztes Arbeiten), sei es durch die Pr¨agung der Informationsgesellschaft durch das Internet, sei es durch den Einsatz von Computertechnik in Krisensituationen (Hochwassermanagement, Kryptosysteme f¨ur Geheimdienste). Diese Aspekte ber¨uhren unter anderem die Gesellschaftswissenschaften, Psychologie und Ethik.

1.2 Algorithmen Zentral f¨ur die Informatik ist der Begriff des Algorithmus. Das ist nichts anderes als eine Vorschrift f¨ur ein wie auch immer geartetes ausf¨uhrendes Medium, z.B. einen Computer oder eine Maschine, eine Anzahl von Operationen durchzuf¨uhren, die einen gew¨unschten Prozeß automatisieren. Ein sch¨ones Beispiel f¨ur einen Algorithmus ist ein einfaches Kochrezept: *************************************************************** Muffins: Verr¨ uhre 200 g Butter, 200 g Zucker, 4 Eier, 1 Pck Backpuler, 1 Pck Vanillezucker, 250 g Mehl, 3 Eßl. Rum und drei mittelgroße gesch¨ alte und zerteilte ¨ Apfel; f¨ ulle den Teig in Muffinf¨ ormchen; backe bei 175-200 Grad f¨ ur etwa 30 min; best¨ aube die Muffins mit etwas Puderzucker *************************************************************** Folgt man diesen umgangssprachlich formulierten Anweisungen, erh¨alt man das erw¨unschte Ergebnis, fertige Muffins. Dieses Rezept formalisiert durch eine Folge von Anweisungen also den

1 WAS IST INFORMATIK?

4

Prozeß des Muffin-Backen. Ein Algorithmus in der Informatik ist nichts anderes als eine u¨ blicherweise in einer vorgegebenen Programmiersprache formalisierte Folge von Anweisungen, die Prozesse der Informationsverarbeitung operationalisieren, z.B. das Sortieren gegebener Zahlen aufsteigend nach der Gr¨oße. Unser Rezept ist von einer sehr einfachen Form, denn es besteht lediglich aus einer Aneinanderreihung einfacher elementarer Anweisungen. Komplexere Algorithmen k¨onnen weitere Strukturen enthalten. Wichtige Konstrukte sind bedingte Anweisungen, etwa: *************************************************************** Muffins: Verr¨ uhre 200 g Butter, 200 g Zucker, 4 Eier, 1 Pck Backpulver, 1 Pck Vanillezucker, 250 g Mehl, 3 Eßl. Rum; falls es Apfelzeit ist f¨ uge drei mittelgroße gesch¨ alte und zerteilte ¨ Apfel hinzu; sonst f¨ uge 100 g Schokoladenst¨ uckchen hinzu; f¨ ulle den Teig in Muffinf¨ ormchen; backe bei 175-200 Grad f¨ ur etwa 30 min; best¨ aube die Muffins mit etwas Puderzucker *************************************************************** Weitere Strukturen sind Schleifen, etwa: *************************************************************** Muffins: Verr¨ uhre 200 g Butter, 200 g Zucker, 4 Eier, 1 Pck Backpulver, 1 Pck Vanillezucker, 250 g Mehl, 3 Eßl. Rum; falls es Apfelzeit ist f¨ uge drei mittelgroße gesch¨ alte und zerteilte ¨ Apfel hinzu; sonst f¨ uge 100 g Schokoladenst¨ uckchen hinzu; f¨ ulle den Teig in Muffinf¨ ormchen; solange die Muffins noch nicht gar sind backe bei 175-200 Grad; best¨ aube die Muffins mit etwas Puderzucker *************************************************************** Algorithmen k¨onnen Variablen enthalten, die von außen gesetzt werden, etwa: *************************************************************** Muffins: Frage nach, wieviele Personen da sind; Speichere die Antwort in der Variablen x; y=x/4; Verr¨ uhre y*200 g Butter, y*200 g Zucker, y*4 Eier, y Pck Backpulver, y Pck Vanillezucker, y*250 g Mehl, y*3 Eßl. Rum; falls es Apfelzeit ist f¨ uge y*drei mittelgroße gesch¨ alte und zerteilte ¨ Apfel hinzu; sonst f¨ uge y*100 g Schokoladenst¨ uckchen hinzu;

1.2 Algorithmen

5

f¨ ulle den Teig in Muffinf¨ ormchen; solange die Muffins noch nicht gar sind backe bei 175-200 Grad; best¨ aube die Muffins mit etwas Puderzucker *************************************************************** Algorithmen k¨onnen sich auf mehrere Teilprogramme aufteilen, um die Struktur klarer zu machen, etwa: *************************************************************** Muffins: Frage nach, wieviele Personen da sind; Speichere die Antwort in der Variablen x; y=x/4; Verr¨ uhre y*200 g Butter, y*200 g Zucker, y*4 Eier, y Pck Backpulver, y Pck Vanillezucker, y*250 g Mehl, y*3 Eßl. Rum; falls es Apfelzeit ist f¨ uge y*drei mittelgroße gesch¨ alte und zerteilte ¨ Apfel hinzu; sonst f¨ uge y*100 g Schokoladenst¨ uckchen hinzu; f¨ ulle den Teig in Muffinf¨ ormchen; abchentest liefert noch nicht fertig solange Teilprogramm St¨ backe bei 175-200 Grad; aube die Muffins mit etwas Puderzucker best¨ ************************************************************** abchentest: Teilprogramm St¨ abchen in das erste Muffin; stecke ein Holzst¨ falls Teig kleben bleibt noch nicht fertig; sonst fertig *************************************************************** Algorithmen k¨onnen Zufallskomponenten enthalten: *************************************************************** abchentest: Teilprogramm St¨ allig heraus; suche ein Muffin zuf¨ abchen in das Muffin; stecke ein Holzst¨ falls Teig kleben bleibt noch nicht fertig; sonst fertig *************************************************************** Programme k¨onnen durch Rekursion auf sich selbst Bezug nehmen: *************************************************************** abchentest: Teilprogramm St¨ allig heraus; suche ein Muffin zuf¨ abchen in das Muffin; stecke ein Holzst¨

1 WAS IST INFORMATIK?

6

falls Teig kleben bleibt noch nicht fertig; sonst teste nochmal genauer durch Probieren des Muffin; falls schmeckt gut fertig; sonst rufe das Teilprogramm St¨ abchentest wieder auf *************************************************************** Dieses ist ein rekursiver Algorithmus: Das Teilprogramm St¨abchentest ruft sich selbst wieder auf. Rekursion ist ein sehr wichtiges Programmierprinzip der Informatik. Eine andere Sache ist h¨aufig, die hier auch das erste Mal (und im Verlaufe Ihres Studiums wahrscheinlich noch shr sehr h¨aufig) auftritt: Programmierfehler! Dieses ist tats¨achlich ein erstes Beispiel eines fehlerhaften Algorithmus: es kann in obigem Algorithmus der Fall eintreten, daß die Anweisungen nicht durchgef¨uhrt werden k¨onnen, n¨amlich dann, falls durch wiederholtes rekursives Aufrufen des St¨abchentests alle Muffins verk¨ostigt wurden und keines mehr im Ofen steckt. Korrekt muß der Algorithmus diesen Fall gesondert ber¨ucksichtigen: *************************************************************** abchentest: Teilprogramm St¨ falls noch mindestens ein Muffin im Ofen allig heraus; suche ein Muffin zuf¨ stecke ein Holzst¨ abchen in das Muffin; falls Teig kleben bleibt noch nicht fertig; sonst teste nochmal genauer durch Probieren des Muffin; falls schmeckt gut fertig; sonst abchentest wieder auf; rufe das Teilprogramm St¨ sonst acker um die Ecke besorge Kuchen beim B¨ *************************************************************** Der Algorithmus ist jetzt schon ganz sch¨on kompliziert geworden. Er ist in gewisser Hinsicht noch einfach, denn es handelt sich um eine sequentielle Folge von Anweisungen. Das heißt, ein einziger Koch ist hier am Werk, der die Anweisungen nacheinander ausf¨uhrt. Alternative sind parallele Programme, in denen mehrere Anweisungen gleichzeitig durch verschiedene Prozessoren ausgef¨uhrt ¨ werden k¨onnen. Beim Backen k¨onnte etwa der K¨uchenjunge schonmal die Apfel sch¨alen, w¨ahrend der Chefkoch den Teig zubereitet. Die Aktionen m¨ussen in parallelen Programmen geeignet syn¨ chronisiert, d.h. abgestimmt werden. Etwa der K¨uchenjunge muß mit den Apfeln fertig sein, bevor der Chefkoch sie zum Teig f¨ugen kann.

1.3 Darstellung Wir haben hier schon einige wichtige Komponenten von Algorithmen informell kennengelernt. Um Algorithmen in der Informatik pr¨azise behandeln zu k¨onnen, ben¨otigt man geeignete Darstellungen.

1.3 Darstellung

7

Allgorithmen beschreibt man h¨aufig in konkreten Programmiersprachen wie C oder Java oder auch in Pseudocode, d.h. einer intuitiven Notation, die sich an u¨ bliche Strukturen von Programmiersprachen anlehnt, aber technische Details ignoriert. Eine Darstellung im Pseudocode ist meist selbsterkl¨arend, wie etwa unser Muffin-Beispiel. Eine gebr¨auchliche Form, Algorithmen zusammen mit ihrer logischen Struktur deutlich zu machen, sind Flußdiagramme. Ein Flußdiagramm besteht aus den elementaren Bausteinen Zuweisungen (dargestellt in K¨astchen), Eingabe/Ausgabe (dargestellt in Parallelogrammen) und Tests (dargestellt in Rauten), die entsprechend ihrer Abarbeitung in einem Algorithmus durch Pfeile miteinander verbunden sind. Zuweisungen sind durch einen Pfeil mit der nachfolgend bearbeiteten Anweisung verbunden. Tests weisen entsprechend dem Ergebnis (ja/nein) zwei Pfeile auf. Zus¨atzlich f¨ugt man gesonderte Symbole zu, die den Start und das Ende des Programms (in Kreisen) explizit machen. Als ein Beispiel betrachten wir ein einfaches Programm in Pseudocode, die sogenannte Collatz-Funktion: lese x; y:=0; solange x6=1 wenn x gerade x:=x/2; sonst x:=x*3+1; y:=y+1; gebe y aus Die Notation x:= deutet an, daß der Variablen x das Ergebnis des auf der rechten Seite stehenden Ausdrucks zugewiesen wird. Diese Funktion manipuliert eine eingegebene nat¨urliche Zahl x iterativ, bis der Wert 1 erhalten ist, und gibt dann die Anzahl der Manipulationen der Zahl aus. Sie ist in der Informatik vor allem deswegen ber¨uhmt, weil bis heute nicht bewiesen werden konnte, daß dieses Programm immer terminiert, d.h. durch die Operationen immer irgendwann der Wert 1 erreicht wird. Das Programm selbst ist nichtsdestotrotz leicht verst¨andlich. Ein Flußdiagramm macht den Ablauf klar:

Start lese x y:=0

x=1

ja

nein ja

x gerade

x:=x/2

Ende nein x:=3x+1

y:=y+1

schreibe y

1 WAS IST INFORMATIK?

8

Flußdiagramme werden h¨aufig verwendet, komplexere Algorithmenstrukturen graphisch deutlich zu machen. Man sieht hier sehr sch¨on, wenn Operationen von anderen unabh¨angig sind, weil sie in parallelen Pfaden des Diagramms angesiedelt sind. Anweisungen im selben Pfad beeinflussen sich potentiell. Man sieht zudem, in welchen F¨allen das Programm in Zyklen, potentiell in eine Endlosschleife laufen kann, da diese Kreisen im Graphen entsprechen. M¨ochte man einen Algorithmus in Form eines Computerprogramms aufschreiben, muß zun¨achst pr¨azisiert werden, wie ein g¨ultiges Programm prinzipiell aussehen kann. Wir haben bisher Anweisungen in umgangssprachlichen Pseudocode gefaßt, den wir aufgrund unseres Sprachverst¨andnis interpretieren konnten. Ein Computer hat kein solches Hintergrundwissen. Klassische Programmiersprachen bestehen aus nach pr¨azisen Regeln gebildeten Folgen. Die Regeln bestimmen die g¨ultige Syntax der Programmiersprache. Programme, die nicht diesen Regeln folgen, sind syntaktisch inkorrekt und werden vom Computer nicht verstanden. Es gibt verschiedene M¨oglichkeiten zu definieren, wie syntaktisch korrekte Programme prinzipiell aussehen. Wie f¨ur wirkliche Sprache auch, gibt man f¨ur Computersprachen deren Grammatik an. Eine sehr gebr¨auchliche Weise, eine solche spezielle Grammatik darzustellen, ist die sogenannte erweiterte Backus-Naur-Normalform (EBNF). 1 Bevor wir dazu kommen, wie so eine EBNF aussieht, steht hier noch einmal die Bemerkung: die nach spezifizierten Regeln gebildeten Programme bilden syntaktisch korrekte Programme, d.h. Programme, die der Computer versteht. Das bedeutet nicht, daß die Programme sinnvoll sind und das tun, was wir m¨ochten, d.h. das impliziert nicht die semantische Korrektheit. Auch dieses ist so wie in der nat¨urlichen Sprache. Etwa der Satz Das Muffin f¨uhrt die Leiter.‘ ist ein syntaktisch korrekter Satz, der aber keine sinnvolle ’ Bedeutung hat. Eine Grammatik in EBNF-Form besteht aus folgenden vier Komponenten • Einer Menge T von sogenannten Terminalsymbolen, d.h. den Bestandteilen, aus denen die Sprache zusammengesetzt ist. In Programmen sind das z.B. Schl¨usselw¨orter wie ‘main’ oder Symbole ‘{’. • Einer Menge von H Hilfssymbolen, die gebraucht werden, die Sprache effizient zu beschreiben, aber nicht selbst in der Sprache vorkommen. • Ein ausgesuchtes Startsymbol aus H. • Eine endliche Menge von Produktionsregeln der Form linke Seite ::= rechte Seite Die linke Seite solcher Ausdr¨ucke besteht aus einem Hilfssymbol aus H. Die rechte Seite hat die Form Alternative1 | . . . |Alternativen mit einer beliebigen Anzahl n von Alternativen. Alternativen selbst bestehen aus einer Folge von Terminal- oder Hilfssymbolen und den Operatoren [·] und {·}, die Symbolfolgen umschließen k¨onnen. Eine gegebene EBNF repr¨asentiert genau alle W¨orter, die man erh¨alt, wenn man angefangen vom Startsymbol eine endliche Anzahl von Produktionsregeln anwendet, bis man zu einem Wort, das nur aus Terminalen besteht, kommt. Das Anwenden einer Produktionsregeln linke Seite ::= 1

Man kann f¨ur alle sogenannten kontextfreien eine Grammatik in dieser Form finden. Es gibt Sprachen, die nicht kontextfrei sind, z.B. nat¨urliche Sprache. Man kann also f¨ur nat¨urliche Sprache keine solche EBNF-Grammatik finden, und es m¨ussen z.B. f¨ur Deutsch komplizierte Regeln gelernt werden. Die allermeisten Programmiersprachen sind allerdings so einfach, daß eine EBNF-Grammatik ausreicht, sie (fast) vollst¨andig zu charakterisieren.

1.3 Darstellung

9

rechte Seite bedeutet dabei folgendes: in dem bisher gebildeten Wort darf das Hilfssymbol einer linken Seite durch eine beliebige Alternative der rechten Seite ersetzt werden. Die speziellen Ausdr¨ucke [·] und {·} bedeuten dabei, daß man die in den Klammern [·] stehende Symbolfolge auch weglassen kann und die in den Klammern {·} stehende Symbolfolge beliebig oft (auch keinmal) wiederholen darf. Ein Beispiel macht dieses Vorgehen deutlich. Wir sind interessiert an ganzen Zahlen. Ganze Zahlen sind Ziffernfolgen der Form 42, 333, 4711, 2004, -89, . . . Es sind also beliebig lange Folgen von Zeichen 0-9 eventuell mit einem negativen Vorzeichen versehen. Hinzu kommt, daß an der ersten Stelle der Ziffern keine 0 stehen sollte, es sei denn es handelt sich um die Zahl 0 selbst. Die folgende EBNF-Grammatik beschreibt genau diese Zahlen. • Terminalsymbole sind {‘−’,‘0’,. . . ,‘9’}. • Hilfssymbole sind { Zahl, Zifferohnenull, Ziffer}. • Startsymbol ist Zahl. • Die Produktionsregeln sind Zahl ::= 0 | [−] Zifferohnenull {Ziffer} Ziffer ::= 0|1|2|3|4|5|6|7|8|9 Zifferohnenull ::= 1|2|3|4|5|6|7|8|9 Eine Zahl ist also die Null oder ein optionales Vorzeichen gefolgt von einer Ziffer ungleich Null gefolgt von beliebig vielen weiteren Ziffern. Die Zahl 4711 erh¨alt man u¨ ber die folgenden Produktionen: Zahl

Zifferohnenull

4

Ziffer

7

Ziffer Ziffer

1

1

Die obige EBNF ist nicht die einzige, um ganze Zahlen zu beschreiben. Eine Alternative stellen etwa folgende Produktionsregeln dar: Zahl negativeZahl positiveZahl Ziffernfolge Zifferohnenull Ziffer

::= ::= ::= ::= ::= ::=

0 | negativeZahl | positiveZahl − positiveZahl Zifferohnenull | Zifferohnenull Ziffernfolge Ziffer | Ziffer Ziffernfolge 1|2|3|4|5|6|7|8|9 0|1|2|3|4|5|6|7|8|9

Es ist bei komplexeren Grammatiken nicht sofort offensichtlich, welche W¨orter durch sie erzeugt werden. Die Theoretische Informatik besch¨aftigt sich mit M¨oglichkeiten, wie man effizient testen kann, ob ein Programm den Regeln einer gegebenen Grammatik gehorcht. Prinzipiell ist dieses f¨ur EBNF-Grammatiken machbar und f¨ur die meisten Programmiersprachen auch sehr effizient. Der Prozeß, der die Syntax eines gegebenen Programms pr¨uft, nennt sich Parsing – gehorcht das Programm nicht den Regeln, wird ein parse error gemeldet.

10

2 ERSTE SCHRITTE IN JAVA

1.4 Eine kurze Historie Nachdem wir informell den Begriff des Algorithmus gekl¨art haben und formale Sprachen f¨ur Algorithmen definieren k¨onnen, soll ein kurzer Blick auf die geschichtliche Entwicklung stehen. Einer der ersten in der Menschheitsgeschichte vorgeschlagenen dokumentierten Algorithmen ist Euklids Verfahren, den gr¨oßten gemeinsamen Teiler zweier nat¨urlicher Zahlen zu finden (siebtes Buch der Elemente, ca. 300 vor Christus). Der Begriff des Algorithmus selbst ist abgeleitet von dem Namen Mohammed ibn Musa abu Djafar alChoresmi, der ca. 800 nach Christus eine Vorgehensweise f¨ur Testamentsvollstreckungen beschrieb, und dem griechischen Wort arithmo f¨ur Zahl. Wichtige Schritte zur heutigen Algorithmentheorie waren Algorithmen f¨ur den Umgang mit Zahlen im Rechenbuch von Adam Riese 1574, Logarithmentafeln zur effizienten Berechnung von Produkten (1614), das bin¨are Zahlensystem von Leipniz (1703), und die Church’sche These (1936), die die Intuition formuliert, daß alle sinnvollen Darstellungen eines Algorithmus im wesentlichen dasselbe auf unterschiedliche Arten ausdr¨ucken, alle Programmiersprachen und Formalisierungen also im Wesentlichen a¨ quivalent sind. Rechenmaschinen, die verm¨oge von Algorithmen Prozesse automatisiert ausf¨uhren k¨onnen, beinhalten als fr¨uhe Vertreter den ca. 6000 Jahre alten Abakus und den auf John Napier zur¨uckgehenden Rechenschieber. Doch erst in der industriellen Revolution gab es mit dem 1801 von Josef Maria Jaquard eingef¨uhrten automatischen Webautomaten mit Lochkarten eine wirklich automatisierte Maschine. Die mechanische Differenzmaschine von Charles Babbage (1782-1871), die als erster Rechner bezeichnet werden kann, wurde aufgrund der komplizierten Mechanik nicht fertig gestellt. Im weiteren Verlauf verbesserte Hermann Hollerith die Lochkartentechnik, die damals vor allem bei der Volksz¨ahlung verwendet wurde. In der Telekommunikation entwickelte man Relais, elektromechanische Schalter, die auch in der Computertechnik verwendet wurden. Konrad Zuse baute 1936 den ersten Computer mit Relais, die Z1, gefolgt von einer Anzahl weiterer, verbesserter Rechner. Im zweiten Weltkrieg nahm die Bedeutung der Informationstheorie zu und schnelle Kodierung und Dekodierung von Nachrichten war ein entscheidender Aspekt der Kriegsf¨uhrung. Die Amerikaner Eckert und Mauchly bauten den ersten Computer in R¨ohrenbauweise, doch erst John von Neumann und die Halbleitertechnik brachten einen durchschlagenden Erfolg in der Computertechnik. Die 1944/45 vorgeschlagene von Neumann Architektur, deren Ideen teilweise schon in Zuses Z1 enthalten waren, bildet die Grundlage f¨ur heutige Rechner. In Abbildung 1 ist das Prinzip eines von Neumann Rechners dargestellt. Ein Prozessor verarbeitet bin¨are im Arbeitsspeicher vorgehaltene Informationen. Mithilfe der Ein- und Ausgabesteuerung kann der Nutzer mit dem Rechner kommunizieren, es kann Information extern gelagert werden, oder ein weiterer Rechner angesprochen werden. Die interne Steuerung des Rechners basiert auf Maschinensprache, einer sehr kleinschrittigen Folge von von der CPU verstandenen Instruktionen. Um den reibunglosen und komfortablen Ablauf der Kommunikation mit dem Nutzer zu gew¨ahrleisten, ist ein Betriebssystem installiert, h¨aufig Linux, Windows, oder Mac OS X. Dieses erm¨oglicht zusammen mit weiteren Programmen wie einem Internet Browser oder einer Java Installation, Dateien zu pflegen, u¨ ber das Internet zu kommunizieren oder eigene Programme zu schreiben.

2 Erste Schritte in Java Der Schwerpunkt dieser Vorlesung liegt in einer Einf¨uhrung in elementare Algorithmen, Datenstrukturen und deren Formalisierung. Wir lernen kennen, wie man elementare Zuweisungen und Kontrollstrukturen im Rechner realisiert, mit unterschiedlichen Datentypen wie nat¨urlichen Zahlen, Wahrheitswerten, reellen Zahlen oder sogenannten abstrakten Datentypen im Rechner umgeht, und was man beim Entwurf eines Algorithmus in Bezug auf deren Bedeutung beachten sollte. Wir

11 Computer Zentraleinheit (CPU) Prozessor

Arbeitsspeicher

Ein− und Ausgabesteuerung

Eingabe: Tastatur, Maus, Kamera, ...

Ausgabe: Bildschirm, Lautsprecher, Drucker, ...

direkter Benutzer

externer Speicher: Festplatte, CD/DVD, ...

Archivierung

Netz: ISDN, Modem, Netzkarte, ...

anderer Rechner

Abbildung 1: Prinzip eines von Neumann Rechners werden uns dabei der Programmiersprache Java bedienen. Wir schließen mit einem kurzen Blick auf andere Programmiersprachen und einer generellen Formalisierung von Information. Was ist Java? Java ist in Amerika das Synonym f¨ur Kaffee. Daneben bezeichnet es eine Programmiersprache, die Programmiersprache f¨ur Web-Anwendungen. Angefangen hat alles mit einer Arbeitsgruppe, die James Gosling, der Erfinder von Java, 1990 bei SUN gr¨undete, weitere Mitglieder waren Patrick Naughton und Mike Sheridan. Es ging um eine einfache Programmiersprache f¨ur Computerchips, benannt Oak – die Eiche – nach einem Baum vor Goslings B¨uro. 1992 wurde hiermit ein Hardware-Ger¨at zum Bedienen eines Fernsehers entwickelt. Ein kleiner Wicht, Duke (jetzt Maskottchen von Java) f¨uhrte den Benutzer durch ein virtuelles Haus und programmierte dort den Videorecorder. Ziel einer daraufhin gegr¨undeten Firma, First Person, war, interaktives Fernsehen mit Oak zu programmieren. Das Projekt wurde ein finanzieller Verlust, da der Auftrag leider an Silicon Graphics statt SUN ging. Nachdem der erste WWW-Browser, Mosaic, 1993 fertiggestellt wurde, gab es allerdings eine neue Aufgabe f¨ur Oak als plattformunabh¨angige Grundlage f¨ur das Internet. 1995 wurde die Programmiersprache umgenannt, Oak gab es schon f¨ur eine andere Programmiersprache. Von einem T-Shirt Aufdruck ’It’s a jungle out there, so drink your Java’ kam der jetzige Name. F¨ur die von Gosling verbesserte Sprache schrieb Noughton eine Anwendung in Form eines Browsers, WebRunner, aufgrund rechtlicher Gr¨unde umbenannt in HotJava. Netscape lizensierte Java und u¨ bernahm dessen Vermarktung. 1997 wurde JDK1.1 (Java Development Kit) freigegeben und von den f¨uhrenden Software-Firmen unterst¨utzt. Java2 kam 1998 auf den Markt. Ab 1999 ist Java als OpenSource-Lizenz (d.h. inklusive Quellcode) verf¨ugbar. Eine exzellente online-Referenz zu Java bietet das Java-Tutorial von SUN: http://java.sun.com/docs/books/tutorial/.

2 ERSTE SCHRITTE IN JAVA

12

2.1 Hello World! Starten wir mit unserem ersten Java-Programm. Gem¨aß einer alten Tradition der Informatik ist das einfach ein Programm, das ‘Hello world!’ ausgibt: /************************************************************ * * HelloWorld.java * *************************************************************/ class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } } Um Hello World! zu erhalten, m¨ussen wir drei Schritte tun: 1. Wir m¨ussen das Programm in irgendeinem Text-Editor schreiben und unter dem Namen HelloWorld.java abspeichern. 2. Wir m¨ussen das Programm in einen f¨ur den Rechner ausf¨uhrbaren Code u¨ bersetzen, indem wir auf der Kommandozeile javac HelloWorld.java eintippen. Es entsteht so eine Datei mit Namen HelloWorld.class in sogenanntem Java Bytecode. 3. Wir m¨ussen das Programm durch den Ausdruck java HelloWorld auf der Kommandozeile ausf¨uhren. Wenn alles geklappt hat, erscheint dann der Text Hello World! auf der Kommandozeile. Verantwortlich daf¨ur ist der Java Interpreter, die auf dem System installierte Java Virtual Machine. F¨ur den Schritt 1. ben¨otigen Sie irgendeinen Text-Editor, etwa vim, emacs oder word-editor. Die Schritte 2. und 3. sind plattformspezifisch und gelten f¨ur die verbreiteten Systeme Linux, Windows und Mac OS X. Sie setzen voraus, daß Java in dem System installiert ist und die Pfade zu den Java-Sources korrekt gesetzt sind; sollte das nicht bereits der Fall sein, dann erhalten Sie das Java Software Development Kit f¨ur verschiedenste Plattformen etwa von Sun unter http://java.sun.com/j2se/1.5.0/index.jsp Schauen wir uns obiges Vorgehen noch einmal genauer an und kl¨aren einige der auftretenden Begriffe: Java Programme sind nichts weiteres als Text in einer speziellen, der Syntax von Java gehorchenden Form, der in einer oder mehreren Dateien abgespeichert ist. Die Syntax und ihre Bedeutung werden wir im weiteren n¨aher kennenlernen. ¨ Java Bytecode wird aus Java Programmen durch Kompilieren oder Ubersetzen erzeugt. Die Pro¨ grammiersprache Java selbst ist eine intuitive und – mit etwas Ubung – gut lesbare Hochsprache, die es dem Benutzer einfach m¨oglich machen soll, Programmabl¨aufe zu automatisieren. Java Bytecode ist eine niedrigere Ausdrucksweise derselben Inhalte in maschinennaher, also f¨ur den Rechner leichter verst¨andlicher Sprache. Im Gegensatz zu Maschinensprache ist Java Bytecode aber plattformunabha¨ ngig und kann von der Java Virtual Machine auf einer beliebigen Plattform ausgef¨uhrt werden.

2.1 Hello World!

13

Die Java Virtual Machine bezeichnet einen Interpreter f¨ur Java Bytecode f¨ur die gegebene Plattform, d.h. sie f¨uhrt Java Bytecode auf der konkreten Maschine aus. Java Bytecode wird h¨aufig in Applikationen auf dem Rechner, auf dem auch die Java Virtual Machine l¨auft, bereitgestellt. Wir werden uns hier auf solche Applikationen beschr¨anken. Java Bytecode kann alternativ in sogenannten applets innerhalb von Internetseiten zur Verf¨ugung gestellt werden und durch die Java Virtual Machine des Rechners, dessen Benutzer die Internetseiten gerade mit einem Internet-Browser betrachtet, ausgef¨uhrt werden. Aufgrund dieser M¨oglichkeit ist Java eine sehr wichtige Sprache im Zusammenhang mit der Internet-Programmierung, da sie einen plattformunabh¨angigen Austausch von Programmen erm¨oglicht. JAva wird dabei w¨ahrend der Ausf¨uhrung interpretiert, nicht vorab einmalig in maschinensprache compiliert, da dieses die Austauschbarkeit f¨ur verschiedene Plattformen verletzen w¨urde. Das ist allerdings langsam, da eine Optimierung der Operationen vor deren Ausf¨uhrung nicht durchgef¨uhrt wird. In vielen Viele Systeme Java-Umgebungen ist daher ein Just-in-Time Compiler integriert. Der Compiler u¨ bersetzt den Code w¨ahrend der Abarbeitung in Maschinensprache und optimiert dabei schon u¨ bersetzte (insbesondere mehrfach auftretende) Stellen. Zur¨uck zum Java-Programm. Die ersten f¨unf Zeilen enthalten lediglich Kommentare, die den Programmnamen und Spezifika beschreiben, um die Lesbarkeit der Programme durch den Nutzer zu erh¨ohen. H¨aufig wird in einem Kommentar am Kopf der Dateien die Funktion des Programms kurz zusammengefaßt, und weitere Information zur Historie des Programms wird integriert. Kommentar innerhalb eines Programms erl¨autert die jeweiligen Programmschritte und Variablen. F¨ur eine gute Programmierung und Wiederverwertbarkeit von Programmen ist eine sinnvolle Kommentierung essentiell! Die Kommentare beeinflussen aber nicht den Ablauf des Programms in Bezug auf den Rechner, er wird beim Parsing ignoriert. Kommentar ist • alles, was (auch u¨ ber mehrere Zeilen) zwischen den Symbolen /* und */ steht, • alles, was hinter dem Symbol \\ bis zum Zeilenende steht. Das Programm besteht dann aus f¨unf Zeilen. Generell ist es so, daß Abst¨ande und Zeilenumbr¨uche zwischen den einzelnen W¨ortern und Symbolen f¨ur die Ausf¨uhrung des Programms irrelevant sind und lediglich der besseren Lesbarkeit dienen. Wir h¨atten das Programm auch z.B. auf nur eine Zeile schreiben k¨onnen, ohne dessen Inhalt zu a¨ ndern. Groß- und Kleinschreibung wird vom Rechner allerdings unterschieden und muß beachtet werden! Das Java-Programm selbst besteht aus einer sogenannten Klasse, der Klasse HelloWorld. Java ist im Gegensatz zu etwa C eine sogenannte objektorientierte Programmiersprache. Die kleinsten Einheiten von Java sind Klassen, d.h. Deklarationen von Objekten, die eine Anzahl von Informationen in Feldern speichern k¨onnen und Methoden zur Verf¨ugung stellen, die die Informationen bearbeiten. Im Gegensatz dazu sind die kleinsten Einheiten von C als sogenannter imperativer Programmiersprache Prozeduren, die eine Anzahl von Variablen bearbeiten und deren Wert a¨ ndern. Den Unterschied imperativer, objektorientierter und weiterer Programmierstile werden wir sp¨ater noch genauer kennenlernen. Eine Klasse ist angedeutet durch das Schl¨usselwort class gefolgt von dem Namen f¨ur die Klasse. Danach stehen in geschweiften Klammern die Elemente der Klasse. Unsere Klasse besitzt nur ein Element, die Methode main. Dieser Name referiert auf eine spezielle Methode, die durch den Java-Interpreter automatisch ausgef¨uhrt wird. Wird durch den Aufruf java Klassenname ein Programm ausgef¨uhrt, sucht der Java-Interpreter nach der main-Methode und f¨uhrt diese aus. Die main-Methode ist immer o¨ ffentlich (public) und inerhalb des Programms nicht mehr ver¨anderbar (static, dieses wird sp¨ater noch n¨aher erl¨autert). Vor und hinter dem Methodennamen stehen in Java Typbezeichner: vor dem Methodennamen der Typ eines Wertes, den die

2 ERSTE SCHRITTE IN JAVA

14

Methode zur¨uckgibt. In unserem Fall ist das void, das heißt nichts. In runden Klammern stehen die Argumente, die die Methode erwartet. Bei main hat dieses immer die Form String[] args und erlaubt, der Methode eine Menge von Zeichenketten mitzugeben. Wir d¨urften also das Programm auch in der Form java HelloWorld los jetzt aufrufen. Da die Argumente nicht weiter verwendet werden, hat dieses keine Auswirkungen auf das Programm. Wir nehmen diesen Kopf‘ der Methode f¨ur unsere ersten Programme erstmal als gegeben hin. Die Methode ’ main f¨uhrt den Befehl System.out.println("Hello, World!"); aus, der den String Hello, World! gefolgt von einem Zeilenumbruch auf der Kommandozeile ausgibt.

2.2 Elementare Datenstrukturen und Operationen An dieser Stelle soll zun¨achst ein Schnelldurchgang durch Kontrollstrukturen und Datentypen von Java stehen, der den Aspekt der Objektorientierung weitgehend außer Acht l¨aßt, sondern auf die Umsetzung von Algorithmen fokussiert. Wir werden uns zun¨achst auf nur eine Klasse beschr¨anken. Wir werden dabei nicht alle in Java m¨oglichen Konstrukte einf¨uhren, sondern uns auf die wichtigsten beschr¨anken. Es gibt sehr viele n¨utzliche Alternativen, die z.B. eine k¨urzere Schreibweise erlauben. Diese finden Sie z.B. in der Java-Dokumentation von Sun. Starten wir mit Variablen, die die Bausteine bilden, um Information zu speichern und in Programmen zu manipulieren. Eine Variable ist zun¨achst ein Bezeicher, etwa ein Buchstabe x oder ein Wort sch¨ onevariable. In Java bereits belegte Schl¨usselw¨orter wie etwa main d¨urfen dabei nicht als Variablenbezeichner verwendet werden. In Java ist es m¨oglich, auch ‘ungew¨ohnliche’ Zeichen, etwa chinesische Schriftzeichen, als Variablenbezeichner zu verwenden. Variablen k¨onnen einen Wert speichern. Java ist eine sogenannte typisierte Sprache, d.h. Variablen besitzen einen bestimmten Typ und k¨onnen nur Werte dieses Typs annehmen. Es gibt zwei verschiedene Arten von Typen • einfache (primitive) Typen und • Referenztypen Referenztypen behandeln wir erst sp¨ater im Abschnitt abstrakte Datentypen. Sie sind extrem wichtig, um objektorientierte Programmierung zu realisieren. Die einfachen Typen in Java sind • boolean: die Werte true und false • char: Charakter, d.h. einzelne Zeichen. In Java sind das sogenannte 16-Bit Unicode Zeichen, die nicht nur alle Zeichen einer deutschen oder amerikanischen Tastatur umfassen, sondern z.B. auch griechische oder chinesische Zeichen. 2 • Verschiedene Typen, um mit ganzen Zahlen umzugehen. In einem Rechner k¨onnen nicht beliebig große Zahlen dargestellt werden. Zahlen werden in Dualdarstellung repr¨asentiert. Wir werden sp¨ater noch die sogenannte polyadische Darstellung pr¨azise einf¨uhren. Die Typen unterscheiden sich hinsichtlich des Bereichs, der abgedeckt wird; dieser ist in der dualen Darstellung durch Zweierpotenzen beschr¨ankt. – byte umfaßt die mit 8 Bit darstellbaren Zahlen −27 bis 27 − 1. – short umfaßt die mit 16 Bit darstellbaren Zahlen −215 bis 215 − 1. – int: Integer ist der gebr¨auchlichste Typ, wenn es um ganze Zahlen geht. Er umfaßt alle mit 32-Bit darstellbaren Zahlen, d.h. die ganzen Zahlen zwischen −2 31 und 231 −1. 2

Sie m¨ussen nur eine passende Tastatur zum Eintippen finden . . .

2.2 Elementare Datenstrukturen und Operationen

15

– long beinhaltet die Zahlen von 2−63 bis 263 − 1. • Einige Typen, um mit reellen Zahlen umzugehen. Auch diese k¨onnen nicht beliebig groß werden und nicht mit beliebiger Genauigkeit betreffend der Nachkommastellen dargestellt werden. Auch die genaue Darstellung reller Zahlen werden wir sp¨ater noch behandeln. – float: alle mit 32 Bit darstellbaren Zahlen in IEEE 754 Gleitkommadarstellung. – double: die gebr¨auchlichste Variante, alle mit 64 Bit darstellbaren Zahlen in IEEE 754 Gleitkommadarstellung. Was das genau heißt, werden wir im Abschnitt u¨ ber reelle Zahlen genauer kennen lernen. Zudem ben¨otigen wir hier auch einen Referenztypen, ohne n¨aher auf die Besonderheiten von Referenztypen einzugehen: • String: eine Zeichenfolge endlicher L¨ange. Wie gebraucht man Variablen? Vor dem ersten Gebrauch innerhalb einer Klassenmethode m¨ussen Variablen deklariert werden. Eine Variablendeklaration hat die Form Variablentyp Variablenbezeichner; oder, wenn man mehrere Variablen vom gleichen Typ deklariert, auch Variablentyp Variablenbezeichner1 , Variablenbezeicher2 , . . . , Variablenbezeichnern ; Ein Beispiel: int x,y,z; int a; char einzeichen; boolean Wahrheitswert; String ganzeswort; Wenn die Variablen deklariert sind, m¨ochte man ihnen Werte zuweisen. Geschieht das nicht, ist in der Regel der Wert der Variablen undefiniert. Variablenzuweisungen haben die Form Variablenbezeichner = rechte Seite; Ein Beispiel: a=42; einzeichen=’B’; Wahrheitswert=true; ganzeswort="huhu"; z=2; In dieser Notation haben wir den Variablen Konstanten (Terminale) zugewiesen. Das sind zum Beispiel die Begriffe true und false f¨ur Boolean, evtl. mit Vorzeichen versehene Ziffernfolgen f¨ur ganze Zahlen, in Hochkommata eingeschlossene Buchstaben f¨ur Charakter oder in Doppelhochkommata eingeschlossene Buchstabenfolgen f¨ur Strings. Die rechte Seite kann allgemeiner ein Ausdruck sein, der einen Wert desselben Typs wie die Variable liefert. Etwa Variablen, die selbst schon einen Wert besitzen: b=a; c=a;

2 ERSTE SCHRITTE IN JAVA

16

oder aus einfachen Ausdr¨ucken mithilfe von Operatoren gebildete komplexere Ausdr¨ucke, wobei die Werte aller auf einer rechten Seite benutzten Variablen definiert sein m¨ussen. Wir listen kurz die gebr¨auchlichsten Operatoren auf: boolean: Stelligkeit einstellig zweistellig zweistellig

Operator ! && ||

Bedeutung Negation logisches und logisches oder

String: Stelligkeit Operator Bedeutung zweistellig + Konkatenation ganze Zahlen: Stelligkeit einstellig zweistellig zweistellig zweistellig zweistellig zweistellig

Operator + * / %

Bedeutung das Negative Addition Subtraktion Multiplikation ganzzahlige Division ohne Nachkommastellen modulo, d.h. Rest bei ganzzahliger Division

reelle Zahlen: Stelligkeit einstellig zweistellig zweistellig zweistellig zweistellig

Operator Bedeutung das Negative + Addition Subtraktion * Multiplikation / Division

Dabei haben wir etwas geschummelt: && berechnet genauer das sogenannte bedingte logische und, das, sofern der linke Term false ergibt, die Auswertung bereits abbricht und false zur¨uckliefert. || ist das bedingte logische oder, daß im Fall von true f¨ur den linken Operatoren bereits true ergibt, ohne den rechten Operator noch zu testen. Die zweistelligen Operatoren werden infix geschrieben, etwa 2.0+42.99 Um die Zugeh¨origkeiten zu definieren, kann man Klammerungen verwenden: (2.0+42.99)*(42.99+4711) Verwendet man keine Klammern, dann sind die Priorit¨aten in der Ausf¨uhrung nach u¨ blichen Konventionen festgelegt, es gilt etwa Punkt- vor Strichrechnung: 2.0+42.99*42.99+4711 = 2.0+(42.99*42.99)+4711 Im Zweifel sollte man die Priorit¨aten nachschauen oder Klammern setzen. Diese Operationen erm¨oglichen, Variablen den Werte komplexerer Ausdr¨ucke zuzuweisen, etwa boolean a, b=true, c; c = !b; a = b || (b && !c); Hierbei haben wir f¨ur b die Konvention verwendet, daß eine Wertzuweisung auch direkt bei der Deklaration der Variablen stehen kann. Zus¨atzlich zu diesen (und weiteren) Operatoren gibt es eine Anzahl zweistelliger Vergleichsoperatoren, die zu zwei Variablen einen booleschen Wert, das Ergebnis des Vergleichs, liefern.

2.2 Elementare Datenstrukturen und Operationen Operator == != < <= > >=

17

Bedeutung gleich ungleich kleiner kleiner oder gleich gr¨oßer gr¨oßer oder gleich

Dieses erm¨oglicht Zuweisungen der Form boolean ergebnis = (42 == 2*21); welches ergebnis den Wert true zuweist. Einige abk¨urzende Schreibweisen f¨ur Zuweisungen, die es auch in C gibt, sind sehr gebr¨auchlich in Java, etwa i++; statt i=i+1;, i+=42; statt i=i+42; und weitere. Variablen verschiedenen Typs haben zun¨achst nichts miteinander zu tun. Da es allerdings h¨aufig vorkommt, daß man Variablen verwendeten Typs miteinander verkn¨upfen m¨ochte, ist die Konvertierung von Typen in Java durch sogenannte Casts der Form (Typ) Variablenbezeichner in vielen F¨allen m¨oglich. Etwa int a = (int)0.42; liefert eine Integervariable a mit dem Wert 0, dem Integeranteil der rellen Zahl 0.42. Casting ist nur f¨ur sinnvolle Typumwandlungen m¨oglich, nicht etwa zwischen rellen Zahlen und boolean, wohl aber zwischen ganzen und reellen Zahlen. Einige Typumwandlungen sind so h¨aufig, daß sie sogar implizit geschehen: ruft man einen Operator mit einer ganzen und einer reellen Zahl auf, wird die ganze Zahl erst in eine reelle Zahl umgewandelt, z.B. 3 * 42.42 liefert 127.26. Generell geschieht das so, daß keine Information verloren geht, d.h. der Typ, der den kleineren Bereich abdeckt, wird zum Typen mit gr¨oßerem Bereich. 3 Auf eine h¨aufige implizite Typumwandlung soll hier explizit hingewiesen werden: die Konkatenation von Strings liefert einen String zur¨uck, etwa zeit = 10; satz = "die Uhr schl¨ agt "; system.out.printeln(satz+zeit); agt 10. liefert den Satz die Uhr schl¨ Hier kommen wir auch schon zum letzten Aspekt, der uns bei Variablen f¨ur’s erste interessieren soll, die Ein- und Ausgabe. Ausgabe von Text auf die Kommandozeile geschieht durch den Aufruf system.out.println(<String>); der den u¨ bergebenen String gefolgt von einem Zeilenumbruch ausgibt, system.out.print(<String>); 3

Das ist ein Unterschied zu C. Außerdem kann aufgrund der nur approximativen Darstellung mancher Zahlen trotzdem Information verloren gehen, wie wir sp¨ater noch sehen werden.

2 ERSTE SCHRITTE IN JAVA

18

unterdr¨uckt den Zeilenumbruch. Der Zeilenumbruch ist u¨ brigens durch den String "\n" charakterisiert. Umgekehrt m¨ochte man Variablen Werte zuweisen. Das Einlesen ist in Java etwas ungew¨ohnlich, da f¨ur andere Zwecke optimiert. Wir beschr¨anken uns daher zun¨achst auf die Kommandozeileneingabe. Ruft man die Klasse der main Methode auf, kann man ihr eine Anzahl von Strings mitgeben, die in der main Methode durch args[0], args[1], . . . ansprechbar sind. Wir k¨onnen also u¨ ber die Kommandozeile Strings einlesen. Strings kann man durch in Java bereitgestellte Methoden in u¨ bliche Datentypen verwandeln: byte b = Byte.parseByte(String0); short s = Short.parseShort(String1); int i = Integer.parseInt(String2); long i = Long.parseLong(String3); float f = Float.parseFloat(String4); double d = Double.parseDouble(String5); Die Umwandlungen werden vorgenommen, so die eingegebenen Strings den entsprechenden Typen beschreiben, ansonsten meldet Java einen Fehler (eine Exception, deren Behandlung wir sp¨ater noch kennenlernen).4 Das soll f¨ur unsere Zwecke erstmal reichen. Wir sind jetzt also in der Lage, komplexe Zuweisungen zu implementieren. Ein Beispiel: /************************************************************ * * HelloWorld advanced.java * *************************************************************/ class HelloWorld advanced { public static void main(String[] args) { String name=args[0]; int anz=Integer.parseInt(args[1]); double mult= Double.parseDouble(args[2]); System.out.println("Hello, "+ name + ", you want the number "+(int)(anz*mult) + "!"); } } Die Eingabe java HelloWorld advanced HAL 2 21.3 liefert den String Hello, HAL, you want the number 42!

2.3 Elementare Kontrollstrukturen Das obige Programm ist immer noch recht langweilig, da wir lediglich Werte zuweisen, aber keinerlei wirklichen Kontrollfluß implementieren k¨onnen. Dieser Abschnitt f¨uhrt einige wesentlich Kontrollstrukturen in Java ein (die es auch in a¨ hnlicher Form in C gibt). Wir haben die Kontrollstrukturen tats¨achlich schon bei unserem anf¨anglichen Kochrezept kennengelernt: 4

Die double- und float-Konvertierungen gelten ab Java 1.2.

2.3 Elementare Kontrollstrukturen

19

• if-Anweisung – die bedingte Ausf¨uhrung hat die Form: if (){ } else { } Ein boolescher Ausdruck ist dabei jeder Ausdruck, der sich zu einem booleschen Wert auswerten l¨aßt. Ein Kommandoblock ist eine durch Semikolons getrennte Folge von Kommandos (auch gar keins), etwa Zuweisungen, Schreibanweisungen, Aufruf von Methoden oder Kontrollstrukturen. Die Anweisung f¨uhrt je nach Wert des booleschen Ausdrucks den ersten oder zweiten Kommandoblock aus. Ein Beispiel: if (i%2 == 0){ System.out.println("Die Zahl "+ i + " ist gerade."); } else { System.out.println("Die Zahl "+ i + " ist ungerade."); } Das Programm testet, ob eine Zahl durch zwei teilbar ist. Die geschweiften Klammern d¨urfen weggelassen werden, wenn gar keins oder nur ein Kommando folgen, so z.B. bei iterierten if-statements. Ein Beispiel: if (i%2 == 0) System.out.println("Die Zahl "+i+" ist gerade."); else if (i%3 == 0) System.out.println("Die Zahl "+i+" ist durch 3 teilbar."); else if (i%4 == 0) System.out.println("Die Zahl "+i+" ist durch 4 teilbar."); else ; Ein leeres else-statement wie dieses letzte d¨urfte man auch weglassen. • while-Schleife – die Wiederholung von Bl¨ocken hat die Form: while () { } Dieses Programm wiederholt den Kommandoblock so h¨aufig (auch keinmal), bis die Bedingung nicht mehr erf¨ullt ist. Ein Beispiel j=2; while ((j
20

2 ERSTE SCHRITTE IN JAVA Dieses Programm testet m¨ogliche Teiler von i angefangen mit zwei bis zum Vorg¨anger von i. Gibt es keinen, dann ist i entweder die Einheit 1 oder eine Primzahl.

Diese beiden Kontrollstrukturen erlauben uns bereits, interessante Programme zu schreiben. Betrachten wir ein Beispiel, zu zwei nat¨urlichen Zahlen soll der gr¨oßte gemeinsame Teiler berechnet werden, d.h. die gr¨oßte positive ganze Zahl, die beide Zahlen ohne Rest teilt. Wir definieren eine Klasse ggT, die den ggT von zwei Zahlen berechnet: class ggT{ public static void main(String[] args){ int x=Integer.parseInt(args[0]); int y=Integer.parseInt(args[1]); if ((x<0)||(y<0)) System.out.println("ggT nicht definiert."); else { int teiler=1, i=1; while((i<=x)&&(i<=y)){ if ((x%i==0)&&(y%i==0)) teiler = i; i++; } System.out.println("ggT ist "+teiler); } } Dieser Algorithmus testet alle Zahlen bis x und y und gibt den gr¨oßten Teiler aus. Eine Alternative ist ein von Euklid vorgeschlagenes Schema, das mit den elementaren Rechenarten + und auskommt: class schneller ggT{ public static void main(String[] args){ int x=Integer.ParseInt(args[0]); int y=Integer.ParseInt(args[1]); if ((x<0)||(y<0)) System.out.println("ggT nicht definiert."); else { while ((x>0)&&(y>0)) { if (x>y) x-=y; else y-=x; } if (x==0) System.out.println("ggT ist"+y); else System.out.println("ggT ist"+x); } } } Dieser Algorithmus zieht von zwei nichtnegativen Zahlen solange wechselseitig die kleinere ab, bis sich eine Null ergibt. Die u¨ berbleibende Zahl ist dann der gr¨oßte gemeinsame Teiler. Dieses Programm ist in der Regel schneller als der erste Versuch, da sich + und - schneller berechnen lassen als %. Es ist allerdings nicht unbedingt offensichtlich, daß dieses Programm wirklich den ggT berechnet. Es ist noch nicht einmal wirklich klar, daß es immer terminiert. Die Hauptbeobachtung

2.3 Elementare Kontrollstrukturen

21

hinter dem Algorithmus ist folgende: sei x ≥ y ≥ 0. Dann ist ggt(x, y) =ggT(x − y, y). 5 Ferner ist ggT(x, 0) = x f¨ur alle x ≥ 0, da jede Zahl 0 teilt. Man verkleinert also die zu testenden Zahlen, ohne deren ggT zu ver¨andern, bis man beim offensichtlichen Fall, daß eine Variable Null ist, endet. Ein formaler Beweis der Korrektheit des Algorithmus wird im n¨achsten Kapitel stehen. Diese beiden Kontrollstrukturen, if-Anweisung und while-Schleife w¨urden tats¨achlich schon ausreichen, um beliebig komplexe Programme zu schreiben. Wie auch bei Zuweisungen gibt es einige alternative Strukturen, die oft verwendete Kontrollfl¨usse kompakter machen. Dazu geh¨oren • die do-while-Schleife, die im Gegensatz zur while-Schleife den Schleifenrumpf mindestens einmal durchl¨auft, bevor die Abbruchbedingung getestet wird: do { } while (); • die for-Schleife als spezielle while-Schleife: for (; ; ) { } Die wohl h¨aufigste Form ist der Art (for i=0;i) { case <Wert0 >: ; break; case <Wert1 >: ; break; case <Wert2 >: ; break; case <Wert3 >: ; break; ... default: ; break; } 5

Das ist eine Stelle, wo etwas Mathematik in der Informatik angebracht ist. Wir beweisen kurz diese Aussage: es reicht zu zeigen, daß jeder Teiler von x und y auch ein Teiler von x − y und y ist und umgekehrt. Denn dann ist der ggT der linken Seite auch ein Teiler der rechten, sogar der gr¨oßte, da ja sonst der ggT der rechten Seite einen gr¨oßeren ggT f¨ur die linke Seite darstellte. Sei also a|x und a|y, d.h. a · m = x und a · n = y f¨ur n, m ∈ N, m ≥ n, da x ≥ y. Dann ist aber x − y = a · (m − n), also x − y auch Teiler der rechten Seite. Gilt umgekehrt a|x − y und a|y, finden wir a · n = x − y und a · m = y f¨ur n, m ∈ N, also a · (n + m) = x, d.h. a teilt auch die linke Seite. 6 Man kann an dieser Stelle lokal auf die Schleife begrenzte Variablen deklarieren: for (int i=0;...)

3 EIGENSCHAFTEN VON ALGORITHMEN

22

Der Term Ausdruck wird ausgewertet und der durch diesen Wert bestimmte Fall ausgef¨uhrt. default umfaßt alle nicht abgedeckten Werte und kann auch weggelassen werden. break sorgt daf¨ur, daß nach Abarbeiten des Komandoblocks die switch Anweisung verlassen wird. Ansonsten w¨urde man alle weiteren folgenden Kommandobl¨ocke auch ausf¨uhren, das case nur den Anfangspunkt, nicht aber den Endpunkt festlegt.

3 Eigenschaften von Algorithmen Wir haben jetzt etwas informell die wesentlichen elementaren Kontrollstrukturen von Java eingef¨uhrt, ohne jedoch die Sprache z.B. in einer EBNF-Grammatik anzugeben oder das Verhalten von Zuweisungen und Kontrollstrukturen pr¨azise zu definieren. Bevor wir zu komplexeren Algorithmen und objektorientierter Programmierung kommen, soll f¨ur eine ganz einfache, abgespeckte Version von Java (und anderer a¨ hnlicher Programmiersprachen wie C) eine formale Definition stehen. Anhand dieser formalen Definition m¨ochten wir einige Eigenschaften von Algorithmen, insbesondere deren Korrektheit und Komplexit¨at untersuchen. Eine essentielle Unterscheidung zur Definition von Programmen ist die Unterscheidung in Syntax von Programmen und Semantik. • Syntax referiert auf die grammatische Form von Programmen, die gewissen Regeln gehorchen m¨ussen, um verstanden zu werden. • Semantik referiert auf die durch das Programm bewirkten Operationen, die Funktionalit¨at, die dem gew¨unschten Verhalten entsprechen sollte. Programme werden zun¨achst u¨ bersetzt. Sind sie syntaktisch nicht korrekt, k¨onnen sie nicht vom Compiler verstanden werden und ein Syntaxfehler wird berichtet. Die Semantik von Programmen zeigt sich erst bei der Ausf¨uhrung. Haben wir z.B. ein Programm geschrieben, das den ggT berechnen soll, dann merken wir erst beim Ausf¨uhren, ob dieser auch wirklich berechnet wird, oder ein semantischer Fehler vorliegt. Wir werden entsprechend zwei Ebenen unterscheiden, die syntaktische und semantische Ebene.

3.1 Syntax und Semantik von Programmen Grundbausteine, verm¨oge denen Information in Programmen gespeichert wird, sind Variablen eines bestimmten Typs. Wir haben mehrere elementare Typen wie Integer oder Boolean kennengelernt, f¨ur die elementare Operationen wie Addition oder Vergleich durchgef¨uhrt werden k¨onnen. Diese Bereiche bilden die Grundbeschreibung der Objekte, mit denen wir im Programm umgehen wollen, und werden als erstes definiert. Formal wird dieses durch den Begriff einer sogenannten (S, Σ)-Algebra charakterisiert.7 Kommen wir zun¨achst zur Syntax: Definition 3.1 Eine Signatur Σ ist ein Paar (S, Σ) mit einer endlichen Menge S von sogenannten Sortensymbolen oder Typbezeichnern und einer endlichen Menge Σ von Zeichenreihen einer der folgenden Bauarten: c :→ s f : s1 × . . . × s n → s p : s1 × . . . × s n 7

Dieser Begriff hat nichts mit Algebren der linearen Algebra oder σ-Algebren der Statistik zu tun, sondern ist ein standard-Begriff in der theoretischen Informatik.

3.1 Syntax und Semantik von Programmen

23

mit n > 0 und s, s1 , s2 , . . . , sn ∈ S. Das Zeichen c heißt ein Konstantensymbol, f heißt ein Funktionssymbol, das Zeichen p ein Relationssymbol. Eine Variablenmenge V u¨ ber der Signatur (S, Σ) besteht aus Zeichenreihen X : s mit einem Variablenbezeichner X und einer Sorte s ∈ S. Kein Variablenbezeichner darf in zwei verschiedenen Zeichenreihen von V vorkommen. Ist X : s in V , so nennen wir X eine Variable aus V vom Typ s. Wir kennen bereits einige Beispiele von Signaturen aus Java, z.B. Boolean oder Integer. Zur Illustration geben wir hier eine Signatur f¨ur Integer an: Typsymbol int Konstantensymbole 0 :→ int Funktionssymbole + : int × int → int − : int → int ∗ : int × int → int Relationssymbole =: int × int <: int × int Wir haben hier einige Symbole wie %, <=, . . . weggelassen. Dieses definiert die grundlegenden Symbole, die wir im Zusammenhang mit Variablen verwenden d¨urfen. Dazu geh¨ort eine geeignete Semantik. Bezogen auf Variablen ist das ein Zustand der Variablen, d.h. eine aktuelle Wertzuweisung, wie sie im Rechner vorliegt. Bezogen auf eine Signatur ist das eine Interpretation der Symoble, die besagt, wie Funktionen, Konstanten und Relationen tats¨achlich berechnet werden. Definition 3.2 Sei Σ eine Signatur. Eine (S, Σ)-Algebra A ist eine Abbildung, die jeder Sorte s ∈ S eine nichtleere Menge sA , jedem Konstantensymbol c :→ s in Σ eine Konstante cA ∈ s A , jedem Funktionssymbol f : s1 × . . . × sn in Σ eine Funktion fA : s1A × . . . × snA → sA und jedem Relationssymbol p : s1 × . . . × sn in Σ eine Relation pA ⊆ s1A × . . . × snA zuordnet. Die Mengen sA f¨ur s ∈ S heißen die Grundbereiche der Algebra A. Sei (S, Σ) eine Signatur, V eine endliche Variablenmenge u¨ ber (S, Σ) und A eine (S, Σ)Algebra. Ein Zustand z u¨ ber A und V ist eine Funktion z, die jeder Variablen X mit X : s in V einen Wert z(X) in der Menge sA zuordnet. Wir m¨ochten an dieser Stelle bemerken, daß wir unter Funktionen auch partielle Funktionen fassen. D.h. es ist erlaubt, wenn der Funktionswert f¨ur einige Eingaben nicht definiert ist. In diesem Fall schreiben wir f (x) ↑. Das ist sinnvoll z.B. f¨ur Funktionen wie die Division, die bei Null einen nicht definierten Werte liefert. Funktionen, die auf allen Eingabewerten definiert sind, nennen wir total. Ein Beispiel f¨ur eine (S, Σ)-Algebra sind die ganzen Zahlen Z, die obige Signatur wie folgt interpretieren:

3 EIGENSCHAFTEN VON ALGORITHMEN

24

Grundbereich intZ = {. . . , −2, −1, 0, 1, 2, . . .} Konstanten 0Z = die Zahl Null Funktionen +Z ist die Addition zweier Zahlen −Z ist das Negative einer Zahl ∗Z ist die Multiplikation zweier Zahlen Relationen
wobei X eine Variable der Variablenmenge, c ein Konstantensymbol, und f ein Funktionssymbol der Stelligkeit n aus der gegebenen Signatur sind. 8 Boolesche Formeln u¨ ber V und (S, Σ) sind durch folgende Regeln erzeugt: BoolescheFormel ::= op atomareFormel

::= ::=

atomareFormel | ¬ BoolescheFormel | (BoolescheFormel op BoolescheFormel) ∧| ∨ | → | ↔ p(Term, . . . , Term) | Term = Term | {z } n−mal

wobei p ein Relationssymbol der Stelligkeit n der gegebenen Signatur ist.

Funktionssymbole und Relationssymbole werden in dieser Notation pr¨afix geschrieben: +(x, y) statt x + y. Wir verwenden der besseren Lesbarkeit wegen die u¨ bliche infix-Notation. Ein Term u¨ ber den ganzen Zahlen ist z.B. ((x ∗ (y + 0)) ∗ (−3)) , eine boolesche Formel (((x < y) ∨ (x = y)) ∨ (y < x)) . Funktionssymbole und Relationssymbole k¨onnen wir direkt auswerten. Die Auswertung kann man kanonisch auf Terme und Formeln ausdehnen: Definition 3.4 Sei A eine Algebra, V eine Variablenmenge und z ein Zustand u¨ ber V . Dann wird der Wert eines Terms t in Algebra A zum Zustand z definiert als 8

H¨atten wir uns nicht auf ein Sortensymbol beschr¨ankt, dann m¨ussten wir Terme speziellen Typs gesondert definieren, um sicherzustellen, daß nur Terme geeigneten Typs f¨ur die jeweiligen Funktionssymbole verwendet werden.

3.1 Syntax und Semantik von Programmen • valA,z (X) = z(X) • valA,z (c) = cA

25

f¨ur X ∈ V ,

f¨ur Konstantensymbole c,

• valA,z (f (t1 , . . . , tn )) = fA (valA,z (t1 ), . . . , valA,z (tn ))

f¨ur Funktionssymbole f .

Sei ϕ eine boolesche Formel. Wir definieren iterativ u¨ ber den Aufbau der Formel den Ausdruck, daß die Formel in Algebra A zum Zustand z gilt, geschrieben A |=z ϕ als: • A |=z p(t1 , . . . , tn ) ⇐⇒ (val(t1 ), . . . , val(tn )) ∈ pA , • A |=z t1 = t2 ⇐⇒ val(t1 ) = val(t2 ), • A |=z ¬ϕ ⇐⇒ A 6|=z ϕ, • A |=z (ϕ ∧ ψ) ⇐⇒ A |=z ϕ und A |=z ψ, • A |=z (ϕ ∨ ψ) ⇐⇒ A |=z ϕ oder A |=z ψ, • A |=z (ϕ → ψ) ⇐⇒ A 6|=z ϕ oder A |=z ψ, • A |=z (ϕ ↔ ψ) ⇐⇒ (A |=z ϕ und A |=z ψ) oder (A 6|=z ϕ und A 6|=z ψ), Dabei verwenden wir 6|= als abk¨urzende Schreibweise daf¨ur, daß |= nicht gilt. Wir schreiben A |= ϕ wenn A |=z ϕ f¨ur alle Zust¨ande z gilt. Wir haben jetzt Syntax und Semantik f¨ur den Bereich definiert, auf dem ein Programm arbeiten kann. Kommen wir zu einer vereinfachten formalen Definition der Syntax und Semantik von Programmen. Wie schon vorher, beschr¨anken wir uns auf nur eine Sorte, so daß wir keine Variablendeklarationen verwenden m¨ussen und uns auf Kontrollstrukturen beschr¨anken k¨onnen. Desweiteren ignorieren wir Ein- und Ausgabefunktionen und die M¨oglichkeit, Methoden aufzurufen. Wir beschr¨anken uns also auf den imperativen Kern von Java. Zun¨achst definieren wir formal, wie so ein abgespecktes Programm, ein while-Programm aussehen darf. Definition 3.5 Sei (S, Σ) eine (einsortige) Signatur und V eine Variablenmenge. Dann ist ein while-Programm u¨ ber (S, Σ) und V durch folgende EBNF-Regeln erzeugt: WhileProgramm Anweisung Zuweisung Test Schleife

::= Anweisung WhileProgramm | ::= Zuweisung | Test | Schleife ::= Variable := Term; ::= if (BoolescheFormel) { WhileProgramm } else { WhileProgramm } ::= while (BoolescheFormel) { WhileProgramm }

ist dabei ein Indikator f¨ur einen leeren String, das leere Programm.

3 EIGENSCHAFTEN VON ALGORITHMEN

26

Wir haben hier nur einen Teil der in Java g¨ultigen Sequenzen formuliert, der f¨ur unsere Zwecke ausreicht. Eine leichte Abweichung von Java besteht in der Darstellung von Formeln, bei der wir uns an die klassische Notation der Mathematik und Informatik halten. Wir verwenden also = statt == f¨ur Gleichheit und die logischen Operatoren ∧, ∨, . . . statt &&, ||, . . . Syntaktisch g¨ultige while-Programme sind alle so erzeugten Strings. F¨ur diese definieren wir formal eine Semantik, die erkl¨art, was w¨ahrend der Programmabarbeitung geschieht. Ein Programm arbeitet auf einem Zustand und ver¨andert die Werte der Variablen in der durch das Programm angegebenen Weise. Wir nehmen, anders als bei tats¨achlich existenten Programmen manchmal der Fall, an, daß allen im Programm gebrauchten Variablen ein initialer Wert zugewiesen ist. Wir spezifizieren die Semantik von Programmen formal durch die sogenannte Interpretersemantik. Diese erkl¨art, wie ein Interpreter die Programmanweisungen sukzessive abarbeitet und einen gegebenen Zustand a¨ ndert. Definition 3.6 Sei A eine (S, Σ)-Algebra und V eine Variablenmenge. Die Interpreterfunktion f u¨ r while-Programme u¨ ber A und V ist eine totale Funktion IA : (α, z) 7→ (α0 , z 0 ), die einem while-Programm α und Zustand z ein Tupel (α 0 , z 0 ) zuordnet bestehend aus dem durch Abarbeitung des ersten Kommandos von α aus z erreichten Zustand z 0 und des noch abzuarbeitenden Restprogramms α0 . IA ist definiert als • IA (, z) = (, z), • IA (X := t; β, z) = (β, z(X/valA,z (t))), (γ β, z) falls A |=z B • IA (if (B){γ} else {δ} β, z) = , (δ β, z) sonst (γ while (B){γ} β, z) falls A |=z B • IA (while (B){γ} β, z) = . (β, z) sonst Dabei bezeichnet z(X/a) den Zustand, den man erha¨ lt, wenn man die Variable X mit dem Wert a belegt und alle anderen Variablenbelegungen gleich la¨ ßt. Die Interpretersemantik definiert, was in einem Schritt bei der Programmabarbeitung geschieht. Wir lassen den Index A auch weg, wenn A aus dem Kontext klar ist, und schreiben schlicht I statt IA . Die Abarbeitung kompletter Programme erh¨alt man durch Iteration der Funktion I: I t (α, z) = I(. . . I (α, z) . . .) | {z } t−mal

beschreibt, was nach t Schritten als Restprogramm und aktueller Zustand erhalten wird. Besonders interessiert sind wir an dem Zustand, der erhalten wird, wenn das Programm abgearbeitet wurde, d.h. an demjenigen z 0 f¨ur das gilt I t (α, z) = (, z 0 ) f¨ur einen Zeitpunkt t. Wir schreiben als Kurznotation I ∞ (α, z) = z 0 , falls I t (α, z) = (, z 0 )

3.2 Korrektheit

27

f¨ur ein t gilt. Zu beachten ist, daß es mehrere solche t geben kann: denn ist I t (α, z) = (, z 0 ), dann gilt dasselbe auch f¨ur alle t0 > t. Der Zustand z 0 ist allerdings unabh¨angig von der konkreten Wahl t, da die Ausf¨uhrung des leeren Programms den Zustand nicht a¨ ndert. Dieses ist also eine formale Definition der Semantik von while-Programmen, die als sehr eingeschr¨ankte Java-Programme interpretiert werden k¨onnen. Eine pr¨azise Definition von tats¨achlichen Java-Programmen w¨are im Prinzip a¨ hnlich, allerdings wesentlich umfangreicher, daher verzichten wir hier darauf. Eine formale Spezifikation ist allerdings n¨otig, einerseits wenn man saubere Compiler f¨ur Programmiersprachen schreiben m¨ochte und am Programmiersprachenentwurf interessiert ist, andererseits wenn man Programme und deren Eigenschaften formal untersuchen m¨ochte.

3.2 Korrektheit Nachdem wir Syntax und Semantik von Programmen formal definiert haben, interessieren wir uns f¨ur semantische Korrektheit von Programmen. Das beeinhaltet Fragestellungen, die im Zusammenhang mit der Programmentwicklung essentiell sind: Wie formalisiert man, was ein Programm semantisch leisten soll? Wie zeigt man, daß ein Programm das leistet, was es leisten soll? Es gibt verschiedene M¨oglichkeiten und Formalisierungen. Die Spezifikation und Programmverifikation ist tats¨achlich ein aktuelles Forschungsgebiet. Wir werden hier eine sehr bekannte Methode, die der partiellen Korrektheitsaussagen, kennenlernen. Wir erweitern zun¨achst den Begriff von Formeln auf pr¨adikatenlogische Formeln: Definition 3.7 Sei (S, Σ) eine (einsortige) Signatur und V eine Variablenmenge. Eine pr¨adikatenlogische Formel wird durch folgende EBNF-Grammatik erzeugt Formel ::= Quantor ::=

BoolescheFormel | Quantor Variable Formel | ¬ Formel | ( Formel op Formel ) ∀|∃

Die G¨ultigkeit pr¨adikatenlogischer Formeln f¨ur eine Algebra A im Zustand z ist f¨ur Quantoren wie folgt definiert • A |=z ∃X ϕ ⇐⇒ es gibt ein a ∈ sA mit A |=z(X/a) ϕ, • A |=z ∀X ϕ ⇐⇒ f¨ur alle a ∈ sA gilt A |=z(X/a) ϕ. F¨ur alle anderen Formen k¨onnen wir die Definition von booleschen Formeln u¨ bernehmen. Wie schon eben, schreiben wir A |= ϕ wenn A |=z ϕ f¨ur alle Zust¨ande z gilt. Die Zeichen ∀ und ∃ heißen auch Quantoren. Sie bedingen, daß die dahinter stehende Variable eine spezielle Bedeutung hat: sie steht nicht f¨ur eine durch einen Zustand definierte Variable, sondern referiert auf alle m¨oglichen Werte (∀) bzw. die Existenz mindestens eines Wertes (∃). Die Teilformel ϕ in einer quantisierten Formel ∀/∃X ϕ heißt auch Wirkungsbereich des Quantors. Im Wirkungsbereich des Quantors ist die Variable X eine sogenannte gebundene Variable. F¨ur gebundene Variablen ist der Wert im jeweiligen Zustand uninteressant, da er f¨ur die Auswertung der Formel nicht benutzt wird. Variablen, die nicht gebunden sind (die ihren Wert also vom derzeitigen Zustand erhalten) heißen freie Variablen Die Pr¨adikatenlogik ist eine klassische Beschreibungssprache der Mathematik und Informatik. Wir haben bereits boolesche Formeln im Zuge von Programmen verwendet. Pr¨adikatenlogische Formeln verwenden wir hier, um das Verhalten eines Programms formal zu beschreiben. Programme dienen einem gewissen Zweck. Sie werden in speziellen Konstellationen aufgerufen, und man

3 EIGENSCHAFTEN VON ALGORITHMEN

28

erwartet, daß diese Konstellationen durch das Programm in gew¨unschte Konstellationen u¨ berf¨uhrt werden. Man kann ein Programm offensichtlich vollst¨andig dadurch beschreiben, daß man sein Verhalten auf allen m¨oglichen Anfangszust¨anden spezifiziert. Da das allerdings sehr viele sein k¨onnen und uns unter Umstanden das genaue Verhalten f¨ur jede beteiligte Variable gar nicht interessiert, erm¨oglichen wir mithilfe partieller Korrektheitsaussagen eine gezieltere Beschreibung. Definition 3.8 Sei (S, Σ) eine Signatur und V eine Variablenmenge. Eine partielle Korrektheitsaussage hat die Form hϕiαhψi mit pr¨adikatenlogischen Formeln ϕ und ψ und einem Programm α u¨ ber (S, Σ) und V .9 ϕ ist die Vorbedingung der Aussage, ψ die Nachbedingung. Sei A eine (S, Σ)-Algebra. Eine partielle Korrektheitsaussage ist in A g¨ultig, falls f¨ur alle Zust¨ande z u¨ ber V folgendes richtig ist: falls A |=z ϕ und I ∞ (α, z) = z 0 , dann gilt A |=z 0 ψ. Partielle Korrektheitsaussagen formalisieren also, daß, falls vor der Abarbeitung des Programms ϕ gilt, nach der Abarbeitung (so daß Programm terminiert) ψ gilt. Eine Feinheit ist zu bemerken, weswegen wir hier auch nur von partieller Korrektheit sprechen. Es ist nicht sichergestellt, daß das Programm terminiert. Falls es nicht terminiert, dann sichert eine partielle Korrektheitsaussage nichts zu, denn es gibt keine Zust¨ande, f¨ur die wir irgendetwas u¨ berpr¨ufen m¨ussten. Dennoch ist eine partielle Korrektheitsaussage sehr n¨utzlich, das Verhalten eines Programms zu beschreiben. Betrachten wir dazu eine abgespeckte Version des Programms, das den ggT berechnet. A:=X;B:=Y; while (0
Partielle Korrektheitsaussagen werden in der Literatur oft mit geschweiften Klammern {ϕ}α{ψ} geschrieben. Wir verwenden hier aber spitze Klammern, um keine Verwechslungen mit geschweiften Klammern der Programmiersprache zu erhalten.

3.2 Korrektheit

29

Programm mit nichtnegativen Werten, dann ist nach Beendigung des Programms eine der Programmvariablen A und B null und die andere speichert den ggT der Anfangszuweisungen. Die Frage ist jetzt, wie wir formal zeigen k¨onnen, daß diese partielle Korrektheitsaussage stimmt. Eine in der Praxis gebr¨auchliche Methode, Programme zu testen, ist, das Programm f¨ur m¨oglichst viele repr¨asentative Eingaben laufen zu lassen und die Ausgabe zu u¨ berpr¨ufen. Das ist nat¨urlich kein Beweis der Korrektheit des Programms, da ja prinzipiell nur endlich viele der in der Regel unendlich vielen m¨oglichen Situationen getestet werden k¨onnen. Sind die Daten repr¨asentativ, was bedeutet, daß die Gesamtheit der Eingaben alle relevanten Zweige des Programms (z.B. Zweige von if-Anwesiungen, Bedingungen bei while-Schleifen) u¨ berspannt, besteht zumindest ein gewisses Vertrauen, daß das Programm tut, was es sollte. Gezielte Testmethoden dieser Art sind Gegenstand des Software-Engineering. Eine Alternative, die erlaubt, Korrektheitsaussagen formal zu beweisen, offeriert die Programmverifikation. Wir lernen hier eine Methode, die Methode der Zusicherungen nach dem Hoareschen Kalk¨ul kennen. Sie erlaubt, sukzessive komplexe Programmteile auf einfachere St¨ucke herunterzubrechen und auf elementare g¨ultige Zusicherungen zur¨uckzuf¨uhren. Diese Methode beschreibt, die Auswirkung von einzelnen Anweisungen auf die G¨ultigkeit von Zusicherungen im Programm. Um dieses formal f¨ur Anweisungen im Programm einzuf¨uhren, ben¨otigen wir noch die Notation von Substitutionen, die den Effekt von Wertzuweisungen in einer Formel ausdr¨ucken k¨onnen. Definition 3.9 Sei (S, Σ) eine Signatur und V eine Variablenmenge. Eine Substitution besteht aus einer endlichen Menge {X1 /s1 , . . . , Xn /sn } mit paarweise verschiedenen Variablen Xi aus V und Termen si u¨ ber (S, Σ) und V . Die Anwendung einer Substitution auf einen Term t ist wie folgt rekursiv definiert: si falls X = Xi in σ vorkommt • Xσ = X sonst • cσ = c f¨ur alle Konstantenbezeichner c, • f (t1 , . . . , tn )σ = f (t1 σ, . . . , tn σ) f¨ur Funktionssymbole f und Subterme ti . Man ersetzt also alle Auftreten von Symbolen Xi gegen die zugeh¨origen si . Analog definiert man f¨ur Formeln ϕ: • [p(t1 , . . . , tn )]σ ist p(t1 σ, . . . , tn σ) f¨ur Relationssymbole p. [t1 = t2 ]σ ist t1 σ = t2 σ. • [¬ϕ]σ = ¬[ϕ]σ [(ϕ op ψ)]σ = ([ϕ]σ op [ψ]σ) f¨ur op ∈ {∧, ∨, →, ↔}. • [QX ϕ]σ = QY [[ϕ]{X/Y }]σ f¨ur Q ∈ {∀, ∃}, wobei Y eine Variable ist, die nicht in der Substitution σ vorkommt. (Man ersetzt also alle Auftreten nicht gebundener Variablen der Formel durch die in der Substitution angegebenen Terme.) Substitutionen erlauben, Wertzuweisungen f¨ur einen Zustand innerhalb einer Formel oder eines Terms zu simulieren. Mithilfe von Substitutionen k¨onnen wir den Effekt von Zuweisungen auf partielle Korrektheitsaussagen modellieren. Wir k¨onnen das Hoaresche Kalk¨ul jetzt vollst¨andig aufschreiben: • -Regel: Falls A |= (ϕ → ψ), dann ist hϕi hψi g¨ultig.

3 EIGENSCHAFTEN VON ALGORITHMEN

30 • Zuweisungsregel: Falls A |= (ϕ → [ψ]{X/t}) dann ist hϕi X := t; hψi g¨ultig.

• Tests: Falls h(ϕ ∧ B)iαhψi und h(ϕ ∧ ¬B)iβhψi g¨ultig sind, dann auch hϕi if(B){α}else{β} hψi. • Schleifen: Falls h(ϕ ∧ B)i α hϕi g¨ultig ist, dann auch hϕi while(B){α} h(ϕ ∧ ¬B)i • Anweisungsfolgen: Falls hϕi α hψi und hψi β hχi g¨ultig sind, dann auch hϕi α β hχi. Um dieses Kalk¨ul anzuwenden, muß man also nur angefangen von den gew¨unschten partiellen Korrektheitsaussagen das Programm mit Zusicherungen folgender Form kommentieren: hϕi if (B) {h(ϕ ∧ B)i α hψi} else {h(ϕ ∧ ¬B)i β hψi} hψi hϕi while (B) {h(ϕ ∧ B)i α hϕi} h(ϕ ∧ ¬B)i hϕi α hξi β hψi Was dann letztlich zu zeigen verbleibt, ist A |= (ϕ → ψ) , wenn hϕihψi oder hϕi hψi im kommentierten Programmtext vorkommt, bzw. A |= (ϕ → [ψ]{X/t}) , wenn hϕi X := t; hψi im kommentierten Programmtext vorkommt. Diese Regeln simulieren das Verhalten des Programms auf den Zusicherungen: das leere Programm hat keinerlei Auswirkung auf die Zust¨ande. Eine Zusicherung f¨ur das leere Programm kann also dann und nur dann gelten, wenn f¨ur Zust¨ande, f¨ur die die Vorbedingung gilt, auch schon die Nachbedingung erf¨ullt ist. Die Zuweisungsregel ber¨ucksichtigt, daß sich der Wert der Variablen X zum Wert des Terms t a¨ ndert. Zus¨atzlich zur Vorbedingung ϕ kann man also X durch t substituieren. 10 Der Test ber¨ucksichtigt, daß je nach G¨ultigkeit der Formel B der erste oder zweite Zweig der bedingten Anweisung durchlaufen wird. 10

Man kann das f¨ur mehrere Zuweisungen direkt generalisieren: falls hϕi X 1 := t1 ; . . . Xn := tn ; hψi vorkommt, ist A |= (ϕ → ψ{xn /tn } . . . {x1 /t1 }) zu zeigen, wobei die Substitutionen der Terme in umgekehrter Reihenfolge vorgenommen werden.

3.2 Korrektheit

31

Die Schleifenregel ist die f¨ur den Benutzer des Hoareschen Kalk¨uls zu Beginn vielleicht schwierigste Regel. Sie basiert auf der Existenz einer sogenannten Schleifeninvarianten, der Formel ϕ in obiger Notation. Die Motivation hinter dieser Schleifeninvarianten ist folgende: Man weiß nicht, wie h¨aufig die Schleife durchlaufen wird, auch keinmal. Man weiß nur, daß zu Beginn des Schleifenrumpfs die Formel B gilt, nach der Schleife nicht mehr. Zus¨atzlich steht an allen Stellen die Schleifeninvariante ϕ. Da es ja a priori nicht klar ist, wie h¨aufig die Schleife durchlaufen wird, fomuliert diese Invariante die Gesetzm¨aßigkeiten, die gelten, egal wie h¨aufig der Schleifenrumpf schon abgearbeitet wurde. Insbesondere auch zum ersten Eintritt in die Schleife und zum finalen Austritt aus der Schleife (wenn es ihn gibt). Diese Regeln sind g¨ultig in dem Sinne, daß alles, was mithilfe dieser Regeln hergeleitet werden kann, eine g¨ultige partielle Korrektheitsaussage darstellt. Der formale Beweis f¨ur diese Eigenschaft ist etwas l¨anger. Um ein Gef¨uhl f¨ur die Art des Beweises zu bekommen, zeigen wir die wesentlichen Teile: Theorem 3.10 Sei hϕiαhψi mit dem Hoareschen Kalku¨ l abgeleitet. Sei z ein Zustand mit A |=z ϕ. Sei I t (α, z) = (, z 0 ). Dann gilt A |=z 0 ψ. Beweis: Die Aussage geschieht durch Induktion u¨ ber t, die Anzahl der Zeitschritte, bis das Programm abgearbeitet wurde. • Induktionsanfang: t = 0. Dann ist notwendig α = das leere Programm und z = z 0 . Es wurde notwendig die -Regel angewandt. Es gilt also A |= (ϕ → ψ), wegen A |= z ϕ, also A |=z ψ. • Induktionsannahme: f¨ur alle Programme α, alle mit dem Hoareschen Kalk¨ul ableitbaren partiellen Korrektheitsaussagen hϕi α hψi, alle Zust¨ande z mit A |=z ϕ und alle t0 < t gilt 0 im Fall I t (α, z) = (, z 0 ) die Aussage A |=z 0 ψ. • Induktionsschritt: wir zeigen die Aussage f¨ur t > 0. Dabei machen wir eine Fallunterscheidung danach, welches die zuletzt angewandte Kalk¨ulregel war. – Die Zuweisungsregel: Die uns interessierende partielle Korrektheitsaussage hat also die Form hϕi X := t; hψi und es gilt nach Voraussetzung in A die Aussage (ϕ → [ψ]{X/t}). Ein Interpreterschritt arbeitet das Programm ab zu dem Tupel I(X := t; , z) = (, z(X/valA,z (t))). Es gilt A |=z(X/valA,z (t)) ψ ⇐⇒ A |=z [ψ]{X/t} d.h. statt den Wert der Variablen X durch den Wert des Terms t zu ersetzen, k¨onnen wir auch die Variable X durch den Term t in der Formel erstezen. Dieses ist das sogenannte Substitutionslemma, das man induktiv u¨ ber den Aufbau von Formeln und Termen zeigen kann. Wir lassen diesen Beweis hier weg. Es gilt also hier ψ wegen der G¨ultigkeit von (ϕ → [ψ]{X/t}). – Die Testregel: Die partielle Korrektheitsaussage ist hϕi if (B) {α 0 } else {β} hψi, und es gilt nach Voraussetzung hϕ ∧ Bi α0 hψi und hϕ ∧ ¬Bi β hψi. Der Interpreter evaluiert das Programm zu zwei m¨oglichen Ergebnissen: t−1 0 I (α , z) falls A |=z B t 0 I (if (B){α } else {β}, z) = I t−1 (β, z) falls A 6|=z B Im ersten Fall gilt in z die Formel ϕ ∧ B, im zweiten Fall ϕ ∧ ¬B, also nach Induktionsvoraussetzung in beiden F¨allen A |=z 0 ψ aufgrund der g¨uligen partiellen Korrektheitsaussagen.

32

3 EIGENSCHAFTEN VON ALGORITHMEN – Die Schleifenregel: Da die Schleifenregel angewandt wurde, wissen wir, die uns interessierende partielle Korrektheitsaussage hat die Form hϕi while(B){α 0 } h(ϕ ∧ ¬B)i und die partielle Korrektheitsaussage h(ϕ ∧ B)i α 0 hϕi ist ebenfalls ableitbar. Die Interpretersemantik macht zwei F¨alle ∗ A 6|=z B: Dann ist I(while(B){α0 }, z) = (, z). Also z = z 0 . Wir wissen also A |=z 0 (ϕ ∧ ¬B). ∗ A |=z B: Dann ist I(while(B){α0 }, z) = (α0 while(B){α0 }, z). Da dieses Programm zum leeren Programm abgearbeitet wird, gibt es Zahlen t0 und t00 und einen 0 00 Zustand z 00 mit I t (α0 , z) = (, z 00 ) und I t (while(B){α0 }, z 00 ) = (, z 0 ). Man kann t0 < t und t00 < t w¨ahlen. Wir wissen, daß im Hoareschen Kalk¨ul die beiden partiellen Korrektheitsaussagen hϕi while(B){α 0 } h(ϕ ∧ ¬B)i und h(ϕ ∧ B)i α0 hϕi ableitbar sind. Nach Voraussetzung ist A |=z ϕ und in diesem Fall gilt A |=z B, also, da t0 < t, A |=z 00 ϕ nach Induktionsvoraussetzung. Da t00 < t, also A |=z 0 (ϕ∧¬B) nach Induktionsvoraussetzung. – Die Anweisungsfolgenregel: dann hat die Korrektheitsaussage der Form hϕi α 0 β hψi und es gibt ein χ, so daß die Korrektheitsaussagen hϕi α 0 hχi und hχi β hψi g¨ultig sind. α0 und β werden je in weniger Interpreterschritten abgearbeitet, etwa t 1 und t2 mit t1 + t2 = t. Nach Induktionsvoraussetzung gilt f¨ur z 00 mit I t1 (α, z) = (, z 00 ) die Formel χ und f¨ur z 0 mit I t2 (β, z 00 ) = (, z 0 ) die Formel ψ.

Damit ist der Beweis beendet. Sie sehen also, die Beweise werden schon etwa komplizierter, wobei wir das Substitutionslemma, das es uns erlaubt, Substitutionen in Formeln und Substitutionen von Werten von Variablen auszutauschen, nicht formal bewiesen haben. Es ist allerdings einsichtig, und der Beweis w¨are nicht sehr schwer (nur lang). Wir haben jetzt ein automatische Verfahren an der Hand, das uns erlaubt, g¨ultige partielle Korrektheitsaussagen abzuleiten. Bevor wir dieses Kalk¨ul weiter diskutieren, soll hier erst ein Beispiel f¨ur dessen Anwendung stehen. Das Programm zur Berechnung des ggT: hX ≥ 0, Y ≥ 0i (1) A:=X; hX ≥ 0, Y ≥ 0, A = Xi (2) B:=Y; hX ≥ 0, Y ≥ 0, A = X, B = Y i (3) ξ = hX ≥ 0, Y ≥ 0, A ≥ 0, B ≥ 0, ggT(X, Y ) = ggT(A, B)i (4) while (0
3.2 Korrektheit else { hξ, 0 < A, 0 < B, ¬B < Ai B:=B+(-A); ξ (9) } ξ (10)

33

(8)

} hξ, ¬((0 < A) ∧ (0 < B))i (11) hX ≥ 0, Y ≥ 0, (A = 0 ∨ B = 0), A = 0 → B = ggT(X, Y ), B = 0 → A = ggT(X, Y )i (12) Die Zusicherungen (1) und (12) m¨ochten wir aufgrund der intendierten Semantik bekommen. Es ergeben sich daraus automatisch: Zusicherungen (2) und (3) modellieren lediglich den Effekt der beiden Zuweisungen. Zusicherung (4) ist die Schleifeninvariante, die automatisch die Form von (5), (10) und (11) festlegt. (6), (7), (8) und (9) folgen sofort aus der Regel f¨ur if-Anweisungen. Es verbleibt, die -Regeln und Zuweisungsregeln zu testen. D.h. die folgenden Schritte: • (1)→[(2)]{A/X}, d.h. (X ≥ 0 ∧ Y ≥ 0) → (X ≥ 0 ∧ Y ≥ 0 ∧ X = X}. Das gilt offensichtlich. • (2)→[(3)]{B/Y} folgt analog. • (3)→(4), das ist offensichtlich. • (6)→[(7)]{A/A-B}, d.h. (X ≥ 0∧Y ≥ 0∧A ≥ 0∧B ≥ 0∧ggT(X, Y ) = ggT(A, B)∧0 < A ∧ 0 < B ∧ B < A) → (X ≥ 0 ∧ Y ≥ 0 ∧ A − B ≥ 0 ∧ B ≥ 0 ∧ ggT(X, Y ) = ggT(A − B, B)). Das gilt, da ggT(x, y) = ggT(x − y, y), falls x − y ≥ 0. • (8)→[(9)]{B/B-A} folgt analog. • (11)→(12) folgt, da ggT(x, 0) = ggT(0, x) = x gilt. Wir sehen, viele der Aussagen folgen komplett automatisch. Es ist an einigen Stellen, bei hintereinanderfolgenden Zusicherungen bzw. Zuweisungen, die logische G¨ultigkeit der entsprechenden Implikationen zu zeigen. F¨ur einen menschlichen Anwender ein wenig schwierig ist, eine geeignete Schleifeninvariante zu finden. Diese k¨onnte im Prinzip eine v¨ollig neue Formel ξ sein, deren geeignete Form man raten muß. Von der Theorie her ist allerdings die Wahl der Schleifeninvarianten nicht schwierig, da man im Prinzip eine Schleifeninvarianten (in den meisten Algebren) automatisch berechnen kann, die zwar etwas lang sein kann, aber garantiert funktionieren muß. Die tats¨achliche Schwierigkeit des Kalk¨uls von theoretischer Warte aus ist tats¨achlich die -Regel: sie verlangt den Nachweis einer Formel A |= (ϕ → ψ), d.h. den automatischen Beweis einer pr¨adikatenlogischen Formel. Das ist ein sogenanntes unentscheidbares Problem, f¨ur das es kein voll automatisches Programm geben kann.11 Bis auf diese Unsch¨onheit kann aber das Hoaresche Kalk¨ul von einem Rechner automatisch angewendet werden. D.h. modulo -Regel kann ein Rechner automatisch seine Programme verifizieren, so man die gew¨unschten Anfangs- und Endzusicherungen vorgibt. 11

Das Problem w¨are das automatische Beweisen von pr¨adikatenlogischen Formeln. Ein wichtiger Anteil an Formeln der Mathematik kann als solche geschrieben werden, wenn auch nicht alle. K¨onnte man solche Beweise komplett automatisieren, dann k¨onnte man einige Mathematiker durch Automaten ersetzen. Um sich ihren Arbeitsplatz zu erhalten ;-), haben sie daher die Unetscheidbarkeit der Pr¨adikatenlogik gezeigt. Es ist allerdings sogar noch schlimmer: die sogenannten G¨odelschen Unvollst¨andigkeitss¨atze zeigen die Unm¨oglichkeit, wichtige Theorien wie etwa die Theorie der nat¨urlichen Zahlen u¨ berhaupt in solch einer Beschreibungssprache zu formalisieren.

3 EIGENSCHAFTEN VON ALGORITHMEN

34

Einen Aspekt haben wir bisher noch nicht diskutiert. Wir haben den Beweis ausgef¨uhrt, der die Korrektheit dieses Kalk¨uls zeigt. Das heißt, alles, was hiermit ableitbar ist, ist auch eine g¨ultige partielle Korrektheitsaussage. Was noch fehlt, ist die umgekehrte Richtung, die sogenannte Vollst¨andigkeit des Kalk¨uls. Wir w¨ußten gerne, daß alle g¨ultigen partiellen Korrektheitsaussagen mit dem Kalk¨ul auch abgeleitet werden k¨onnen. Sonst k¨onnte es uns passieren, daß wir ein semantisch korrektes Programm schreiben, aber dieses nicht beweisen k¨onnen. Man kann (mit einem a¨ hnlich umfangreichen Beweis, der automatisch Zwischenzusicherungen anhand der sogennannten weakest precondition berechnet) in der Tat zeigen, daß dieses Kalk¨ul u¨ ber sogenannten ausdrucksstarken Algebren (z.B. den ganzen Zahlen mit den u¨ blichen Operationen) vollst¨andig ist. Diesen Beweis lassen wir hier weg. Wie bereits erw¨ahnt, reicht die Ableitung einer partiellen Korrektheitsaussage nicht aus, um die semantische Korrektheit des Programms zu zeigen, da sie keinerlei Garantien u¨ ber die Terminierung des Programms beinhaltet. F¨ur die semantische Korrektheit eines Programms muß zus¨atzlich noch gezeigt werden, daß es auf allen interessanten Eingaben auch terminiert. Kritisch sind dabei nur Schleifen, die nicht unbedingt verlassen werden m¨ussen. Wir zeigen exemplarisch die Terminierung des Programms ggT. • Das Programm ggT sei in einem Zustand gestartet, in dem die Vorbedingung {X ≥ 0, Y ≥ 0} gilt. Behauptung: Der Wert von A + B in der while-Schleife des Programms ggT ist immer ≥ 0, und der Wert wird bei jedem Schleifendurchlauf echt kleiner. • Beweis dieser Behauptung: A ≥ 0 und B ≥ 0 sind Bestandteil der Schleifeninvarianten, also gilt auch A + B ≥ 0. Außerdem wissen wir zu Beginn der Schleife A > 0 und B > 0. Seien a und b die Werte von A und B vor einem Schleifendurchlauf. Dann wird entweder der if-Fall durchlaufen, und wir haben nach dem Schleifendurchlauf die Werte a − b und b, oder es wird der else-Fall durchlaufen, und wir haben die Werte a und b − a. Wir finden also a − b + b < a + b bzw. a + b − a = b < a + b, da a > 0 und b > 0 gilt. Da es nur endlich viele ganze Zahlen ≥ 0, die kleiner als der anf¨angliche Wert von A+B sind, gibt, endet die Schleife nach endlich vielen Schritten. Da dieses die einzige Schleife des Programms ist, terminiert das Programm immer. Es kann f¨ur ein beliebiges Programm schwierig werden, dessen Terminierung zu beweisen. Etwa f¨ur die Collatz-Funktion, die wir schon eingef¨uhrt haben, ist das bis heute nicht gelungen. Von theoretischer Warte aus liegt das daran, daß auch die Terminierung von Programmen ein sogenanntes unentscheidbares Problem ist.

3.3 Komplexit¨at Zus¨atzlich dazu, ob ein Programm tut, was was es soll, sind wir an der Laufzeit interessiert. Was n¨utzt es uns, ein korrektes Programm zu verwenden, wenn wir auf das Ergebnis mehrere Wochen warten m¨ussen? Das stellt die Frage nach der Komplexita¨ t der Algorithmen bzw. des Problems. Es gibt verschiedene Arten der Komplexit¨at, die zwei wichtigsten sind: • Zeitkomplexit¨at: wie lange muß man auf das Ende des Programms warten, wie viele Interpreterschritte sind n¨otig? • Speicherbedarf: wie viele Variablen werden gleichzeitig im Programm verwendet, wie sehr lastet das Programm den Hauptspeicher des Rechners aus? Wir werden uns im folgenden nur um die Zeitkomplexit¨at k¨ummern. In gewisser Weise schauen wir damit auch auf den Speicherplatzbedarf, da der Speicherplatzbedarf nicht gr¨oßer sein kann als

3.3 Komplexit¨at

35

die Zeitkomplexit¨at – f¨ur einen Schreib- oder Lesevorgang ben¨otigen wir ja je mindestens einen Zeitschritt. Wie mißt man den Zeitbedarf eines Programms? Man kann ein Programm starten und mit einer Stoppuhr (oder mit einem internen Kommando, das z.B. die CPU-Zeit mißt) die Zeit messen. Das gibt Informationen z.B. u¨ ber die Unterschiede zweier unterschiedlicher Implementationen f¨ur ein konkretes Problem. Eine derartige Messung ist allerdings stark von den Gegebenheiten abh¨angig, z.B. der verwendeten Prozessorleistung, und sie sagt nur wenig u¨ ber die G¨ute des implementierten Programms aus. Um einen Algorithmus zu beurteilen, ist man daher am prinzipiellen Verhalten des Algorithmus interessiert, und nicht der exakten Laufzeit in Sekunden. Viele Algorithmen berechnen eine Funktion oder verarbeiten Information in Abh¨angigkeit von einer variierenden Eingabe. Der Algorithmus zur Berechnung des ggT zum Beispiel verwendet zwei nat¨urliche Zahlen als Eingaben und berechnet deren ggT. Die Laufzeit des Algorithmus ist abh¨angig von diesen Eingaben, f¨ur kleine Zahlen l¨aßt sich der ggT effizienter berechnen als f¨ur gr¨oßere. Es ist daher u¨ blich, die Laufzeit eines Algorithmus in Abh a¨ ngigeit von der Gr¨oße der Eingaben anzugeben, so daß sich das prinzipielle Verhalten f¨ur unterschiedliche Eingaben abzeichnet. Ein zweiter Aspekt ist, daß Konstanten fu¨ r die Laufzeit uninteressant sind, da sie maschinenabh¨angig sind: ein doppelt so schneller Prozessor verarbeitet dasselbe Programm in der H¨alfte der Zeit, ohne am prinzipiellen Programmverhalten etwas zu a¨ ndern. Beide Aspekte werden im Rahmen der sogenannten O-Notation ber¨ucksichtigt: Definition 3.11 Seien f und g : N → N Funktionen. Man schreibt f = O(g) falls es eine positive Konstante c und ein n0 ∈ N gibt mit f (n) ≤ c · g(n)∀n ≥ n0 . Dieses ist eine sogenannte worst-case Komplexit¨at, da man f¨ur alle Eingaben der L¨ange ≥ n 0 die Laufzeit absch¨atzen muß. In der Regel betrachtet man als n die Gr¨oße der Eingabe f¨ur das Programm, z.B. die Gr¨oße x + y im Programm ggT. f (n), die interessierende Funktion, ist die Laufzeit des Programms f¨ur Eingaben der Gr¨oße n. Deren prinzipielles Verhalten kann man mit der O-Notation beschreiben. F¨ur unser ggT-Programm ergibt sich etwa dessen Laufzeit als O(x+y), sofern x und y die Eingaben sind. Das ist nach unseren obigen Argumentationen bereits klar: die Schleife startet mit x + y und verringert diesen Wert in jedem Durchlauf um mindestens eins. Es gibt also maximal x + y Schleifendurchl¨aufe mit je einer konstanten Anzahl an Interpreterschritten (etwa c 1 ) und eine konstante Anzahl an weiteren Anweisungen (etwa c2 ). Der Aufwand ist also maximal c1 · (x + y) + c2 ≤ (c1 + c2 ) · (x + y) f¨ur x + y ≥ 1. Ein paar spezielle Sprechweisen werden h¨aufig verwendet: Definition 3.12 Sei n die Gr¨oße der Eingabe f¨ur einen Algorithmus. Man referenziert auf den Aufwand des Algorithmus wie folgt: • konstanter Aufwand im Fall O(1), • logarithmischer Aufwand im Fall O(log n), • linearer Aufwand im Fall O(n), • quadratischer Aufwand im Fall O(n2 ),

3 EIGENSCHAFTEN VON ALGORITHMEN

36

• polynomieller Aufwand falls es einen Exponenten m ∈ N gibt, so daß der Aufwand O(n m ) ist. • exponentiellen Aufwand im Fall O(2n ). Der Aufwand f¨ur ggT ist also linear. Wir h¨atten den ggT auf der Basis der Operationen + und - auch komplizierter berechnen k¨onnen: teiler:=1; i:=2; while (i≤X∧i≤Y){ sum1:=i;sum2:=i; while (sum1<X) {sum1:=sum1+i;} while (sum2
Wir haben hier die sog. Euler-McLaurinsche Summenformel verwendet: lim n→∞ (1 + 1/2 + 1/3 + . . . + 1/n − ln(n + 1)) = C mit der Eulerschen Konstanten C = 0.57721 . . .

37 einziger Algorithmus es l¨osen k¨onnte. Dieses geschieht durch Beweis durch Widerspruch, einer gebr¨auchlichen Technik in der Mathematik und Informatik. Eine andere in diesem Bereich sehr n¨utzliche Technik sind sogenannte Reduktionen, die Sie z.B. in der Komplexit¨atstheorie in der theoretischen Informatik noch sehen werden. Eine L¨osung des Halteproblems soll, gegeben ein Programm, entscheiden, ob das Programm anh¨alt. Wir zeigen hier, daß es einen solchen Algortihmus, der das Anhalten eines anderen Programms automatisch voraussagt, prinzipiell nicht geben kann. Wir nehmen dazu an, daß Programme als String u¨ bergeben werden k¨onnen (z.B. durch eine geeignete Kodierung der Programme bzw. durch den Programmtext.). Wir zeigen durch Widerspruch, daß das Haltebproblem nicht durch einen Algorithmus gel¨ost werden kann: Sei public static boolean halt(String[] args) eine solche Methode mit R¨uckgabewert true falls das u¨ bergebene Programm anh¨alt false sonst Wir f¨uhren diese Annahme ad absurdum. Wir schreiben eine Klasse, die diese Methode benutzt: public static void aetsch(String[] args){ public static void main(String[] args){ if (halt(args)) while (true) ; else; } } Was passiert, wenn wir die main-Methode von aetsch mit dem Text des Programms aetsch selbst aufrufen? Wir kommen an die Bedingung der if-Anweisung und erhalten zwei F¨alle: • halt liefert true, d.h. halt sagt, daß die main-Methode terminiert. Dann wird in halt die while-Schleife erreicht, eine Endlosschleife. Widerspruch. • halt liefert false, d.h. daß die main-Methode nicht terminiert. Dann wird nichts weiter gemacht und die main-Methode terminiert. Widerspruch. Es kann also so ein Programm nicht geben, das Halteproblem ist unentscheidbar.

4 Datenstrukturen Nach diesem Exkurs in eine formale Definition und Untersuchung von Algorithmen kommen wir wieder auf die im Rechner gespeicherten Informationen zur¨uck. Diese sind in Java in typisierten Variablen verschiedener Typen, etwa der elementaren Typen Boolean, Integer, . . . hinterlegt. Physikalisch gesehen gibt es prinzipiell zwei verschiedene M¨oglichkeiten, Informationen zu verarbeiten • analoge Darstellung: Signale nehmen kontinuierliche Werte an, etwa bei einem Meßinstrument der Zeigerausschlag in Abh¨angigkeit vom fließenden Strom. • digitale Darstellung: Signale nehmen diskrete bin¨are Werte an. Diese k¨onnen z.B. zwei Spannungsbereichen entsprechen (High und Low). Digitale Werte sind durch elektronische Schaltungen besonders gut und fehlertolerant darstellbar.

4 DATENSTRUKTUREN

38

Handels¨ubliche Rechner arbeiten auf der Basis digitaler Informationen. Das hat einige Konsequenzen f¨ur die Darstellung der Variablen, die im Fall von rellen Zahlen ja von der Idee her analog sind. Wir gehen in diesem Kapitel zun¨achst auf Boolean, als grundlegende Algebra mit zweiwertiger (digitaler) Information ein, betrachten dann die Darstellung von ganzen und rellen Zahlen mithilfe dieser M¨oglichkeiten, und wenden uns schließlich komplexeren Datentypen, den Klassen in Java zu, die elegante objektorientierte Programmierung erm¨oglichen.

4.1 Boolesche Werte Boolean besitzt die Konstanten true und false. Dieses entspricht den zwei Werten, die bei digitalen elektronischen Schaltungen unterschieden werden, so daß sich diese Algebra neben ihrem konkreten Einsatz in Programmen zur Beschreibung elektronischer Schaltungen anbietet. Grundlegende Operationen werden in Java mit Symbolen der Form ! (Negation), || (oder), && (und), usw. bezeichnet. In klassischen booleschen Formeln verwendet man stattdessen die Symbole ¬, ∧, ∨, → und ↔, die wir bereits eingef¨uhrt haben. Der Vollst¨andigkeit halber geben wir hier noch einmal die Definition dieser Operatoren in Form von sogenannten Wahrheitswerttabellen an: x ¬x true false false true

x true true false false

y true false true false

x∧y true false false false

x true true false false

y true false true false

x∨y true true true false

Die Symbole → und ↔ sind nicht wirklich n¨otig, da wir sie durch die u¨ brigen ersetzen k¨onnten. Aus der Definition sieht man schnell (z.B. durch Vergleich der zugeh¨origen Wahrheitswerttabellen) x → y ⇐⇒ ¬x ∨ y,

x ↔ y ⇐⇒ (x ∧ y) ∨ (¬x ∧ ¬y)

In Hinblick auf elektronische Schaltungen verwendet man obige elementare Operationen als elementare Schaltelemente oder Gatter, die in Schaltpl¨anen z.B. wie folgt gezeichnet werden: 1

nicht

&

und

>1

oder

Und- und oder-Gatter und Terme verwendet man nicht nur f¨ur zwei, sondern auch f¨ur mehr Eingaben. Etwa einen und-Operator mit drei Eingaben a ∧ b ∧ c = (a ∧ b) ∧ c = a ∧ (b ∧ c). Beachten Sie, daß die Reihenfolge, in der die Argumente betrachtet werden, f¨ur ∧ und ∨ egal ist, so daß man den Operator sofort auf n Stellen erweitern kann, ohne eine Reihenfolge festlegen zu m¨ussen. Weitere u¨ bliche Schaltelemente, die durch diese drei Schaltelemente simuliert werden k¨onnen, sind • nand: ¬(x ∧ y), • nor: ¬(x ∨ y), • xor: ((x ∨ y) ∧ ¬(x ∧ y)) (Symbol in Schaltpl¨anen ist ’=1’) • xnor: ¬(x xor y) oder auch (x ↔ y) Diese Schaltelemente k¨onnen durch Kombination der Basisbilder mit den Symbolen = 1, ≥ 1 und & und der Negation, dargestellt durch ◦, gezeichnet werden. Aus diesen einfachen Gattern k¨onnen weitere komplexere Schaltungen realisiert werden. So zum Beispiel ein Halbaddierer, der zu zwei

4.1 Boolesche Werte

39

¨ gegebenen Bits deren Summe und etwaigen Ubertrag berechnet. Wir identifizieren true mit 1 und false mit 0. Dann entspricht diese Rechnung der Tabelle x 0 0 1 1

¨ y Summe Ubertrag 0 0 0 1 1 0 0 1 0 1 0 1

Offensichtlich gilt Summe = x xor y = (x ∨ y) ∧ ¬(x ∧ y),

¨ Ubertrag = x∧y,

so daß man diese Schaltung aus zwei und-Gattern und einem oder-Gatter erh¨alt. Wir k¨urzen das Ergebnis eines Halbaddierers mit H1 (x, y) und H2 (x, y) ab. Ein Volladdierer ber¨ucksichtigt als ¨ zus¨atzliche Eingabe c einen Ubertrag aus etwaigen vorhergehenden Rechnungen und entspricht der Tabelle ¨ a b c Summe Ubertrag 0 0 0 0 0 0 1 0 1 0 1 0 0 1 0 1 1 0 0 1 0 0 1 1 0 0 1 1 0 1 1 0 1 0 1 1 1 1 1 1 Einen Volladdierer erh¨alt man z.B. indem man zun¨achst a und b addiert und die sich ergebende ¨ Summe mit dem Ubertrag c addiert. Der Gesamt¨ubertrag ergibt sich aus der oder-Verkn¨upfung der ¨ Ubertr¨ age dieser beiden Halbaddierer. Also Summe = H1 (H1 (a, b), c),

¨ Ubertrag = (H2 (a, b) ∨ H2 (H1 (a, b), c))

oder als Schaltbild a b c

H

H >1

Wir bezeichnen einen Addierer mit A(a, b, c). Das ganze fortsetzend, erhalten wir ein Addierwerk An f¨ur zwei n-stellige bin¨are Zahlen an . . . a1 und bn . . . b1 . A1 (a1 , b1 ) = H(a1 , b1 ) ist ein einfacher Halbaddierer. Eine Stelle weiter kommen wir durch Hinzuf¨ugen eines Volladdierers f¨ur die neuen ¨ Eingaben und den Ubertrag. F¨ur i > 1 ist Ai (an . . . a1 , bn . . . b1 ) = A(an , bn , Ai−1 (an−1 . . . a1 , bn−1 . . . b1 )), genau wie beim u¨ blichen schriftlichen Addieren. Dieser Addierer heißt ripple-carry-Addierer. Er ben¨otigt n − 1 Addierer und einen Halbaddierer. Ein Halbaddierer in diesem Entwurf kann seinen ¨ Wert dabei erst bestimmen, wenn der Ubertrag (das carry Bit) durch den vorigen Addierer gesickert ist (ripple). Man kann die Addition auch effizienter gestalten z.B. mit dem sogenannten carry-look-ahead¨ Addierer, der die Ubertr¨ age, das carry-Bit, schon vorab (look-ahead) berechnet. Wir betrachten

4 DATENSTRUKTUREN

40

hier nur einen 4-Bit Addierer. Beim ripple-carry-Addierer werden nacheinander folgende Formeln ¨ berechnet, um den Uberlauf (bezeichnet als ci ) zu bestimmen: c1 = a 1 ∧ b 1 c2 = (a2 ∧ b2 ) ∨ (H1 (a2 , b2 ) ∧ c1 ) = (a2 ∧ b2 ) ∨ (H1 (a2 , b2 ) ∧ a1 ∧ b1 ) c3 = (a3 ∧ b3 ) ∨ (H1 (a3 , b3 ) ∧ c2 ) = (a3 ∧ b3 ) ∨ (H1 (a3 , b3 ) ∧ a2 ∧ b2 ) ∨ (H1 (a3 , b3 ) ∧ H1 (a2 , b2 ) ∧ a1 ∧ b1 ) c4 = (a4 ∧ b4 ) ∨ (H1 (a4 , b4 ) ∧ c3 ) = (a4 ∧ b4 ) ∨ (H1 (a4 , b4 ) ∧ a3 ∧ b3 ) ∨ (H1 (a4 , b4 ) ∧ H1 (a3 , b3 ) ∧ a2 ∧ b2 ) ∨ (H1 (a4 , b4 ) ∧ H1 (a3 , b3 ) ∧ H1 (a2 , b2 ) ∧ a1 ∧ b1 ) Zu beachten ist, daß jeweils in den letzten Termen keinerlei vorherige carry-Bits c i vorkommen, ¨ sondern nur Ausdr¨ucke ai und bi , die sofort verf¨ugbar sind. Man kann also alle Ubertr¨ age sofort (evtl. parallel) berechnen. Je zu addierenden Bits ben¨otigt man einen Halbaddierer, einige und- und ein oder-Gatter (jeweils mehrstellig). Die Tiefe dieser einzelnen Schaltkreise, d.h. die Anzahl der in diesen einzelnen Schaltkreisen hintereinander geschalteten elementaren Gatter, ist unabh¨angig von der Anzahl der Bits, die addiert werden m¨ussen, immer vier (mehrstelliges oder, mehrstelliges und, zwei Gatter f¨ur den Halbaddierer). Kommen wir zur¨uck auf die grundlegenden Operationen ∧, ∨ und ¬. Wir haben bereits implizit einige Identit¨aten genutzt. Es gilt: 1. Kommutativit¨at: a ∧ b = b ∧ a, a ∨ b = b ∨ a 2. Assoziativit¨at: a ∧ (b ∧ c) = (a ∧ b) ∧ c, a ∨ (b ∨ c) = (a ∨ b) ∧ c 3. Absorption: a ∧ (a ∨ b) = a, a ∨ (a ∧ b) = a 4. Nullelement: false ∨ a = a, false ∧ a = false 5. Einselement: true ∧ a = a, true ∨ a = true 6. Satz vom Widerspruch, Satz vom ausgeschlossenen Dritten: a ∧ ¬a = false, a ∨ ¬a = true 7. Distributivit¨at: a ∧ (b ∨ c) = (a ∧ b) ∨ (a ∧ c), a ∨ (b ∧ c) = (a ∨ b) ∧ (a ∨ c) Diese Identit¨aten kann man leicht nachpr¨ufen, indem man die Wahrheitswerttabellen der linken und der rechten Seiten vergleicht. Diese Gleichungen sind die Axiome eines sogenannten distributiven komplement¨aren Verbandes. Die Verbandstheorie besch¨aftigt sich mit derartigen Strukturen und leitet allgemeine Aussagen ausschließlich anhand dieser Axiome her. Es gelten etwa automatisch die folgenden S¨atze nur aufgrund dieser Axiome: • Das Null- und Einselement sind eindeutig festgelegt. • doppelte Negation: ¬¬a = a • de-Morgansche Gesetze: ¬(a ∧ b) = ¬a ∨ ¬b, ¬(a ∨ b) = ¬a ∧ ¬b F¨ur boolesche Formeln kann man diese Regeln nat¨urlich anhand der Wahrheitswerttabellen verifizieren. Sie folgen aber schon ausschließlich aufgrund der Axiome f¨ur einen distributiven komplement¨aren Verband. Zur Demonstration m¨ochten wir das hier f¨ur die doppelte Negation zeigen:

4.1 Boolesche Werte

41

• Erster Schritt: Sei c mit a ∧ c = false und a ∨ c = true, dann ist c = ¬a (eindeutiges Komplement). Beweis: 3. 1.+6.+V. 7. 1.+6.+V. 1.+7. ¬a = ¬a ∨ (¬a ∧ a) = ¬a ∨ (a ∧ c) = (¬a ∨ a) ∧ (¬a ∨ c) = (a ∨ c) ∧ (¬a ∨ c) = 4.+6. c ∧ (a ∨ ¬a) = c • Zweiter Schritt: Wegen der Eindeutigkeit des Komplements, und da ¬¬a das Komplement von ¬a ist, reicht es zu zeigen: ¬a ∧ a = false und ¬a ∨ a = true. Beweis: das folgt unmittelbar mit 1. und 6. Wir haben bereits gesehen, daß es mehrere M¨oglichkeiten gibt, bestimmte komplexere logische Funktionen mithilfe einfacher Operationen zu realisieren, etwa carry-look-ahead Addierer oder ripple-carry-Addierer. Oft ist daher eine normierte Darstellung boolescher Formeln, die z.B. leichter u¨ berpr¨ufen l¨aßt, ob zwei Formeln identisch sind, n¨utzlich. Oft verwendete Normalformen sind die konjunktive Normalform und die disjunktive Normalform. Definition 4.1 Ein Literal ist entweder eine Variable X, ein Konstantensymbol true oder false oder eine negierte Variable ¬X. Eine boolesche Formel ϕ ist in konjunktiver Normalform, falls es eine Konjunktion von Disjunktionen von Literalen darstellt, d.h. ϕ hat die Form ϕ1 ∧ . . . ∧ ϕ n mit ϕi = (Li1 ∨ . . . ∨ Lini ) und Literalen Lij . Eine boolesche Formel ϕ ist in disjunktiver Normalform, falls es eine Disjunktion von Konjunktionen von Literalen darstellt, d.h. ϕ hat die Form ϕ1 ∨ . . . ∨ ϕ n mit ϕi = (Li1 ∧ . . . ∧ Lini ) und Literalen Lij . Ein Besipiel f¨ur eine konjunktive Normalform ist (true ∨ ¬X ∨ X ∨ Y ) ∧ (X ∨ ¬Y ) ∧ (¬X ∨ Y ) , f¨ur eine disjunktive Normalform ist (X ∧ Y ) ∨ (¬X ∧ false ∧ Y ) . So eine Normalform ist nicht eindeutig, da man ja Literale permutieren oder verdoppeln kann, aber wesentlich einfacher und u¨ bersichtlicher, als eine generelle boolesche Formel. Man kann jede gegebene Formel durch folgenden Algorithmus in konjunktive bzw. disjunktive Form verwandeln: • ersetze rekursive die Zeichen → und ↔ mithilfe der Identit¨aten ϕ → ψ ⇐⇒ ¬ϕ ∨ ψ, ϕ ↔ ψ ⇐⇒ (ϕ ∧ ψ) ∨ (¬ϕ ∧ ¬ψ). Es bleiben nur noch die Zeichen ¬, ∧ und ∨. • Ersetze rekursive alle ¬, so daß sie nur noch in Form von Literalen vorkommen, mithilfe der Identit¨aten ¬¬ϕ = ϕ, ¬true = false, ¬false = true, ¬(ϕ ∧ ψ) = ¬ϕ ∨ ¬ψ, ¬(ϕ ∨ ψ) = ¬ϕ ∧ ¬ψ

4 DATENSTRUKTUREN

42

• Vertausche von außen nach innen rekursive ∧ bzw. ∨ durch die Distributivgesetze, • evtl. Vereinfachungen, wenn gew¨unscht: a ∨ ¬a = true, a ∨ a = a, . . . Wir demonstrieren das an einem Beispiel: (a → ¬(b ∨ ¬a)) ∧ (c ∨ b) • ersetze →: (¬a ∨ ¬(b ∨ ¬a)) ∧ (c ∨ b) • ¬ kommt zu den Variablen: (¬a ∨ (¬b ∧ ¬¬a)) ∧ (c ∨ b) = (¬a ∨ (¬b ∧ a)) ∧ (c ∨ b) • vertausche ∧ und ∨: f¨ur eine konjunktive Normalform: (¬a ∨ ¬b) ∧ (¬a ∨ a) ∧ (c ∨ b), a¨ quivalent zu (¬a ∨ ¬b) ∧ (c ∨ b), f¨ur eine disjunktive Normalform: (¬a ∧ c) ∨ (¬a ∧ b) ∨ (¬b ∧ a ∧ c) ∨ (¬b ∧ a ∧ b), a¨ quivalent zu (¬a ∧ c) ∨ (¬a ∧ b) ∨ (¬b ∧ a ∧ c).

4.2 Ganze Zahlen Kommen wir von booleschen / bin¨aren Werten zu ganzen Zahlen. Ganze Zahlen werden im Rechner intern digital dargestellt, d.h. durch eine endliche Folge von Werten true und false bzw. 0 und 1. Grundlage f¨ur eine solche Darstellung ist die Repr¨asentation von Zahlen bzgl. der Basis 2. Allgemeiner definieren wir: Definition 4.2 Sei B ≥ 2 eine nat¨urliche Zahl, die Basis der Zahlendarstellung. Eine ganze Zahl dargestellt im B-adischen Zahlensystem oder auch polyadischen Zahlensystem ist eine nichtleere endliche, evtl. mit einem Vorzeichen behaftete Ziffernfolge der Form [+/−] bn bn−1 . . . b0 oder auch [+/−] bn bn−1 . . . b0 |B mit bi ∈ {0, . . . , B − 1}. Dabei sind f¨uhrende Nullen weggelassen, d.h. nur im Fall n = 0 kann bn = 0 gelten. Diese Ziffernfolge repr¨asentiert die ganze Zahl [+/−]

n X

bi · B i .

i=0

(Dabei ist B 0 = 1 definiert, wie u¨ blich.) Unsere u¨ bliche Zahldarstellung im Dezimalsystem benutzt die Basis 10. Andere gebr¨auchliche Darstellungen sind: • im Dualsystem zur Basis 2, • oktal, zur Basis 8, • sedezimal zur Basis 16. Es gilt z.B. 10100110000|2 = 2460|8 = 1328|10 = 530|16 . Wir wissen, daß es zu jeder ganzen Zahl genau eine Darstellung im Dezimalsystem gibt (wenn man f¨uhrende Nullen wegstreicht). Dasselbe gilt f¨ur allgemeine polyadische Zahlen: f¨ur jede ganze Zahl x und jede nat¨urliche Zahl B ≥ 2 gibt es genau eine Darstellung zur Basis B. Um das einzusehen, zeigen wir zweierlei:

4.2 Ganze Zahlen

43

• Es gibt zu jeder ganzen Zahl x eine B-adische Darstellung. Beweis: Wir geben (in Pseudocode) ein Programm an, das eine gegebene positive Zahl in eine B-adische Darstellung verwandelt. F¨ur negative Zahlen k¨onnen wir dann einfach das Inverse umwandeln und mit geeignetem Vorzeichen versehen. i:=0; while (x>0) { b[i]:=x%B; x:=x/B; i++; } Wir teilen also sukzessive x durch B und speichern den Rest beim Teilen als die Ziffern der B-adischen Darstellung. Wir haben dabei von einer noch nicht behandelten Datenstruktur, einem Array b Gebrauch gemacht. b kann man sich hier als Platzhalter f¨ur beliebig viele Variablen b[0], b[1], . . . vorstellen, in denen wir die (a priori nicht beschr¨ankten) Koeffizienten b0 , b1 , . . . der B-adischen Darstellung speichern k¨onnen. Dieses Programm terminiert, da x jedesmal ganzzahlig durch B geteilt wird, also irgendwann null werden muß. Dieses Programm liefert korrekte Werte, wie man z.B. durch folgende g¨ultige partielle Korrektheitsaussage sieht (wobei wir bei der Notation von Formeln bezogen auf die Variablen b[i] etwas lax sind; man k¨onnte die Formeln im Zweifel u¨ ber einer geeigneten Algebra array pr¨azise machen.):

Wir haben zu zeigen:

hx = x0 ≥ 0i i:=0; P j ξ = hx ≥ 0, x0 = x · B i + i−1 j=0 b[j] · B i while (x>0) { hξ, x > 0i b[i]:=x%B; x:=x/B; i++; ξ } hξ, x ≤ 0i P j hx0 = i−1 j=0 b[j] · B i

P j – x = x0 ≥ 0 → (x ≥ 0 ∧ x0 = x · B 0 + 0−1 j=0 b[j] · B ), da die Summe leer ist, gilt das offensichtlich. P j i+1 – (x ≥ 0 ∧ x0 = x · B i + i−1 + j=0 b[j] · B ∧ x > 0) → (x/B ≥ 0 ∧ x0 = x/B · B P i−1 i j 13 x%B · B + j=0 b[j] · B ). Das gilt, da x = x/B · B + x%B gilt. P Pi−1 j j – (x ≥ 0∧x0 = x·B i + i−1 j=0 b[j]·B ∧x ≤ 0) → x0 = j=0 b[j]·B ist offensichtlich, da x = 0 ist. 13

Der Summand f¨ur i ist gesondert geschrieben, da eine Termersetzung f¨ur b[i] vorgenommen wurde.

4 DATENSTRUKTUREN

44 • Die B-adische Darstellung ist eindeutig. Beweis: Wir nehmen an, es gibt zwei Darstellungen der Zahl x=

n1 X

i

bi · B =

i=0

n2 X

b0i · B i

i=0

mit bi , b0i ∈ {0, . . . , B − 1} ohne f¨uhrende Nullen. Wir nehmenP O.E. an, x > 0 (0 ist trivial, f¨ur negative Zahlen betrachten wir einfach das Inverse). Es gilt ni=0 (B − 1) · B i = B n+1 − 1 < B n+1 . Sei n1 ≥ n2 . Wir teilen beide Seiten ganzzahlig durch B n1 . Wir erhalten f¨ur die linke Seite nX 1 −1 bi /B n1 = bn1 b n1 + |i=0 {z }
bei ganzzahliger Division, denn die Summe ist kleiner als B n1 . Gilt n2 < n1 , dann w¨are die rechte Seite ganzzahlig geteilt durch B n1 null, also bn1 null; wir haben aber f¨uhrende Nullen gestrichen. Also ist n2 = n1 und die rechte Seite ganzzahlig geteilt durch B n1 gibt b0n1 . Also sind die gr¨oßten beiden Ziffern der Zahlen gleich. Induktiv u¨ ber die L¨ange der Zahlen erh¨alt man so die Eindeutigkeit, da man jetzt die gr¨oßten Summanden auf beiden Seiten k¨urzen kann. Jede ganze Zahl l¨asst sich also eindeutig in B-adischer Darstellung schreiben, und wir haben auch einen konkreten Umrechnungsalgorithmus erhalten. Interessant ist, daß man in B-adischer Darstellung genauso wie im u¨ blichen Dezimalsystem rechnen kann, Addition geschieht durch stel¨ ¨ lenweises Addieren mit Ubertrag, Multiplikation durch stellenweises Multiplizieren mit Ubertrag. Im Rechner sind Zahlen nur mit einer bestimmten Genauigkeit gespeichert: die Anzahl der Bits gibt die Anzahl der gespeicherten Stellen an. In einer vorzeichenlosen Darstellung kann man in k . . B − 1} = B k − 1 darstellen. In einer vorzeichenbehafStellen die Zahlen 0| .{z . . 0} = 0 bis B | − 1 .{z k

k

teten Darstellung kann man entweder ein Bit f¨ur die Darstellung des Vorzeichens reservieren, also die Zahlen −B k−1 − 1 bis B k−1 − 1 darstellen (die 0 hat zwei Darstellungen +0 und −0), oder den obigen Bereich in zwei Bl¨ocke einteilen, von denen der eine als positive Werte, der andere als negative Werte interpretiert wird. Im Fall von k Bits wird in der Regel der Bereich [0, B k−1 − 1], also die Ziffern 00 . . . 0 bis 01 . . . 1 als positiv interpretiert. Die Zahlen 1 . . . mit f¨uhrender 1 werden als negative Zahlen in sogenannter Komplementdarstellung interpretiert. Definition 4.3 Eine Ziffernfolge bk−1 . . . b0 mit bi ∈ {0, B − 1} wird unter der Komplementdarstellung zur Basis B mit k Stellen ausgewertet als −bk−1 · B

k−1

+

k−2 X

bi B i

i=0

Das B-Komplement x¯ einer solchen Ziffernfolge x erha¨ lt man, indem man jede Ziffer zu B − 1 erg¨anzt und 1 addiert. F¨ur Zahlen mit f¨uhrender 0, d.h. positive Zahlen, ist die Komplementdarstellung offensichtlich die u¨ bliche B-adischeP Darstellung. Zahlen mit f¨uhrender 1 sind negative Zahlen. Wegen der Gleichung k−2 k−1 x = −1 · B + i=0 bi B i erh¨alt man die Komplementdarstellung negativer Zahlen als B k−1 + Pk−2 i k−1 . F¨ur B = 2, was uns im Folgenden interessieren wird, erh¨alt man also die i=0 bi B = x+2·B Komplementdarstellung der negativen Zahl x als x + 2k . 11 . . . 1 entspricht der Zahl −1, 10 . . . 0 entspricht der Zahl −B k−1 . In Komplementdarstellung sind daher in k Bits die Zahlen −B k−1 bis

4.2 Ganze Zahlen

45

B k−1 − 1 dargestellt. Das Komplement von der Dualzahl 10011111 mit acht Stellen ist 01100001, 42 hat im Oktalsystem mit 4 Stellen das Komplement 7736. Addiert man das B-Komplement einer Zahl, aufgefasst als Zahl in B-adischer Darstellung, zur Zahl selbst in B-adischer Darstellung, erh¨alt man: ! k−1 ! k−1 k−1 X X X (B − 1 − bi )B i + 1 = (B − 1)B i + 1 = B k − 1 + 1 = B k (∗) bi B i + i=0

i=0

i=0

Das B-Komplement einer Zahl erh¨alt man also als Differenz zur sogenannten Erg¨anzungszahl B k im B-adischen System, d.h. x+ x¯ = B k . Diese Beobachtung erlaubt, im B-adischen Zahlensystem die Subtraktion durch Addition und Komplementbildung zu ersetzen: x−y = x+ y¯−B k . Beachten Sie, daß B k in k Bits nicht mehr darstellbar ist, sondern lediglich einer 1 an der Stelle k + 1 (von rechts gez¨ahlt) entspr¨ache. Daher ist die Zubtraktion dieser Erg¨anzungszahl in der Regel durch ¨ automatischen Uberlauf realisiert. Ein Beispiel f¨ur zwei positive Dualzahlen mit 8 Bits: x1 = 50|10 = 00110010|2 , x2 = 40|10 = 00101000|2 Wir m¨ochten x1 − x2 berechnen. Wir erhalten: x1 x¯2

00110010|2 11011000|2 100001010|2 = 00001010|2 + 100000000|2 = 10|10 + 28 |10

F¨ur die Zahlen x1 = 50|10 = 00110010|2 , x2 = 70|10 = 01000110|2 ergibt sich x1 x¯2

00110010|2 10111010|2 11101100|2 = −00010100|2 + 100000000|2 = −20|10 + 28 |10

Dabei ist 11101100 das 2-Komplement von 00010100. Im Dualsystem (B = 2) gilt sogar, daß wir die Subtraktion in dieser Form direkt auf den Komplementdarstellungen berechnen k¨onnen, ohne uns um Vorzeichen k¨ummern zu m¨ussen. Die ¨ Komplementdarstellung und Uberlauf bei zu vielen Stellen liefert automatisch richtige Ergebnisse. Wir formulieren dieses formal pr¨azise: seien x, y mit x, y, x − y ∈ [−2k−1 , 2k−1 − 1]. Seien xC und ¨ ¨ y C die Komplementdarstellungen. Bezeichne +2 die Addition mit Uberlauf, die Uberlauf u¨ ber die erste Stelle hinweg unterdr¨uckt. Dann ist xC +2 y C = (x − y)C . Wir unterscheiden sechs F¨alle: • x ≥ 0, y ≥ 0, |x| ≥ |y|. Dann ist die Komplementdarstellung von x, y, und x − y deren Dualdarstellung. y¯ ist 2k − x. Wir erhalten x + y¯ = x + (2k − y) = (x − y) + 2k , wobei der zus¨atzliche Term 2k bei der Addition +2 ignoriert wird. • x ≥ 0, y ≥ 0, |x| < |y|. Dann ist die Komplementdarstellung von x und y die Dualdarstellung, die Komplementdarstellung der negativen Zahl x−y ist die Dualzahl (x−y)+2·2 k−1 = (x − y) + 2k . Wir finden x + (2k − y) = x − y + 2k .

4 DATENSTRUKTUREN

46

• x < 0, y < 0, |x| ≥ |y|. Dann ist die Komplementdarstellung von x bzw. y durch die Zahlen x + 2k bzw. y + 2k gegeben. Wir erhalten x + 2k + (2k − (y + 2k )) = x − y + 2k . x − y ist negativ, also ist das die Komplementdarstellung von x − y. • x < 0, y < 0, |x| < |y|. Wie eben erhalten wir als Ergebnis x − y + 2k . x − y ist positiv, die Komplementdarstellung also x − y. Der zus¨atzliche Term 2k verschwindet bei Addition +2 . • x ≥ 0, y < 0. Es ist xC + y C = x + (2k − (y + 2k )) = x − y. x − y ist positiv, also stimmt das Ergebnis. • x < 0, y ≥ 0. Es ist xC + y C = (x + 2k ) + (2k − y) = x − y + 2k + 2k . x − y ist negativ, die Komplementdarstellung also x − y + 2k . Der zus¨atzliche Term entf¨allt bei Addition +2 . Wir haben hierbei vorausgesetzt, daß alle Zahlen, insbesondere auch x−y, im darstellbaren Bereich sind. Ist das nicht der Fall, dann ist das Ergebnis falsch, d.h. das Ergebnis ist nicht die Komplementdarstellung der Differenz. Ein Beispiel: 2k−1 − 1 − (−2k−1 ) berechnet sich in dieser Darstellung als . . 0}) = 0 1| .{z . . 1} +1 0| .{z . . 0} = 1| .{z . . 1} 0 1| .{z . . 1} +(1 0| .{z k−1

k−1

k−1

k−1

k

Diese Zahl w¨are in Dualdarstellung das korrekte Ergebnis. In Komplementdarstellung entspricht das aber −1, ist also falsch. Sie k¨onnen dieses in Java testen! Folgendes Programm subtrahiert die kleinste Integerzahl −231 (durch die Konstante Integer.MIN VALUE erh¨altlich) von der gr¨oßten Integerzahl 2 31 − 1 (Integer.MAX VALUE). Das Ergebnis ist f¨alschlicherweise −1. public class ganz { public static void main(String[] args) { int x=Integer.MIN VALUE; // −231 int y=Integer.MAX VALUE; // 231 − 1 int diff=y-x; // diff ist zu groß f¨ ur Integer! System.out.println(y+" - "+x+" = "+diff); // gibt −1! } } Man muß bei s¨amtlichen Operationen darauf achten, daß Zahlen nur in einem endlichen Bereich dargestellt werden. Verl¨aßt man den Bereich, ist das Ergebnis in der Regel falsch. Die Komplementdarstellung zur Basis 2 wird im Rechner intern zur Darstellung ganzer Zahlen benutzt. Die Komplementbildung f¨ur bin¨are Werte ist besonders effizient m¨oglich, da die einzelnen Bits lediglich geflipt werden m¨ussen. Zudem kann man hier die Subtraktion besonders effizient realisieren, wie wir gesehen haben.

4.3 Floating point Reelle Zahlen entsprechen den Punkten auf der Zahlengeraden: wie die ganzen Zahlen auch, sind sie nach oben und unten unbeschr¨ankt. Zudem liegen in einem beliebig kleinen Intervall der Zahlengeraden beliebig viele reelle Zahlen. Sie sind u¨ berabz¨ahlbar. Insbesondere kann man eine allgemeine reelle Zahl (spezieller die sogenannten transzendenten Zahlen) nicht mithilfe einer endlichen Anzahl von Ziffern exakt darstellen. Generell haben reelle Zahlen die Form ± zahl.ziffernfolge

4.3 Floating point

47

mit einer nichtnegativen Zahl vor dem Komma und einer evtl. unendlich langen Ziffernfolge nach dem Komma. (Wir k¨ummern uns an dieser Stelle nicht darum, was eine unendlich lange Ziffernfolge denn bedeutet. In der Mathematik werden reelle Zahlen u¨ ber die durch diese Ziffernfolgen definierte konvergente Reihen eingef¨uhrt.) Computer stellen reelle Zahlen intern verm¨oge endlich vieler diskreter Stellen dar. Ein Verlust von Information ist dabei unvermeidlich, und der ad¨aquate Umgang mit dieser Darstellung, so daß sich der Informationsverlust nicht zu nicht tolerierbaren Fehlern akkumuliert, ist nicht einfach. Man kann prinzipiell zwei verschiedene Formate w¨ahlen: • Die Festkommadarstellung reserviert jeweils eine feste Anzahl von Bits zur Darstellung der Vorkomma- und Nachkommastellen. Etwa 123.4711 mit drei Vorkomma- und vier Nachkommastellen. Analog zur B-adischen Darstellung kann eine Festkommadarstellung verschiedene Basen benutzen, im Rechner in der Regel die Basis 2. Eine Ziffernfolge Pn der Form 0 0 0 an . . . a0 .a1 . . . am mit ai , ai ∈ {0, . . . , B − 1} steht dann f¨ur die reelle Zahl i=0 ai B i + P m −i i=1 ai B . Man kann mit Festkommazahlen im Prinzip wie mit ganzen Zahlen in Badischer Darstellung umgehen, deren Darstellung ist eindeutig und elementare Operationen leicht berechenbar. Ein Nachteil der Festkommadarstellung ist, daß die ‘Feinheit’ der Darstellung a priori festgelegt ist. Bei m Nachkommastellen liegt prinzipiell in ‘L¨ochern’ der L¨ange B −m der Zahlengerade keine Zahl und eine genauere Darstellung etwa kleiner Zahlen nahe null ist unm¨oglich. Man kann allerdings durch Erh¨ohung der Stellen die Zahlen beliebig gut approximieren und die L¨ocher beliebig klein machen: verwendet man m Nachkommastellen, dann kann man reelle Zahlen bis auf einen Fehler von maximal B −m darstellen. • Die Fließkommadarstellung (Floating point) erlaubt, die Anzahl der Stellen nach Bedarf auf Vor- und Nachkommastellen zu verteilen. Eine derartige Darstellung wurde unter anderem in der IEEE Norm 75414 zur bin¨aren Fließkommadarstellung spezifiziert. Diese Norm und die mit dieser Darstellung verkn¨upften Risiken sollen Bestandteil dieses Abschnitts sein. Schonmal vorweggenommen: ein nicht-sachgem¨aßer Umgang mit floating points war bereits die Ursache fataler Fehlschl¨age in mehreren milliardenschweren Projekten, Sie k¨onnen es eigentlich nur besser machen . . . Java gehorcht dieser IEEE-Norm. Wir beschr¨anken uns hier auf den Fall von bin¨arer Information, d.h. der Basis 2. float benutzt 31 Bit, der Datentyp double benutzt 64 Bit. Zahlen sind prinzipiell so dargestellt, daß Bereiche mit kleinen und mit großen Zahlen gut abgedeckt sind, wobei die L¨ucken bei großen Zahlen gr¨oßer sein d¨urfen als bei kleinen (denn es kommt in solchen Bereichen h¨aufig nicht so sehr auf genaue Nachkommastellen an, wie wenn man ohnehin sehr kleine Werte betrachtet. Nehmen Sie etwa eine Million im Vergleich zu 0.001.) Prinzipiell sind Zahlen in folgendem Format dargestellt: (−1)s · m · 2e−b repr¨asentiert durch eine Bitfolge mit • einem Vorzeichenbit s, das das Vorzeichen ±1 der Zahl definiert, s = 0 bedeutet positive Zahlen, s = 1 negative. 14

IEEE steht f¨ur eine aus der AIEE (American Institute of Electrical Engineers) und IRE (Institute of Radio Engineers) gegr¨undete Gesellschaft im Bereich Informatik, Elektrotechnik und verwandter Wissenschaften, die vor allem in den U.S.A. eine f¨uhrende Position einnimmt. Zu ihren Aufgaben z¨ahlt unter anderem die Organisation von internationalen Tagungen und die Herausgabe wichtiger Zeitschriften in verschiedenen Gebieten. Die IEEE tr¨agt durch Entwicklung von Normen fundamental zur Standardisierung verschiedenster Techniken bei.

4 DATENSTRUKTUREN

48

• einer Mantisse m, die f¨ur Float aus 23 Bits, f¨ur double aus 52 Bit besteht, diese wird als Dualzahl interpretiert, • einem Exponenten e, der f¨ur Float 8 Bit, f¨ur double 11 Bit beansprucht, • einem festen Bias b, der f¨ur alle Zahlen gleich gew¨ahlt ist, bei float als 127 = 1111111 2 und bei double als 1023; der Exponent wird als Dualzahl interpretiert und der Bias abgezogen. Eine solche Darstellung ist normalisiert, sofern 1≤m<2 gilt. In der Regel rechnet man nur mit normalisierten Zahlen. Man kann jede solche Darstellung außer der Null einfach normalisieren, indem man sukzessive • im Fall m ≥ 2 die Mantisse sukzessive durch 2 teilt und den Exponenten erh¨oht, • im Fall m < 1 die Mantisse sukzessive mit 2 multipliziert und den Exponenten erniedrigt. F¨ur normalisierte Darstellungen ist das erste Bit der Mantisse immer 1, daher wird es weggelassen, und man spart ein Bit. Die duale Ziffernfolge m wird also als die Dualzahl 1m · 2 −l(m) = 1.m interpretiert, wobei l(m) die L¨ange der Mantisse ist. Ein Beispiel: 0.085 entspricht s e m 0 01111011 [1.]01011100001010001111010 + 123 1.3599999 Wir erhalten 2123−127 · 1.3599999 = 0.084999993, also eine Approximation der Zahl. Wir kommen hier zur ersten wichtigen Beobachtung: Relle Zahlen sind in der Regel nur approximativ im Rechner dargestellt. Insbesondere kann es sein, daß zur Basis 10 exakt darstellbare Zahlen in der Fließkommadarstellung zur Basis 2 nicht exakt repra¨ sentiert werden k¨onnen. Eine solche Zahldarstellung erlaubt, die reellen Zahlen in einem endlichen Bereich mit L¨ochern, die nach außen hin gr¨oßer werden, zu repr¨asentieren. Es sind jeweils die f¨uhrenden Bits einer Zahl innerhalb der Mantisse dargestellt, der Exponent bestimmt die Gr¨oßenordnung der gesamten Zahl. Insbesondere gibt es immer einen kleinen Bereich um 0, der nicht darstellbar ist. F¨ur float ist der gr¨oßte Exponent 1 . . . 1, der 28 − 1 − 127 = 128 repr¨asentiert. Der kleinste ist 0 . . . 0, der −127 entspricht. Die gr¨oßte Mantisse ist 1 . . . 1. Die kleinste Mantisse ist 0 . . . 0, die der unterdr¨uckten 1 entspricht. Die Null ist in normalisierter Darstellung nicht mehr darstellbar, daher muß daf¨ur eine spezielle Konvention getroffen werden. Eine sinnvolle Wahl ist, Null durch die betragsm¨aßig kleinste Zahl zu repr¨asentieren, also durch die Folge mit Mantisse 0 . . . 0 und Exponent 0 . . . 0. (Das Vorzeichen ist dabei egal, d.h. es gibt ±0.) Dieses hat zur Konsequenz, daß die Darstellung der Zahlen in der u¨ blichen lexikographischen Anordnung der Anordnung auf dem Zahlenstrahl entspricht. Es gibt insbesondere eine Repr¨asentation f¨ur +0 und −0. (Diese Werte erh¨alt man automatisch auch bei Underflow, d.h. Zahlen, die zu nahe bei 0 sind um dargestellt zu werden, also zu kleinem Exponenten.) Weitere Werte sind reserviert: eine Mantisse 0 und maximaler Exponent steht f¨ur ±∞ (diese Werte erh¨alt man bei Overflow, d.h. zu großen oder kleinen Werten, also zu großem Exponenten oder wenn man eine Zahl ungleich 0 durch 0 teilt), eine Mantisse 6= 0 und maximaler Exponent steht f¨ur NaN, d.h. not a number (dieses erh¨alt man z.B. f¨ur 0.0/0.0,

4.3 Floating point

49

unendlich/unendlich, etc.). Mit dieser Konvention sind die betragsm¨aßig gr¨osten in float darstellbaren Zahlen die Werte ±(225 − 1) · 2−24 · 2127 , die betragsm¨aßig kleinsten Zahlen (ohne Null) ±(224 + 1) · 2−24 · 2−127 . Wie rechnet man mit Zahlen in Fließkommadarstellung? Prinzipiell gilt folgendes: seien (−1) s1 · m1 · 2e1 und (−1)s2 · m2 · 2e2 zwei Zahlen im Fließkommaformat. Dann erh¨alt man f¨ur die Basisoperationen: (−1)s1 · m1 · 2e1 + (−1)s2 · m2 · 2e2 = ((−1)s1 · m1 + (−1)s2 · m2 · 2e2 −e1 ) · 2e1 und (−1)s1 · m1 · 2e1 · (−1)s2 · m2 · 2e2 = ((−1)s1 +s2 · m1 · m2 ) · 2e1 +e2 Addition (und Subtraktion) kann man also durch Angleichen des Exponenten und Addition (Subtraktion) der Mantissen erreichen, Multiplikation (und Division) erh¨alt man durch Multiplikation (Division) der Mantissen und Addition (Subtraktion) der Exponenten. F¨ur das IEEE floating point Format muß man noch auf den Bias achten, der bei der Multiplikation (Division) geeignet zu erg¨anzen ist. Die sich ergebenden Zahlen sind in der Regel nicht normiert und eine erneute Normierung ist n¨otig. Diese Operationen sind im Rahmen der Darstellung pr¨azise, wenn sie mit allen vorhandenen Stellen ausgef¨uhrt werden. Das kann allerdings f¨ur Zahlen verschiedener Gr¨oßenordnungen unangemessen aufwendig sein. Betrachten wir die Addition der bez¨uglich der Basis 10 dargestellten Zahlen (der Einfachheit halber sind also hier Mantisse und Exponent einfache dezimale Zahlen statt bin¨ar dargestellter Werte) 2.15 · 1012 und 1.25 · 10−5. M¨ochte man x − y berechnen, geschieht das pr¨azise als x = 2.15 · 1012 y = 0.0000000000000000125 · 1012 x − y = 2.1499999999999999875 · 1012 gerundet: 2.15 · 1012 Dasselbe Ergebnis h¨atte man bekommen, wenn man y nur mit einer begrenzten Anzahl (etwa zwei) Stellen bezogen auf den Exponenten 1012 dargestellt h¨atte. Fließkommaarithmetik benutzt in der Regel nur eine feste Anzahl Stellen (die allerdings mehr als die Stellen der Darstellung sein k¨onnen) und berechnet die Operationen basierend auf diesen Stellen. Zahlen, die mehr Stellen als die Rechengenauigkeit ben¨otigen w¨urden (wie die Darstellung von 1.25 · 10 −5 bezogen auf die Skalierung 1012 ) werden einfach rechts abgeschnitten, d.h. alle nicht in die vorhandenen Stellen passenden Eintr¨age auf der rechten Seite ignoriert. Dieses Vorgehen f¨uhrt potentielle Fehler ein: neben der gegebenenfalls ohnehin nur approximativen Darstellung der Zahlen k¨onnen arithmetische Operationen den Fehler potenzieren. Ein Beispiel, 10.1 − 9.93 berechnet sich bei zwei Nachkommastellen als x = 1.01 · 101 y = 0.99 · 101 x − y = 0.02 · 101 Es ist allerdings 10.1−9.93 = 0.17, das mit der Antwort 0.02·101 in keiner einzigen Nachkommastelle u¨ bereinstimmt! Wir stellen also fest: Fließkommaarithmetik mit einer festen Anzahl Stellen f¨ugt in der Regel zus¨atzliche Fehler in die Ergebnisse ein. Es stellt sich die Frage, wie man diese Fehler spezifiziert, wie groß sie werden k¨onnen, wo besondere Gefahren liegen und wie man diese weitestgehend vermeiden kann. Eine erste wichtige Unterscheidung ist die Notation der Pr¨azision einer Berechnung und ihre Akkurazita¨ t. Die Pr¨azision einer Rechnung referiert auf die Anzahl der Stellen (in der Regel der Mantisse), die f¨ur eine Rechnung verwandt und dargestellt werden. F¨ur float haben wir eine Pr¨azision von 23(+1)

4 DATENSTRUKTUREN

50

Bit. Die Akkurazit¨at referiert auf die Anzahl der Stellen einer Zahl, die korrekt sind. In der Regel ist das weniger, als die Pr¨azision angibt, und die letzten Ziffern einer Berechnung werden zwar dargestellt, sie stimmen aber nicht. Wir m¨ochten eine m¨oglichst große Akkurazit¨at der Berechnung haben. Es gibt zwei verbreitete M¨oglichkeiten, die Akkurazit¨at anzugeben: • Der absolute Fehler gemessen in units in the last place (ulps) referiert auf die letzten Stellen in der (normierten) Darstellung der Zahl, die falsch sind. Wir nehmen an, die Basis sei B (z.B. B = 2). Wird die Zahl x durch m · B e mit p Stellen der Mantisse und Normierung 1 ≤ m < B dargestellt, dann ist der absolute Fehler |m − (x/B e )| · B p−1 ulps. Als Beispiel, repr¨asentiert 0.02 · 101 mit drei Stellen (zwei Nachkommastellen) die Zahl 0.17, dann ist das um (2 − 0.17/10−1 ) · 102 = 30 ulps falsch (bezogen auf die normierte Darstellung). Ein Fehler um weniger als ein ulp bedeutet, daß alle dargestellten Ziffern korrekt sind, aber die Pr¨azision f¨ur eine exakte Darstellung der Zahl nicht ausreicht. Die Einheit ulps gibt also direkt den Fehler in den letzten Bits an. • Der relative Fehler der Darstellung m · B e f¨ur x ist die Gr¨oße |m · B e − x|/|x|, d.h. die Differenz der beiden Zahlen im Verh¨atnis zur Gr¨oße der darzustellenden Zahl. Der relative Fehler erweist sich f¨ur Fehlerabsch¨atzungen h¨aufig als gut zug¨anglich. Der relative Fehler von der Darstellung 0.2 f¨ur 0.17 ist |0.2 − 0.17|/0.17 = 0.176. Normalerweise wird allerdings der relative Fehler in der Einheit := B/2 · B −p angegeben, um zu kleine Werte zu vermeiden. Relativer Fehler (als Vielfaches von ) und ulps weichen um den Faktor B e /(|x| · ) voneinander ab.15 Je nach Genauigkeit der Darstellung (|x| ≈ |m| · B e mit m ∈ [1, B)) unterscheidet sich das nur wenig oder deutlich. Mithilfe dieser Notation k¨onnen wir den Fehler von Operationen spezifizieren. Dieser kann sehr groß werden: • Der relative Fehler bei der Subtraktion zweier Fließkommazahlen mit Basis B und p Stellen kann (B − 1)/ werden. Diesen Fehler erhalten wir etwa durch Subtraktion von x = 1.0 . . . 0 (p − 1 Nullen) und y = 0.B − 1 . . . B − 1 (p Stellen B − 1, darstellbar als B − 1.B − 1 . . . B − 1 · 10−1). Die Differenz x − y ist B −p . Benutzt man nur p Stellen, dann wird die rechteste Stelle von y ignoriert, wir erhalten also B −p+1 mit relativem Fehler |B −p − B −p+1 |/B −p = B − 1 = (B − 1)/. Das ist ein ziemlich großer Fehler je nach Wert von x. Der IEEE Standard verlangt davon abweichend, daß die Basisoperationen exakt mit verf¨ugbaren allen Stellen durchgef¨uhrt und erst danach gerundet wird. Das kann bei Zahlen ungleicher Gr¨oße sehr ineffizient werden, wie wir gesehen haben. Abhilfe kann man schaffen, wenn mehr Stellen f¨ur die Berechnung der Subtraktion und anderer Operationen verwandt werden, als Bits f¨ur die Zahlendarstellung explizit zur Darstellung benutzt werden, sogenannte guard digits f¨ur arithmetische Operationen. Wir erhalten schon bei nur einem guard digit (d.h. einem Bit zus¨atzlich f¨ur die Rechnung) eine wesentlich bessere Akkurazit¨at: • Sind x und y Fließkommazahlen mit Basis B und p Ziffern, dann hat eine Subtraktion mit p + 1 Stellen und anschließender Rundung h¨ochstens den relativen Fehler 2 = B −p+1 . Das 15

Das kann man direkt nachrechnen: sei B die Basis und p die Anzahl Stellen. Sei m · B e eine Darstellung von x. Dann ist Be |m · B e − x|/(|x| · B/2 · B −p ) = |m − x/B e | · B p−1 |x| der Quotient von relativem und absoluten Fehler.

4.3 Floating point

51

ist wesentlich kleiner als (B − 1)/! Verwendet man drei zus¨atzliche Bits, kann man das Ergebnis von exakter Rechnung und nachtr¨aglicher Rundung sogar exakt erhalten. 16 Durch die IEEE Norm sind also Fehler einzelner Operationen nur beschr¨ankt durch die Darstellungsgenauigkeit und Rundung. Kombiniert man diese Operationen allerdings ung¨unstig in einem Programm, kann das fatale Folgen haben, da ja die einzelnen Zahlen jeweils mit einem Fehler dargestellt werden. Fehler k¨onnen sich bis zur Katastrophe aufschaukeln! Ein paar T¨ucken: • Vergleich von Fließkommazahlen: double x=0.1+0.1+0.1; if (x==0.3) System.out.println("gleich"); else System.out.println(nicht gleich"); double y=0.1+0.1+0.1+0.1+0.1; if (y==0.5) System.out.println("gleich"); else System.out.println(nicht gleich"); liefert not equal gefolgt von equal. Problem: Zahlen sind nicht unbedingt exakt darstellbar. Werden sie in Operationen verwendet, k¨onnen kleine Rundungsfehler daf¨ur sorgen, daß sie nicht mit dem erwarteten Wert u¨ bereinstimmen. Um Gleichheit von Fließkommazahlen zu testen, ist es daher nicht ratsam, exakte Gleichheit (a==b) zu testen. Abhilfe schafft ein absoluter Vergleich |a-b| < oder relativer Vergleich |a-b| < *min{|a|,|b|}. (Aber auch diese Vergleiche haben ihre T¨ucken und eine gute Wahl von h¨angt vom Gebrauch ab.) Beachten Sie, daß durch a¨ hnliche Effekte auch Vergleiche mit < und > ungew¨ohnliche Auswirkungen haben k¨onnen! • Catastrophic cancellation: double x1=10.000000000000004; double x2=10.000000000000000; double y1=10.00000000000004; double y2=10.00000000000000; double z=(y1-y2)/(x1-x2); System.out.println(z); 16

Das soll hier nicht genau erl¨autert werden. Kommen wir zum Beweis f¨ur ein guard digit. Wir betrachten nur den Fall x > y > 0. Der Rest ist a¨ hnlich. Wir k¨onnen ohne Einschr¨ankung annehmen, daß x die Form x 0 .x1 . . . xp−1 hat. Wir verschieben y entsprechend und ignorieren alle rechten Ziffern, die nicht in p + 1 Bits (Genauigkeit und guard Bit) passen. Die Zahl sei y 0 . Es gilt y − y 0 ≤ (B − 1)(B −p−1 + . . . + B −p−k ) f¨ur ein k. Die Subtraktion mit einem guard Digit liefert den Wert x − y 0 + δ mit dem durch Rundung m¨oglichen Fehler |δ| ≤ B/2 · B −p . Der Fehler |(x − y) − (x − y 0 − δ)|/(y − y 0 − δ) ist von Interesse. Es gibt drei F¨alle: – x − y ≥ 1. Dann ist der relative Fehler maximal (y − y 0 + δ)/1 ≤ B −p ((B − 1)(B −1 + . . . + B −k ) + B/2) < B −p (1 + B/2). – x − y 0 < 1. Dann ist δ = 0, denn es mußte nicht gerundet werden. x − y ist mindestens 1.0 . . . 0 − 0. 0 . . 0} B . . B − 1} > (B−1)(B −1 +. . .+B −k ). Der relative Fehler ist also maximal (B−1)B −p (B −1 + | .{z | − 1 .{z k

p

. . . + B −k )/((B − 1)(B −1 + . . . + B −k )) = B −p .

– x − y < 1 und x − y 0 ≥ 1. Dann muß x − y 0 = 1 gelten, also δ = 0, also dieselbe Argumentation wie eben ist korrekt.

4 DATENSTRUKTUREN

52

Man kann nachrechnen, daß sich eigentlich 10 ergeben sollte. Java liefert aber 11.5! Problem: Sehr kleine Zahlen wurden aus sehr großen Zahlen durch Subtraktion gewonnen. Die ersten Stellen stimmen exakt u¨ berein und heben sich also weg. Die letzten Stellen r¨ucken nach, haben aber nur noch eine sehr geringe Akkurazit¨at, die dann f¨ur das ungenaue Ergebnis verantwortlich ist. Man sollte also vermeiden, sehr a¨ hnliche Zahlen zu summieren. Analoge Probleme treten auf, wenn man gr¨oßenordnungsm¨aßig sehr verschiedene Zahlen summiert, wobei die kleinere Zahl im schlimmsten Fall die gr¨oßere gar nicht a¨ ndert, da sie nur irrelevante Bits beeinflußt. Ein weiteres Beispiel: wir berechnen ex nach der Taylorformel (eine Methode der Mathematik, Funktionen lokal durch Polynome anzun¨ahern) als ex = 1 + x + x2 /2 + x3 /3! + x4 /4! + . . . f¨ur negative Zahlen x. Die Reihe konvergiert absolut und gleichm¨aßig, dennoch liefert Java horrende Ergebnisse f¨ur negative Zahlen. Das Problem ist, daß man in der Summe viele Paare wie (f¨ur x = −25) 2524 /24! und −2525 /25! erh¨alt, die sich in Theorie, nicht aber in der konkreten Rechnung im Fließkommaformat zu Null addieren. • Over- und Underflow: Bei Multiplikationen und Divisionen muß man sehr große und sehr kleine Werte m¨oglichst vermeiden, da sie sonst leicht in nicht mehr darstellbare Bereiche nahe Null (d.h. die Werte werden f¨alschlicherweise exakt Null) oder ±∞ f¨uhren k¨onnen. Je nach Gegebenheiten muß man Abhilfe schaffen, z.B. durch k¨unstliche Setzung auf kleine oder große Werte ungleich Null und Unendlich, oder Ersetzen der Multiplikation durch eine Addition und Exponentiation. ¨ • Instabile Numerik: Programme, bei denen kleine Anderungen der Eingabe nur zu kleinen ¨ Anderungen der Ausgabe f¨uhren, heißen numerisch stabil. Wir sind an solchen interessiert. Oft kann man durch geeignete Vorsichtsmaßnahmen Berechnungen numerisch stabil gestalten, wobei allerdings das Design stabiler Algorithmen hochgradig nicht trivial ist! Es gibt allerdings auch Probleme, die prinzipiell keine stabilen Verfahren zulassen (ill-conditioned problems). Ein Beispiel ist die logistische Gelichung, die zu einem sogenannten chaotischen ¨ System f¨uhrt, bei dem im Limes sehr kleine Anderungen sehr große Auswirkungen haben. Es soll beginnend von einem Startwert x(0) zum Zeitpunkt t die Gr¨oße x(t) = Rx(t − 1)(1 − x(t − 1)) berechnet werden. F¨ur große R ist das nicht mehr stabil m¨oglich! Solche chaotischen Systeme treten auch in der Natur auf (etwa in Wachstumsprozessen oder auch die Trajektorie vom Orbit von Pluto)! Problem: das Iterieren von Rechnungen mit kleinem Fehler kann zu beliebig großen Abweichungen f¨uhren. Es gibt also einige Probleme und auch prinzipiell nicht numerisch stabil l¨osbare Aufgaben. In den allermeisten F¨allen treten aber ungew¨unschte Verhalten aufgrund einer nicht ad¨aquaten Behandlung der Numerik auf, die sich gelegentlich erst bei extremen Werten zeigt. Zum Abschluss zwei Beispiele aus dem wirklichen Leben: • Ariane rocket 5 explodierte 40 Sekunden nach Start bei der Jungfernfahrt, 7 Billionen Dollar auf einen Schlag vernichtend. Das Problem lag an Werten f¨ur die Beschleunigung, die einen ¨ Uberlauf in einem Teil des Programms hervorriefen, das f¨ur die Rekalibrierung der Steuerung n¨otig war. Eine Kopplung von weiteren Effekten f¨uhrte dann zum Ende von Ariane. • 1991 traf eine amerikanische Patriotrakete statt des anvisierten Ziels eine (bewohnte) Baracke. Der initiale Fehler wurde durch die nicht exakte Darstellbarkeit von 1/10 im Programm verursacht.

4.4 Klassen und Methoden

53

4.4 Klassen und Methoden Wir k¨onnen jetzt komplexe Kontrollstrukturen schreiben und deren Auswirkung formal spezifizieren und sogar verifizieren. Diese Programme k¨onnen allerdings je nach den Gegebenheiten sehr un¨ubersichtlich werden. Wir haben bei unserem anf¨anglichen Kochrezept bereits eine M¨oglichkeit verwendet, Programme u¨ bersichtlicher und k¨urzer zu gestalten: die Einteilung des Kontrollflusses in mehrere Module. Definition von Klassen Die Grundbausteine von Java als objektorientierter Programmiersprache sind Klassen. Das ist unterschiedlich zu einer imperativen Programmiersprache wie C. Klassen sind von der Idee her komplexere Variablentypen mit mehreren Eintr¨agen und Werten, die alle Methoden, diese zu beeinflussen, innerhalb der Datenstruktur selbst zur Verf¨ugung stellen. Sie bilden die kleinsten Einheiten in Java. Durch die Kapselung aller eine Klasse betreffende Information und aller damit zusammenh¨angenden Operationen innerhalb der Klassen ist eine sehr u¨ bersichltliche, modulare und gut wartbare Programmierung m¨oglich. Man kann, wenn Klassen definiert sind, Variablen dieser Klasse benutzen, sogenannte Objekte. Objekte sind Instanzen einer Klasse. Eine Klasse in Java hat generell folgende Form class { <Methoden> } Variablen und Methoden d¨urfen dabei in beliebiger Reihenfolge vorkommen. Ein Beispiel class Kreis{ public double radius; static private final double pi=3.14; public double flaeche(){ return (pi*radius*radius);} } Elemente der Klasse sind class members, Klassenmitglieder, d.h. Variablen oder Methoden. Variablen referiert auf Variablendeklarationen und etwaige Instanziierungen z.B. mit Konstanten; in obigem Fall hat die Klasse Kreis die Felder radius und pi. Variablendeklarationen bestehen, wie wir schon wissen, aus einem Variablentypen, z.B. einem primitiven Typen double, und einem Variablenbezeichner. Diesem darf an Ort und Stelle ein Wert zugewiesen werden, wie oben mit pi=3.14 geschehen. Oben sind verschiedene zus¨atzliche Charakterisierungen gebraucht: • final bedeutet bei Variablen, daß deren Wert genau einmal gesetzt wird und sich danach nicht mehr a¨ ndert. Final-Variablen m¨ussen initialisiert werden. Sie sind zum Beispiel zur Definition von Konstanten gebr¨auchlich. Der Versuch, final-Variablen zu a¨ ndern, bewirkt einen Fehler. • Es gibt sogenannte Klassen- und Instanzvariablen. Klassenvariablen sind durch static markiert. Es sind Felder, die sich alle Objekte der Klasse teilen. Instanzvariablen (ohne static) sind Felder, die jedes Objekt der Klasse einzeln besitzt. Klassenvariablen speichern also etwas, das bei allen Objekten gleich ist. In obigem Fall geh¨ort das Feld pi gemeinsam allen Kreis-Objekten, die Kreise besitzen nicht gesonderte Konstanten pi.

4 DATENSTRUKTUREN

54

• Variablen k¨onnen eine unterschiedliche Sichtbarkeit haben. private bedeutet, daß nur das Objekt selbst dieses Feld sehen und beeinflussen darf; das sind also Geheimnisse der Klasse, ¨ die kein anderer wissen darf, z.B. weil deren unkontrolierte Anderung zu einem inkonsistenten Zustand der Objekte f¨uhren k¨onnte. public bedeutet, daß alle auch von außen auf dieses Feld zugreifen d¨urfen, das sind also Informationen, die jeder wissen sollte. Zudem gibt es noch protected, was Visibilit¨at innerhalb des Pakets, der Klasse und abgeleiteter Klassen bedeutet. Letzlich gibt es package, was Sichtbarkeit im Paket bedeutet. Wir behandeln hier keine Pakete, sondern werden, da wir nur kleinere Beispiele betrachten, alle Klassen in eine Datei schreiben. Der Name ergibt sich aus dem Namen der Klasse, die die main-Methode implementiert. Alle Klassen in einer Datei sind automatisch Elemete eines anonymen Paketes. Der Compiler u¨ bersetzt die Klassen in durch .class bezeichnete Dateien. Per Default (also ohne Angabe) sind Variablen nicht static, package (also Paketsichtbar, d.h. in unserem Fall von nur einem Paket sichtbar) und nicht final. Als Bemerkung: Man k¨onnte auch Klassen selbst mit dem Zusatz public versehen. Dann m¨ussen sie in einem File gleichen Namens stehen und sind u¨ berall sichtbar. Default bei Klassen ist Paketsichtbarkeit. Methoden haben generell die Form <Modifikation> (Variablenliste){ } Eine Modifikation a¨ hnlich wie bei Variablen kann vorgegeben werden: • final bedeutet, daß die Methoden sp¨ater nicht mehr ge¨andert werden d¨urfen (wie das ginge, sogenanntes Overriding, diskutieren wir sp¨ater). • static referiert auf Klassenmethoden statt Instanzmethoden. Klassenmethoden sind f¨ur die Klasse und keine einzelnen Objekte zust¨andig und d¨urfen nur auf Klassenvariablen zugreifen, aber nicht auf Instanzvariablen der Klasse. • private bedeutet, daß die Methode nur aus der Klasse selbst heraus sichtbar ist, public ver¨andert die Sichtbarkeit auf die Außenwelt, protected bedient die Klasse selbst, das Paket und alle abgeleiteten Klassen, package bedient das Paket und die Klasse selbst. Per default sind Methoden vom Paket zugreifbar, nicht final und nicht static. Methoden k¨onnen innerhalb einer (m¨oglicherweise leeren) Variablenliste Variablen u¨ bernehmen, die innerhalb der Methode verwendet werden k¨onnen. Diese werden call by value u¨ bergeben, d.h. Ver¨anderungen primitiver Typen innerhalb der Methode haben keinen Effekt auf die Außenwelt. Was sie bei Objekten bewirken, diskutieren wir sp¨ater. Eine leere Liste kann auch als void geschrieben werden. Die Methode muß einen Wert zur¨uckgeben, induziert durch den Typ vor dem Methodennamen. Innerhalb eines Anweisungsblocks dient der Befehl return (<Wert>); dazu, einen Wert zur¨uckzugeben. Wird dieses Kommando ausgef¨uhrt, dann gibt die Methode die Auswertung von Wert zur¨uck und terminiert. Wird nichts zur¨uckgegeben, steht vor der Methode void. Objekte Jetzt zu Objekten. Objekte einer Klasse k¨onnen genau wie alle anderen Variablen auch deklariert werden:

4.4 Klassen und Methoden

55

; Die Deklaration eines Objektes bedeutet allerdings noch nicht, daß diese Objekte existieren. Eine Deklaration benachrichtigt lediglich den Compiler, daß in Zukunft der Identifier f¨ur Objekte dieser Klasse benutzt wird. Ein tats¨achliches Objekt bekommt man durch eine Instanziierung, die dem Compiler sagt, tats¨achlich Speicherplatz f¨ur dieses Objekt neu zur Verf¨ugung zu stellen. Auf das Objekt wird dann anschließend im Programmcode durch eine Referenz, d.h. einen Zeiger, der sagt, wo dessen Werte anzutreffen sind, verwiesen. Dann kann man den enthaltenen Feldern Werte zuweisen, sie initialisieren und mit dem Objekt rechnen. Beachten Sie, daß wir im Fall von primitiven Typen nicht zwischen Deklaration und Instanziierung unterschieden haben. Bei primitiven Typen ist der ben¨otigte Platz f¨ur ihre Darstellung a priori klar. Eine Deklaration stellt sofort diesen Platz zur Verf¨ugung. Bei Klassen ist der ben¨otigte Speicherplatz aufwendiger zu berechnen. Der Computer stellt daher bei der Deklaration lediglich den Speicherplatz f¨ur die Referenz auf das Objekt zur Verf¨ugung. Erst bei der Instanziierung wird Speicherplatz f¨ur die Felder des Objektes beschafft und die Referenz verweist dann auf diesen Speicherplatz. Verm¨oge der Referenz k¨onnen die Felder initialisiert und belegt werden. Klassen sind daher als Referenztypen bezeichnet. Die folgende Graphik zeigt den Unterschied. <primitiver Typ> X;

Wert

Y;

Referenz

Feld1 Feld2 Feld3

Konstruktoren Wie instanziiert man Referenztypen? In vielen F¨allen verwendet man dazu den Befehl new gefolgt vom Namen der Klasse, den sogenannten Default-Konstruktor. Etwa Kreis kreis; kreis=new Kreis(); hat den Effekt, daß die Variable kreis deklariert und mithilfe der Instanziierung Speicherplatz zur Verf¨ugung gestellt wird. Anschließend kann man auf die Elemente des Objekts durch einen Punkt zugreifen: kreis.radius=42; System.out.println(kreis.flaeche()); Unsere Programmierung an dieser Stelle ist unsch¨on, da es gegen einen wesentlichen Aspekt der objektorientierten Programmierung, die weitm¨oglichste Kapselung, verst¨oßt. Wenn der Radius von außen gesetzt wird, dann muß die exakte Art, wie der Radius intern gespeichert und verwandt wird, z.B. der genaue Datentyp bekannt sein. Das kann leicht zu Fehleren f¨uhren, wenn z.B. aus welchen Gr¨unden auch immer ein System intern mit anderen Variablentypen rechnen m¨ochte (z.B. integer statt double). Greifen Programme von außen direkt auf radius zu, dann h¨atte eine ¨ Anderung des Formats von radius Auswirkungen auf das gesamte Programm. Man w¨urde daher

56

4 DATENSTRUKTUREN

lieber den Zugriff auf das Feld Radius vermeiden. Da allerdings der Radius irgendwie von außen vor Beginn aller weiteren Rechnungen gesetzt werden muß, ben¨otigt man zus¨atzliche Konstrukte, sogenannte Konstruktoren. Konstruktoren sind a¨ hnlich zu Methoden, die den Namen der Klasse selbst tragen, keinen Wert zur¨uckliefern und zur Instanziierung eines Objekts statt des DefaultKonstruktors aufgerufen werden k¨onnen. Etwa in unserem Fall: class Kreis{ double radius; static private final double pi=3.14; public Kreis(double radius){ this.radius=radius;} public double flaeche(){ return (pi*radius*radius);} } Der Aufruf Kreis kreis=new Kreis(42.0); deklariert und instanziiert einen Kreis mit Radius 42. Eine Besonderheit: insbesondere innerhalb ¨ von Konstruktoren ist es u¨ blich, Variablen ‘doppelt’ zu benennen; in diesem Fall heißt der Ubergabeparameter des Konstruktors genauso wie ein Feld der Klasse. Man kann doppelte Variablen nat¨urlich umgehen. M¨ochte man sie doch nutzen, dann u¨ berdeckt die letzte Definition alle vorher¨ gehenden, kreis bezieht sich innerhalb des Konstruktors auf den Ubergabeparameter. Man muß daher explizit darauf hinweisen, daß das Feld der zur Zeit betrachteten Instanz this.radius benutzt wird. this referiert innerhalb der Klasse explizit auf die derzeitige Instanz (d.h. deren Referenzwert). Polymorphie Sobald ein Konstruktor definiert wurde, existiert der Default-Konstruktor nicht mehr. Kreis kreis=new Kreis(); w¨are also in obiger Klasse verboten. Man kann allerdings explizit mehr als einen Konstruktor mit demselben Namen, aber unterschiedlicher Parameterliste verwenden: class Kreis{ private double radius; static private final double pi=3.14; public Kreis(double radius){ this.radius=radius;} public Kreis(){ this.radius=1.0;} public double flaeche(){ return (pi*radius*radius);} } ¨ Dieses f¨allt unter das Stichwort Uberladen und Polymorphie: man darf denselben Namen f¨ur Methoden und Konstruktoren unterschiedlicher Stelligkeit oder unterschiedlichen Parametertypen verwenden. Die aktuelle Parameterliste entscheidet dann, welche Methode verwendet wird. In obiger Situation ist also folgendes m¨oglich Kreis kreis1 = new Kreis(); Kreis kreis2 = new Kreis(42.0);

4.4 Klassen und Methoden

57

Aufgrund dieses Mechanismus muß man bei den Variablentypen exakt sein: Methoden und Konstruktoren unterscheiden sich, wenn sie denselben Namen, aber Parameter unterschiedlichen Typs haben. Der Aufruf Kreis kreis2=new Kreis(42); w¨urde in obigem Fall einen Konstruktor mit Integer-Parameter aufrufen, so es ihn g¨abe. Klassen-/Instanzvariablen und -methoden Kommen wir, ausgestattet mit diesem Arsenal, nochmal zu den Stichw¨ortern Klassen- versus Instanzvariable zur¨uck. Wir m¨ochten aus welchen Gr¨unden auch immer unsere Kreise durchnummerieren. Neben dem Radius hat also jeder Kreis auch ein Feld id, eine nat¨urliche Zahl deklariert als private int id; Angefangen von 0 m¨ussen wir mit jedem neuen Kreis-Objekt den aktuellen zu vergebenden Identifier um eins erh¨ohen. Das kann nat¨urlich von außen geschehen: der Konstruktor wird zu Kreis(double radius,int maxid){ this.radius=radius; this.id=maxid;} und Aufrufe haben die Form int maxid=0; Kreis kreis1 = new Kreis(42,maxid); maxid++; Kreis kreis2 = new Kreis(1.0,maxid); Das ist nat¨urlich unsch¨on, da man die richtige Z¨ahlung außerhalb der Klasse vorhalten muß. Alternative bietet eine Klassenvariable, d.h. einer Variable maxid, die von allen Instanzen geteilt und bei Instanziierung eines neuen Objekts automatisch erh¨oht wird: class Kreis{ double radius; private int id; static private final double pi=3.14; static private int maxid=0; public Kreis(double radius){ this.radius=radius; this.id=maxid; maxid++;} public Kreis(){ this.radius=1.0; this.id=maxid; maxid++;} public double flaeche(){ return (pi*radius*radius);} } Noch etwas eleganter unter Vermeidung von Codeverdoppelung ist die folgende Alternative, die die Tatsache verwendet, daß man innerhalb von Methoden und Konstruktoren andere Konstruktoren verwenden darf:

4 DATENSTRUKTUREN

58

class Kreis{ double radius; private int id; static private final double pi=3.14; static private maxid=0; public Kreis(double radius){ this.radius=radius; this.id=maxid; maxid++;} public Kreis(){ this(1.0);} public double flaeche(){ return (pi*radius*radius);} } Das Argument this referiert auf einen bereits definierten Konstruktor der Klasse, der f¨ur das Element ausgef¨uhrt wird. Dieser Aufruf muß als erstes im neuen Konstruktor verwandt werden. Dieses ist ein Beispiel, wo eine Klassenmethode sinnvoll werden k¨onnte: public static int whatismaxid(){return(maxid);} ¨ Klassenvariablen sind vorhanden, sobald das System die Klasse gesehen hat. Offentliche Klassenvariablen und Klassenmethoden k¨onnen daher verwendet werden, auch wenn kein Element der Klasse erzeugt wurde. Sie k¨onnen durch den Klassennamen statt Objektnamen referenziert werden. In obigem Beispiel liefert also der Aufruf System.out.println(Kreis.whatismaxid()); vor Erzeugung eines Kreis-Objekts den Wert 0. Parameterubergabe ¨ Kommen wir nochmal zur¨uck zu Variablen, Parameter¨ubergabe und Zuweisungen. Generell wird bei der Parameter¨ubergabe und einer Zuweisung der Wert der betrachteten Variablen verwandt, ¨ und nicht die Variable selber. Das hat zur Folge, daß Anderungen des Wertes keine direkten Auswirkungen auf das umgebende (aufrufende) Programm haben. Ruft man eine Methode mit dem Integer x auf und a¨ ndert x innerhalb der Methode, wird der Wert von x außerhalb also nicht tangiert. Bei Referenztypen sieht das allerdings ein bißchen komplizierter aus: Der Wert einer betrachteten Variablen ist • der tats¨achliche Wert bei primitiven Typen, • eine Referenz auf die Felder bei Referenztypen. Das hat zur Folge daß sich diese unterschiedlichen Variablentypen unterschiedlich verhalten und unterschiedlich behandelt werden m¨ussen. Prozedur¨ubergaben in Java sind call by value: F¨ur primitive Typen wird also der finale Wert ¨ u¨ bergeben und ver¨andert, nicht die Speicherstelle, wo die Variable steht. Anderungen stehen also an einer anderen Speicherstelle und haben daher keinen Einfluß auf die Originalvariable. F¨ur Refe¨ renztypen wird die Referenz kopiert. Andert man (was man normalerweise nicht tut) die Referenz ¨ selbst, hat das keinen Einfluß auf die Originalreferenz. Andert man aber verm¨oge der Kopie der Referenz die (original) Felder, auf die die Kopie zeigt, hat das einen Einfluß auf die Felder und also das originale Objekt. Folgende Graphik macht das deutlich:

4.4 Klassen und Methoden <primitiver Typ> X;

59 Methode(X);

Y;

Kopie Wert

Methode(Y); Kopie

Referenz

Wert

Referenz

Feld1 Feld2 Feld3

Ein Beispiel der Effekte: class Einpaarzahlen{ int i; double x; public Einpaarzahlen(int i, double x){ this.i=i; this.x=x;} void Tuwas(Einpaarzahlen zahlen, int i, double x){ zahlen.i++; zahlen.x++; i++; x++; System.out.println(i); System.out.println(x); System.out.println(zahlen.i); System.out.println(zahlen.x); } public static void main(String[] args){ int i=42; double x=42.0; Einpaarzahlen zahlen = new Einpaarzahlen(i,x); System.out.println(i); System.out.println(x); System.out.println(zahlen.i); System.out.println(zahlen.x); zahlen.Tuwas(zahlen,i,x); System.out.println(i); System.out.println(x); System.out.println(zahlen.i); System.out.println(zahlen.x); } } Die Aufrufe liefern : 42 42.0 42 42.0 43 43.0 43 43.0 42 42.0 43 43.0

i x zahlen.i zahlen.x i x zahlen.i zahlen.x i x zahlen.i zahlen.x

print in main

print in Tuwas

print in main

4 DATENSTRUKTUREN

60 Vergleich- und Zuweisung von Referenztypen

Entsprechend muß man bei Operationen und Zuweisungen der unterschiedlichen Typen aufpassen. Primitive Variablen werden zu ihrem Wert ausgewertet, wenn man vergleicht oder zuweist, wie man es erwartet. Referenztypen werden zu dem Wert der Referenz ausgewertet. Weist man Referenztypen wie folgt zu kreis1=kreis2;

/* falsch f¨ ur Referenztypen! */

dann ist das Ergebnis also etwas unerwartet: in zwei Variablen hat man dieselbe Referenz auf die Felder des Kreis gespeichert, die Felder des Kreis existieren selbst nur einmal. M¨ochte man wirklich eine Kopie aller Felder und deren Werte bekommen, muß man dieses geeignet implementieren: man ben¨otigt eine Methode, die alle Felder des betrachteten Objekts mit primitiven Datentypen und evtl. rekursive alle durch Felder mit Referenzen dargestellten Subobjekte kopiert. Eine Kopiermethode der Klasse Kreis k¨onnte etwa wie folgt aussehen: public Kreis cloneKreis() { /* Kopie f¨ ur Referenztypen */ Kreis helpme = new Kreis(this.radius); return (helpme); } Eine Kopie erh¨alt man dann durch17 kreis2=kreis1.cloneme(); Analog testen Vergleiche der Form kreis1==kreis2 lediglich, ob in den Variablen dieselben Referenzen gespeichert sind. In der Regel ist das nicht das gew¨unschte Ergebnis. Man betrachtet Objekte als gleich, wenn der Inhalt aller ihrer Felder inklusive eventueller Subobjekte gleich ist. Also muß auch dieser Operator gesondert implementiert werden, etwa f¨ur Kreis (bei Gleichheit von zwei Kreisen f¨ur gleiche Radien) public boolean isequal(Kreis you){ if (you.radius==this.radius) return (true); else return (false); } ¨ Diese Methode erlaubt die korrekte Uberpr¨ ufung18 kreis1.isequal(kreis2) Wie schon erw¨ahnt ist String ein Referenztyp, der Zuweisungen im Text der Form String string="Hello World!"; zul¨aßt. Dieses kann man als spezielle Instanziierung sehen: In Hochkommata geschriebene Strings k¨onnen direkt verwendet werden und sind intern durch eine feste Referenz gespeichert. Strings m¨ussen aber durch die durch Java bereitgestellte Methode equals verglichen werden und Kopien der Inhalte statt Referenzen (so man sie braucht) bekommt man durch clone. 17

Java stellt die generelle Klasse clone(); zur Verf¨ugung, die h¨aufig f¨ur die ben¨otigten Zwecke angepaßt werden kann. Wir wollen das an dieser Stelle nicht vertiefen. 18 Java bietet die Methode equals, die f¨ur solche Zwecke u¨ berschrieben werden sollte.

4.4 Klassen und Methoden

61

class strings{ public static void main(String[] args){ String string1=args[0]; String string2=args[1]; String string3="Hello World!"; if ((string1+" "+string2+"!")==string3) System.out.println("ja"); else System.out.println(nein"); if ((string1+" "+string2+"!").equals(string3)) System.out.println("ja"); else System.out.println(nein"); } } Diese Programm liefert mit strings Hello World aufgerufen f¨ur den ersten Vergleich nein, denn es werden die Referenzen verglichen, f¨ur den zweiten Vergleich ja. Vererbung Ein letzter Punkt zu Klassen und Methoden: diese werden sehr n¨utzlich, sobald sie als Klassenhierarchie verwendet werden. Klassen k¨onnen als Unterklassen bereits bestehender Klassen definiert werden. Sie erben dann alle relevanten Eigenschaften der Oberklasse und k¨onnen aufbauend auf diesem Verm¨achtnis noch beliebig viele zus¨atzliche Funktionalit¨aten implementieren. Die Tatsache, daß eine Klasse erbt, wird durch den Zusatz extends deutlich gemacht. Ein Beispiel, betrachten wir eine Variation unserer Kreis Klasse von vorhin: class Kreis{ double radius; static final double pi=3.14; Kreis(double radius){this.radius=radius;} Kreis(){this.radius=1.0;} double flaeche(){return(pi*radius*radius);} } Eine sinnvolle Unterklasse w¨are, Kreise mit Mittelpunkt und zus¨atzlichen Funktionalit¨aten auszustatten: class Kreismitmittelpunkt extends Kreis{ double x,y; Kreismitmittelpunkt(double radius, double x, double y){ super(radius); this.x=x; this.y=y;} Kreismitmittelpunkt(){ Kreismitmittelpunkt(1.0,0.0,0.0);} void verschiebe(double x,double y){ this.x+=x; this.y+=y;} } Eine abgeleitete Klasse • erbt (d.h. es ist sichtbar) von der Oberklasse

4 DATENSTRUKTUREN

62

– alle Variablen, die in der Oberklasse zur Verf¨ugung stehen und nicht durch private markiert sind, – alle Methoden, die in der Oberklasse zur Verf¨ugung stehen und nicht durch private markiert sind, • erbt nicht von der Oberklasse – mit private markierte Variablen und Methoden, – Konstruktoren In obigem Fall erbt die Klasse Kreismitmittelpunkt also die Variablen radius, pi und double und die Methode flaeche. Klassen k¨onnen nur eine Oberklasse haben, nicht mehrere. Es ist n¨otig, neue Konstruktoren zu definieren, da ja in der Regel zus¨atzliche Funktionalit¨aten implementiert werden m¨ussen. Man kann den Konstruktor der Oberklasse f¨ur die neue Definition verwenden, so wie oben dargestellt. Das Statement super darf nur am Anfang des Konstruktors stehen. Es ruft den entsprechenden Konstruktor der Oberklasse auf. Da Java sicherstellen muß, daß die Objekte inklusive aller ererbten Felder ad¨aquat initialisiert sind, ruft Java immer implizit entweder den Konstruktor der Oberklasse auf, so das nicht explizit wie oben geschieht oder ein anderer Konstruktor bem¨uht wird. Wird f¨ur Unterklassen kein Konstruktor definiert, dann ist der Default-Konstruktor folgendes public (){ super();} Dieses schl¨agt fehl, wenn kein parameterloser Konstruktor der Superklasse existiert. Soweit zu den Konstruktoren. Nun zu den anderen Elementen: die Unterklasse erbt alles wie oben angegeben. Da keine als private markierten Methoden und Variablen und keine Instanzmethoden und Variablen geerbt werden, k¨onnen diese nicht angesprochen werden. Nichtsdestotrotz existieren sie als Elemente der Oberklasse und ererbte Methoden der Oberklasse, die auf diese Elemente zugreifen, funktionieren. H¨atten wir also radius oder pi als private deklariert, h¨atten wir keinen Zugriff darauf von der Unterklasse und diese Elemente w¨aren nicht sichtbar in der Unterklasse. Nichtsdestotrotz existieren diese Elemente als Felder der Objekte und k¨onnen durch die ererbten Methoden der Oberklasse manipuliert werden. Die F¨ahigkeiten der Oberklasse bleiben also erhalten, auch wenn sie der Unterklasse verborgen sein k¨onnen. Die Unterklasse kann lediglich die Interna dieser F¨ahigkeiten nicht einsehen und benutzen, sondern nur die entsprechend als nicht private gekennzeichneten Methoden. Schematisch erhalten wir also etwa folgendes Bild, wobei die gepunkteten Linien die Elemente der Oberklasse, die gestrichelten die davon abgeleitete Klasse markieren:

Konstruktoren

benutzt

Methoden/Variablen

private Methoden private Variablen

Konstruktoren

benutzt

public/protected/package Methoden und Klassen

sichtbar in der Unterklasse existiert in der Unterklasse

4.4 Klassen und Methoden

63

Unterklassen k¨onnen weitere Unterklassen haben, wir k¨onnten also etwa eine weitere Klasse wie Kreismitmittelpunktundfarbe extends Kreismitmittelpunkt definieren. Wir sagten bereits, daß Methoden, die nicht private deklariert sind, in der Unterklasse sichtbar sind. Ab und zu m¨ochte man aber die Methoden der Oberklasse nicht in dieser Form verwenden. Etwa wenn man eine Implementation vorfindet, die fast stimmt, aber in einem Punkt bezogen auf einige Methoden ge¨andert werden sollte, m¨ochte man die Methoden austauschen. Das geht, ¨ es nennt sich Uberschreiben oder Overriding. Nehmen wir an, die Klasse Kreis bes¨aße sch¨one und schwierig zu implementierende Funktionalit¨aten wie etwa graphische Darstellungsm¨oglichkeiten etc. Allerdings w¨urden wir gerne Quadrate statt Kreise verwenden. Quadrate besitzen einen anderen Fl¨acheninhalt. Wir m¨ussen also die Methode flaeche u¨ berschreiben. class Quadrat extends Kreis{ Kreis(double radius){super(radius);} Kreis(){super();} double flaeche(){return(radius*radius);} Die Klasse erbt die Felder radius und pi. Die Konstruktoren werden weitgehend u¨ bernommen. Die Methode Fl¨ache wird u¨ berschrieben. Der Aufruf Kreis kreis=new(42.0); Quadrat quadrat=new(42.0); System.out.println(kreis.flaeche()); System.out.println(quadrat.flaeche()); Liefert die Ausgabe 5538.96 1764.0 Man kann nicht nur Methoden, sondern auch Variablen u¨ berschreiben, ihnen zum Beispiel einen anderen Typ oder (z.B. als final Konstante) einen anderen Wert geben. Ab und zu kommt es vor, daß man doch die Methode der Oberklasse verwenden m¨ochte, was dann durch eine explizite Referenz super geschehen kann. Ein Beispiel: class Quadrat extends Kreis{ static final double pi=3.14159; Quadrat(double radius){super(radius);} Quadrat(){super();} double flaeche(){return(super.flaeche()/pi);} Es wird hier die Fl¨achenberechnung der Oberklasse verwendet, um die Fl¨achenberechnung f¨ur Quadrat zu implementieren. Die Felder der Oberklasse bekommt man analog durch das Schl¨usselwort super. Damit ist die Methode flaeche f¨ur diese Unterklasse neu definiert. Immer, wenn f¨ur ein Objekt der Klasse Quadrat die Methode flaeche benutzt wird, ist dieses die Methode ¨ der Unterklasse. Achtung: bei der Ubergabe von Parametern kann ein Parameter einer Klasse als Objekt einer Unterklasse instanziiert werden, d.h. ein Parameter Kreis kann mit einem Quadrat belegt werden. Auch dann wird die f¨ur Quadrat zust¨andige Methode flaeche verwendet. Intern ist dieses durch sogenannte dynamic method invocation realisiert. Die in einem Programm gebrauchten Methoden sind an das betrachtete Objekt gebunden und werden ausgehend vom Objekt dynamisch w¨ahrend der Laufzeit aufgerufen. M¨ochte man verhindern, daß Methoden u¨ berschrieben werden, deklariert man sie als final. M¨ochte man verhindern, daß Klassen abgeleitet werden k¨onnen, verwendet man ebenfalls final, d.h. in beiden F¨allen ist dieses die endg¨ultige Version der Klasse bzw. Methode.

4 DATENSTRUKTUREN

64

Dieses war eine schnelle Tour durch die Grundz¨uge der Objektorientierung. Da sehr viele neue ¨ Begriffe betrachtet wurden, hier noch einmal der Uberblick der wichtigen Elemente, die wir gelernt haben: • Klassen und Objekte einer Klasse • Zugriffsrechte public/private/protected/package • Methoden und Konstruktoren ¨ • Uberladen • Klassen- und Instanzvariablen • Primitive Typen und Referenztypen • Vererbung ¨ • Uberschreiben Diese Prinzipien erlauben einen sehr eleganten Entwurf von Programmen, der vor allem durch Kapselung (also leichte Wartung und Austauschbarkeit der einzelnen Einheiten) und Modularit¨at entspricht. Rekursion Wir wollen als letzten wichtigen Punkt in diesem Kapitel noch ein mit der Nutzung von Methoden m¨ogliches Paradigma kennenlernen. Methoden erlauben nicht nur, Programmteile zu kapseln und Modularisieren, sondern auch prinzipielle Steuerung des Kontrollfluß durch rekurisve Methodenaufrufe. Was ist Rekursion? Schauen Sie in diesem Skript auf Seite 64 nach! Wenn Sie jetzt bl¨attern, werden Sie merken, daß dieser Verweis ein Bezug auf die Stelle ist, an der wir uns gerade befinden, ein R¨uckbezug. Rekursion bedeutet, daß Methoden sich gegenseitig verwenden, insbesondere auch sich selbst verwenden k¨onnen, wenn nur passende Objekte da sind. Wir demonstrieren dieses an einem einfachen Beispiel: Stille Post. Stille Post funktioniert so, daß ein eine Anzahl Leute in einer Reihe stehen und, angefangen vom ersten, ein Wort weitergefl¨ustert wird. Dieses k¨onnte man mit den bisherigen M¨oglichkeiten z.B. in einer Schleife implementieren. Wir verwenden hier eine rekursive L¨osung. class Mensch{ int hoervermoegen; int message; Mensch naechster; Mensch(int hoervermoegen, Mensch naechster){ this.hoervermoegen=hoervermoegen; this.naechster=naechster; this.message=0; } Mensch(int hoervermoegen){ this.hoervermoegen=hoervermoegen; this.naechster=this; this.message=0; }

4.4 Klassen und Methoden

65

void pass(int message){ // Weitergeben der Nachricht message+=this.hoervermoegen; this.message=message; if (!this.last()) naechster.pass(message); } void output(){ System.out.print(this.message); if (!this.last()) naechster.output(); } boolean last() { return (this.naechster==this); } } class stillepost{ public static int Max; // wieviele public static int Nachricht;// erste Nachricht public static void main(String[] args){ Max=Integer.parseInt(args[0]); Nachricht=Integer.parseInt(args[1]); // Achtung: einfacher Generator!!!! Mensch letztermensch= new Mensch((int)(Math.random()*10-5)); Mensch mensch=letztermensch; for (int i=0;i<Max-1;i++) mensch=new Mensch((int)(Math.random()*10-5),mensch); mensch.pass(Nachricht); letztermensch.output(); } } Wir haben hier Nachrichten einfach als Integer realisiert. Die Tatsache, daß die Menschen normalerweise nicht genau h¨oren und etwas falsches weitergeben wurde hier durch die Addition einer Zufallszahl realisiert. Man sieht, die Weitergabe geschieht rekursive, der Mensch veranlasst, so er nicht der letzte Mensch ist, den jeweils n¨achstn, die Nachricht weiterzugeben. Zum Schluß dieses Kapitels steht hier ein l¨angeres (klassisches) Beispiel eines objektorientierten Entwurfs, das Rekursion sehr viel extensiver gebraucht: das acht Damen Problem. Acht, allgemeiner n Damen sollen so auf einem Schachbrett platziert werden, daß sie sich nicht gegenseitig bedrohen. Zwei Damen bedrohen sich, wenn sie in derselben Zeile, Spalte oder Diagonale stehen. F¨ur n = 4 gibt es zwei L¨osungen, f¨ur n = 8 schon einige mehr. Dennoch ist das Problem sehr aufwendig, da man ja im Prinzip alle m¨oglichen Stellungen der Damen ausprobieren muß. Wie k¨onnen davon ausgehen, daß in jeder Spalte genau eine Dame steht, und die Damen dementsprechend nummerieren. Dann bleiben aber noch einige Zeilen auszuprobieren, f¨ur die erste Damen n m¨ogliche Zeilen, f¨ur die zweite n = 1, . . . , insgesamt n!. Die Basisidee f¨ur einen objektorientierten Entwurf ist, nacheinander in jede Spalte eine Dame zu stellen, die sich selbst eine zul¨assige Zeile sucht. Dazu muß sie u¨ berpr¨ufen, ob sie nicht von einer anderen Dame geschlagen wird und, so sie keine Zeile mehr findet, Vorg¨angerdamen eventuell anschubsen, damit diese an neue Positionen wandern. Das Program besteht so nur aus lokalen Operationen und Messages der Objekte. Der Gesamtablauf ist dann denkbar einfach: die oberste Ebene generiert nacheinander acht Damen in den acht Spalten und sagt ihnen sukzessive, sie m¨ogen doch eine L¨osung finden. Die L¨osung wird dann ausgedruckt:

4 DATENSTRUKTUREN

66

class Queens{ public static int MAX; // Anzahl der Zeilen public static void main(String[] args){ MAX = Integer.parseInt(args[0]); // Lese Anzahl Zeilen Queen lastQueen = new Queen(1); // Setze Queen in Row 1 boolean geht=true; // die anderen Queens for (int i=2; (i<=MAX && geht); i++){ // je eine Queen, die ihre Vorgaengering kennt lastQueen = new Neighborqueen(i,lastQueen); // soll sich selbst eine Position suchen if (!lastQueen.findSolution()) geht=false; } if (geht) lastQueen.printSolution(); // L¨ osung else System.out.println(leider nicht"); } } Wir benutzen hier zwei Klassen, Queen und die davon abgeleitete Klasse Neighborqueen, die nicht nur sich selbst, sondern auch den linken Nachbarn kennt. Queens werden mit folgenden F¨ahigkeiten ausgestattet: • Der Konstruktor setzt die von außen vorgegebene Spalte und die Initialposition, die oberste Zeile. • findSolution sucht nach L¨osungen ausgehend von dem aktuellen Kenntnisstand. Wenn die Dame nur sich selbst kennt (also keine Konflikte beobachten kann), ist alles ok. • advance sucht nach weiteren m¨oglichen Positionen. F¨ur eine einzelne Dame besteht das nur aus der M¨oglichkeit, eine Zeile weiter zu r¨ucken. • can Attack ist eine Methode, bei der eine fremde Dame die jetzige anschubst und fragt, ob sie im Konflikt ist. • PrintSolution druckt alles Bekannte von der L¨osung aus, die aktuelle Position. Zur Klasse Queen: class Queen{ protected int row; // Zeile protected final int column;// Spalte, die ist fest // Initialisieren mit fester Spalte und Zeile 1 Queen(int column){ this.column=column; row=1; }

4.4 Klassen und Methoden

67

// Testet, ob es eine L¨ osung f¨ ur die Dame gibt. // Eine einzelne Dame schl¨ agt nie, also geht das ok public boolean findSolution(){ return true; } // Geht eine Position weiter, wenn m¨ oglich. protected boolean advance(){ if (++row<=Queens.MAX) return true; row=1; return false; } // Testet, ob die Queen mit der ¨ ubergebenen in Konflikt ist protected boolean canAttack(Queen queen){ int diff=queen.column-column; return (row==queen.row) || (row-queen.row==diff)|| (queen.row-row==diff); } // Druckt die Position der Queen public void PrintSolution(){ System.out.println(column+" "+row); } Diese Klasse ist nur f¨ur die linke Dame bzw. eine einzelne Dame geeignet. Es wird keine Information transferiert. Alle Damen bis auf die linke haben einen linken Nachbarn. Diese k¨onnen außer ihrer derzeitigen Position auf den linken Nachbarn schauen und alle Informationen, Ausgaben und Versuche verm¨oge des linken Nachbarn auf die ganze linke Spielh¨alfte ausdehenen. Daher wird die Klasse abgeleitet und die Funktionalit¨at erweitert: • Der Konstruktor setzt auch den linken Nachbarn. Im Feld neighbor ist eine Referenz auf diesen gespeichert. • findSolution testet, ob irgendein linker Nachbar mich attackieren kann. Falls dem der Fall ist, wird die n¨achste L¨osung ausprobiert. • advance hat die M¨oglichkeiten entweder sich selbst eine Position vorzur¨ucken, oder den Nachbarn anzuschupsen und ihn dazu zu bringen, an eine andere g¨ultige Position zu wechseln. Der Nachbar weiß dann schon, wie er gegebenenfalls seine Nachbarn anschupsen kann, ihrerseits an g¨ultige Positionen zu gehen. • canAttack testet, ob ich oder irgendein Nachbar die u¨ bergebene Queen attackieren kann, woxu er einerseits die Diagonal- und Zeilenbedingungen f¨ur sich selbst testet, andererseits den Nachbarn anschubst, dasselbe zu tun. PrintSolution gibt die L¨osung aus und schubst den Nachbarn an, dasselbe zu tun. class Neighborqueen extends Queen{ protected final Queen neighbor;// hat einen linken Nachbarn

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

68

// der Konstruktor setzt auch den Nachbarn public Neighborqueen(int column,Queen n){ super(column); neighbor=n; } // Testet, ob es eine L¨ osung f¨ ur die Dame gibt. public boolean findSolution(){ while (neighbor.canAttack(this)) if (! advance()) return false; return true; } // Geht eine Position weiter, wenn m¨ oglich. // Das impliziert auch alle Vorg¨ anger! protected boolean advance(){ return super.advance() || (neighbor.advance()&&neighbor.findSolution()); } // Testet, ob die Queen oder die Vorg¨ anger // mit der ¨ ubergebenen in Konflikt sind protected boolean canAttack(Queen queen){ return super.canAttack(queen) || neighbor.canAttack(queen); } // Druckt die L¨ osung inklusive der Vorg¨ anger public void printSolution(){ neighbor.printSolution(); super.printSolution(); } } Hier haben wir ein wichtiges Konzept benutzt, das bisher nur implizit deutlich war: Rekursion. Es ist m¨oglich, Konstruktoren und Methoden u¨ berall, wo sie sichtbar sind, aufzurufen. Das kann auch rekursiv geschehen, d.h. man kann auch Methoden innerhalb der Methode selbst aufrufen. Das ist hier geschehen f¨ur advance, canAttack und printSolution. Das Programm liefert f¨ur verschiedene n die folgenden Zeilen-Spaltenkombinationen als L¨osung n 4 5 6 7 8

1 2 1 2 1 1

2 4 3 4 3 5

3 1 5 6 5 8

4 3 2 1 7 6

5 6 7 8 4 3 5 2 4 6 3 7 2 4

5 Algorithmen fur ¨ abstrakte Datentypen Abstrakte Datentypen im Gegensatz zu primitiven Datentypen sind komplexe Typen mit typischen Operationen, die f¨ur diese Datentypen bereit gestellt werden. Die Typen werden ausschließlich

5.1 Arrays

69

durch diese generischen Operationen ver¨andert. In diesem Kapitel werden wir einige wichtige abstrakte Datentypen kennen lernen, n¨amlich • Felder oder Arrays, die eine feste Anzahl von Elementen eines bestimtmen Typs in einer festen Reihenfolge aufsammeln, • Listen, die beliebig viele Elemente eines Typs ausfsammeln, insbesondere die speziellen Listen Keller (stack) und Schlange (queue), die den Zugriff einschr¨anken, • B¨aume, • Graphen.

5.1 Arrays Starten wir mit Arrays, die in Java bereits zur Verf¨ugung gestellt werden. Nehmen wir an, wir haben eine feste Anzahl n von Elementen desselben Typs zu verwalten. Als ein Beispiel n Zahlen, etwa die Gewinnzahlen bei einer Lotterie oder die Teilnehmer einer Veranstaltung. Wir bezeichnen den Typen der Elemente abstrakt als Typ. Java bietet die M¨oglichkeit, Felder, d.h. Arrays einer vorgegebenen festen L¨ange zu benutzen. Die Deklaration [] ; definiert ein Array name mit Elementen vom Typ Typ. Instanziiert wird ein Array durch Aufrufen des Konstruktors. Zu diesem Zeitpunkt muß man angeben, wieviele Elemente im Array sein sollen, denn diese Anzahl wird zur Allokation des Speicherplatzes ben¨otigt. Eine Instanziierung geschieht in der Form =new []; wobei Gr¨ oße eine nat¨urliche Zahl angibt, die Anzahl Elemente des Arrays. Steht ein Array zur Verf¨ugung, dann sind zwei Operationen wesentlich: • Manipulieren/Schreiben eines einzelnen Eintrags des Array, • Lesen eines Eintrags des Array. In Java werden beide Operationen mit einer einzigen Notation erreicht: name[i] verweist auf das i-te Element des Arrays name. Benutzt man diesen Ausdruck als rechte Seite einer Zuweisung, erh¨alt man den Wert des Array an der Stelle i. Benutzt man den Ausdruck als linke Seite einer Zuweisung, wird die i-te Stelle ver¨andert. Achtung: Man z¨ahlt dabei beginnend von 0. Ein Array der Gr¨oße n besitzt also die Elemente 0 bis n−1. Benutzt man ein nicht zul¨assiges i außerhalb des Bereichs, dann erh¨alt man eine Fehlermeldung, das Ergebnis ist nicht definiert. Das definiert fast vollst¨andig den Umgang mit Arrays. Zwei kurze Zus¨atze, die vielfach die Notation vereinfachen: die L¨ange eines Array (so man sie nicht weiß, etwa weil das Feld als Parameter u¨ bergeben wurde) erf¨ahrt man durch .length (ohne Klammern!). Konstante Eintr¨age kann man direkt als Block an ein Array zuweisen, wie in folgendem Beispiel deutlich ist boolean[] wahrheitsfeld={true,false,false,true,true}; Folgendes Programst¨uck legt ein Array mit 42 Elementen an:

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

70

int [] feld = new int[42]; // deklarieren und instanziieren von feld for (int i=0;i<42;i++) feld[i]=i+1; // einlesen der Elemente for (int i=0;i<41;i++) System.out.println(feld[i]); // ausgeben int [] Array nocheindfeld = new int[42]; for (int i=0;i<42;i++) nocheinfeld[i]=feld[i]; // elementweises Kopieren Zu beachten ist, daß Felder als Referenztypen behandelt werden m¨ussen. Sie m¨ussen instanziiert werden. Kopieren und vergleichen muß elementweise geschehen, da die Variablen lediglich Referenzen auf die Feldinhalte und nicht die Feldinhalte selbst beinhalten. Ein weiterer Punkt: Elemente eines Arrays k¨onnen nat¨urlich auch Referenztypen sein. Es d¨urfen auch selbst Arrays sein, also ein Array von Arrays usw. Die Deklaration und Instanziierung des Arrays geschieht dann genauso wie f¨ur einfache Typen: [] = new []; Zu beachten ist allerdings, daß damit die einzelnen Felder, d.h. die einzelnen im Array aufgesammelten Variablen des gew¨unschten Typs noch nicht instanziiert sind. Das Array besitzt lediglich so viele Felder mit potentiellen Referenzen, wie gew¨unscht, die Referenzen zeigen aber noch auf nichts. Bevor man also die einzelnen Felder benutzt, muß man sie z.B. wie folgt instanziieren: for (int i=0;i(); F¨ur Arrays von Arrays gibt es die Kurznotation int[][] feldfeld; Auf die Elemente greift man enstprechend mit feldfeld[i][j] zu. Instanziieren kann man entweder alles Felder auf einmal, sofern sie eine gleiche L¨ange haben feldfeld=new int[42][44]; oder sukzessive, z.B. bei unterschiedlichen L¨angen der Teilfelder feldfeld=new int[42][]; for (int i=0;i
5.1 Arrays

71

class Inhalt{ int was; boolean gleichmir(Inhalt you){return you.was==this.was;} boolean kleinermir(Inhalt you){return you.wasmax) return -1; return i; } } class mainmethode{ public static void main(String[] args){ Feld feld=new Feld(args); Inhalt me=new Inhalt(); me.setzmich("42"); System.out.println(feld.suchwas(me)); } } Hier werden sukzessive die Elemente durchgegangen bis das Element gefunden wird oder alle Elemente angesehen wurden. Der Aufwand des Algorithmus f¨ur ein Feld der L¨ange n ist O(n), denn man muß im schlimmsten Fall jedes Element von 0 bis n − 1 einmal anschauen, um festzustellen, daß das gesuchte Element nicht im Feld enthalten ist. Man k¨onnte das beschleunigen, wenn man sicherstellen k¨onnte, daß das Feld sortiert ist. Dann k¨onnte man statt einer linearen Suche wie eben sogenannte bin¨are Suche verwenden. Die bin¨are Suche vergleicht das gesuchte Element je mit dem im Array in der Mitte stehenden Element. Ist das gesuchte Element kleiner, weiß man, daß man nur noch auf der linken Seite suchnen muß und die rechte sowieso nicht in Frage kommt. Ist das Element gr¨oßer, braucht man nur die rechte H¨alfte zu betrachten. Man spart sich also jeweils eine H¨alfte. Eine konkrete Implementation ist die folgende: ... public int suchwasbin¨ ar(Inhalt was){ return suchwasbin¨ ar(was,0,feld.length-1); }

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

72

public int suchwasbin¨ ar(Inhalt was,integer min,integer max){ if (min>max || min<0 || max>feld.length-1) return -1; int mid=min+(max-min+1)/2; if was.gleichmir(feld[mid]) return mid; if was.kleinermir(feld[min]) return suchwasbin¨ ar(was,mid+1,max); else return suchwasbin¨ ar(was,min,mid-1); } ... Was ist der Aufwand dieser Implementation? Genau wie unser Dame-Programm ist diese Implementation ein Beispiel f¨ur ein rekursives Programmdesign: suchwasbin¨ ar f¨uhrt die Ausgabe auf sich selbst zur¨uck, indem suchwasbin¨ ar je nach Fall mit versetzten Schranken aufgerufen wird. Am sortierten Array [0, 1, 2, 3, 33, 42, 72, 100, 4711] soll das Vorgehen demonstriert werden: wir nehmen an (was auch sonst), wir suchen 42. Wir erhalten graphisch folgendes Verhalten: 0 1 2 3 33 42 72 100 4711 min

mid

max

0 1 2 3 33 42 72 100 4711 min mid max

0 1 2 3 33 42 72 100 4711

0 1 2 3 33 42 72 100 4711

min

min max mid

mid max

Vier Schritte reichen aus, um das Element zu finden. W¨are 42 nicht enthalten, h¨atten wir im n¨achsten Schritt gewußt, daß dem so ist, ohne alle Elemente anzusehen. Es ist generell so, daß der Aufwand bin¨arer Suche O(log2 n) ist f¨ur ein sortiertes Feld der L¨ange n, d.h. der Suchbereich max-min ist n. Insbesondere f¨ur große n ist das erheblich weniger Aufwand als einfache sequentielle Suche. Wir wollen diese Behauptung durch Induktion u¨ ber n zeigen: • Wir zeigen, daß der Aufwand bin¨arer Suche in einem Feld der L¨ange n durch c·max{1, log 2 n} f¨ur eine feste Konstante c und alle n ≥ n0 f¨ur ein n0 ist. • Wir w¨ahlen n0 = 1. Zur Konstante c: In suchwasbin¨ ar steht eine konstante Anzahl an Schritten, bevor man je nach Situation zu einem return kommt. Wir bezeichnen c 0 als die daf¨ur maximal ben¨otigte Laufzeit, also die maximale Zeit, bis man zu einem return kommt. Wir w¨ahlen c = 2 · c0 . • Induktionsanfang, ein Feld der L¨ange 1 sei gegeben. Wir rufen bin¨are Suche mit den Variablenbelegungen min=max auf (min und max m¨ussen dabei nicht notwendig 0 sein). mid=min+(max-min+1)/2=min (ganzzahlige Division). Wir testen also, ob an der betrachteten Stelle das Element steht. Entweder das ist der Fall, und das Programm terminiert, oder die Grenzen werden min+1>max bzw. min>max-1 und das Programm terminiert im n¨achsten Schritt. Das ist eine konstante Laufzeit, begrenzt durch c = 2 · c 0 , da man maximal zweimal die Methode aufruft. • Induktionsvoraussetzung: f¨ur alle Felder der L¨ange n0 < n ben¨otigt der Algorithmus maximal O(n0 ) = c · log2 n0 Schritte f¨ur eine feste Konstante c.

5.1 Arrays

73

• Indutkionsschritt: betrachten wir ein Feld der L¨ange n > 2. Es wird eine konstante Anzahl Schritte ausgef¨uhrt, bis man zu einem der folgenden drei F¨alle kommt: – die Grenzen u¨ berschneiden sich oder das Element ist gefunden, – man sucht im linken Bereich min bis mid-1 weiter, – man sucht im rechten Bereich mid+1 bis max weiter. In den beiden letzten F¨allen ist das Restfeld, in dem man noch sucht, maximal halb so lang wie das Originlafeld. Der Aufwand ist also f¨ur diese Unterf¨alle nach Induktionsvoraussetzung ≤ c · log2 (n/2). Wir erhalten also als Aufwand f¨ur diese beiden F¨alle c + c · log2 (n/2) = c · log2 2 + c · log2 (n/2) = c · log2 (2 · n/2) = c · log2 n Sortieren ¨ Diese Uberlegungen f¨uhren uns zu einem zweiten klassischen Algorithmus in Verbindung mit Arrays: Sortieren von gegebenen Zahlen in einem Feld. Es gibt viele verschiedene Sortieralgorithmen, und wir werden hier einige wichtige kennenlernen. Zun¨achst ein naiver Ansatz: ein Feld ist sortiert, sofern an der ersten Stelle das kleinste Element steht, an der zweiten Stelle das zweitkleinste, an der dritten Stelle das drittkleinste usw. Wir k¨onnen also sortieren, indem wir nacheinander das jeweils kleinste Element der rechten Seite an die betrachtete Stelle schreiben. Das ist der sogenannte minsort-Algorithmus, den wir durch zus¨atzliche Methoden f¨ur die Klasse Feld realisieren: ... void sortiermich1(){ sortiermich1(0,feld.length-1); } // sortiert von min bis max void sortiermich1(int min,int max){ if (0<=min && min<max && max
74

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR ... public void tauschemit(Inhalt wovon){ int help=this.was; this.was=wovon.was; wovon.was=help; } public void kopiermichvon(Inhalt wovon){ this.was=wovon.was; } ...

Das Programm sucht sukzessive das Minimum und schreibt es je an die erste Stelle des noch zu sortierenden Restfeldes. Was ist der Aufwand des Algortihmus? Bestimmend f¨ur den Aufwand sind die Methoden sortiermich1 und suchmeinminimum. suchmeinminimum ben¨otigt f¨ur ein durch die Grenzen abgestecktes Feld der L¨ange n gr¨oßenordnungsm¨aßig n Schritte. sortiermich1 benutzt suchmeinminimum und ruft rekursiv sortiermich1 mit einem um eins k¨urzeren Feld auf. Bis auf Konstanten ist der Aufwand also f¨ur ein Feld der Gr¨oße n n + (n − 1) + . . . + 2 + 1 = n · (n + 1)/2 = O(n2 ) Dieser Aufwand ist unabh¨angig davon, wie das Feld aussieht und f¨allt sowohl bei einem bereits sortierten Feld, als auch einem nicht sortierten an. Ein alternatives, ebenfalls einfaches Sortierverfahren beruht auf folgender Idee: ein Feld ist sortiert, sobald es keine Fehlstellungen mehr gibt, d.h. benachbarte Elemente, wobei das rechte kleiner als das linke ist. Der Algorithmus geht sukzessive von links nach rechts durch das Feld durch und tauscht solche Fehlstellungen. Man kann dabei beobachten, daß nach dem ersten Durchgang sicher das gr¨oßte Element des Felds ganz rechts steht, nach dem zweiten das zweitgr¨oßte auf dem vorletzten Platz, usw. Man braucht also nur jeweils bis zu dieser Stelle testen. Da die Elemente also wie Blasen aufsteigen, heißt der Algorithmus Bubblesort. Als Programmcode: void bubblesort(int min,int max){ boolean sortiert=true; if (min<max) { for (int i=min;i<max;i++) if (feld[i].kleinermir(feld[i+1])) { feld[i].tauschemit(feld[i+1]); sortiert=false; } if (!sortiert) bubblesort(min,max-1); } } Bubblesort ist genauso einfach wie Minsort, hat aber einen Vorteil bei schon sortierten Feldern: in diesem Fall geht das Programm genau einmal durch das Feld durch und terminiert, da keine Fehlstellung aufgetreten ist. Das Verfahren hat also f¨ur schon sortierte Felder den Aufwand O(n). Im schlechtesten Fall allerdings ben¨otigt auch Bubblesort den Aufwand O(n 2 ): f¨ur ein invers sortiertes Feld [n, . . . , 1] erh¨alt man nach einem Durchlauf das Feld [n − 1, . . . , 1, n], bei dem der noch zu sortierende erste Teil wieder invers aufgereiht ist. Ein Durchlauf hat den Aufwand O(n). Man ben¨otigt also gr¨oßenordnungsm¨a¨ıg auch hier n + (n − 1) + (n − 2) + . . . = n(n + 1)/2 = O(n 2 )

5.1 Arrays

75

Schritte. Man kann zeigen, daß dieses auch der Aufwand im Mittel ist, Bubblesort ist also ein im Mittel quadratisches Verfahren. Es gibt bessere Sortierverfahren, die mit ein wenig mehr Programmieraufwand schneller sortieren. Wir lernen als erstes den sogenannten Mergesort kennen. Die Grundidee ist folgende: angenommen, wir k¨onnten irgendwie die linke und rechte H¨alfte des Arrays sortieren. Dann w¨urden wir daraus das sortierte Gesamtarray erhalten, indem wir die Felder zusammenmischen, englisch merge. Das kann geschehen, indem man bei beiden Feldern von links anf¨angt und jeweils das kleinere der beiden Elemente in das zusammengemischte Feld schreibt. Mergesort ersetzt also die Sortiermethode wie folgt: void sortiermich2(int min, int max){ int mid; if (0<=min && min<max && max
76

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR • Induktionsvoraussetzung: f¨ur n0 < n sei der Aufwand O(n0 log2 n0 ). • Induktionsschluß: f¨ur n > 2 ruft sortiermich2 sich selbst mit um die H¨alfte k¨urzeren Feldern auf und mergemich f¨ur diese Felder. Das ist nach Voraussetzung O(n/2 log2 n/2) + O(n/2 log2 n/2) + O(n) = O(n log2 n) Diese letzte Rechnung m¨ochten wir explizieren. Die Konstante in O(n) sei c 1 , in O(n log2 n) sei c. Indem wir c eventuell erh¨ohen, k¨onnen wir c1 ≤ c annehmen. Dann ergibt sich der Aufwand f¨ur gen¨ugend große n als c · (n/2 log2 n/2 + n/2 log2 n/2) + c1 n ≤ c · (n log2 n/2 + n log2 2) = cn log2 n

Zu beachten ist, daß der rekursive Aufbau des Mergesort auch den Beweis f¨ur die Laufzeitschranke bestimmt und sehr kurz und elegant macht. Der Algorithmus Mergesort ist also deutlich effizienter als Minsort oder Bubblesort f¨ur große Felder. Allerdings ben¨otigt er zus¨atzlichen Speicherplatz f¨ur das Zusammenmischen, das ja ein Hilfsfeld ben¨otigt. Dieses ist, je nach Gr¨oße der Objekte, eventuell nicht gegeben. Ein letztes Sortierverfahren im Zusammenhang mit Arrays: Quicksort, eines der gebr¨auchlichsten Verfahren, da es sehr einfach und gleichzeitig schnell ist. Die Grundidee ist quasi umgekehrt zu Mergesort: man teilt das Feld rekursiv in kleinere Elemente (die vorne stehen) und gr¨oßere Elemente (die hinten stehen) ein, und sortiert separat die Teilfelder. Das Einteilen geschieht durch Vergleich mit einem Referenzelement des Felds. void quicksort(int min, int max) { if (0<=min && min<max && max
5.1 Arrays

77

n zu sortieren, als A(n) = 2 · A(n/2) + O(n), genau wie bei Mergesort, also den Aufwand O(n log n). Allerdings kann es passieren, daß Quicksort sehr ungleich aufteilt, in eine lange und eine lehre H¨alfte. Das erg¨abe einen Aufwand proportional zu n + (n − 1) + (n − 2) + . . . = O(n 2 ). Also einen quadratischen Aufwand wie Bubblesort oder Minsort. Anders als diese Algorithmen hat Quicksort aber im Mittel nur den Aufwand O(n log n), wie man wie folgt einsieht: Sei Cn der Aufwand, im Mittel (also gemittelt u¨ ber alle m¨oglichen Situationen) ein Feld der L¨ange n zu sortieren. Man erh¨alt die Rekursionsformel cn = n +

n 1 X · (ck−1 + cn−k ) n k=1

denn man ben¨otigt n Vergleiche, ein Herausgreifen des Partitionselements und den Aufwand, die beiden Teilfelder zu sortieren. Diese k¨onnen jede Aufteilung von n − 1 Elementen in k − 1 und n − k realisieren, je P nachdem, welches Element zum Vergleich herangezogen wird. Diese Summe ist n + 1 + 1/n · 2 · nk=1 ck−1 mit c0 = c1 = 0. Es ergibt sich also n · cn − (n − 1) · cn−1 = n(n + 1) − (n − 1)n + 2

X

ck−1 − 2

1≤k≤n

= n(n + 1) − (n − 1)n + 2 · cn−1

X

ck−1

1≤k≤n−1

Also ncn = (n + 1)cn−1 + 2n oder

X 1 cn cn−1 2 = + = ... = 2· n+1 n n+1 k 1≤k
Rn Dises ist ungef¨ahr 2 1 x1 dx = 2 · ln n. Wir erhalten cn ≈ (n + 1) · 2 · ln n. Quicksort hat also auch im Mittel nur den Aufwand O(n log n). Dabei benutzt es, anders als Mergesort, keinen zus¨atzlichen Speicherplatz. Alles zusammengenommen haben wir also folgende vier Sortieralgorithmen kennengelernt: minsort bester Fall O(n2 ) mittlerer Fall O(n2 ) schlechtester Fall O(n2 ) ja im Platz

bubblesort O(n) O(n2 ) O(n2 ) ja

mergesort quicksort O(n log n) O(n log n) O(n log n) O(n log n) O(n log n) O(n2 ) nein ja

Es gibt noch viele weitere wichtige Sortieralgorithmen, die im Wesentlichen entweder die mittlere Laufzeit O(n2 ) (direkte Methoden) oder O(n log2 n) (f¨ur effizientere Verfahren) besitzen, aber ein unterschiedliches Verhalten zeigen, wenn bereits fast sortierte Folgen betrachtet werden, oder in Bezug auf Speicherplatzbedarf etc. g¨unstige Eigenschaften besitzen. Es schließt sich hier die Frage an: k¨onnten wir die Sortierung noch effizienter l¨osen, oder haben wir schon den schnellsten Algorithmus gefunden? Es gibt Algorithmen, die spezielle Eigenschaften der Daten ausnutzen k¨onnen, etwa eine weitgehende Vorsortierung oder die Tatsache, daß nur endlich viele verschiedene zu sortierende Elemente auftauchen. Da Sortieren eine in vielen Programmen oder auch im Rechner h¨aufig vorkommende Aktion ist (es wird nach Untersuchungen von Computerherstellern ein viertel der kommerziell verbrauchten Rechenzeit f¨ur Sortieren aufgewendet), gibt es eine F¨ulle von Literatur zu diesem Thema und sehr viele verschiedene Sortierverfahren. Man kann aber zeigen, daß Mergesort als sogenanntes allgemeines Sortierverfahren optimal ist. Ein allgemeines Sortierverfahren ist ein Verfahren, das Informationen u¨ ber die zu sortierenden Elemente

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

78

nur durch einen Vergleich der Elemente erhalten kann und keine zus¨atzliche Information (Position, Beschr¨ankung der Elemente, . . . ) verwenden kann. Es gilt: jedes allgemeine Sortierverfahren hat die Komplexit¨at O(n log n). Dieses k¨onne wir hier sogar f¨ur den schlechtesten Fall beweisen: Grundbeobachtung ist, daß ein Sortierverfahren implizit nur durch Vergleiche im Programmablauf unterscheiden muß, welche Permutation von n Elementen vorliegt; das gilt, da ja f¨ur jede Permutation das Programmverhalten bezogen auf die Elemente ein anderes ist, da man bei verschieden permutierten Arrays nur durch unterschiedliche Operationsabl¨aufe zu einem sortierten Arary kommen kann. Wieviele Vergleiche ben¨otigt man, um all n! verschiedenen Permutationen voneinander zu unterscheiden? Jede Unterscheidung unterteilt die Permutationen in zwei H¨alften. Man muß sukzessive so h¨aufig unterteilen, bis nur noch je eine m¨ogliche Permutation u¨ brig ist. Da jede sukzessive Unterteilung von n! Elementen mindestens eine mindestens n!/2 große Menge hervorbringt, ben¨otigen wir mindestens log2 (n!) Unterteilungen, d.h. Programmschritte. Das ist von der Gr¨oßenordnung n log 2 n. Sortieren ohne Zusatzinformation hat also diese Komplexit¨at. Man kann sogar zeigen, daß Sortieren ohne Zusatzinformation auch im Mittel (also gemittelt u¨ ber alle m¨oglichen zu sortierenden Arrays) diese Komplexit¨at hat. (Das ist aber etwas aufwendiger, so daß wir den Beweis hier weglassen.) Wir haben gesehen, daß wir in einem sortierten Array in der Zeit O(log n) suchen k¨onnen, in einem nicht sortierten Array in der Zeit O(n). Allerdings ben¨otigt Sortieren den Aufwand O(n log n). Ist ein Array nur einmal gegeben, oder selten zu a¨ ndern und oft eine Suche durchzuf¨uhren, dann ergibt sich mit bin¨arer Suche und Sortieren eine bessere Effizienz. M¨ochte man diesen Gewinn formalisieren, verwendet man h¨aufig die sogenannte amortisierte Komplexit a¨ t von Operationen. Sei eine Folge von N Operationen gegeben und deren Aufwand O(f (n, N )); dann ist der amortisierte Aufwand einer einzelnen Operation die Gr¨oße O(f (n, N )/N ). Damit wird Rechnung getragen, daß sich einige komplexe Operationen im Programmfluß amortisieren k¨onnen, da sie selbst sehr lange dauern, aber andere Operationen erheblich beschleunigen, und damit in der Gesamtfolge deutlich g¨unstiger sind, als einzeln betrachtet. Ist unser Programmfluß etwa ein Sortieren gefolgt von hundertfachem Suchen, dann dominiert der logarithmische Aufwand f¨ur bin¨are Suche den Aufwand O(n log n) von einmaligem Sortieren. Die komplexe Sortieroperation amortisiert sich also.

5.2 Listen Wir haben Felder als Ansammlung von Inhalten gleichen Typs kennengelernt. In Feldern ist die Anzahl Elemente a priori fest und kann nicht mehr variiert werden. Listen verallgemeinern demgegen¨uber zu einer angeordneten Ansammlung von Elementen gleichen Typs, dessen Anzahl nicht fest ist und w¨ahrend des Programms ge¨andert werden kann. Ein typisches Beispiel sind etwa Benutzer einer Bibliothek. Es k¨onnen neue Benutzer hinzukommen und alte gel¨oscht werden, die Anzahl variiert. Eine geordnete Ansammlung von Elementen gleichen Typs kann man durch die Datenstruktur einer Liste realisieren. Wir benutzen wieder eine Klasse Inhalt, um die zu speichernde Information zu typisieren. Im Fall von Arrays haben wir nach und nach Methoden entwickelt, die gew¨unschte Funktionalit¨aten implementieren. Wir gehen f¨ur Listen andersherum vor und spezifizieren zun¨achst abstrakt gew¨unschte Funktionalit¨aten. Anders als bei Arrays k¨onnen wir die Elemente nicht mehr notwendig direkt ansprechen, da sich deren Anzahl a¨ ndert und kein fester Indizierungsbereich zur Verf¨ugung stehen muß. Stattdessen k¨onnen wir die Datenstruktur als eine Kette von Elementen ansehen, wo wir Anfang und Ende kennen und an der wir uns entlanghangeln k¨onnen. Wir ben¨otigen: • Konstruktor, Erzeugen einer leeren Liste ohne Elemente,

5.2 Listen

79

• feststellen, ob wir am Ende der Liste sind, • an den Anfang der Liste gehen, • ein Element weitergehen, • das aktuelle Element ausgeben, • an den aktuellen Platz ein Element einf¨ugen, • das aktuelle Element l¨oschen. Eine m¨ogliche Java-Implementation basiert auf folgender Repr¨asentation einer Liste:

Anfang

Aktuell

Listenelemente speichern den Inhalt und einen Verweis auf den Nachfolger. Die Liste ist dann durch den Verweis auf das erste Element und den Verweis auf die aktuelle Position charakterisiert. Als Klassen: class Listenelement{ Inhalt was; Listenelement next; // rekursive Definition einer Klasse! Listenelement() {was = new Inhalt(); next=null;} Inhalt binich() {return was;} void setzmich(Inhalt you) {was.kopiermichvon(you);} void setznext(Listenelement you) {this.next=you;} Listenelement givenext() {return next}; } class Liste{ Listenelement first; // Listenanfang Listenelement act; // aktuelles Element private Listenelement prev; // Vorgaenger des aktuellen Liste() {first=null; act=null; prev=null;} boolean atend() {return (act==null);} void tobegin() {act=first; prev=null;} void tonext() {if (!atend()) {prev=act; act=act.givenext();}} Inhalt giveact() {if (!atend()) return(act.binich()); else return null;} void writeact(Inhalt was){ Listenelement help=new Listenelement(); help.setzmich(was); help.setznext(act); if (prev!=null) prev.setznext(help); else first=help; act=help; }

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

80

void deleteact(){ if (!atend()){ act=act.givenext(); if (prev!=null) {prev.setznext(act);} else {first=act;} } } } Die Bezeichnung null deutet die leere Referenz an, die auf nichts zeigt. Damit kann man z.B. Suche nach einem Element in der Liste realisieren: boolean suchinhalt(Inhalt was){ tobegin(); while (!atend()){ if (giveact().gleichmir(was)) return true; else tonext(); } return false; } Listensuche hat offensichtlich den Aufwand O(n) f¨ur eine Liste der L¨ange n. Das ist in diesem Fall nicht schneller m¨oglich, da man keinen direkten Zugriff zu einzelnen Listenelementen hat, sondern sich, um alle Elemente zu adressieren, vom Beginn der Liste durch die Nachfolger ‘hangeln’ muß. Hashing Eine sch¨one Anwendung von Listen in Kombination mit Arrays ist sogenanntes Hashing, eine gebr¨auchliche Art der Speicherverwaltung. Wir haben jetzt bereits Arrays und Listen als ein m¨ogliche Speichermedien kennengelernt. Bei Arrays kann man direkt auf Elemente zugreifen, aber der Platz ist beschr¨ankt. Bei Listen muß man u¨ ber die Nachfolgerbeziehung die Elemente anspechen, aber daf¨ur ist der Platz genau der jeweiligen (dynamischen) Anzahl der Elemente entsprechend (plus ein wenig Overhead f¨ur die Verzeigerung). In unsortierten Arrays dauert die Suche O(n), genau wie in Listen. Sind die Elemente sortiert (was Aufwand O(n log n) hat), dann kann man neue Elemente im Array in logarithmischer Zeit finden. Hashverfahren versuchen, Informationen noch schneller, im besten Fall in konstanter Zeit zu finden. Das ist zum Beispiel f¨ur einen Compiler wichtig: Benutzer deklarieren und benennen im Programm Methoden, Klassen und Variablen, die im Programmtext h¨aufig benutzt werden. Ein Compiler muß an jeder dieser Stellen die Definition nachsehen, die er an einer zentralen Stelle gespeichert hat. Das heißt, er muß den jeweiligen Namen einer Methode mit dem jeweiligen Programmcode der Methode in Verbindung bringen. Das geschieht sehr h¨aufig, sollte also m¨oglichst effizient geschehen. Der Compiler sollte also idealerweise vom Namen direkt auf die Speicherstelle schließen k¨onnen, wo der zugeh¨orige Programmcode abgelegt ist. Die Basisidee f¨ur Hashverfahren ist, die Speicherstelle nicht durch Vergleiche sukzessive einzuschr¨anken, sondern direkt aus dem Inhalt des gesuchten Objekts zu berechnen. Objekte sind typischerweise z.B. Namen, die durch Zahlen etwa gem¨aß ASCII oder Unicode kodiert werden k¨onnen, oder Zahlen, notiert als X. Wir nehmen hier an, X seien einfach nat¨urliche Zahlen. Eine Hashtabelle ist ein Speichbereich mit einer festen Anzahl Stellen, etwa N St¨uck. Eine Hashfunktion ist dann nichts anderes als eine Abbildung h : X → {0, . . . , N − 1} ,

5.2 Listen

81

die jedem m¨oglichen Inhalt aus X direkt per Berechnung ihren Speicherplatz zuweist, an dem dazu relevante Information gespeichert ist. Sucht man einen Eintrag x ∈ X, kann man also direkt durch A[h(x)] darauf zugreifen. Die Sache hat einen Haken: In der Regel kann X beliebig groß werden und N ist beschr¨ankt. Die Funktion h ist also nicht injektiv. D.h. es sind tendentiell mehrere Werte an jeder Speicherstelle vertreten. Man spricht in diesem Fall von einem Konflikt. Im Fall eines Konflikts muß man irgendeine L¨osung herbeif¨uhren. Es gibt im wesentlichen zwei M¨oglichkeiten: Sogenanntes geschlossenes Hashing verwendet zur Speicherung nur das betrachtete Array. Tritt ein Konflikt beim Ablegen von Information auf, speichert es den Inhalt an einer anderen, durch eine weitere Vorschrift zu berechnende noch freie Ersatzstelle. Zus¨atzlich zur Funktion h gib es also noch eine weitere Vorschrift, die die Speicherpl¨atze im Fall von Konflikten belegt (Re-Hashing). Es gibt mehr oder weniger gute Strategien, solche Ersatzstellen zu finden. Darum wollen wir uns jetzt nicht k¨ummern. Offenes Hashing verwendet an den Eintr¨agen des Arrays angelegte verkettete Listen und neue Elemente werden einfach in diese Listen (z.B. an der aktuellen Position) eingef¨ugt. Der Speicherplatz ist also unbeschr¨ankt, da er aus einem begrenzten Feld von unbegrenzten Listen besteht. Innerhalb des Feldes werden die Speicherpl¨atze (also die Anfangsst¨ucke der Listen) berechnet, innerhalb der Listen wird anschließend linear durch ‘Durchhangeln’ gesucht. Suche besteht also aus einer • Berechnung der Hashfunktion f¨ur den Beginn der Liste (konstante Zeit), • Suche innerhalb der Liste (lineare Zeit mit Bezug zur L¨ange der Liste). Sind die Listen nicht zu lang, dann kann man auch diese Suche als linear ansehen, und offenes Hashing ist effizient. Was sind gute Hashfunktionen? Hashfunktionen sollten die Elemente m¨oglichst gleichm¨aßig u¨ ber den Indexfeldern verteilen, um so Konflikte m¨oglichst gering zu halten und m¨oglichst kurze Listen zu behalten. Man m¨ochte also Funktionen h finden, die auftretende Elemente aus X gleichm¨aßig u¨ ber — {0, . . . , N − 1} verteilen. Das Design guter Hashfunktionen ist nicht ganz ¨ einfach und basieren h¨aufig auf statistischen Uberlegungen. Erschwerend kommt dabei hinzu, daß die zu speichernden Inhalte oft alles andere als gleichm¨aßig u¨ ber X verteilt sind – man denke etwa an typische Variablenbezeichner i, j, k oder x1, x2, x3, . . . (Programmierer verwenden nicht m¨ogliche Namen gleichm¨aßig, sondern assoziieren mit den Namen eine Semantik!) Eine einfache naheliegende Funktion ist (Divisions-Rest-Verfahren) h(k) = k mod N . Dieses l¨aßt sich leicht berechnen. F¨ur schlecht gew¨ahltes N ist diese Vorschrift allerdings nicht sehr gut: ist etwa N eine Potenz der Basis B der Darstellung der Inhalte x ∈ X, dann z¨ahlen nur die letzten Bits der Darstellung, der Rest wird nicht ber¨ucksichtigt, die Bilder sind also nicht gleichverteilt und der Speicher ist nicht ausgenutzt. Aus demselben Grund sollte N nicht Zahlen B k ± j mit kleinen Zahlen j teilen, da dann die letzten Bits irrelevant w¨urden. Als gute Wahl haben sich z.B. Primzahlen bew¨ahrt, die diese Werte nicht teilen. Kommen wir zu einer Implementation geschlossenen Hashings mit Listen. Wir nehmen an, die zu speichernden Werte X seien ganze Zahlen (Integer). Wir verwenden als Hashfunktion die Divisions-Rest-Methode und verwenden f¨ur N die Zahl 97 (da 42 leider keine Primzahl ist). Wir ben¨otigen eine Erweiterung der Klasse Inhalt, um einem Inhaltsobjekt einen Integerwert zuzuweisen int to int()return was; Wir definieren die folgende Klasse

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

82

class Hashtabelle{ static int N=97; Liste[] hashfeld; Hashtabelle(){ hashfeld = new Liste[N]; for (int i=0;i
Anfang

Aktuell

Ende

Ein Listenelement h¨atte also das zus¨atzliche Feld prev, das auf den Vorg¨anger zeigt und beim L¨oschen und Einf¨ugen entsprechend angepaßt wird.

5.2 Listen

83

Bei generellen Listen, wie bisher eingef¨uhrt, kann man an jede Stelle der Liste gehen und dort l¨oschen oder einf¨ugen. Es gibt wichtige spezielle Listenformen, bei denen die sichtbaren Stellen beschr¨ankt sind. Wichtige solche Modelle sind die Schlange (queue) und der Keller (stack). Hier sind jeweils nur die Enden der Liste sichtbar. Bei der Schlange darf man (wie bei einer Warteschlange vor einem Verkaufsschalter) lediglich an einer Seite einf¨ugen (sich hinten anstellen) und an der anderen Seite auslesen (der erste der Schlange wird bedient). Prinzip: first in - first out (FIFO). Eine Schlange ist z.B. relevant, wenn man abzuarbeitende Prozesse auf dem Rechner speichert; diese stehen dann in einer Warteliste, bis sie an die Reihe kommen, das heißt alle Vorg¨anger abgearbeitet wurden. Die Prozesse werden also der Reihe nach nach dem Prinzip der FIFO abgearbeitet. Die Operationen einer FIFO sind abstrakt also • Konstruktor, erzeuge leere Schlange, • isempty: teste, ob die Schlange leer ist, • insert: f¨uge ein Element am Anfang der Schlange ein, • delete: lese und l¨osche das letzte Element der Schlange. Schlangen kann man sehr sch¨on z.B. mithilfe von doppelt verketteten Listen implementieren. Wir m¨ochten das hier nicht realisieren, sondern uns dem stack zuwenden. Beim Keller darf man nur an einem Ende einf¨ugen und auslesen, Prinzip last in - first out (LIFO). (Das ist so wie mit einem Arbeitsstapel von Papier, der auf dem Schreibtisch liegt. Man nimmt immer das oberste Blatt herunter, oder legt oben auf den Stapel etwas auf.) Schauen wir uns den Keller etwas genauer an: Die Operationen sind • Konstruktor, erzeuge leeren Stack, • isempty : teste, ob der Stack leer ist, • pop: l¨osche das oberste Element, • top: lese das oberste Element, • pop: schreibe Element auf den Stack. Eine Implementation kann, da ja nur am Anfang gelesen und geschrieben werden kann, sehr einfach wie folgt aussehen: class Stack{ Listenelement first; Stack() {first = null;} boolean isempty() {return(first==null);} void pop() {if (!isempty()) first=first.givenext();} Inhalt top() {if (!isempty()) return(first.binich()); else return null;} void push(Inhalt was) { Listenelement help=new Listenelement(); help.setzmich(was); help.setznext(first); first=help; } }

84

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

Keller sind eine in der Informatik weit verbreitete Datenstruktur, da sie unter anderem geeignet sind, die Abarbeitung rekursiver Programme, Variablenallokation und Belegungen zu realisieren: die jeweils aktuellen Variablen stehen am Kopf des Kellers. Ruft eine Methode eine andere Methode oder sich selbst rekursiv auf, dann wird der jetzige Zustand mit allen weiteren noch abzuarbeitenden Befehlen auf den Stack gelegt und zun¨achst die neu aufgerufene Methode mit dem aktuellen Variablenspektrum ausgef¨uhrt. Ruft diese ihrerseits Methoden auf, wandert sie selbst auf den Stack. Ganz zuunterst steht das, was als erstes eingef¨ugt wurde, die noch abzuarbeitenden Befehle des main zusammen mit den dort definierten Variablen. Da jeweils die obersten Variablen und Methoden betrachtet werden, bleibt der gespeicherte Zustand der vorherigen Methoden erhalten, bis sie weiter berabeitet werden k¨onnen. Das heißt, eine Organisation der Methodenaufrufe und Variablenbelegungen als Stack macht es sehr einfach m¨oglich, die jeweils g¨ultigen Variablenwerte zu erhalten: auch wenn eine Methode sich selbst mehrfach aufgerufen hat und also ihre Variablen je Aufruf neu belegt hat, definieren immer die obersten Variablenwerte die aktuell g¨ultigen Belegungen. Wir m¨ochten hier zwei andere Beispiele betrachten, wof¨ur ein Stack gebraucht werden kann. Die erste Anwendung ist das Auswerten von Postfixausdru¨ cken. Betrachten wir arithmetische Ausdr¨ucke mit den Zeichen + und ∗, also Terme der Form (((8 + 9) ∗ (3 + 2)) + (3 ∗ 3)). Diese sind durch folgende EBNF-Regel erzeugt Ausdruck ::= 0 | 1 | . . . | 9 | (Ausdruck + Ausdruck) | ( Ausdruck ∗ Ausdruck ) Sie sind in sogenannter Infix-Notation geschrieben, das heißt der Operator + und ∗ steht je zwischen den beiden zu addierenden oder zu multiplizierenden Ausdr¨ucken. Wir k¨onnen solche Ausdr¨ucke alternative in Postfixnotation schreiben, d.h. der Operator steht jeweils hinter den beiden zu multiplizierenden/addierenden Ausdr¨ucken. Das hat den Vorteil, daß Klammern nicht n¨otig sind, da sich die Zerlegung in Teilterme eindeutig ergibt. Obiger Ausdruck in Postfix-Notation w¨are etwa 8 9 + 3 2 + ∗ 3 3 ∗ +. Die entsprechende EBNF-Regel lautet Ausdruck ::= 0 | 1 | . . . | 9 | Ausdruck Ausdruck + | Ausdruck Ausdruck ∗ Postfixausdr¨ucke k¨onnen sehr einfach mithilfe eines Stacks ausgewertet werden. Wir erweitern dazu zun¨acht den Stack um eine Hilfsmethode, die top und pop aufruft und den Wert zu einem Integer umwandelt: int topundpop(){ int help=top().to_int(); pop(); return(help); } Auswerten von Postfixausdr¨ucken ist dann sehr einfach: eine Zahl wird direkt zu ihrem Wert ausgewertet und der Wert auf einem Stack gespeichert. Sobald man einen Operator liest, verkn¨upft man die beiden obersten Elemente des Stacks, die die Werte der zwei unmittelbar vorangegengenen Teilterme speichern, mithilfe des Operators und schreibt den Wert auf den Stack. Am Schluß ist dann der Wert des Ausdrucks auf dem Stack gespeichert und braucht nur noch ausgelesen zu werden. Als Programm: public static void main (String[] args){ /* wandelt String in Array of Char um */ char[] a = args[0].toCharArray(); int N=a.length; Keller s = new Keller();

5.2 Listen

85 for (int i=0; i=’0’) && (a[i]<=’9’)) s.push(a[i]-’0’); } System.out.println(s.top());

} F¨ur obigen Postfix-Ausdruck ergibt sich so der Wert 94. Es ist nicht so offensichtlich, daß der Algorithmus im allgemeinen korrekt ist. Daher beweisen wir dieses hier formal durch Induktion. Wir zeigen: Sei t ein Postfix-Ausdruck, stack der Keller. Wird t mit obiger Schleife verarbeitet startend vom Keller stack, dann hat der Keller nach Abarbeitung von t die Form Wert(t)stack, d.h. der Wert von t wurde oben im Keller zugef¨ugt, der Kellerinhalt sonst nicht ver¨andert. (Insbesondere bek¨ame man also, wenn man von einem leeren Keller aus startet und t abarbeitet, den Wert von t im Stack.) Die Induktion ist u¨ ber den Aufbau des Terms: • Induktionsanfang: t ist eine einfache Zahl. Dann wird t direkt ausgewertet und auf den Stack gelegt. Die Aussage gilt. • Induktionsvoraussetzung: gelte die Aussage f¨ur alle k¨urzeren Terme als t. • Induktionsschluß: wir zeigen die Aussage f¨ur den Term t der Form t 1 t2 ∗ oder t1 t2 +. Nach Voraussetzung hat der Keller nach Abarbeitung von t1 die Form Wert(t1 )stack, nach Abarbeitung von t2 die Form Wert(t2 )Wert(t1 )stack. Einlesen von ∗ bzw. + f¨uhrt dazu, daß diese beiden Werte vom Stack gelesen und multipliziert/addiert werden. Da dieses der Wert von t ist, erh¨alt man also den Keller Wert(t)stack. Diese Art der Auswertung wird zum Beipsiel in der Praxis bei postscript-Druckern genutzt. Postscript ist eine einfache Programmiersprache, die Terme in Form von Postfix-Ausdr¨ucken abspeichert. Die Operatoren enthalten dabei neben arithmetischen Ausdr¨ucken auch graphische Anweisungen, an eine bestimmte Stelle zu gehen, dort eine Linie zu zeichnen, etc. postscript-Drucker werten diese Ausdr¨ucke mithilfe eines Stack aus und erzeugen das gew¨unschte Druckergebnis. Als zweite Anwendung f¨ur die Datenstruktur eines Kellers soll hier ein anderes klassisches Beispiel stehen, die T¨urme von Hanoi. Das Beispiel geht zur¨uck auf eine 1883 vom franz¨osischen Mathematiker Edouard Lucas ersonnene Geschichte: Im Großen Tempel von Benares, unter dem Dom, der die Mitte der Welt markiert, ruht eine Messingplatte, in der drei Diamantnadeln befestigt sind, jede eine Elle hoch und so stark wie der Ko¨ rper einer Biene. Bei der Erschaffung der Welt hat Gott vierundsechzig Scheiben aus purem Gold auf eine der Nadeln gesteckt, wobei die gr o¨ ßte Scheibe auf der Messingplatte ruht, und die u¨ brigen, immer kleiner werdend, eine auf der anderen. Das ist der Turm von Brahma. Tag und Nacht sind die Priester unabl a¨ ssig damit besch¨aftigt, den festgeschriebenen und unver¨anderlichen Gesetzen von Brahma folgend, die Scheiben von einer Diamantnadel auf eine andere zu setzen, wobei der oberste Priester nur jeweils eine Scheibe auf einmal umsetzen darf, und zwar so, dass sich nie eine kleinere Scheibe unter einer gr o¨ ßeren befindet. Sobald dereinst alle vierundsechzig Scheiben von der Nadel, auf die Gott sie bei der Erschaffung der Welt gesetzt hat, auf eine der anderen Nadeln gebracht sein werden, werden der Turm samt dem Tempel und allen Brahmanen zu Staub zerfallen, und die Welt wird mit einem Donnerschlag untergehen. Man kann sich u¨ berlegen, daß das Umsetzen aller Scheiben mindestens 264 − 1 = 18.446.744.073.709.551.615

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

86

Z¨uge dauert, was bei einer Sekunde pro Zug immerhin 5 Milliarden Jahre ausmacht: M¨ochte man die unterste Scheibe des Turms mit n = 64 Scheiben zum Zielort bewegen, muß vorher der gesamte obere Teil von n − 1 = 63 Scheiben zur anderen freien Stange gebracht worden sein; anschließend m¨ussen diese n − 1 Scheiben an ihren Bestimmungsort wandern. Bezeichnet A(n) die Anzahl der n¨otigen Scheibenbewegungen f¨ur n Scheiben, dann gilt also A(n) = A(n − 1) + 1 + A(n − 1) mit A(1) = 1. Man sieht durch Induktion: A(n) = 2n − 1. Wir brauchen uns daher von dieser Geschichte nicht verunsichert f¨uhlen. Stattdessen implementieren wir hier eine L¨osung f¨ur n Scheiben mithilfe von Stacks. Obige Argumentation ver¨at uns auch schon eine (optimale) L¨osung: wir m¨ussen rekursive die obersten Scheiben auf die freie Stange bringen, die unterste an den Zielort, und rekursive die obersten an den Zielort. class Hanoi{ Stack[] turm; Hanoi(int n){ turm=new Stack[3]; for (int i=0;i<3;i++) turm[i]=new Stack(); Inhalt help=new Inhalt(); for (int i=n;i>0;i--){ help.setzmichint(i); turm[0].push(help); } } boolean gueltig(int von, int nach){ return(!turm[von].isempty() && (turm[nach].isempty() || !turm[von].top().kleinermir(turm[nach].top()))); } void zieheeins(int von, int nach){ if (gueltig(von,nach)){ turm[nach].push(turm[von].top()); turm[von].pop(); System.out.println(von+" -> "+nach); } } void zieheviele(int wieviel,int von,int nach){ if (wieviel>0){ zieheviele(wieviel-1,von,frei(von,nach)); zieheeins(von,nach); zieheviele(wieviel-1,frei(von,nach),nach); } } int frei(int eins, int zwei){return (3-eins-zwei);} } Dabei haben wir die neue Methode setzmichint benutzt, die ein Inhaltsobjekt mithilfe eines int statt String setzt. Die Initialisierung eines Hanoi-Turms mit n Scheiben und der Aufruf zieheviele(n,0,2) f¨uhren dann zu einer L¨osung, n Scheiben von 0 nach 2 zu bewegen.

5.3 B¨aume

87

5.3 B¨aume Wir kommen jetzt zu nicht-linear verzeigerten Datenstrukturen. Als erstes betrachten wir B¨aume, die eine in der Informatik sehr n¨utzliche Datenstruktur darstellen z.B. um tats¨achliche Abstammungsb¨aume zu modellieren, Terme und Formeln darzustellen, Klassenhierarchien von Java zu visualisieren, etc. Formal ist ein Baum wie folgt definiert: ein Baum ist entweder • der leere Baum, • oder er besteht aus einem Knoten, der ein Element speichert, und auf eine Liste von Teilb¨aumen t1 , . . . , tn f¨ur ein n ∈ N verweist. Diese Teilb¨aume d¨urfen auch leer sein. B¨aume findet man h¨aufig wie folgt dargestellt: 1

2

4

3

7

6

5

9

10

8

11

Knoten sind durch Kreise markiert, die durch Pfeile zu ihren Teilb¨aumen verbunden sind. Leere B¨aume werden dabei u¨ blicherweise nicht dargestellt. In den Kreisen steht in diesem Fall der Inhalt, eine einfache Zahl. Bei diesem Baum sind die Knoten einfach nur durchnummeriert. Man k¨onnte statt einer einfachen Durchnummerierung eine Formel darstellen: +

*

4

+

−

9

*

6

10

8

11

Dieser Baum repr¨asentiert die Formel (4 ∗ (−9)) + (6 + (10 ∗ 11) + 8). Einige Sprechweisen • Knoten in diesem Baum stehen durch die durch Teilb¨aume gegebenen Verbindungen in direkter Beziehung zueinander. Sind zwei Knoten n1 und n2 miteinander verbunden, und ist n2 in einem zu n1 zugeordneten Teilbaum, dann heißt n1 Vater/Elter von n2 und n2 Kind von n1 . Z.B. ist 1 Elter von 2 und 3, 2 und 3 sind Kinder von 1. • Knoten, die keine Kinder haben, heißen Bla¨ tter. Es gibt genau einen Knoten, der keinen Elter hat, dieser heißt Wurzel. Alle anderen Knoten heißen innere Knoten. In obigem Baum ist 1 die Wurzel, 4, 9, 6, 10, 11, und 8 die Bl¨atter.

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

88

• Ein Pfad in einem Baum ist eine Folge von Knoten n1 , . . . , ni , so daß jeweils ni Elter von ni+1 ist. Etwa 1, 3, 6 oder 1, 2, 5. Der leere Pfad enth¨alt gar keinen Knoten. Die L a¨ nge eines Pfades ist die Anzahl der in ihm enthaltenen Knoten. • Die H¨ohe eines Baumes ist die maximale L¨ange der Pfade in diesem Baum. Etwa im Beispiel ist die H¨ohe 4. Der leere Baum hat H¨ohe 0. Die Tiefe eines Knotens ist die L¨ange eines Pfades von der Wurzel bis zum Knoten. Etwa 5 hat die Tiefe 3. • Ein Baum heißt k-Baum, falls alle Knoten maximal k Kinder haben. Ein Baum heißt bin a¨ rer Baum, falls alle Knoten maximal zwei Kinder haben. Wir betrachten hier exemplarisch bin¨are B¨aume. Was f¨ur Methoden sollten zur Verf¨ugung stehen? Genau wie bei Listen m¨ochte man • den leeren Baum initialisieren, • testen, ob der Baum leer ist, • die Wurzel addressieren, • testen, ob wir an einem Blatt sind, • zum linken oder rechten Kind gehen, • von einem Knoten den Wert auslesen oder setzen, • Knoten einf¨ugen und l¨oschen; Knoten einf¨ugen und l¨oschen ist allerdings etwas problematisch: was sollen wir mit den Kindern tun, wenn wir einen Knoten l¨oschen bzw. einen Knoten einf¨ugen. Eine sinnvolle Beschr¨ankung ist daher, nur im leeren Baum oder leeren Kindern einf¨ugen zu k¨onnen und nur Bl¨atter l¨oschen zu d¨urfen. Anders als bei Listen ist es nicht unbedingt ratsam oder erforderlich, den Baum zusammen mit einer aktuellen Sichtbarkeitsposition zu realisieren, da man sich am Baum nicht in linearer Weise ‘langhangeln’ kann. Wir ben¨otigen also keinen Verweis auf eine aktuelle Position im Baum. Stattdessen verwendet man oft rekursive Aufrufe, gegeben eine konkrete Knotenposition im Baum. Es ist daher n¨utzlich, wenn man sich von einer gegebenen Knotenposition aus am Baum entlanghangeln kann. Wir statten daher Baumelemente mit entsprechenden Methoden aus, die ein Navigieren im Baum gestatten. Baumalgorithmen sind entsprechend der rekursiven Struktur von B¨aumen h¨aufig rekursiv aufgebaut. Ein einfaches Beispiel, das Berechnen der H¨ohe eines bin¨aren Baums etwa, k¨onnte wie folgt aussehen: wir nehmen an, daß zu einem konkreten Knoten act der linke Teilbaum durch die Methode left, der rechte Teilbaum durch die Methode right erhalten werden kann. Die Methode isempty testet, ob ein Baum leer ist. Der Algorithmus ist dann wie folgt: int height(knoten act) { if (act.isempty()) return 0; int a = height(act.left()); int b = height(act.right()); if (a
5.3 B¨aume

89

Navigation Wie k¨onnen wir in einem Baum oder Teilbaum navigieren? Wie k¨onnen wir insbesondere alle Elemente des Baums nacheinander erreichen? Eine sehr einfache M¨oglichkeit, alle Elemente eines Baums zu besuchen, ist eine sogenannte Eulertraversion des Baumes: eine Eulertour besucht angefangen von der Wurzel jeden Knoten mindestens einmal und kehrt zur Wurzel zur¨uck. Das geht rekursive sehr einfach – man f¨angt an der Wurzel an und geht zum linken Teilbaum und seinem Eulertraversal, zur¨uck u¨ ber die Wurzel zum rechten Teilbaum und seinem Eulertraversal und zur¨uck zur Wurzel, wie in folgendem Baum angedeutet: 1

2

4

3

5

8

7

6

9

10

Ein Eulertraversal hat generell folgende Form void eulertraverse(von){ if !isempty(von) eulertraverse(von.giveleft()); eulertraverse(von.giveright()); } Dabei referenziert von auf die Wurzel des zu traversierenden Baumes, giveleft und giveright liefern den linken bzw. rechten Teilbaum der Wurzel. Eine Eulertraversierung offeriert zudem M¨oglichkeiten, einen Baum als linearen String darzustellen! Man kann alle Knoten in einer durch das Eulertraversal induzierten Reihenfolge ausgeben, und so eine lineare Liste der Knoteninhalte des Baumes bekommen. Je nachdem, an welcher Stelle obiger zwei rekursiven Aufrufe man den Inhalt des betrachteten Knotens ausgibt, erh¨alt man eine andere Reihenfolge: • Pr¨aorder: der Knoteninhalt wird vor dem Traversal des linken Teilbaums ausgegeben, Ergebnis: 1 2 4 5 8 3 6 7 9 10 • Inorder: der Knoteninhalt wird zwischen dem Traversal des linken und rechten Teilbaums ausgegeben, Ergebnis: 4 2 8 5 1 6 3 9 7 10 • Postorder: der Knoteninhalt wird nach dem Traversal des rechten Teilbaums ausgegeben, Ergebnis: 4 8 5 2 6 9 10 7 3 1 Pr¨aorder w¨urden wir z.B. verwenden, wenn in einem Baum Funktionssymbole und Konstantenbezeichner gespeichert sind:

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

90

f

g

a

g

h

b

f

c

d

e

ergibt in Preorder f gahbgcf de bzw. mit zus¨atzlichen Klammern um die Substrings und Kommata zwischen zwei Teilstrings f (g(a, h(b), g(c, f (d, e)))) Inorder verwendet man h¨aufig f¨ur infix geschriebene Operatoren, etwa boolesche Formeln oder mathematische Ausdr¨ucke. Eine alternative Traversion eines Baumks ist die Breitensuche: man besucht ebenenweise die Knoten eines Baums, angefangen bei der Wurzel, dann deren Kinder, danach deren Kinder usw. Im Baum am Beginn dieses Abschnitts w¨urde man also die Knoten ihrer Nummer nach besuchen: 1, 2, 3, 4, 5, . . . , 10. Eine einfache Realisierung von Breitensuche benutzt eine Schlange: es wird angefangen von der Wurzel jeweils ein Element von der Schlange genommen und dessen Kinder zur Schlange zugef¨ugt, bis die Schlange leer ist. Da man an einem Ende einf¨ugt und am anderen Ende l¨oscht, betrachtet man so die Elemente ebenenweise. Als Algorithmus erhielte man (mit den entsprechenden Methoden f¨ur die Schlange, die sich von selbst erkl¨aren): Schlange queue = new(Schlange); queue.insert(root); while (!queue.isempty()) { help = queue.getelement(); /* gebe help aus, um die Baumelemente gemaess Breitensuche aufzuzaehlen */ if (!help.left().isempty()) queue.insert(help.left()); if (!help.right().isempty()) queue.insert(help.right()); } Termparsing Wir m¨ochten als Anwendung (und konkrete Implementation einer Teilfunktionalit¨at) von B¨aumen einen Algorithmus schreiben, der einen als Inorder geschriebenen mathematischen Ausdruck mit den zweistelligen Operatoren +, ∗ und − und Integerzahlen einliest, als Baum repr¨asentiert und auswertet. Wir gehen dabei davon aus, daß die einzelnen Zeichen nacheinander auf der Kommandozeile eingegeben werden. G¨ultige Ausdr¨ucke sind durch folgende EBNF charakterisiert Term ::= op ::=

Zahl | ( Term op Term ) *|-|+

Zahl darf dabei irgendeine Integerzahl sein. Diese Terme sollen ausgewertet werden. Wir lesen sie dazu den Term als einen Baum ein, der sich auswerten kann. B¨aume unterscheiden sich durch

5.3 B¨aume

91

Listen dadurch, daß sis zwei Nachfolger statt nur einem haben. Die vorherigen Klassen werden wie folgt erweitert und modifiziert, wobei Auswerte- und Ausgabefunktionen schon integriert sind:

class Inhalt{ String was; //nach Bedarf nicht nur int boolean gleichmir(Inhalt you) {return was.equals(you.was);} // geht, da strings nicht veraenderbar void setzmich(String wovon) {was=wovon;} // verschiedene Auswertungen int Ieval() {return Integer.parseInt(was);} // Integerwert char Ceval() {return was.charAt(0);} // Characterwert String Seval() {return was;} // Stringwert } class Baumelement{ Inhalt was; Baumelement left, right; Baumelement(){ was=new Inhalt(); left=right=null; } boolean isleave(){return (left==null && right==null);} boolean hasleftchild(){return left!=null;} boolean hasrightchild(){return right!=null;} int eval(){ // Termauswertung if (isleave()) return was.Ieval(); if (hasleftchild() && hasrightchild()) switch (was.Ceval()){ case ’*’: return left.eval()*right.eval(); case ’+’: return left.eval()+right.eval(); case ’-’: return left.eval()-right.eval(); default: return 0; } return(0); } String out(){ // Termausgabe if (isleave()) return was.Seval(); if (hasleftchild() && hasrightchild()) return "("+left.out()+was.Seval()+right.out()+")"; return ; } int readfrom(String[] args,int i){ // Einlesen ab Position i if (args[i].equals("(")){ // Teilterm left=new Baumelement(); right=new Baumelement(); int j=left.readfrom(args, i+1); // links was.setzmich(args[j]); // Operator return right.readfrom(args, j+1)+1; //rechts und Klammer zu }

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

92

else {was.setzmich(args[i]); return i+1;} //Literal } } class Baum{ Baumelement root; Baum() {root=null;} boolean isempty(){return (root==null);} void readfrom(String[] args){ // Einlesen if (args.length>0){ root=new Baumelement(); rootreadfrom(args,0); } } String out(){ // Ausgabe if (isempty()) return " "; return root.out(); } int eval(){ //Auswertung if (isempty()) return 0; return root.eval(); } public static void main(String[] args){ Baum term = new Baum(); term.readfrom(args); System.out.print("Der Term "+term.out()); System.out.println(" ist "+term.eval()); } } Mithilfe dieser Klasse werden Ausdr¨ucke rekursiv als Terme interpretiert, entsprechend ihrer Struktur in einem Baum gespeichert mit Operationen als innere Knoten und Werten als Bl¨attern, und rekursive ausgewertet. Der Aufruf java Baum ( ( 4 - 2 ) * ( ( 6 + 3 ) + ( ( 7 - 4 ) * 4 ) ) ) ¨ man f¨uhrt zur Ausgabe Der Term ((4-2)*((6+3)+((7-4)*4))) ist 42. 19 Ubergibt einen nicht g¨ultigen Ausdruck, terminiert das Programm entweder vorzeitig mit einem Fehler, oder es wird ignoriert (fehlende Klammern am Ende werden etwa einfach u¨ bersehen). Heapsort Baumstrukturen spielen auch eine große Rolle beim Abspeichern von Daten. Sie erm¨oglichen, Daten schnell nach ihrer Gr¨oße geordnet abzuspeichern und wiederzufinden. Es existieren dazu 19 Man muß bei der Eingabe die Zeichen *, ( und ) sch¨utzen, da sie sonst von der Shell als Sonderzeichen gedeutet werden, das geschieht z.B. mit \. Der Aufruf ist also eigentlich

java Baum $ \( 4 - 2 $ \* $ \( 6 + 3 $ + $ \( 7 - 4 $ \* 4 \) \) \)

5.3 B¨aume

93

verschiedene spezielle Typen von B¨aumen, die geeignete Bedingungen an die Anordnung der Elemente erf¨ullen, so daß man Auslesen und Einf¨ugen sehr effizient gestalten kann. Wir wollen hier als kleine Demonstration dessen einen weiteren Sortieralgorithmus kennenlernen, den Heapsort. Ein Heap ist ein bin¨arer Baum mit der Bedingung, daß der Wert eines Knotens im Baum gr¨oßer ist als der Wert seiner Kinder. Insbesondere kann man in einem Heap das Maximum aller Werte sehr schnell finden: es ist der Wert an der Wurzel des Baums. Dieses dient als Idee f¨ur folgendes Sortierverfahren: Man liest die Elemente nacheinander ein, so daß sie einen Heap bilden. Danach entfernt man nacheinander jeweils das Element and der Wurzel (das noch verbleibende gr¨oßte Element) und repariert den Heap, bis kein Element mehr u¨ brig bleibt. Die Folge der Elemente ist dann der Gr¨oße nach sortiert. Man ben¨otigt f¨ur diese Prozedur zwei zentrale Methoden: swim und sink. • swim: Reparatur des Heap, wenn ein neues Element als Blatt eingef¨ugt wird. F¨ur ein beliebiges Element, das als Blatt eingef¨ugt wird, muß die Bedingung des Heap nicht erf¨ullt sein. Ist das Element zu groß, dann muß es an einer h¨oheren Stelle des Heap aufgeh¨angt werden, es muß quasi nach oben schwimmen, bis es richtig steht. Algorithmisch kann man dieses dadurch realisieren, daß man das neu eingef¨ugte Element mit seinem Elter vergleicht. Ist der Elter kleiner, tauscht man das neue Element mit dem Elter. Und f¨ahrt mit dem Knoten fort, an dem das Element jetzt steht, da es immer noch gr¨oßer als sein neuer Elter sein kann. Sp¨atestens an der Wurzel ist dann Schluß. Diese Prozedur ben¨otigt man beim sukzessiven Einf¨ugen der Elemente in den Heap. • sink: Reparatur des Heap, wenn ein neues Element als Wurzel eingef¨ugt wird. Genau umgekehrt zur vorherigen Prozedur kann es sein, daß die Wurzel zu klein ist. Sie muß also soweit nach unten sinken, bis sie an der richtigen Stelle steht. Dazu vergleicht man die Wurzel mit dem gr¨oßeren der Kinder, und tauscht, sodern das Kind gr¨oser als der Elter ist. Mit dem neuen Knoten f¨ahrt man dann fort, bis keine Fehlstellung mehr vorliegt oder man an den Bl¨attern angekommen ist. Diese Prozedur wird ben¨otigt, wenn die Wurzelelemente des Heap iterativ gel¨oscht und durch ein beliebiges anderes Element des Heaps erzetzt wird. Diese beiden Methoden bilden das Kernst¨uck des Heapsort. Wir stellen hier eine konkrete Implementation innerhalb von einem Array vor. Man kann die Elemente eines bin¨aren Baums in einem Feld abspeichern und hier sehr schnell f¨ur ein gegebenes Element Kinder/Eltern referenzieren: Element 1 speichert die Wurzel, 2 und 3 dessen Kinder, 4 und 5 die Kinder von Knoten 2, 6 und 7 die Kinder von Knoten 3 usw. Allgemein findet man die Kinder von Element i an den Stellen 2i und 2i + 1, den Elter von i an der Stelle i/2 (ganzzahlige Division). Damit kann der Heapsort sehr einfach wie folgt in einem Feld implementiert werden: class heap{ int[] h; int n; heap(String[] wovon){ n=wovon.length+1; h = new int[n]; for (int i=1;i
94

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR void tausche(int i,int j) { if ((i>0)&&(j>0)&(i1)&&(i0)&&(i<=ende/2)) { int max = i*2; if ((max+1<=ende) && (h[max]h[i]) { tausche(i,max); sink(max,ende); } } } void heapsort() { for (int i=n-1;i>1;i--) { tausche(1,i); sink(1,i-1); this.out(); } } void out() { for (int i=1;i
5.3 B¨aume

95

} class mainmethode{ public static void main (String[] args){ heap H =new heap(args); H.out(); H.heapsort(); H.out(); } } Dieses Algorithmus sortiert offensichtlich im Platz. Was ist der Aufwand? Die Methodenswim und sink ben¨otigen maximal so lange, wie der l¨angste Pfad im Baum ist, d.h. O(log n) falls n Elemente betrachtet werden. Die Methode swim wird f¨ur jedes eingef¨ugte Element aufgerufen, die Methode sink wird f¨ur jedes ausgelesene Element aufgerufen, also beide n Mal. Damit hat der Algorithmus den Aufwand O(n log n) auch im schlechtesten Fall. Spielb¨aume Eine weitere sehr sch¨one Anwendung von Baumstrukturen kann man h¨aufig bei der Programmierung strategischer Spiele finden. Betrachten wir dazu ein einfaches Zwei-Personen-Spiel, Tic-TacToe. Auf einem Feld mit 3x3 K¨astchen setzen zwei Spieler abwechselnd einen Stein. Wer zuerst drei Steine in einer Waagerechten, Senkrechten oder Diagonale bekommt, gewinnt. Sofern alle Steine gesetzt sind und keine Dreierreihe entstanden ist, endet das Spiel unentschieden. M¨ogliche Spielverl¨aufe kann man sehr sch¨on als Spielbaum darstellen: an den Knoten sind die Spielst¨ande gespeichert, die Kinder eines Knoten stellen alle in einem Zug m¨oglichen Folgepositionen des Spielstandes dar. Der Anfang von Tic-Tac-Toe w¨urde dann durch folgenden Baum dargestellt, sofern schwarz den ersten Zug macht:

...

...

...

...

...

...

...

Offensichtlich entsteht selbst f¨ur dieses einfache Spiel ein sehr großer Baum. Gewinne f¨ur schwarz sind Bl¨atter, bei denen schwarz drei Steine in Reihe hat. Gewinne f¨ur weiß sind Bl¨atter, bei denen weiß drei Steine in Reihe hat. Wir m¨ochten jetzt ein Programm implementieren, das es dem Rechner erm¨oglicht, strategisch gegen einen Menschen zu spielen. Der Rechner hat dabei den Vorteil, daß er zumindest bei diesem einfachen Spiel noch alle Folgesituationen bedenken und sich den besten Spielzug aussuchen

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

96

kann. Was heißt aber ‘bester Spielzug’? Das sogenannte min-max Verfahren geht davon aus, daß sich jeder Spieler optimal verh¨alt. Ein Zug, der direkt zum Sieg f¨uhrt, ist optimal. Ein Zug, der nach einem beliebigen Zug des Gegners und einem geeigneten Zug meinerseits zum Gewinn f¨uhrt, ist ebenfalls optimal, usw. Mein Gegner verh¨alt sich ebenso, nur versucht er genau das Gegenteil, also einen Verlust f¨ur mich herbeizuf¨uhren. Dieses kann man im Spielbaum formal machen, indem man startend von den Bl¨attern jede Position bewertet: Gewinnsituationen werden mit 1, Verlustsituationen mit −1, Patt mit 0 bewertet. Allgemeiner k¨onnen wir die Bl¨atter mit irgendwelchen Zahlen bewerten, die den Verlust bewerten, z.B. wenn man mehr oder weniger hoch verlieren kann, wie etwa bei Kartenspielen. Ausgehend von den Bl¨attern bekommen innere Knoten folgenden Wert: • sofern ich selbst an der Reihe bin, bekommt der Knoten den Wert des Maximums seiner Kinder, denn ich w¨ahle einen f¨ur mich optimalen Zug. • sofern der Gegner an der Reihe ist, bekommt der Knoten den Wert des Minimums seiner Kinder, denn mein Gegner w¨ahlt einen f¨ur ihn optimalen, also f¨ur mich schlechtesten Zug. Ein Beispiel (f¨ur eine allgemeine Bewertung der Bl¨atter, etwa Punktverluste beim Kartenspielen): 12

MAX 10

MIN MAX

10 10 −5 3

12 12 −6 12 8

12 10 12 3

3 13

3

7

13 8 3

3 2 −4

7 6 −1

Eine optimale Strategie unter dieser Hypothese ist dann eine, die in jeder Position einen Zug w¨ahlt, der zu einem Nachfolger mit optimaler Bewertung f¨uhrt. In obigem Fall ist das der markierte Pfad.Ein min-max Verfahren kann sehr einfach als Spielstrategie implementiert werden. Dazu ist zun¨achst ein kleiner Nachtrag zu Java n¨otig: Bisher haben wir lediglich beim Programmaufruf von der Kommandozeile aus eingelesen. Um gegen den Rechner zu spielen, m¨ussen wir offensichtlich nach jeder Runde unseren n¨achsten Zug eingeben. Java stellt im Paket java.io Ein- und Ausgaberoutinen auf der Basis von Streams zur Verf¨ugung. Dieses ist daher begr¨undet, daß in der Regel eine Eingabe u¨ ber eine Applikation oder Web-Oberfl¨ache erfolgt, so daß Zeichenketten das ad¨aquate Format zu dessen Speicherung sind. Wir m¨ochten allerdings keine Zeichenketten, sondern Zahlen einlesen, m¨ussen also Streams in solche umwandeln. Eine sehr einfache M¨oglichkeit offeriert folgende von Robert Sedgewick und Kevin Wayne (Princeton University) bereitgestellte Klasse, hier zusammen mit der Demonstration im main, wie man sie benutzt: /*************************************************** * Compilation: javac StdIn.java * Execution: java StdIn * * Supports reading variables of type int, double, * String, boolean, * long, or float from standard input. * * % java StdIn * Enter an integer: 3 * Your integer was 3 *

5.3 B¨aume * Enter a double: 3.14 * Your double was 3.14 * * Enter a string: pi * Your String was pi * * Enter a boolean: true * Your String was true * *************************************************/ import java.io.IOException; public class StdIn { private static int c = ’ ’; private static final int EOF = -1; // can’t create an instance of this class private StdIn() { } // is the current character whitespace? private static boolean isBlank() { return Character.isWhitespace((char) c); } // is it at end of the file already? private static boolean isEOF() { return c == EOF; } // return EOF if end of file or IO error private static void readC() { try { c = System.in.read(); } catch(IOException e) { c = EOF; } } // is there more input? public static boolean isEmpty() { while (!isEOF() && isBlank()) readC(); return isEOF(); } // read a token - use StringBuffer for efficiency public static String readString() { StringBuffer s = new StringBuffer(); // eat up whitespace while (!isEOF() && isBlank()) readC();

97

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

98

// now get the string while (!isEOF() && !isBlank()) { s.append((char) c); readC(); } if (s.length() == 0) throw new RuntimeException("Tried to read from empty stdin"); else return s.toString(); } public static int readInt() { return Integer.parseInt(readString()); public static double readDouble() { return Double.parseDouble(readString()); public static float readFloat() { return Float.parseFloat(readString()); public static long readLong() { return Long.parseLong(readString());

} } } }

public static boolean readBoolean() { String s = readString().toLowerCase(); if (s.equals("true") || s.equals("yes") || s.equals("1")) return true; if (s.equals("false") || s.equals("no") || s.equals("0")) return false; throw new RuntimeException(s + " is not a valid boolean value"); } // test client public static void main(String[] args) { // read in an integer and print it out System.out.print("Enter an integer: "); int x = StdIn.readInt(); System.out.println("Your integer was " + x); System.out.println(); // read in an double and print it out System.out.print("Enter a double: "); double y = StdIn.readDouble(); System.out.println("Your double was " + y); System.out.println(); // read in a String and print it out System.out.print("Enter a string: "); String z = StdIn.readString(); System.out.println("Your string was " + z); System.out.println();

5.3 B¨aume

99

// read in a boolean and print it out System.out.print("Enter a boolean: "); boolean b = StdIn.readBoolean(); System.out.println("Your boolean was " + b); System.out.println(); } } Diese Klasse stellt die Methode readString zur Verf¨ugung, die mithilfe eines sogenannten buffered String (ein String, dessen L¨ange und Inhalt nicht bei der Instanziierung schon fesgelegt ist und also ge¨andert werden kann) Zeichenketten einliest, wobei u¨ bersch¨ussige Leerzeichen entfernt werden. Weitere Methoden der Klasse wandeln den String gegebenenfalls in ein gew¨unschtes Format umwandelt, wie im main demonstriert. Die Einleseprozeduren sind static, daher k¨onnen sie in anderen Programmen elegant als Einleseprozeduren benutzt werden, sobald die Klasse bekannt ist (durch Referenz auf den Klassennamen StdIn). Damit k¨onnen wir das Spiel realisieren: /* Tic Tac Toe Implementation */ /* Ein Kaestchen im Feld */ class SQUARE { private int element; SQUARE(){ element = 0;} boolean isyou() { return (element == 1); } boolean isme() { return (element == -1); } boolean isempty() {return (element == 0); } void setyou() { element = 1; } void setme() { element = -1; } void makeempty() { element = 0; } void output() { if (element == 1) System.out.print("*"); if (element == -1) System.out.print("o"); if (element == 0) System.out.print(".");} } /* Spielfeld und Zuege class FIELD {

*/

private SQUARE[][] field; /* Konstruktor */ FIELD(){ field = new SQUARE[3][3]; for (int i=0;i<3;i++) for (int j=0;j<3;j++) field[i][j] = new SQUARE();} /* Ausgabe des Spielfeldes */ void output(){ for (int i=0;i<3;i++) { for (int j=0;j<3;j++) field[i][j].output();

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

100

System.out.println(); } System.out.println(); } /* erfrage einen Zug */ void get_move(){ boolean noch = true; int x; int y; while (noch){ System.out.print("Sie sind dran! "); x = StdIn.readInt()-1; y = StdIn.readInt()-1; System.out.println(); if ((0<=x)&&(x<3)&&(0<=y)&&(y<3)&&field[x][y].isempty()) { noch = false; field[x][y].setyou(); } else{ System.out.println("Der Zug ist ungueltig!"); output(); } } } /* Computerzug inklusive min-max Verfahren */ void set_move(){ int value; int alpha = -2; /* - unendlich */ int maxi =0,maxj =0; for (int i=0;i<3;i++) for (int j=0;j<3;j++) { if (field[i][j].isempty()) { field[i][j].setme(); value = MIN(); field[i][j].makeempty(); if (value>alpha){alpha = value; maxi=i;maxj=j;} } } System.out.println("Ich ziehe nach "+(maxi+1)+" "+(maxj+1)); System.out.println(); field[maxi][maxj].setme(); } int MIN() { int value = 2;

/* + unendlich */

5.3 B¨aume

101

int helpvalue; if (wins("me")) return(1); if (wins("you")) return(-1); if (besetzt()) return(0); if (besetzt()) return(0); for (int i=0;i<3;i++) for (int j=0;j<3;j++) { if (field[i][j].isempty()) { field[i][j].setyou(); helpvalue = MAX(); field[i][j].makeempty(); if (helpvalue < value) value=helpvalue; } } return (value); } int MAX() { int value = -2; /* - unendlich */ int helpvalue; if (wins("me")) return(1); if (wins("you")) return(-1); if (besetzt()) return(0); for (int i=0;i<3;i++) for (int j=0;j<3;j++) { if (field[i][j].isempty()) { field[i][j].setme(); helpvalue = MIN(); field[i][j].makeempty(); if (helpvalue > value) value=helpvalue; } } return (value); } boolean ende(){ return(besetzt()||wins("me")||wins("you")); } /* Testet, ob me oder you gewinnt */ boolean wins(String who){ if (who.equals("me")) return (field[0][0].isme() && field[0][1].isme() && field[0][2].isme()) || (field[1][0].isme() && field[1][1].isme() && field[1][2].isme()) || (field[2][0].isyou() && field[2][1].isyou() && field[2][2].isyou()) ||

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

102 (field[0][0].isyou() (field[0][1].isyou() (field[0][2].isyou() (field[0][0].isyou() (field[0][2].isyou() }

&& && && && &&

field[1][0].isyou() field[1][1].isyou() field[1][2].isyou() field[1][1].isyou() field[1][1].isyou()

&& && && && &&

field[2][0].isyou()) || field[2][1].isyou()) || field[2][2].isyou()) || field[2][2].isyou()) || field[2][0].isyou());

/* testet, ob alles voll ist */ boolean besetzt(){ for (int i=0;i<3;i++) for (int j=0;j<3;j++) if (field[i][j].isempty()) return(false); return (true); } } public class ttt_simple { static boolean you = false; static FIELD spielfeld = new FIELD(); static boolean start(){ System.out.println("Moechten Sie anfangen?"); String antw = StdIn.readString(); return (antw.equals("ja") || antw.equals("Ja") || antw.equals("j") || antw.equals("J")); } static void ende(){ if (spielfeld.wins("you")) System.out.println("Sie haben gewonnen!"); else if (spielfeld.wins("me")) System.out.println("Ich habe gewonnen!"); else System.out.println("Patt!"); } public static void main(String[] args){ you = start(); spielfeld.output(); while (!spielfeld.ende()) { if (you) spielfeld.get_move(); else spielfeld.set_move(); System.out.println("Aktuelles Spielfeld: "); spielfeld.output(); you = !you; } ende(); }

5.3 B¨aume

103

} Es werden rekursive alle Z¨uge ausprobiert und je abwechselnd das Minumum/Maximum dar¨uber berechnet. Diese einfache Strategie hat allerdings einen gravierenden Nachteil: um die Bewertungen zu bekommen, muß der gesamte Baum generiert werden, in jedem Zug werden alle m¨oglichen Nachfolger berechnet. Das ist in der Regel aufwendig, bei den allermeisten Spielen aufgrund der Anzahl der Spielm¨oglichkeiten unm¨oglich. Eine Vereinfachung kann dadurch geschehen, daß man nicht alle Bereiche des Baums durchsucht, sondern nur die wirklich n¨otigen. Eine sehr verbreitete M¨oglichkeit dazu stellt das alphabeta-Verfahren zur Verf¨ugung. Dessen Prinzip ist einfach: wenn ein Zug offensichtlich schlecht ist, braucht man nicht genau nachrechnen, wie schlecht er genau ist, da man ihn sowieso nicht nimmt. Bei der Durchsuchung des Spielbaums f¨uhrt man daher zwei Werte α und β mit. α ist der Wert, den wir auf dem Pfad zu diesem Knoten mindestens erreichen k¨onnen, wie wir aufgrund schon durchsuchter Bereiche wissen. β ist der Wert, den der Gegner mindestens erreichen kann. Es ist α ≤ β, und dieses Intervall spannt die noch interessanten Bereiche auf. An einem Knoten, an dem wir an der Reihe sind, an dem also maximiert wird, k¨onnen folgende F¨alle eintreten • ein Zug f¨uhrt zu einer Situation, die β u¨ berschreitet. Dann k¨onnen wir die Suche in diesem Knoten abbrechen, denn sie w¨are schlechter f¨ur den Gegner, als eine schon besuchte Alternative. Der Gegner w¨urde diese Variante also sowieso nicht nehmen. • liegt ein Zug im Intervall [α, β], k¨onnen wir den bisherigen α Wert auf diesen neuen, besseren Wert erh¨ohen, • liegen alle Werte unterhalb α, hat das Durchsuchen zu keinen besseren Z¨ugen gef¨uhrt. Entsprechend umgekehrt geht man an einem Knoten, an dem der Gegner an der Reihe ist, vor: • ein Zug f¨uhrt zu einer Situation, die α unterschreitet. Wir w¨urden den Gegner also nie hierher kommen lassen; die Suche in dem Knoten wird abgebrochen. • ein Zug liegt im Intervall [α, β], wir setzen β auf diesen neuen, f¨ur unseren Gegner besseren Wert. So wird sukzessive das Suchfenster eingeschr¨ankt und uninteressante Bereiche k¨onnen u¨ berschlagen werden. Ein Beispiel:

−inf12 inf

MAX MIN

−inf10 inf

MAX −inf10 inf 10 −5 3

10 12 inf

12 3 inf

−inf12 10

10 12 inf

10 13 12

12 3 inf

−6 12 cut

10 12 3

13 cut cut

3 2 −4

cut

Es werden also einige Bereiche weggeschnitten. Der erste cut (drittes Blatt) kann deswegen stattfinden, weil der Wert 12 den beta-Wert 10 u¨ berschreitet, unser Gegner wird uns also nicht zu dieser M¨oglichkeit kommen lassen, sondern den linkesten Pfad nehmen. Nach Durchsuchen des linken Teilbaums wissen wir, daß wir mindestens 10 erreichen k¨onnen, setzen also den alpha-Wert hoch. Im mittleren Teilbaum f¨uhrt der linke Ast zum Wert 12, unser Gegner wird uns also keine Wahl, die zu besseren Ergebnissen f¨uhrt, lassen. Entsprechend wird nach Erreichen der 13 abgeschnitten,

104

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

der Ast kommt nicht in Frage. Die untere Schranke verbessert sich f¨ur den rechten Ast zu 12. Wir erreichen hier im linken Teilast 3. Das ist schlechter als 12, und unser Gegner w¨urde uns nur zu etwas h¨ochstens 3 kommen lassen. Der rechte Ast kommt f¨ur uns also nicht in Frage. Mathematisch gesprochen, haben wir also die minmax-Berechnung wie folgt reduziert: max{min{max{10, −5, 3}, max{−6, 12, ?}}, min{max{10, 12, 3}, max{13, ?, ?}}, min{max{3, 2, −4}, ?}} Die Fragezeichen brauchen offensichtlich nicht ausgewertet zu werden, um das eng¨ultige Ergebnis zu bestimmen. Alpha-Beta-Verfahren liefern exakt dieselben Ergebnisse, wie das min-max Verfahren, allerdings eventuell mit erheblich weniger Aufwand. Die Effizienz h¨angt dabei sehr von der Reihenfolge ab, in der die Knoten besucht werden. Man sollte mit den Bereichen anfangen, die tendentiell f¨ur den jeweils betrachteten Spieler vielversprechend sind, da sie ein sehr fr¨uhes Einengen des Suchintervalls gestatten. In der Regel ist der Suchraum trotzdem noch sehr groß, so daß die Verfahren mit geeigneten Heuristiken kombiniert werden m¨ussen, und der Baum in der Regel nur bis zu einer gewissen Suchtiefe evolviert wird. Eine weitere Effizienzsteigerung kann dadurch erreicht werden, daß doppelte Knoten (also identische Spielsituationen an verschiedenen Stellen des Spielbaums) nicht doppelt ausgewertet werden, sondern z.B. mithilfe einer Hashtabelle gespeichert werden. Wir m¨ochten hier das Alpha-Beta-Verfahren f¨ur das Spiel Tic-Tac-Toe implementieren. Das Spielprogramm kann dann wie folgt ver¨andert werden: /* Computerzug inklusive alpha-beta Verfahren */ void set_move(){ int alpha = -2; /* I loose */ int beta = 2; /* I win */ int value; int maxi =0,maxj =0; for (int i=0;i<3;i++) for (int j=0;j<3;j++) { if (field[i][j].isempty()) { field[i][j].setme(); value = MIN(alpha,beta); field[i][j].makeempty(); if (value>alpha) {alpha = value; maxi=i;maxj=j;} } } System.out.println("Ich ziehe nach "+(maxi+1)+" "+(maxj+1)); System.out.println("Aktuelles Spielfeld: "); System.out.println(); field[maxi][maxj].setme(); } int MIN(int alpha, int beta) { int value = 2;

5.3 B¨aume

105

if (wins("me")) return(1); if (wins("you")) return(-1); if (besetzt()) return(0); for (int i=0;i<3;i++) for (int j=0;j<3;j++) { if (field[i][j].isempty()) { field[i][j].setyou(); value = MAX(alpha,beta); field[i][j].makeempty(); if (value<=alpha) return(alpha); if (value < beta) beta=value; } } return (beta); } int MAX(int alpha, int beta) { int value =-2; if (wins("me")) return(1); if (wins("you")) return(-1); if (besetzt()) return(0); for (int i=0;i<3;i++) for (int j=0;j<3;j++) { if (field[i][j].isempty()) { field[i][j].setme(); value = MIN(alpha,beta); field[i][j].makeempty(); if (value>=beta) return(beta); if (value > alpha) alpha=value; } } return (alpha); }

Zu beachten ist dabei, daß wir keine Datenstruktur, die einen Baum implementiert, ben¨otigen. Vielmehr wird implizit durch die in den Methoden MIN und MAX vorhandene Rekursion ein Spielbaum aufgebaut und (mit Unterst¨utzung des schnellen alpha-beta-Verfahrens) durchsucht. Weitere Optimierungen sind m¨oglich, wenn wir zum Beispiel die Bewertung von schon ausgewerteten Spielsituationen im Speicher vorhalten. Trotzdem ist es in der Regel so, daß eine exakte Berechnung der Werte aufgrund der Gr¨oße der B¨aume unm¨oglich ist. H¨aufig wird daher nur eine feste Anzahl Spielz¨uge in die Zukunft geschaut und die Situationen, die dann noch keine Endpositionen sind, aufgrund von Heuristiken bewertet.

106

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

5.4 Graphen B¨aume bestehen aus Knoten, die durch Eltern-Kind-Beziehungen verkn¨upft sind. Die spezielle Struktur von B¨aumen mit einer Wurzel und genau einem Elternknoten pro Kind machen es einfach, einen Baum zu traversieren, wie wir anhand des Eulertraversals gesehen haben. In der Wirklichkeit findet man h¨aufig viel schwierigere geometrische Beziehungen von einzelnen Knoten zueinander. Wir verallgemeinern daher von einem Baum zu einem Graphen: Definition 5.1 Ein Graph besteht aus einer endlichen Menge von Knoten V und einer Menge von Kanten E ⊂ V × V , die Verbindungen zwischen Knoten V repra¨ sentieren. Ein Graph ist also nichts anderes als eine M¨oglichkeit, einzelne Objekte, die Knoten, und ihre wechselseitige Beziehung, die Kanten, darzustellen. Im Gegensatz zu B¨aumen k¨onnen Knoten irgendwie verkn¨upft sein. Es gibt einige spezielle Sprechweisen: • Ein Graph hat gerichtete Kanten, sofern f¨ur Kanten (u, v) die Reihenfolge eine Rolle spielt. Bei ungerichteten Kanten wird (u, v) mit (v, u) identifiziert. • Ein Graph hat gelabelte Knoten mit Knotenlabeln in L, falls jedem Knoten v ∈ V ein Label l(v) ∈ L zugeordnet ist. Ein Graph hat gelabelte Kanten, falls jeder Kante (u, v) ∈ E ein Label l((u, v)) ∈ L zugeordnet ist. • Eine Kante heißt inzident f¨ur einen Knoten v, falls sie von der Form (u, v) oder (v, u) ist. Zwei Knoten heißen adjazent, falls sie durch eine Kante verbunden sind. • Ein Pfad ist eine alternierende Liste von Knoten und Kanten, beginnend und endend mit einem Knoten, so daß die einem Knoten vor- bzw. nachfolgende Kante zum Knoten inzident ist. Die L¨ange eines Pfades ist die Anzahl der beteiligten Kanten. Ein Pfad heißt Zyklus, falls der Anfangs- und Endknoten gleich ist. (Dieses ber¨ucksichtigt ungerichtete Kanten. F¨ur gerichtete Kanten k¨onnten man zus¨atzlich verlangen, daß die Kanten alle ‘in dieselbe Richtung’ zeigen.) • Ein Graph heißt zusammenh¨angend, falls alle zwei Knoten im Graphen durch einen Pfad verbunden werden k¨onnen. Ansonsten heißt ein Graph unzusammenh a¨ ngend. Ein Graph zerf¨allt in sogenannte Zusammenhangskomponenten, d.h. zusammenh¨angende Teilgraphen, die wechselseitig nicht durch Pfade erreichbar sind. • Ein Subgraph eines Graphen (V, E) ist ein Graph (V 0 , E 0 ), so daß V ⊂ V 0 und E ⊂ E 0 gilt. F¨ur einen aufspannenden Subgraphen gilt zus¨atzlich V = V 0 . • Eine Beobachtung ist hier interessant: wir hatten B¨aume eingef¨uhrt, die Knoten durch ElternKind Beziehung verbinden. Wir k¨onnen einen Baum als speziellen Graphen auffassen, indem wir alle Eltern-Kind-Beziehungen durch eine Kante ersetzen. Es ergibt sich so ein spezieller gerichteter Graph mit einem ausgezeichneten Knoten, der Wurzel. Der Graph ist insbesondere zusammenh¨angend und zyklenfrei. Im Zusammenhang mit Graphen gibt es einen davon abgeleiteten Begriff von B¨aumen als spezielle Graphen. Ein Baum ohne Wurzel ist definiert als zusammenh¨angender zyklenfreier Graph. Gegen¨uber unserer Definition aus dem letzten Kaptiel ist die hierarchische Anordnung der Knoten abstammend von der Wurzel in einem Baum ohne Wurzel nicht mehr gegeben. Wozu sind Graphen wichtig? Das f¨angt schon in der griechischen Mythologie an. Dort war in einem komplizierten Labyrinth Minotaurus, halb Biest, halb Mensch, versteckt. Niemand konnte ihn finden und bezwingen – bis zu Theseus (und seiner Geliebten). Dieser wurde von Ariadne

5.4 Graphen

107

mit einer antiken Implementation eines modernen Graphenalgorithmus versorgt: dem Ariadnefaden zur Markierung schon besuchter Kanten. Theseus konnte so das Biest finden und, nach dessen ¨ Uberwindung, m¨uhelos zum Ausgang in die Arme der geliebten Ariadne zur¨uckfinden. Abstrakt kann das Labyrinth als Graph mit Knoten entsprechend der Orte im Labyrinth, d.h. der Verzweigungen, und Kanten entsprechend der Wege zwischen diesen Orten aufgefasst werden. Ein zweites klassisches Beispiel ist das von Leonhard Euler gel¨oste K¨onigsberger Br¨uckenproblem: wie kann man in der Innendstadt von K¨onigsberg einen Weg finden, der jede Br¨ucke genau einmal u¨ berquert, um beim philosophischen Lustwandeln stets abwechslungreiche Ausblicke zu haben? Die Innenstadt hat dabei die folgende (leicht verzerrte) Form:

Als Graph speichert man nur die wesentliche Information: die Stadtteile als Knoten und die Br¨ucken als Verbindungen, also

Das entstandene Gebilde ist hier allerdings kein normaler Graph, sondern ein sogenannter Multigraph, bei dem mehr als eine Kante zwischen zwei Knoten liegen darf. In der obigen Definition lassen wir das nicht zu, und berauben kurzerhand die Innenstadt von K¨onigsberg um zwei Br¨ucken:

Graphen werden als Datenstruktur verwendet, um Routing Tabellen f¨ur Rechnernetze zu repr¨asentieren. Knoten sind Rechner, Switches, etc. und Kanten werden durch die Verbindungen der Rechner untereinander gegeben. Der wohl meist genutzte Graph in heutiger Zeit ist das Internet mit seinen Web-Seiten. Jede Web-Seite entspricht einem Knoten, jeder Link zwischen Web-Seiten einer Kante zwischen diesen Knoten. Browsen in Web-Seiten entspicht dem Besuchen von Wegen im durch das Internet definierten Graphen. Welche Methoden ben¨otigt man f¨ur den ad¨aquaten Umgang mit Graphen und wie kann man Graphen im Rechner darstellen? Zu einem Graphen m¨ochten wir gerne • die Anzahl der Kanten und Knoten angeben k¨onnen, • die Kanten und Knoten enumerieren k¨onnen, • zu einem gegebenen Knoten Anzahl und Enumeration der inzidenten Kanten angeben k¨onnen, • zu zwei Knoten bestimmen, ob sie adjazent sind,

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

108

• zu einer gegebenen Kante die anliegenden Knoten angeben k¨onnen, • Knoten einf¨ugen und l¨oschen k¨onnen, • Kanten einf¨ugen und l¨oschen k¨onnen. Hinzu kommen einige Operationen, wenn man gerichtete statt ungerichteter Kanten betrachtet. Wir beschr¨anken uns im Folgenden der Einfachheit halber auf ungerichtete und zun¨achst auch ungelabelte Graphen. Repr¨asentation Welche Datenstruktur kann derartige Informationen gut speichern? Je nach Art des Graphen und Verwendungszweck bieten sich verschiedene Darstellungen an: • Kantenliste: Man speichert Informationen zu Knoten und Kanten wie etwa Label getrennt in je einer Struktur (z.B. einer Liste). Welche Kanten zu welchen Knoten geh¨oren ist durch an den Kanten angeh¨orige Information gespeichert: jede Kante verweist auf die zur Kante geh¨orenden Knoten. F¨ur unser Klein-K¨onigsberg erg¨abe sich etwa die Darstellung: 1

1 2

4

2

3

(1,4)

4

(1,2)

(2,3)

(2,4)

(3,4)

3

Wir benutzen also zwei Datentypen: Knotenobjekte und Kantenobjekte, die je auf zwei Knotenobjekte verweisen. Diese Darstellung ist sehr einfach und nicht redundant. Allerdings k¨onnen nicht alle Operationen schnell implementiert werden: organisiert man die Enumerationen der Kanten und Knoten als Liste, dann ben¨otigt Aufz¨ahlen, Einf¨ugen und Ersetzen O(m) bzw. O(n) Zeitschritte, wobei n bzw. m die Anzahl der Knoten/Kanten angibt. Zu einer gegebenen Kante k¨onnen die Endknoten in O(1) angegeben werden. Die inzidenten Kanten zu einem Knoten anzugeben, verlangt, die Kantenliste komplett zu durchsuchen, also O(m). Entscheiden, ob zwei Knoten adjazent sind, verlangt dieselbe Gr¨oßenordnung. Das kann sehr aufwendig werden, da ein Graph mit n Knoten bis zu n 2 Kanten besitzen kann. • Adjazenzliste: Die Adjazenzliste f¨ugt zus¨atzliche (redundante) Information in die Darstellung, die es erlaubt, die inzidenten Kanten schneller zu enumerieren und schneller zu entscheiden, ob zwei Knoten adjazent sind. An den einzelnen Knoten werden auch die inzidenten Kanten gespeichert. Diese sind also in Zeit O(Anzahl inzidenter Kanten) erreichbar. F¨ur unser K¨onigsberger Beispiel erhalten wir: 1 2 3

4

(1,4)

(1,2)

1

3

2

(1,4)

(2,3)

(2,4)

(3,4) gleich

4

(1,2)

(2,3)

(2,4)

(3,4)

5.4 Graphen

109

Hierbei haben wir die Kantenliste doppelt gezeichnet, um die gegenseitigen Verweise nicht unn¨otig u¨ berlappen zu lassen. In dieser Form ist die Beziehung der Knoten zu den Kanten und die Zugeh¨origkeit der Kanten zu den Knoten gleich abgespeichert. Man kann schnell entscheiden, ob zwei Knoten adjazent sind, indem man die beiden zugeh¨origen Kantenlisten auf gmeinsame Elemente u¨ berpr¨uft.

• Adjazenzmatrix: Die Adjazenzmatrix erlaubt, sogar in konstanter Zeit zu entscheiden, ob zwei Knoten adjazent sind. Wir denken uns die Knoten von 1 bis n durchnummeriert. Dann werden die Kanten in einer n × n Matrix abgespeichert, wobei an der Stelle (i, j) angezeigt wird, ob eine Kante von i nach j besteht oder nicht. Im K¨onigsberger Beispiel ist das

1 2 3 4

1 − 1 − 1

2 1 − 1 1

3 − 1 − 1

4 1 1 1 −

Dieser effiziente Zugriff auf Kanten wird allerdings durch einen in der Regel vergr¨oßerten Speicherplatzbedarf bezahlt: man ben¨otigt immer O(n2 ) Speicherplatz, auch wenn die Anzahl der Kanten wesentlich geringer sein sollte. Eine Adjazenzmatrix ist daher nur bei einer kleinen Anzahl Knoten oder Graphen mit vielen Kanten zu empfehlen.

Wir implementieren hier eine Adjazenzmatrix. Wir gehen dabei davon aus, daß Knoten immer durch nat¨urliche Zahlen von 0 bis n − 1 durchnummeriert werden. Um in Bezug auf den Inhalt von Knoten (m¨ogliche Label) allgemein zu bleiben, implementieren wir eine Klasse, die die bei uns einfach nur bin¨arwertige Kanteninformation beinhaltet.

class Kante{ boolean da; Kante(){da=false;} void set(){da=true;} void unset(){da=false;} boolean istda(){ return(da);} }

Wir implementieren hier eine beschr¨ankte Klasse, die von einem Gaphen mit einer festen Anzahl an Knoten ausgeht, die nicht gel¨oscht oder zugef¨ugt werden. Dann k¨onnen wir diese Knoten einfach durchnummerieren und mit den Indizes eines Arrays identifizieren. Knoten sind bei uns also lediglich Integerzahlen, so daß wir hier keine gesonderte Klasse verwenden.

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

110

class Graph{ int n; Kante[][] kanten; Graph(int n){ this.n=n; kanten =new Kante[n][n]; for (int i=0;i
5.4 Graphen

111 if (!besucht[k]){ besucht[k]=true; System.out.println(i+" -> "+k); start search(k,0,besucht); } start search(i,k+1,besucht); } }

Diese Methode besucht alle Knoten in der Zusammenhangskomponente, in der i liegt, in einem Graphen. Wir nehmen dabei an, daß sowohl (i, j) und (j, i) als Kanten abgespeichert sind, wie in unserer Klasse der Fall. Man kann leicht durch Widerspruchsbeweis einsehn, daß wirklich alle Knoten besichtigt werden: wir nehmen an, es gibt einen nicht besuchten Knoten j. Dieser ist in der Zusammenhangskomponente enthalten, wir finden also einen Pfad von i zum Knoten j. Wir nehmen an, j sei der in diesem Pfad erste nicht besuchte Knoten. Dann ist der Vorg¨anger im Pfad besucht, und das Programm betrachtet der Reihe nach alle Nachbarn von diesem Knoten, also auch j. Widerspruch. Die Methode ben¨otigt lineare Zeit verglichen zur Anzahl der Knoten plus Kanten, denn es werden der Reihe nach nur die noch nicht besuchten Knoten und deren anliegende Kanten betrachtet. Obige Methode gibt nacheinander die Kanten aus, verm¨oge der die Knoten erreicht wurden. Sammelt man diese Kanten auf, dann haben wir tats¨achlich einen Spannbaum der Zusammenhangskomponente des Graphen erhalten. Basierend auf diesem Algorithmus k¨onnen wir sehr einfach • entscheiden, ob der Graph zusammenh¨angend ist, das ist genau dann der Fall, wenn alle Knoten in der zur¨uckgegebenen Ausgabeliste vorhanden sind; • Pfade zwischen Kanten suchen, z.B. als Teilmenge des berechneten Spannbaums; • Zyklen in der Zusammenhangskomponente erkennen, n¨amlich genau dann, wenn bei der Suche ein schon besuchter Knoten erreicht ist. Eine Alternative zur depth-first search ist breath-first-search, wobei zun¨achst alle zu einem Knoten benachbarten neuen Knoten markiert und dann sukzessive deren weitere unmittelbare und noch nicht besuchten Nachbarn untersucht werden. Dieser Algorithmus basiert auf der Vorhaltung eines Stacks der je noch zu untersuchenden Knoten, der pro Schritt w¨achst. Anstelle einer JavaImplementation beschreiben wir den Algorithmus nur im Pseudocode, startend von einer Liste noch zu besuchender Knoten: breath-first-search(liste) solange (!liste.empty()) a=liste.top(); liste.pop(); f¨ ur alle Nachbarn b von a falls (!besucht(b)) markiere b als besucht h¨ ange b hinten an die liste an Dieser Algorithmus besucht der Reihe nach alle Knoten. Er ben¨otigt genau wie depth-first-search nur lineare Zeit im Vergleich zur Anzahl Kanten und Knoten. Er hat den Vorteil, daß er auch bei (hier allerdings nicht betrachteten) unendlich großen Graphen der Reihe nach alle Knoten ausgeben w¨urde (wof¨ur er nat¨urlich unendlich lange br¨auchte). Depth-first-search w¨urde bei unendlich großen Graphen in unendlich langen Pfaden ’h¨angen’ bleiben.

112

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

Spannb¨aume Als einen weiteren wichtigen Algorithmus kommen wir zu sogenannten minimalen Spannb¨aumen. Dazu erweitern wir die Inhalte von Kanten: jede Kante (i, j) ist zus¨atzlich mit einer nichtnegativen L¨ange l(i, j) ausgestattet. Stellen Sie sich vor, n Orte (die Knoten) seien vorgegeben mit m¨oglichen Verbindungsstrecken zwischen diesen Orten (den Kanten). Etwa Computer in einem Flur mit Kabelsch¨achten und einer L¨ange der Kabelsch¨achte. Man m¨ochte alle Knoten entlang m¨oglicher Verbindungsstrecken miteinander verbinden, so daß die Gesamtverbindungsstrecke m¨oglichst klein ist, also alle Computer miteinander mit m¨oglichst wenig Kabel verbinden. Dieses ist die Frage nachP einem minimalen Spannbaum: ein Subgraph (V 0 , E 0 ) des Graphen hat die sogenannten Kosten (i,j)∈E 0 l(i, j). Wir m¨ochten m¨oglichst geringe Kosten haben, so daß alle Knoten in V 0 enthalten sind, der Graph also aufgespannt wird. Man sieht leicht, daß ein minimaler aufspannender Graph immer zyklenfrei, d.h. als Spannbaum gew¨ahlt werden kann. Wie erh¨alt man einen minimalen Spannbaum? Ein wesentlicher Schritt ist folgende Beobachtung: Theorem 5.2 Sei (V, E) ein zusammenh¨angender Graph mit gewichteten Kanten. Sei V 0 , V 00 ⊂ V mit V 0 ∩ V 00 = ∅ und V 0 ∪ V 00 = V . Sei e eine Kante von einem Knoten in V 0 zu einem Knoten in V 00 mit minimalem Gewicht l(e). Dann ist e in mindestens einem minimalem Spannbaum von E enthalten. Dieses kann durch Widerspruch bewiesen werden. Wir betrachten also solch ein minimales e und nehmen an, es sei in keinem minimalen Spannbaum enthalten. Sei ein minimaler Spannbaum gegeben. Wenn wir e zu diesem Baum hinzuf¨ugen, muß ein Zyklus mit Element e entstehen, da ja jeder Knoten von jedem anderen im Spannbaum erreichbar ist. In diesem Zyklus gibt es also eine weitere Kante von V 0 nach V 00 . F¨ur diese Kante e0 gilt l(e0 ) ≥ l(e) nach Voraussetzung. Wenn wir e0 durch e ersetzen, erhalten wir wieder einen Spannbaum, da ja e und e 0 in einem Zyklus liegen. Die Kosten dieses Spannbaums k¨onnen aber maximal so hoch wie die des betrachteten minimalen sein. Widerspruch. Ausgehend von dieser Beobachtung k¨onnen wir unser Problem l¨osen: wir starten von der leeren Menge und erweitern diese durch jeweils minimale Kanten zu einem Spannb¨aum, bis die gesamte Knotenmenge u¨ berdeckt ist. Im Pseudocode ist dieses der Algorithmus von Prim: initialisiere den Spannbaum T = ∅ solange noch nicht alles ¨ uberdeckt ist f¨ uge die g¨ unstigste Kante e = (u, v) mit u im Spannbaum, v neu hinzu Kurzeste ¨ Pfade ¨ Ahnlich zu obigem Poblem minimaler Spannb¨aume ist das Problem, in einem gegebenen Graphen k¨urzeste Pfade zu finden. Dieses taucht sehr h¨aufig in der Praxis auf, etwa wenn es sich beim Graphen um Orte und deren Entfernungen voneinander handelt, z.B. in einem Verkehrsverbund. Ein wichtiges Problem ist, f¨ur einen gegeben Ort die jeweils k¨urzeste Verbindung zu allen anderen Orten zu finden. Ein sehr bekannter Algorithmus in diesem Zusammenhang ist der Algorithmus von Dijkstra. Die Idee ist einfach: wir starten von der Menge M , die nur den Startknoten v selbst enth¨alt, zusammen mit dem Pfad (v), der bei v stehenbleibt. Die Menge wird jetzt sukzessive um Knoten (und Pfade von v zu diesen Knoten) erweitert, f¨ur die die k¨urzeste Verbindung zu v offensichtlich ist. Und zwar wird immer der Knoten zur Menge zugef¨ugt, dessen Verbindung zu v die kleinste der noch u¨ briggebliebenen Knoten ist. Diese Reihenfolge macht es sehr leicht, die Verbindung einzuschr¨anken: eine k¨urzeste Verbindung dieses Knotens muß entlang einem Pfad mit Knoten nur in M laufen. W¨are das n¨amlich nicht der Fall, dann g¨abe es einen Knoten außerhalb

5.4 Graphen

113

von M auf diesem Pfad, und dieser andere Knoten w¨are dann n¨aher an v, als der gerade betrachtete. Diese Feststellung macht es sehr einfach, die Pfade konkret zu berechnen: es wird in jedem Schritt f¨ur jeden Knoten die k¨urzeste Verbindung zu v innerhalb M berechnet und der Knoten mit minimaler Verbindung zugef¨ugt. Beim Zuf¨ugen eines Knoten zu M kann die k¨urzeste Verbindung zu v in M f¨ur alle Knoten w leicht neu berechnet werden: sie ist entweder die alte Verbindung, oder die Verbindung, die von v zum neuen Knoten und dann zu w f¨uhrt. Als Pseudocode lautet der Algorithmus folgendermaßen: (V = {v1 , . . . , vk } sei die Knotenmenge des Graphen. Die jeweils k¨urzeste Entfernung in M sei im Feld D abgespeichert, der Pfad im Feld P . Wir markieren Kanten von i zu j mit i-j) M = {v}; fuer alle i nicht in M: D[i] = Laenge der Kante von v-i, falls eine Kante existiert, sonst unendlich P[i] = (v-i), falls existent, sonst leerer Pfad while (M <> V) waehle ein j aus M\V mit minimalem D[j] fuege j zu M dazu fuer alle i nicht in M: falls D[j]+Laenge(j-i) < D[i] /* kuerzer ueber j */ D[i] = D[j]+Laenge(j-i) P[i] = (P[j],j-i) /* Pfad ueber j */ Betrachten wir als Beispiel folgenden Graphen versehen mit Kantengewichten:

1

10

100 5

30

2 50

60

10 20

4

3 Wir erhalten iterativ folgende Pfadl¨angen und Pfade von 1 zum Knoten i; endg¨ultige Pfade mit Knoten in M sind je fett gedruckt: 1 0 (1) 0 (1) 0 (1) 0 (1) 0 (1)

2 10 (1-2) 10 (1-2) 10 (1-2) 10 (1-2) 10 (1-2)

3 ∞ () 60 (1-2-3) 60 (1-2-3) 60 (1-2-3) 60 (1-2-3)

4 30 (1-3) 30 (1-4) 30 (1-4) 30 (1-4) 30 (1-4)

5 100 (1-5) 100 (1-5) 90 (1-4-5) 90 (1-4-5) 70 (1-2-3-5)

Was ist der Aufwand dieses Algorithmus? Die a¨ ußere Schleife wird n Mal durchlaufen, wenn n die Anzahl der Knoten ist. Der Aufwand jedes Durchlaufs kommt auf die Art der Implementation des Graphen an. Verwendet man eine Adjazenzmatrix, dann betrachtet man in den Durchl¨aufen n − 1, n − 2, . . . , 1 Knoten, der Aufwand ist also insgesamt O(n2 ). F¨ur sehr sp¨arlich vernetzte Graphen

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

114

mit einer Anzahl e von Kanten, die sehr viel geringer als n2 ist, kann man die Implementation effizienter gestalten. Die Gr¨oßen D[j] kann man in einem Heap entsprechend ihrer Gr¨oße speichern, wobei das kleinste Element an der Wurzel steht. F¨ur die Neuberechnung der D[j] m¨ussen lediglich diejenigen Knoten betrachtet werden, f¨ur die es eine Verbindung i − j gibt. Diese sind in einer Adjazenzliste direkt zugreifbar. Die Anzahl ist durch die Anzahl der Kanten e begrenzt. Der Aufwand zur Neuordnung des Heap ist je log n, wie wir beim Heapsort Algorithmus gesehen haben. Der Gesamtaufwand f¨ur sp¨arlich vernetzte Graphen und eine Adjazenzliste ist also O(e · log n). Ein a¨ hnliches Problem ist, f¨ur jedes Paar i und j von Knoten die k¨urzeste Verbindung zu finden. Offensichtlich kann man dieses Problem l¨osen, indem man den Dijkstra-Algorithmus f¨ur jeden Startknoten aufruft, was einen Auwand von O(n3 ) bzw. O(en · log n) bei Implementation durch eine Adjazenzliste entspricht. Eine einfache, wenn auch nicht effizientere Alternative bietet der Algorithmus von Floyd: es wird zu Beginn f¨ur jedes Paar i und j die Kante i − j mit deren Kosten (unendlich, falls die Kante nicht existiert) als Verbindung initialisiert. Es wird dann iterativ getestet, ob die Verbindung, die u¨ ber die Kante k geht, g¨unstiger ist, und gegebenfalls der Pfad umgebogen. Als Pseudocode: (D speichere die Kosten in einer Matrix, P die Pfade.) for i=1 to n for j=1 to n if i-j existiert P[i][j] = (i-j) D[i][j] = Kosten(i-j) else P[i][j] = () D[i][j] = unendlich for k = 1 to n for i = 1 to n for j = 1 to n if D[i][k]+D[k][j] < D[i][j] /* ueber k ist es guenstiger */ D[i][j] = D[i][k]+D[k][j] P[i][j] = (P[i][k]-P[k][j]) /* Pfad i nach k und k nach j */ Dieser Algorithmus hat ebenfalls den Aufwand O(n3 ), da er drei verschachtelte for-Schleifen mit je n Durchl¨aufen enth¨alt. Er besticht durch eine extrem einfache Formulierung. Der Algorithmus berechnet im kten Durchlauf der a¨ ußeren for-Schleife f¨ur alle Paare i und j den k¨urzesten Weg, der nur durch Knoten 1 bis k l¨auft, daher ist der Algorithmus in der Gesamtheit korrekt. Wir zeigen die Entwicklung der Matrix f¨ur obigen Graphen:

1 2 Start: 3 4 5

1 0 () ∞ () ∞ () ∞ () ∞ ()

2 10 (1-2) 0 () ∞ () ∞ () ∞ ()

3 ∞ () 50 (2-3) 0 () ∞ () ∞ ()

4 30 (1-4) ∞ () 20 (3-4) 0 () ∞ ()

5 100 (1-5) ∞ () 10 (3-5) 60 (4-5) 0 ()

1 2 k = 2: 3 4 5

1 0 () ∞ () ∞ () ∞ () ∞ ()

2 10 (1-2) 0 () ∞ () ∞ () ∞ ()

3 4 5 60 (1-2-3) 30 (1-4) 100 (1-5) 50 (2-3) ∞ () ∞ () 0 () 20 (3-4) 10 (3-5) ∞ () 0 () 60 (4-5) ∞ () ∞ () 0 ()

5.4 Graphen

115

1 2 k = 3: 3 4 5

1 0 () ∞ () ∞ () ∞ () ∞ ()

2 10 (1-2) 0 () ∞ () ∞ () ∞ ()

3 60 (1-2-3) 50 (2-3) 0 () ∞ () ∞ ()

4 30 (1-4) 70 (2-3-4) 20 (3-4) 0 () ∞ ()

5 70 (1-2-3-5) 60 (2-3-5) 10 (3-5) 60 (4-5) 0 ()

1 2 k = 4: 3 4 5

1 0 () ∞ () ∞ () ∞ () ∞ ()

2 10 (1-2) 0 () ∞ () ∞ () ∞ ()

3 60 (1-2-3) 50 (2-3) 0 () ∞ () ∞ ()

4 30 (1-4) 70 (2-3-4) 20 (3-4) 0 () ∞ ()

5 70 (1-2-3-5) 60 (2-3-5) 10 (3-5) 60 (4-5) 0 ()

Dieses ist die endg¨ultige Matrix. K¨onigsberg Im Zusammenhang mit Pfaden, wollen wir die L¨osung des K¨onigsberger Br¨uckenproblems nicht vorenthalten: Euler zeigte, daß es keinen Pfad geben kann, der jede Br¨ucke genau einmal abl¨auft. So ein Pfad, der jede Kante genau einmal durchl¨auft, heißt auch Eulerpfad. Wir k¨onnten dieses Problem algorithmisch l¨osen, indem wir alle m¨oglichen Pfade in dem Graphen der Maximall¨ange m aufz¨ahlen und nachpr¨ufen, daß keiner von diesen jede Kante genau einmal besucht. Euler hat eine elegantere mathematische L¨osung gefunden: betrachten wir einen Pfad im Graphen. Bis auf den Anfangs und Endknoten besitzt jeder im Pfad vorkommende Knoten eine gerade Anzahl inzidenter Kanten, denn es f¨uhrt (evtl. mehrfach) eine Kante zum und eine Kante vom Knoten. Betrachten wir die in einem Eulerpfad von K¨onigsberg (in der Originalversion mit sieben Br¨ucken) vorhandenen Kanten, das sind (1, 2), (1, 2), (2, 3), (2, 3), (2, 4), (1, 4), (3, 4) in irgendeiner Permutation. Wir sehen: 1, 3 und 4 haben eine ungerade Anzahl! Es kann also keinen Eulerpfad geben. Endliche Automaten Eine ganz andere Anwendung von Graphen ist die M¨oglichkeit, damit sogenannte endliche Automaten darzustellen. Was ist ein endlicher Automat? Stellen Sie sich darunter eine ganz einfache Maschine vor, die verschiedene Zust¨ande haben kann. Abh¨angig von einer sehr begrenzten Menge von Eingaben wechselt die Maschine ihren internen Zust¨and, sonst nichts. Ein einfaches Beispiel, ein Kugelschreiber. Dieser kann sich im Zustand befinden, wo man mit ihm schreiben kann, oder, wo die Miene nicht sichtbar ist. Die Eingabe besteht im Dr¨ucken des Knopfes. Dieses verursacht ¨ einen Ubergang vom Zustand ‘schreiben’ in ‘nicht schreiben’ bzw. umgekehrt. Als Graph erh¨alt man also folgendes Bild, das Zustands¨ubergangsdiagramm: druecken

schreiben

nicht schreiben

druecken

116

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

Offensichtlich ist dieses ein sehr einfacher Automat mit nur zwei Knoten, d.h. internen Zust¨anden, und nur einer m¨oglichen Eingabe, die zwischen den Zust¨anden wechselt. Aber schon dieser einfache Automat hat eine mathematische Funktion: er kann berechnen, ob die Anzahl der Eingaben gerade oder ungerade ist. Startend vom Zustand ‘nicht schreiben’ befindet man sich n¨amlich dann und nur dann im Zustand ‘schreiben’, wenn man eine ungerade Anzahl h¨aufig gedr¨uckt hat. Kommen wir zu einem etwas komplizierteren Automaten, einem Getr¨ankeautomaten. Wir nehmen an, man kann in dem Automaten nur ein Getr¨ank bestellen, das 50 Cent kostet. Der Automat akzeptiert 10, 20 oder 50 Cent-St¨ucke und gibt kein Wechselgeld. Die Zust¨ande des Automaten sind in folgendem Diagramm dargestellt:

10

rest: 50

50 20

rest: 40 10 rest: 30 10 rest: 20 10

rest: 10

20

50 50

20 20,50

10,20,50 rest: 0

F¨ur jeden Zustand gibt es drei m¨ogliche Eingaben, die zu Folgezust¨anden f¨uhren. Man kann u¨ ber mehrere Kombinationen von Eingaben hinweg zum gew¨unschten Zustand, an dem der Automat mindestens 50 Cent erhalten hat und das Getr¨ank ausgibt, kommen, im Graphen als ‘rest: 0’ bezeichnet. Wir haben hier zwei weitere Besonderheiten eingef¨uhrt: ein Pfeil zeigt von Außen auf den obersten Zustand. Dieses soll bedeuten, daß wir in diesem Zustand das System starten, es ist der Startzustand. Der unterste Zustand ist doppelt umrandet, und es f¨uhren von dort keine weiteren Pfeile weg. Es ist ein Endzustand, in dem das System terminiert, und in unserem Fall der Automat ein Getr¨ank ausgeben w¨urde. Dieses ist ein typisches Beispiel eines technischen Systems, das sehr elegant durch solch einen Zustands¨ubergangsgraphen beschrieben wird. H¨aufig sind dabei Zus¨atze n¨otig, die wir hier vermieden haben, wie etwa eine Ausgabe des Automaten (etwa Geldr¨uckgabe). Ein weiteres Beispiel: Ein Bauer steht mit einem Sack Korn, einem Fuchs und einer Gans an einem Fluß und m¨ochte alle Dinge in einem Boot auf die andere Seite transportieren. Allerdings paßt je nur ein Gegenstand (neben dem Bauern) ins Boot. Er muß also mehrfach fahren. Das Problem ist dabei, daß die Gans, sobald alleine gelassen, das Korn fressen wird, ebenso macht sich der Fuchs u¨ ber die Gans her, sobald er ohne Aufsicht ist. Was tut der Bauer? Wir stellen die Situation durch ein Zustands¨ubergangsdiagramm dar, das die je an der linken/rechten Seite des Flusses befindlichen Gegenst¨ande repr¨asentiert sowie die Aktionen, die der Bauer in den einzelnen Situationen durchf¨uhren kann. Wir erhalten so:

5.4 Graphen

117

{} {b,f,g,k} {b,f,g,k} {} g

g

g

{b,g} {f,k}

{f,k} {b,g} b

g

g f

b

{k} {b,f,g}

k

g

f

{b,f,k} {g}

k

{b,g,k} {f}

k {f} {b,k,g}

{g} {b,f,k}

f

g

k

b

b

{b,f,g} {k}

f

g

Dabei sind nur wenige Aktionen, m¨oglich: ein Transportieren von Fuchs (f), Gans (g), Korn (k), bzw. der Bauer kann eine Leerfahrt (b) unternehmen, so daß nichts gefressen wird. Anhand dieser Darstellung sehen wir sofort: die k¨urzeste M¨oglichkeit, den gew¨unschten Endzustand zu erreichen, beinhaltet sieben Bootsfahrten. Es gibt dabei zwei prinzipiell verschiedene M¨oglichkeiten, entspre¨ chend der zwei k¨urzesten Aste vom Startzustand zum Endzustand. Der Bauer kann die L¨osung allerdings erheblich l¨anger gestalten, indem er Gegenst¨ande nutzlos u¨ ber den Fluß transportiert. Im Gegensatz zu obigen Automatendiagrammen hat dieses eine weitere Besonderheit: bestimmte Aktionen sind in bestimmten Zust¨anden nicht m¨oglich, etwa, Korn im Zustand zu transportieren, wo Fuchs und Gans auf einer Seite sind. Ein weiteres Automatendiagramm: wir lesen einen Text ein, und m¨ochten wissen, ob das Wort ‘ebay’ oder ‘web’enthalten ist. Ein ganz einfacher nichtdeterministischer Automat, der dieses leistet, ist der folgende:

b

e

e

a eb

eba

lese

da! w

*

y

w

we

b

e

*

Der Ausdruck * steht dabei f¨ur einen beliebigen Buchstaben. Dieser Automat ist indeterministisch, d.h. bei Einlesen des Zeichens e oder b kann er den Startzustand lese wechseln, muß aber nicht. Was n¨utzt uns das f¨ur das Suchen der W¨orter ebay oder web? Nun, es gibt mindestens eine M o¨ glichkeit von Zustands¨uberg¨angen, die, falls eins der W¨orter im Text ist, in den Endzustand u¨ berf¨uhrt wird; kommt keins der W¨orter vor, bleiben wir vorher stecken. Diese Eigenschaft ist offensichtlich, und das Zustands¨ubergangsdiagramm zu zeichnen, ist sehr einfach. Allerdings n¨utzt uns das wenig, wenn wir ein Programm schreiben wollen, das die W¨orter sucht: woher sollen wir wissen, in welchen der Folgezust¨ande wir gehen sollen? An dieser Stelle m¨ochten wir den Begriff von Automaten etwas theoretischer beleuchten. Definition 5.3 Ein (indeterministischer) endlicher Automat besteht aus • einer endlichen Menge von Zust¨anden Z = {z1 , . . . , zn }

118

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

• einem ausgezeichneten Startzustand zs ∈ Z und einer Menge von Endzust¨anden Ze ⊂ Z, • einer endlichen Menge von Eingabezeichen A = {a1 , . . . , am }, • einer Menge von Produktionsregeln der Form zi aj → zk f¨ur zi , zk ∈ Z und aj ∈ A. Dieses Bild ist in Zustands¨ubergangsdiagrammen aufgezeichnet: Zust¨ande entsprechen Knoten, Startknoten und Endknoten sind gesondert markiert, die Eingaben entsprechen an Pfeilen stehenden Symbolen, jede Produktion zi aj → zk entspricht einem von zi nach zk f¨uhrenden und mit aj markierten Pfeil. So ein Automat dient dazu, bestimmte Prozesse zu modellieren. Es stellt sich heraus, daß wichtige Eigenschaften des Automaten anhand der sogenannten von ihm erzeugten Sprache untersucht werden k¨onnen. Die von einem Automaten erzeugte Sprache sind alle die Symbolfolgen, deren Eingabe und sukzessive Abarbeitung mit dem Automaten im Zustands¨ubergangsdiagramm vom Startzustand zu einem Endzustand f¨uhrt. Es darf dabei mehrere m¨ogliche Endzust¨ande geben. (Das haben wir bisher in unseren Diagrammen nicht ben¨otigt.) Die erzeugten W¨orter kann man als zul¨assige bzw. gesuchte Operationsfolgen bei der Interaktion mit dem Automaten auffassen: beim Colaautomaten die Bedienungsfolgen, die dazu f¨uhren, daß wir ein Getr¨ank aus dem Automaten bekommen; beim Bauer die Folgen, die dazu f¨uhren, daß alle Objekte auf die andere Seite transportiert werden; beim Suchen von W¨ortern alle die Texte mit ebay oder web als Teilwort. Formal ist dieses wie folgt definiert: Definition 5.4 Die von einem Automaten erzeugte Sprache besteht aus allen W o¨ rtern a = ai1 . . . aik u¨ ber A, so daß die Abarbeitung von a startend mit dem Startzustand im Automaten zu einem Endzustand f¨uhrt, d.h. es gibt Zust¨ande zj0 , . . . , zjk mit zj0 = zs , zjk ∈ Ze und Produktionsregeln zjk−1 aik → zjk f¨ur alle k ≥ 1. In der Regel sind wir nicht so sehr am Automaten selbst interessiert, sondern an dessen Ergebnis, d.h. der von ihm erzeugten Sprache. Wir definieren daher: Definition 5.5 Zwei Automaten heißen a¨ quivalent, falls sie dieselbe Sprache erzeugen. Eine kurze Zwischenbemerkung: wir haben die Erzeugung von W¨ortern durch Produktionsregeln schon bei EBNF-Grammatiken kennengelernt. Ein Automat entspricht der EBNF-Grammatik mit Startsymbol S, EBNF-Regeln S ::= z f¨ur alle z ∈ Ze , z ::= z 0 a f¨ur alle Produktionsregeln z 0 a → z im Automaten und z ::= a f¨ur alle zs a → z im Automaten, wobei zs der Startzustand ist. Dieses rollt den Automaten quasi von hinten auf: ausgehend vo einem Endzustand darf man all die Symbole hinzuf¨ugen, die als Label auf einem Pfad im Zustands¨ubergangsgraphen stehen. Kommen wir zur¨uck zu unserem anf¨anglichen Automaten, der ebay und web erkennt. Die von ihm erzeugte Sprache sind alle Texte, die eines der beiden W¨orter enthalten; nur leider ist dieser Automat indeterministisch in dem Sinn, daß wir nicht wissen, wohin wir ausgehend vom Startzustand bei Eingabe eines e oder w gehen sollen. Folgt bay bzw. eb, sollten wir den Startzustand verlassen, um das folgende Wort zu erkennen. Folgt es nicht, enden wir beim Verlassen des Zustands in einem der Zwischenknoten, ohne je zum Ende zu kommen. Da wir keine hellseherischen F¨ahigkeiten besitzen, versuchen wir, das Problem auf klassische Weise zu l¨osen. Zun¨achst die theoretischen Aspekte: Wir sind an solchen Automaten interessiert, wo dieses Problem nicht auftaucht, sogenannten deterministischen endlichen Automaten. Definition 5.6 Ein deterministischer endlicher Automat ist ein endlicher Automat, so daß es f u¨ r jedes Tupel (s, a) ∈ S × A genau eine Produktion sa → a0 gibt. In deterministischen Automaten wissen wir also, wohin wir uns wenden m¨ussen, wenn wir ein Symbol einlesen: es gibt genau einen Folgezustand, der mit diesem Symbol markiert ist. Wir setzen

5.4 Graphen

119

kurz q 0 := δ(q, a) falls qa → q 0 im Automaten gilt. Offensichtlich k¨onnen wir δ als Funktion sehen, die jedem Tupel genau einen Folgezustand zuordnet. Eine bemerkenswerte Tatsache ist die folgende: Theorem 5.7 Zu jedem indeterministischen endlichen Automaten gibt es einen a¨ quivalenten deterministischen. Der Beweis benutzt die sogenannte Teilmengenkonstruktion von B¨uchi: sei ein indeterministischer endlicher Automat mit Zust¨anden Z, Startzustand zs , Endzustand ze , Eingabezeichen A und Produktionsmenge Π gegeben. Wir definieren einen neuen deterministischen Automaten mit • Z 0 ist die Potenzmenge von Z, d.h. die Menge aller Teilmengen von Z, • Startzustand ist {zs }, • Endzust¨ande Ze0 sind alle Teilmengen in Z, die einen Endzustand aus Ze enthalten, • die Eingabezeichen sind, wie f¨ur den original Automaten, A, • Produktionen sind von der Form M a → M 0 f¨ur M ⊂ Z, d.h. M ∈ Z 0 und a ∈ A mit M 0 := {z 0 ∈ Z | ∃z ∈ M za → z 0 ∈ Π}. Es gehen also die Menge M und das Symbol a auf die Menge aller Zust¨ande, die durch ein Element aus M und a erreicht werden k¨onnten. Dieses ordnet offensichtlich jedem Tupel M und a genau eine Menge M 0 zu, die evtl. leer sein kann oder auch viele Elemente enthalten kann, je nach Ausgangsautomaten. Es muß jetzt gezeigt werden, daß die von den Automaten erzeugte Sprache identisch ist. Dazu zeigen wir durch Induktion u¨ ber die L¨ange des Wortes y u¨ ber A: startend von einem Zustand M ∈ Z 0 wird y zur Menge M 0 u¨ berf¨uhrt, die aus allen Zust¨anden in Z besteht, die man durch Start in einem z ∈ M und Abarbeitung von y im original Automaten erreicht. • |y| = 0: ohne Eingabe bleibt man im Zustand selbst, die Aussage ist offensichtlich. • |y| ≥ 1: sei y = ay 0 mit einem Buchstaben a und Restwort y 0 . Nach Definition von den Produktionsregeln im neuen Automaten wird M durch Abarbeitung von a zur Menge M 00 aller Zust¨ande u¨ berf¨uhrt, die im original Automaten ausgehend von einem Zustand von M und a erreichbar sind. Nach Induktionsvoraussetzung wird diese Menge unter Abarbeitung von y 0 weiter zu all denen Zust¨anden verarbeitet, die von einem Zustand aus M 00 und y 0 erreichbar sind. H¨angt man diese beiden Schritte hintereinander, erh¨alt man die Induktionsbehauptung. Die Aussage folgt jetzt sofort, wenn man den Spezialfall der Startmenge {z s } f¨ur M einsetzt. Denn die Finalmenge Ze0 sammelt dann die Abarbeitungssequenzen auf, die im original Automaten unter mindestens einer Wahl der Rechnung zu einem Endzustand gef¨uhrt h¨atten. Zu bemerken ist, daß dieser Beweis, obwohl etwas theoretisch, konstruktiv ist: er gibt zu einem indeterministischen Automaten einen a¨ quivalenten deterministischen an, d.h. wir k¨onnten die Konstruktion benutzen, um zu einem gegebenen indeterministischen Automaten einen deterministischen zu finden. Schauen wir uns dieses f¨ur einen kleinen Automaten an: er soll xx oder u im Text finden. Nichtdeterministisch erhalten wir das wie folgt:

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

120 x

x

x *

ende

start u *

*\{x,u} x {start}

*\{x,u}

u

*\{u}

x

{start,x}

{start,x,ende}

u

u

{start,ende}

x

*\{x}

Der daraus konstruierte deterministische Automat ist ebenfalls angegeben. Wir haben dabei einige Zust¨ande weggelassen (die Zust¨ande {}, {ende}, {x} und {x, ende}), da sie nie vom Startzustand aus erreicht werden. Der a¨ quivalente deterministische Automat ist hier nur unwesentlich gr¨oßer, als der deterministische. Wir k¨onnten ihn sogar noch weiter vereinfachen, ohne die akzeptierte Sprache zu a¨ ndern: wir k¨onnten die beiden Zust¨ande, die ende beinhalten, zu einem einizgen zusammenfassen. Es wird allerdings ein Nachteil der Konstruktion deutlich: h¨atten wir uns streng ans Schema gehalten und alle Zust¨ande aufgezeichnet, h¨atten wir alle Teilmengen der drei Originalzust¨ande erhalten, das sind sieben St¨uck. Bei wachsender Anzahl von Zust¨anden w¨achst die Anzahl der Teilmengen exponentiell schnell, die aus indeterministischen Automaten erzeugten deterministischen Automaten k¨onnen also sehr groß werden. Aus diesem Grund ist es sinnvoll, auch die Formulierung indeterministischer Automaten zuzulassen, da sie z.B. bei der Suche von Teilw¨ortern eine sehr elegante und kompakte M¨oglichkeit der Darstellung offerieren. Die Idee, zu Teilmengen u¨ berzugehen, kann aber sp¨ater zur Implementation von indeterministischen Automaten genutzt werden, wie wir sehen werden. Kommen wir zum Schluß zur Implementation von Automaten. Wir m¨ochten ein Programm schreiben, daß f¨ur einen Automaten und ein gegebenes Wort entscheidet, ob das Wort in der vom Automaten erzeugten Sprache liegt; wir m¨ussen also im Wesentlichen angefangen vom Startzustand die Buchstaben sukzessive abarbeiten und testen, ob ein Finalzustand erreicht wurde. Dabei ¨ h¨angt die Ubergangsfunktion, die einen Zustand zum n¨achsten u¨ berf¨uhrt, und der Anfangs- und Endzustand vom gegebenen Automaten ab. Sind diese allerdings fest, findet die Akzeptanz eines Wortes immer auf die gleiche Weise statt. Um dieses sehr einfach zu implementieren, benutzen wir ein Konzept von Java, das wir noch nicht kennengelernt haben: abstrakte Klassen. Abstrakte Klassen in Java sind dazu da, abstrakte Konzepte effizient zu implementieren. Ein abstraktes Konzept ist etwa eine Zahl. Zahlen kann man addieren, multiplizieren, subtrahieren, etc. Allerdings gibt es keine allgemeine Zahl, sie ist ein abstraktes Konzept. Im Rechner gibt es nur konkrete Zahlen, z.B. long, int, short. Diese konkreten Konzepte sind Realisierungen der abstrakten Klasse, die die tats¨achlichen Anzahl Bits und die genaue Darstellung realisieren. Sie benutzen aber alle dieselbe Form f¨ur einige Methoden, und man kann f¨ur alle konkreten Zahldarstellungen z.B. den Euklidischen Algorithmus implementieren, ohne die genaue Realisierung der Zahlen zu kennen, also auf abstrakter Ebene. Eine abstrakte Klasse in Java ist durch das Schl¨usselwort

5.4 Graphen

121

abstract vor der Klasse gekennzeichnet. Eine abstrakte Klasse hat die Eigenschaft, daß man keine Instanzen dieser Klasse bilden darf. Java meldet bei dem Versuch, eine abstrakte Klasse zu instanziieren, einen Fehler. Eine abstrakte Klasse darf abstrakte Methoden beinhalten. Das sind Methoden, f¨ur die der Kopf und also die Parameter festgelegt sind, deren Rumpf aber leer ist, die also nicht implementiert sind. Dieses sind in der Regel Methoden, die von der konkreten Realisierung des abstrakten Konzepts abh¨angig sind. Als ein Beispiel ist etwa die Division von ganzen Zahlen und double verschieden implementiert, aber deren Aufruf identisch. Man darf abstrakte Methoden in der Klasse selbst und in anderen Methoden von anderen Klassen verwenden. Was n¨utzen abstrakte Klassen? Sie k¨onnen vererben. Insbesondere kann man also von einem abstrakten Konzept, das die Grundlagen impelementiert, aber die Details, die sich nach der konkreten Auspr¨agung richten, offen l¨aßt, eine konkrete Klasse, die alle Implementationen liefert, ableiten. Eine von einer abstrakten Klasse abgeleitete Klasse muß alle noch nicht implementierten (abstrakten) Methoden u¨ berschreiben und implementieren, sonst ist sie selbst abstrakt (letzteres ist erlaubt, nur kann man dann auch von der Unterklasse keine Instanzen erzeugen). Im Fall von einem Automaten benutzen wir solch eine abstrakte Klasse, um das allgemeine Konzept, aus der Zustands¨ubergangsfunktion die Erkennung von W¨ortern abzuleiten, zu implementieren. In folgendem Programm sind auch zwei konkrete Automaten angegeben, die diese Klasse implementieren: der erste Automat testet, ob die Anzahl x im Wort gerade ist, indem er bei jedem gelesenen x, startend vom Zustand 0, in den Zustand 1 bzw. 0 wechselt. Der zweite Automat testet, ob im Wort mindestens einmal eine Folge von genau 7 y enthalten ist. Dieser Automat charakterisiert seine Zust¨ande durch zwei Variablen: einen Z¨ahler, der die Anzahl der in diesem Block bereits gelesenen y z¨ahlt, und einen bin¨aren Wert, der sich merkt, ob man sich innerhalb oder außerhalb eines y-Block befindet. Bei jedem neuen Betreten eines y-Block springt dieser auf 1, und die Anzahl y wird zur¨uckgesetzt. Eine Kleinigkeit: ab 8 y stoppen wir das Z¨ahlen. Das ist eigentlich nicht n¨otig (außer bei sehr vielen y und der Gefahr, daß wir Under-/Overflow erhalten), sondern aus formalen Gr¨unden geschehen: die Zust¨ande sind in diesem Automaten durch das Tupel (state1,state2) charakterisiert. W¨urden wir nicht ab 8 stoppen, w¨urden wir unendlich viele verschiedene Zust¨ande erhalten, was bei einem endlichen Automaten nicht zugelassen ist. 20 Der dritte implementierte Automat realisiert direkt die Zustands¨ubergangsfunktion durch Fallabfrage (also durch Speichern der Tabelle, die jedem Zustand und Eingabezeichen den Folgezustand zuweist). Dabei d¨urfen nur a, b und c eingegeben werden, und es gibt nur 3 Zust¨ande. abstract class automat{ abstract void init(); /* setzt den Startzustand */ abstract boolean next(char a); /* setzt Folgezustand bei Buchstaben a, liefert false, falls unzulaessig */ abstract boolean isfinalstate(); /* true, falls Endzustand erreicht */ boolean acceptword(String word){ char[] a = word.toCharArray(); init(); for (int i=0;i
Da Z¨ahlen sehr nat¨urlich ist und h¨aufig vorkommt, erweitert man endliche Automaten in der Praxis oft um Zustandsz¨ahler.

122

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

} } class xautomat extends automat{ /* Automat testet, ob eine gerade Anzahl x vorkommt */ private int state =0; void init(){ state=0;} boolean next(char a){ if (a==’x’) state++; state = state%2; return true; } boolean isfinalstate(){ if (state==0) return true; return false; } } class yautomat extends automat{ /* Automat testet, ob (genau) 7 y hintereinander vorkommen */ private int state1 = 0; /* Anzahl der gelesenen y */ private int state2 = 0; /* beim y-lesen oder nicht */ private int state3 = 0; /* schonmal genau 7 y gelesen */ void init(){state1 = 0; state2 = 0; state3 = 0;} boolean next(char a){ if (a==’y’){ if (state2==0){ state1=1; state2=1;} else {state1++; if (state1>8) state1=8;} } else{ state2=0; if (state1==7) state3=1; } return(true); } boolean isfinalstate(){ if (state1==7||state3==1) return true; return false; } } class abcautomat extends automat{ /* Automat mit Uebergangsfunktion, nimmt nur die Zeichen abc */ private int state = 0; void init(){state=0;} boolean next(char a){ switch (state){ case 0: switch (a){ case ’a’: state = 0; break;

5.4 Graphen

123 case ’b’: state = 1; break; case ’c’: state = 2; break; default: return false; } break; case 1: switch (a){ case ’a’: state case ’b’: state case ’c’: state default: return } break; default: switch (a){ case ’a’: state case ’b’: state case ’c’: state default: return } break; } return true;

= 1; break; = 0; break; = 2; break; false;

= 1; break; = 2; break; = 0; break; false;

} boolean isfinalstate() { if (state==0) return false; return true; } }

class mainmethode{ public static void main(String args[]){ xautomat xa = new xautomat(); yautomat ya = new yautomat(); abcautomat abc = new abcautomat(); if (xa.acceptword(args[0])) System.out.println("eine gerade Anzahl x"); if (ya.acceptword(args[0])) System.out.println("genau 7 y hintereinander"); if (abc.acceptword(args[0])) System.out.println("abc ist ok"); } } Die Implementation eines randomisierten Automaten ist etwas schwieriger. Das Problem hierbei ist, daß man sich in jedem Schritt ja alle m¨oglichen Folgezust¨ande merken muß, die in Frage k¨amen, um nach Abarbeitung des Wortes zu entscheiden, ob wenigstens eine der M¨ogliochkeiten zu einem Finalzustand gef¨uhrt h¨atte. Wir implementieren den indeterministischen Automaten zur Erkennung von ebay und web basierend auf der abstrakten Klasse automat. Die Idee ist, je einen Vektor vorzuhalten, dessen L¨ange der Anzahl der Zust¨ande entspricht. Der Vektor ist an der Stelle i true dann und nur dann, wenn der Zustand Nummer i im aktuellen Schritt erreicht

124

¨ ABSTRAKTE DATENTYPEN 5 ALGORITHMEN FUR

werden kann. Wir merken uns also die Teilmenge aller erreichbaren Zust¨ande in diesem Vektor. Folgezust¨ande erhalten wir, indem wir f¨ur jeden Zustand in diesem Vektor die m¨oglichen Folge¨ zust¨ande berechnen. Die Berechnung eines Ubergangsschritts hat jetzt also einen Aufwand, der proportional zur Anzahl der Zust¨ande ist. class webautomat extends automat{ private boolean[] zustandsvektor; /* moegliche folgezustaende */ /* Reihenfolge: lese,e,eb,eba,w,we,da */ webautomat(){ zustandsvektor = new boolean[7]; } void init(){ for (int i=1;i<7;i++) zustandsvektor[i]=false; zustandsvektor[0]=true; } boolean next(char a){ boolean[] hilfsvektor = new boolean[7]; for (int i=0;i<7;i++) hilfsvektor[i]=false; if (zustandsvektor[0]) hilfsvektor[0]=true; if (zustandsvektor[0]&&a==’e’) hilfsvektor[1]=true; if (zustandsvektor[0]&&a==’w’) hilfsvektor[4]=true; if (zustandsvektor[1]&&a==’b’) hilfsvektor[2]=true; if (zustandsvektor[2]&&a==’a’) hilfsvektor[3]=true; if (zustandsvektor[3]&&a==’y’) hilfsvektor[6]=true; if (zustandsvektor[4]&&a==’e’) hilfsvektor[5]=true; if (zustandsvektor[5]&&a==’b’) hilfsvektor[6]=true; if (zustandsvektor[6]) hilfsvektor[6]=true; for (int i=0;i<7;i++) zustandsvektor[i]=hilfsvektor[i]; return true; } boolean isfinalstate() { return (zustandsvektor[6]); } } Eine Bemerkung an dieser Stelle zu Java: neben dem Konzept der abstrakten Klassen, das wir hier benutzt haben, gibt es das verwandte Konzept der Interfaces. Ein Interface kann, genau wie eine abstrakte Klasse, nicht instanziiert werden. Ein Interface enth¨alt u¨ berhaupt keine implementierten Methoden oder Felder (daher darf man die Markierung abstract vor den Methoden hier weglassen), nur Methodenk¨opfe f¨ur noch zu implementierende Methoden und evtl. Konstanten, die durch static und final gekennzeichnet sind. Interfaces haben einen wesentlichen Unterschied zu abstrakten Klassen: sie k¨onnen vererben, wobei Mehrfachvererbung zugelassen ist. Das heißt, eine Klasse kann so viele Interfaces implementieren, wie sie m¨ochte. Damit sind die Einschr¨ankungen an in Interfaces enthaltenen Programmcode n¨otig, denn es darf zu keinen Konflikten kommen, wenn zwei Interfaces dieselben Methoden verwenden. Da diese Methoden beide in der Unterklasse durch eine Implementation realisiert werden, kann es zu keinen Problemen kommen. Dieses w¨are anders, wenn man (wie etwa in C++ ) Mehrfachvererbung bei Klassen zuließe und evtl. zwei verschiedene Implementationen einer Methode vorliegen k¨onnen.

5.4 Graphen

125

Ein Interface wird durch das Schl¨usselwort interface gekennzeichnet. Eine Klasse (auch abstrakt), die von einem Interface erbt, markiert dieses durch die Kennzeichnung implements. Eine Klasse ist notwendigerweise wieder abstrakt, wenn nicht alle Methoden des Interface implementiert werden. Interfaces sind in der Regel dazu gut, die Schnittstellen f¨ur Methoden und Pro¨ gramme zu deklarieren. Der Ubergang zu abstrakten Klassen ist dabei fließend. Abstrakte Klassen verwendet man in der Regel, wenn einige Implementationen auf der Basis von abstrakten Konzepten fest liegen, aber einige Grundlagen sich a¨ ndern k¨onnen, also f¨ur die effiziente Umsetzung von vielen verschiedenen fast gleichen Klassen. Interfaces stehen f¨ur abstrakte Konzepte, die an verschiedenen Stellen benutzt werden k¨onnen. Wir haben bei der Implementation unserer Automaten als Eingaben nur char zugelassen. Wir wollen dieses a¨ ndern: Sequenzen von Strings sollen eingegeben werden d¨urfen, diese werden umgewandelt in Zahlen, die die Eingabezeichen durchnummerieren. Ein Interface k¨onnte diese Schnittstelle zur Verf¨ugung stellen: interface buchstaben{ int[] convert(String[] was); } abstract class automat{ abstract void init(); /* setzt den Startzustand */ abstract boolean next(int a); /* setzt Folgezustand bei Buchstaben a, liefert false, falls unzulaessig */ abstract boolean isfinalstate(); /* true, falls Endzustand erreicht */ boolean acceptword(int[] a){ init(); for (int i=0;i
6 ALGORITHMENENTWURF

126

if (was[i].equals("x")) wasint[i]=0; else wasint[i]=1; return wasint; } } class mainmethode{ public static void main(String args[]){ xautomat xa = new xautomat(); if (xa.acceptword(xa.convert(args))) System.out.println("eine gerade Anzahl x"); } } Die Implementation eines abstrakten Automaten hat mit der Konvertierung der eingelesenen Zeichen in eine Buchstabenkette nichts zu tun. Ein einzelner Automat aber schon, da er die zul¨assigen Zeichen kennt und die Umwandlung in Integer vornehmen muß. Das kann man durch die Einf¨uhrung eines Interface realisieren, das nur vom konkreten Automaten implementiert werden muß. Dieses bietet auch eine elegante M¨oglichkeit, das bisher sehr einfache Interface z.B. zu einer aufwendigen Benutzeroberfl¨ache, wo die Zeichen eingelesen und korrigiert werden k¨onnen, zu erweitern. Zu beachten ist: Methoden eines Interface sind public (sie m¨ussen ja u¨ berschrieben werden k¨onnen), so daß sie bei der Implementation als public deklariert werden m¨ussen. Ein anderer Bereich, wo Interfaces angebracht sind, ist bei Sortierprogrammen: wir haben dort immer zwei Klassen benutzt, eine Klasse, die die zu sortierenden Elemente enth¨alt, und eine Klas¨ se, die darauf aufbauend Felder dieser Elemente sortiert. Bei der Anderung der Inhalte mußten wir bisher die Klasse, die sortiert, ebenfalls neu u¨ bersetzen. Dieses k¨onnten wir uns sparen, wenn wir die Inhalte als Interface und die Klasse, die sortiert, als abstrakte Klasse realisieren. Dann w¨urde ¨ je nur die finale Klasse, die die Elemente realisiert und die Sortiermethode erbt, bei Anderung der Inhalte u¨ bersetzt werden m¨ussen.

6 Algorithmenentwurf Wir m¨ochten hier einen abstrakten Blick auf die Algorithmen werfen. Eine wichtige Frage ist: wie bekommt man gute Algorithmen? Abgesehen von viel Erfahrung gibt es einige prinzipielle Schemata bzw. Entwurfparadigmen, die in einigen Situationen zum Erfolg f¨uhren k¨onnen.

6.1 Divide and Conquer Divide and Conquer – teile und herrsche, das war schon ein erfolgreiches Prinzip alter r¨omischer Feldherren. Im Algorithmenentwurf bedeutet dieses, ein Problem in mehrere Teilprobleme zu zerlegen, diese zuerst (in der Regel rekursiv) zu l¨osen, und dann eine Gesamtl¨osung aus den Teill¨osungen zu konstruieren. Wir haben dieses Prinzip etwa beim Sortieren schon kennengelernt: der Mergesort-Algorithmus sortiert zuerst (rekursiv) die linke und rechte H¨alfte des gegebenen Felds (divide) und mischt die Ergebnisse zu einer Gesamtl¨osung zusammen (and conquer). In a¨ hnlicher Weise ist Quicksort als Implementation solch eines Verfahrens interpretierbar. Es ist klar, daß nicht jedes Problem in einfachere Teilprobleme zerlegt werden kann. Aber es gibt Beispiele, wo dieses Verfahren gegen¨uber naiven direkten L¨osungen sogar wesentliche Laufzeitvorteile erm¨oglicht.

6.2 Dynamische Programmierung

127

Ein Beispiel: die Multiplikation von zwei Bin¨arzahlen der L¨ange n. Nach Grundschulart w¨urden wir etwa zwei achtstellige Bin¨arzahlen wie folgt multiplizieren:

+ + + +

11010110 01011011 11010110 110101100 11010110000 110101100000 11010110000000 100110000010010

Man ben¨otigt etwa O(n2 ) Operationen, wenn n die L¨ange der Zahlen ist, denn f¨ur jedes Bit der einen Zahl schreiben wir die andere Zahl versetzt auf. Wir versuchen es anders, durch divide and conquer: wir zerlegen die beiden Zahlen in einen ersten und gleich großen zweiten Teil, also (abstrakt) x ist x1 x2 , y ist y1 y2 , wobei die einzelnen Teilfolgen je k Bits beinhalten. Also x = x1 · 2k + x2 und y = y1 · 2k + y2 . Dann ist x · y = x1 · y1 · 22k + (x1 · y2 + x2 · y1 ) · 2k + x2 · y2 = x1 · y1 · 22k − (x1 − x2 ) · (y1 − y2 ) · 2k + (x2 · y2 + x1 · y1 ) · 2k + x2 · y2 Die letzte Zeile enth¨alt drei verschiedene Multiplikationsterme: x1 ·y1 , x2 ·y2 und (x1 −x2 )·(y1 −y2 ). Die Zahlen in diesen Termen sind dabei nur k = n/2 Bits lang. Sei A(n) der Aufwand, zwei Zahlen mit n Bits zu multiplizieren. Dann bekommen wir, wenn wir das Produkt mit der zweiten Formel berechnen, die Rekursionsgleichung A(n) = 3 · A(n/2) + O(n). Der Faktor O(n) ber¨ucksichtigt die Multiplikation mit 2k bzw. 22k , was einem Bitshift u¨ ber maximal n Zeichen entspricht, und die Addition der einzelnen Ergebnisse, die eine konstante Anzahl Zahlen mit O(n) Ziffern addiert. A(1) ist konstant. Diese Rekursionsgleichung f¨uhrt zum Aufwand A(n) = O(nlog 3/ log 2 ) = O(n1.5849... ). (Beweis: Sei > 0 beliebig klein, und nehmen wir an, der Term O(n) k¨onne durch c · n begrenzt werden. W¨ahlen wir dann c 0 = c/(1 − (1/2) ), dann finden wir A(n) ≤ c0 · nlog 3/ log 2+ , denn A(n) ≤ 3 · A(n/2) + c · n ≤ 3 · c0 · (n/2)log 3/ log 2+ + c · n ≤ 3c0 nlog 3/ log 2+ · (c/c0 + (1/2) ) = 3c0 nlog 3/ log 2+ . Da beliebig klein gew¨ahlt werden darf, folgt die Behauptung.) Wir haben also durch dieses Prinzip die Effizienz des Verfahrens verbessern k¨onnen gegen¨uber einer direkten Implementation. Weitere Beispiele f¨ur dieses Prinzip kann man z.B. f¨ur die Multiplikation von Matrizen (Verfahren von Strassen) finden, welches in a¨ hnlicher Weise Matrizen zun¨achst in vier Teilmatrizen zerlegt und dann kombiniert.

6.2 Dynamische Programmierung Nicht immer ist eine rekursive L¨osung die effizienteste. Insbesondere, wenn bei der Rekursion viele Teilaufgaben doppelt aufgerufen w¨urden, sollte man eine andere Variante w¨ahlen. Ein einfaches Besipiel: die Fibonaccizahlen sind definiert als A0 = 0, A1 = 1, An+2 = An + An+1 . Das gibt offensichtlich eine einfache rekursive Strategie, die Zahlen zu berechnen: Um A n+2 zu berechnen, kann eine Methode rekursiv An und An+1 aufrufen: int fib(int i){ if (i<1) return 0;

6 ALGORITHMENENTWURF

128 if (i==1) return 1; return(fib(i-1)+fib(i-2)); }

Das f¨uhrt allerdings dazu, daß in jedem rekursiven Schritt eine weitere Verzweigung auftritt, man also f¨ur die Berechnung exponentiell viele Additionen auswerten muß. Offensichtlich berechnet man viele Terme dabei doppelt, denn es gibt ja prinzipiell nur n Fibonaccizahlen kleiner als A n . Eine wesentlich effizientere (lineare) iterative Variante ist daher int fib(){ if (max<1) return 0; if (max==1) return 1; int[] help = new int[max+1]; help[0]=0; help[1]=1; for (int j=2;j<=max;j++){help[j]=help[j-1]+help[j-2];} return help[max]; } Ein wichtiges Prinzip, daß bei der Berechnung optimaler L¨osungen von Problemen h¨aufig Verwendung findet und auf einer a¨ hlichen Beobachtung beruht, ist die dynamische Programmierung. Wir erkl¨aren das an einem Beispiel. Ein bekanntes Problem ist das Rucksackproblem: Ein Rucksack mit maximal zul¨assigem Gewicht K ist so zu bef¨ullen, das die eingepackten Gegenst¨ande maximalen Wert haben, aber das Gesamtgewicht nicht u¨ berschritten wird. Nehmen wir an, es d¨urfen 10 kg eingepackt werden, zur Auswahl steht: 1. eine Karte (Nutzen 10, Gewicht 1), 2. ein Kompaß (Nutzen 10, Gewicht 1), 3. eine Regenjacke (Nutzen 5, Gewicht 2) 4. Wasser (Nutzen 14, Gewicht 3) 5. Essen (Nutzen 14, Gewicht 3) 6. Streichh¨olzer (Nutzen 3, Gewicht 0) 7. eine Taschenlampe (Nutzen 5, Gewicht 1) 8. Verbandszeug (Nutzen 8, Gewicht 2) 9. ein Java-Handbuch ( Nutzen 1, Gewicht 4) 10. ein Laptop (Nutzen 1, Gewicht 6) 11. ein Stofftier (Nutzen 2, Gewicht 1) (Wir benutzen nur ganzzahlige Gewichte.) Was tun? Es sei ni der Nutzen des Gegenstands i, und wi sein Gewicht. Es sei Ni (k) der Nutzen, wenn wir alle Gegenst¨ande 1 . . . i betrachten und den Rucksack optimal bepackt haben, wobei K das zul¨assige Gesamtgewicht ist. Dann gilt Ni (K) = max{Ni−1 (K), Ni−1 (K − wi ) + ni } denn wir k¨onnen den Gegenstand i entweder nicht einpacken (erster Fall) oder einpacken (zweiter Fall). Diese Gleichung nennt sich auch Bellmann Gleichung, und sie taucht in a¨ hnlicher Form bei

6.2 Dynamische Programmierung

129

vielen Optimierungsproblemen auf. Wir sind offensichtlich interessiert an N 11 (10), dem maximal erreichbaren Nutzen, wenn wir alle Gegenst¨ande und das zul¨assige Gesamtgewicht betrachten. Wir k¨onnen obige Gleichung verwenden, um eine rekursive L¨osung zu implementieren. Allerdings besteht hier genau wie bei den Fibonaccizahlen das Problem, daß die Anzahl rekursiver Aufrufe exponentiell mit der Anzahl der Gegenst¨ande w¨achst. Wir k¨onnen aber denselben Trick wie bei den Fibonaccizahlen anwenden: offensichtlich kann man die Gr¨oße F i (k) aus den Gr¨oßen Fj (k 0 ) f¨ur j < i bestimmen. Wir berechnen daher diese Gr¨oßen iterativ in einer Matrix, startend von i = 0, bis wir an der gew¨unschten Gr¨oße angekommen sind. Der Aufwand reduziert sich dann zu O(n·K) statt O(2n ), falls n die Anzahl der Gegenst¨ande und K das zul¨assige Gesamtgewicht sind. Dieses Prinzip nennt sich dynamische Programmierung: wird bei rekursiven Programmaufruf auf eine (geringe, d.h. polynomielle) Anzahl von Teilproblemen mehrfach zur¨uckgegriffen, dann ist es h¨aufig effizienter, diese Teilprobleml¨osungen dynamisch zu generieren und zu speichern, so daß sukzessive alle Teilprobleme bis hin zur L¨osung erzeugt werden. F¨ur unseren Rucksack erhielten wir die folgende Matrix: (11 Gegenst¨ande, Maximalgewicht 10) 0 1 0 2 0 3 0 4 0 5 0 6 0 7 0 8 0 9 0 10 0

1 10 10 10 10 10 10 10 10 10 10

2 10 20 20 20 20 20 20 20 20 20

3 10 20 20 25 25 25 25 25 25 25

4 10 20 20 25 34 34 39 39 39 39

5 10 20 20 25 34 34 39 48 48 53

6 13 23 23 28 37 37 42 51 51 56

7 13 23 28 28 37 42 42 51 56 56

8 13 23 28 31 37 42 45 51 56 59

9 13 23 28 31 37 42 45 51 56 59

10 13 23 28 31 37 42 45 51 56 59

11 13 23 28 31 37 42 45 51 56 59

Der Pfad zum Optimum f¨uhrt dabei u¨ ber (fett) Karte, Kompass, Wasser, Essen, Streichh¨olzer und Verbandszeug. Java-Handbuch und Laptop bleiben zu Hause, und auch Stofftier, Regenjacke und Taschenlampe m¨ussen dran glauben. Als Programm: class element{ int wert=0; int gewicht=0; String name=""; } abstract class rucksack{ int n; int K; element[] elements; rucksack(int n,int K){ this.n = n; this.K = K; elements = new element[n+1]; for (int i=1;i<=n;i++) elements[i] = new element(); } void print_matrix(int[][] matrix)

6 ALGORITHMENENTWURF

130 {

for (int j=1;j<=K;j++) { for (int i=1;i<=n;i++) System.out.print(matrix[i][j]+" & "); System.out.println(); } } void print_solution(int[][] matrix) { int i=n; int j=K; while (i>0) { if (matrix[i][j]!=matrix[i-1][j]) { System.out.print(elements[i].name); j = j-elements[i].gewicht; } i=i-1; System.out.println(" i,j: "+i+" "+j); } } int find_solution(){ int[][] matrix = new int[n+1][K+1]; for (int j=1;j<=K;j++) matrix[0][j]=0; for (int i=1;i<=n;i++) for (int j=1;j<=K;j++) { matrix[i][j] = matrix[i-1][j]; if ((j-elements[i].gewicht>=0)&& (matrix[i-1][j-elements[i].gewicht]+elements[i].wert >matrix[i][j])) matrix[i][j]= matrix[i-1][j-elements[i].gewicht] +elements[i].wert; } print_matrix(matrix); print_solution(matrix); return matrix[n][K]; } } class krams extends rucksack{ static int n=11; static int K=10; krams(){ super(11,10); elements[1].wert=10; elements[1].gewicht=1; elements[1].name="Karte";

6.3 Greedy-Verfahren

131 elements[2].wert=10; elements[2].gewicht=1; elements[2].name="Kompass"; elements[3].wert=5; elements[3].gewicht=2; elements[3].name="Regenjacke"; elements[4].wert=14; elements[4].gewicht=3; elements[4].name="Wasser"; elements[5].wert=14; elements[5].gewicht=3; elements[5].name="Essen"; elements[6].wert=3; elements[6].gewicht=0; elements[6].name="Streichhoelzer"; elements[7].wert=5; elements[7].gewicht=1; elements[7].name="Taschenlampe"; elements[8].wert=8; elements[8].gewicht=2; elements[8].name="Verbandzeug"; elements[9].wert=1; elements[9].gewicht=4; elements[9].name="Java-Handbuch"; elements[10].wert=1; elements[10].gewicht=6; elements[10].name="Laptop"; elements[11].wert=2; elements[11].gewicht=1; elements[11].name="Stofftier";

} } class mainmethode{ public static void main(String[] args) { krams backpack = new krams(); backpack.find_solution(); } } Dynamische Programmierung haben wir tats¨achlich bereits beim Algorithmus von Floyd zur Bestimmung aller k¨urzesten Verbindungen von allen Knotenpaaren in einem Graphen benutzt. Die Gr¨oße D[i][j] im kten Schritt speichert dabei den jeweils k¨urzesten Pfad von i nach j nur u¨ ber Knoten von 1 bis k, wir setzen dieses als Dk [i][j], um es deutlich zu machen. Es gilt dann die Bellmann-Ungleichung Dk+1 [i][j] = min{Dk [i][j], Dk [i][k] + Dk [k][j]}, denn der k¨urzeste u¨ ber k f¨uhrende Weg setzt sich aus dem k¨urzesten Weg von i nach k und k nach j zusammen. Diese Gr¨oßen werden im Floyd-Algorithmus induktiv u¨ ber k in einer Matrix berechnet.

6.3 Greedy-Verfahren Greedy bedeutet gierig. Wir m¨ochten wieder optimale L¨osungen finden. Wir halten aber nicht viel von Rekursion oder dynamischem Programmieren, sondern m¨ochten uns auf ganz einfache Verfahren beschr¨anken. Greedy-Verfahren k¨onnen verwandt werden, um aus Einzelbausteinen eine L¨osung iterativ zusammenzubauen. Nehmen wir als Beispiel wieder das Rucksackproblem: eine L¨osung besteht aus allen im Rucksack befindlichen Objekten. Tendentiell sind wertvolle Objekte gut, wir packen sie ein (wenn sie noch in den Rucksack passen), weniger wertvolle Objekte m¨ussen warten. Dieses f¨uhrt uns auf ein ‘gieriges’ Verfahren: wir packen immer das Objekt ein, das noch in den Rucksack passt und maximalen Wert hat, bis der Rucksack voll ist. (Ein solches Verfahren

132

6 ALGORITHMENENTWURF

w¨urden z.B. Menschen beim Kofferpacken verwenden, wenn sie wenig Zet haben, weil in f¨unf Minuten der Zug f¨ahrt . . . ) Als Pseudocode w¨are also ein Greedy-Verfahren f¨ur das Rucksackpacken wie folgt:

M = alle Gegenstaende solange Rucksack noch nicht voll waehle wertvollsten Gegenstand aus M falls er in den Rucksack passt, tue ihn dazu, sonst weglegen

Dieses ist offensichtlich ein sehr kurzer und einleuchtender Algorithmus. Was liefert er? Wir packen nacheinander ein: Wasser, Essen, Karte, Kompaß, Verbandszeug, Streichh¨olzer, und wir erhalten unsere optimale Rucksackbepackung mit diesem einfachen Algorithmus! Greedy-Verfahren sind h¨aufig gut und immer schnell und einfach zu implementieren. Allerdings finden sie oft nicht die beste L¨osung, sondern nur eine ziemlich gute (und in manchen F¨allen auch eine ziemlich schlechte. . . ). H¨atten wir etwa folgende Gegenst¨ande zur Verf¨ugung: Schokolade (die Riesentafel, Gewicht 9, Nutzen 5), M¨usliriegel (Gewicht 4, Nutzen 4), Kekse (Gewicht 3, Nutzen 3), Erdbeeren (Gewicht 2, Nutzen 2), Kaugummi (Gewicht 1, Nutzen 1), dann w¨urde der Greedy Algorithmus Schokolade und Kaugummi einpacken, Nutzen 6. Dynamisches Programmieren h¨atte die optimale L¨osung, bestehend aus M¨uslireigeln, Keksen, Erdbeeren und Kaugummi mit Nutzen 10 gefunden. Es ist also im Allgemeinen nicht sichergestellt, daß mit einem Greedy Algorithmus die optimale L¨osung gefunden wird (anders als bei dynamischem Programmieren). Nichtsdestotrotz sind Greedy Verfahren aufgrund ihrer Schnelligkeit und einfachen Implementation oft n¨utzlich, wenn man an ganz guten (nicht unbedingt optimalen) L¨osungen interessiert ist. Es gibt Probleme, wo man zeigen kann, daß ein Greedy Verfahren sogar optimal ist. Tats¨achlich haben wir das schon benutzt: der Algorithmus von Dijkstra ist ein Greedy Verfahren, das garantiert die k¨urzesten Verbindungen von einem Knoten im Graphen zu allen anderen liefert. Was haben wir beim Dijkstra-Algorithmus gemacht? Wir waren gierig (oder besser gesagt geizig, da es hier um Minimierung geht), und haben jeweils den Knoten hinzugef¨ugt, der bezogen auf die schon konstruierten Pfade minimale L¨ange hat. Es liegt am speziellen Problem, daß wir hier damit auch die tats¨achlich optimalen Pfade finden.

6.4 Backtracking Kommen wir wieder zu unserem Rucksackproblem zur¨uck. Wir stellen das Problem jetzt etwas anders: wir m¨ochten wissen, ob wir eine Bepackung mit Wert mindestens 10 finden k¨onnen. Wir haben im Algorithmus Wahlm¨oglichkeiten: wir k¨onnen das wertvollste Objekt wie im Greedy Algorithmus oder irgendein anderes Objekt, das noch hereinpaßt, hinzuf¨ugen. Es ensteht folgender Baum von m¨oglichen Optionen (wir haben hier die m¨oglichen Erweiterungen des Rucksackinhalts dem Wert der Elemente nach geordnet, und große Teile des Baums weggelassen, angedeutet durch Punkte):

6.5 Randomisierte Verfahren

133 {}

{Schoko}

{Schoko,Kaugummi}

{Muesli}

{Kekse} ...

{Muesli,Kekse}

{Muesli,Kekse,Erdbeere}

{Muesli,Kekse,Erdbeere,Kaugummi}

{Erdbeere} ...

{Muesli,Erdbeere} ...

{Kaugummi} ... {Muesli,Kaugummi} ...

{Muesli,Kekse,Kaugummi}

{Muesli,Kekse,Kaugummi,Erdbeere}

Der erste Versuch (der linkeste Pfad, der beim Greedy Algorithmus begangen wird), hat nicht zum Erfolg gef¨uhrt. Wir wissen aber, daß wir andere M¨oglichkeiten gehabt h¨atten. Backtracking ist das Verfahren, bei Versuchen, die nicht zum Ziel f¨uhren, den letzten Zug zur¨uckzunehmen und den n¨achsten auszuprobieren, bis ein Erfolg eintritt, oder der Baum vollst¨andig durchsucht ist. Backtracking ist also Tiefensuche (Eulertraversal) im Baum der m¨oglichen Abl¨aufe. Im Fall von unserem Rucksack w¨urde schon der zweite Versuch durch Backtracking zum Erfolg f¨uhren, es w¨are also ein sehr effizientes Verfahren. Da allerdings solche B¨aume sehr groß (sogar unendlich groß) werden k¨onnen, ist beim Backtracking eine gute Strategie, in welcher Reihenfolge die m¨oglichen Schritte angeorndet sind, sehr relevant. Eine Anordnung nach einem Greedy Kriterium ist h¨aufig n¨utzlich. Zudem ist es h¨aufig sehr n¨utzlich, Teile des Baums, die nicht mehr erfolgreich sein k¨onnen, fr¨uhzeitig wegzulassen (branch and bound Verfahren, a¨ hnlich der alpha-beta Suche bei Spielb¨aumen). Backtracking wird h¨aufig in Kombination mit Greedy Verfahren und geeigneten Suchstrategien f¨ur den Baum bei sogenannten NP-vollst¨andigen Problemen angewandt, also Problemen, bei denen man alle m¨oglichen L¨osungsans¨atze aufz¨ahlen muß.

6.5 Randomisierte Verfahren Randomisierte Verfahren sind Algorithmen, die Zufallskomponenten enthalten, deren Verlauf also nicht immer gleich ist.21 Was soll das n¨utzen? Stellen Sie sich etwa vor, Sie versuchen durch Backtracking, eine L¨osung zu finden, und kommen nach geraumer Zeit nicht zu einem Ergebnis. Wenn Sie die Suche im Baum irgendwann einfach abbrechen, k¨onnen Sie zwar nicht wirklich sicher sein, daß es keine L¨osung gibt. Aber Sie wissen es mit einer gewissen Wahrscheinlichkeit, die umso gr¨oßer ist, je mehr M¨oglichkeiten Sie ausprobiert haben. Dieses ist tats¨achlich von großer Bedeutung in einem f¨ur die Verschl¨usselung von Nachrichten wichtigen Problem: dem Finden und Testen von Primzahlen. 2002 wurde zwar ein relativ einfacher polynomieller Algorithmus zum Testen von Primzahlen gefunden, aber er hat noch einen relativ hohen Koeffizienten (12) und ist daher in der Praxis ungeeignet (und lange Zeit war kein deterministischer polynomieller Algorithmus u¨ berhaupt bekannt). Es gibt aber sehr wohl (schon 21

Eine Anmerkung: wir haben bereits randomisierte Automaten kennengelernt, die eine sehr elegante Formulierung z.B. von Suchen von W¨ortern in Texten erm¨oglichen. Unsere Implementation, mithilfe solch eines Automaten Texte zu suchen, war aber deterministisch, da wir gleichzeitig alle M¨oglichkeiten des Automaten ausprobiert haben. Randomisierte Algorithmen probieren dagegen nur einige M¨oglichkeiten aus.

134

6 ALGORITHMENENTWURF

l¨anger) effiziente randomisierte Algorithmen, die mit sehr hoher Wahrscheinlichkeit sagen k¨onnen, ob eine Zahl eine Primzahl ist (und die z.B. bei u¨ blichen PCs verwandt werden, um Nachrichten verschl¨usselt z.B. beim e-commerce und Internet-banking zu u¨ bermitteln; der Netscape Communicator oder das Programmpaket PGP (pretty good privacy) benutzen dieses; zu sogenannten public key Kryptographieverfahren kommen wir sp¨ater noch, wenn wir uns abstrakt um den Informationsbegriff k¨ummern). Folgender Satz (der sogenannte ‘kleine Fermat’) aus der Zahlentheorie bildet die Grundlage eines probabilistischen Primzahltests: Theorem 6.1 Eine Zahl n ist dann und nur dann Primzahl, wenn gilt a n−1 gibt beim Teilen durch n den Rest 1 f¨ur alle 0 < a < n. Wir k¨onnen also testen, ob eine Zahl Primzahl ist, indem wir f¨ur alle diese Werte a den Rest beim Teilen durch n berechnen. Da das ganz sch¨on viele sind, begn¨ugt man sich damit, wenige zuf¨allige a auszuw¨ahlen und die Eigenschaft nur f¨ur diese zu testen. Dabei gibt es einige Randf¨alle, die man auf jeden Fall ausschließen sollte: gerade Zahlen (offensichtlich) oder sogenannte Carmichael Zahlen, welche die unangenehme Eigenschaft haben, sich fast wie Primzahlen zu verhalten, ohne wirklich welche zu sein. Folgender Pseudoalgorithmus wird verwendet: waehle a in {2..n-1} zufaellig aus falls ggt(a,n)<> 1 oder n gerade: keine Primzahl falls aˆ(n-1) beim Teilen durch n nicht 1 gibt: keine Primzahl fuer alle d>0 mit 2ˆd teilt (n-1) /* zusaetzliche Tests aˆ((n-1)/2ˆd) */ falls 1 < ggT(n,aˆ((n-1)/2ˆd)-1
6.6 Nebenl¨aufigkeit

135

6.6 Nebenl¨aufigkeit Algorithmen k¨onnen sequentiell ablaufen, d.h. die Reihenfolge der Anweisungen (die evtl. randomisiert sein k¨onnen) ist von vorneherein festgelegt, oder sie k¨onnen Nebenl a¨ ufigkeit (concurrency) beinhalten, d.h. die Reihenfolge einiger Anweisungen ist nicht festgelegt und darf variiert werden. Das heißt im Prinzip: die Anweisungen werden in mehrere Bl¨ocke zerhackt und einige der Bl¨ocke laufen gleichzeitog. Dieses erlaubt eine ad¨aquate Modellierung von vielen Algorithmen, bei denen im Prinzip viele gleichberechtigte Aktionen nebeneinander laufen: Etwa die Implementation von Benutzeroberfl¨achen, wo der Benutzer irgendwann einen Button dr¨uckt, ein Fenster schließt, in mehreren Fendstern gleichzeitig arbeitet, Druckauftr¨age weggeschickt werden, aufwendige Rechenprozesse im Hintergrund laufen, etc. Parallel dazu l¨adt das System etwa eine Datei aus dem Internet, spielt eine MP3 Datei ab, und aktiviert nach einigen Minuten ohne Benutzerinteraktion den Bildschirmschoner. Es finden also gleichzeitig mehrere unabh¨angige Aktionsfolgen statt. Nebenl¨aufigkeit erlaubt einerseits, sehr elegant Programmteile, die nichts oder wenig miteinander zu tun haben, unabh¨angig voneinander zu implementieren. Zweitens gestattet es die Parallelisierung von Programmen, sofern mehr als ein Prozessor zur Verf¨ugung steht, da nebenl¨aufige Prozesse unabh¨angig voneinander auf unterschiedlichen Prozessoren/Maschinen gerechnet werden k¨onnen. Finden obige Aktionen also auf einem Multiprozessorrechner statt, k¨onnte sich ein Prozessur nur um das Dekodieren der aus dem Internet geladenen Datei k¨ummern, ein weiterer um den Bildschirmschoner, etc. und das System ist insgesamt schneller. Auf einem EinprozessorSystem muß allerdings die Reihenfolge irgendwie (in der Regel vom System) festgelegt werden. Probleme kann es dabei geben, sofern mehrere dieser Aktionen dieselben Resourcen ben¨otigen, etwa mehrere Aktionen gleichzeitig auf dieselbe Datei zugreifen und diese a¨ ndern wollen. In diesen F¨allen sind geeignete Vorsichtsmechanismen zur Synchronisation der Aktionen n¨otig. Nebenl¨aufigkeit beinhaltet also die folgenden wesentlichen Aspekte: • Nebenl¨aufigkeit bedeutet, daß Programmteile unabh¨angig voneinander abgearbeitet werden, die Reihenfolge der Abarbeitung ist nicht festgelegt und kann gleichzeitig auf mehreren Prozessoren (oder sogar verteilt u¨ ber das Internet) geschehen; • bei der Sequentialisierung nebenl¨aufiger Anweisungsfolgen m¨ussen nur die Anweisungsfolgen innerhalb eines Anweisungsblocks nacheinander ausgef¨uhrt werden, unabh¨angige nebenl¨aufige Prozesse d¨urfen beliebig verzahnt werden; das gestattet, gleichzeitig mehrere unabh¨angige Programmbl¨ocke zu modelieren; • diese Verzahnung kann sich von Lauf zu Lauf unterscheiden; das Ergebnis eines Programms ist nicht notwendig reproduzierbar, wenn die Reihenfolge der Aktionen das Ergebnis beeinflußt; • unterschiedliche Ergebnisse des Programms treten insbesondere bei Schreib-/Schreib- und Schreib-/Lese-Konflikten auf, wenn auf dieselben Resourcen zugegriffen und diese durch die Aktionen verschieden kopiert/gel¨oscht/. . . werden; • es k¨onnen je nach Sequentialisierung unterschiedliche Probleme/Fehler auftreten; die Sequentialisierung und Verifikation nebenl¨aufiger Programme ist nicht unbedingt einfach und erfordert vertiefte weitere Techniken. Wir sind damit schon bei Problemen der Nebenl¨aufigkeit angelangt. Ein Beispiel hierf¨ur, wie es etwa in einem Betriebssystem auftreten k¨onnte: es sind vier Fenster ge¨offnet. Gleichzeitig laufen in den Fenstern die folgenden Aktionen: 1. herunterladen der Datei a (groß) aus dem Internet

6 ALGORITHMENENTWURF

136 2. drucken der Datei b (ebenfalls groß) 3. editieren der Datei c 4. l¨oschen der Datei d

Die Aktionen k¨onnen je etwas l¨anger dauern, und werden parallel bedient: es werden gleichzeitig in 1) neu geladene Daten von a gespeichert, in 2) weitere Sequenzen von b zum Drucker geschickt, in 3) die Datei c angezeigt und in 4) die Speicherzellen der Datei d ver¨andert. Probleme gibt es allerdings, wenn ein oder mehrere der Dateien a,b,c,d identisch sind. Je nach Sequentialisierung kann es dann sein, daß zun¨achst die Datei heruntergeladen, dann gedruckt, dann ge¨andert, dann gel¨oscht wird, oder auch erst heruntergeladen, dann gel¨oscht, drucken liefert dann einen Fehler. Es muß also in jedem Fall sichergestellt werden, daß es zu keinen Konflikten kommt, etwa im Editor eine Datei angezeigt wird, die es gar nicht mehr gibt. Threads in Java: Das Feld der nebenl¨aufigen Programmierung ist sehr weit und komplex, so daß wir hier nur auf ein paar Grundz¨uge eingehen. Das geschieht im Zusammenhang von Threads in Java. In Java gibt es einerseits die Notation nebenl¨aufiger Prozesse, die unabh¨angige Anweisungsfolgen in verschiedenen Namensr¨aumen f¨ur Variablen und Methoden bezeichnen. Andererseits gibt es innerhalb eines einzelnen Programmes oder Programmpaketes angesiedelte parallele F¨aden‘, ’ sogenannte Threads, die unabh¨angig voneinander parallel ausgef¨uhrt werden. Threads sind Objekte, d.h. integraler Bestandteil von Java-Programmen; jedes Java-Programm besteht aus einem oder mehreren Threads. Prinzipiell gibt es zwei M¨oglichkeiten, Threads zu erzeugen, die Implementation des Interface Runnable, oder die Ableitung von der Klasse Thread, die ihrerseits eine Implementation von Runnable darstellt. Wir betrachten hier nur die zweite M¨oglichkeit. Threads besitzen unter anderem • eine run-Methode, die sagt, was w¨ahrend des Ausf¨uhrens des Thread geschieht und automa¨ tisch durch das System aufgerufen wird; eigene Threads implementiert man durch Uberladen der Methode run, • eine start-Methode, die einen Thread startet, so daß das System ihn durch run ausf¨uhren kann. Das reicht schon aus, erste nebenl¨aufige Aktionen zu implementieren: class StringThread extends Thread{ private String text; StringThread(String text){ this.text=text; } public void run(){ for (int i=0;i<10;i++) System.out.println(text); } static public void main(String[] args){ StringThread ping= new StringThread("piff"); StringThread pong= new StringThread("paff"); ping.start(); pong.start(); for (int i=0;i<10;i++) System.out.println("puff");

6.6 Nebenl¨aufigkeit

137

} } Die Ausgabe dieses Programms h¨angt sehr von Ihrem System ab. Es kann sein, daß zuerst der Hauptthread seine Methode abschließt, man also hintereinander erst nur puff, dann piff, dann paff erh¨alt. Das kann aber, je nach Realisierung auch gemixt ausgegeben werden. Intern ist es so, daß gleichzeitig das der Thread des Hauptprogramms und die beiden selbstdefinierten Threads Zeit beanspruchen, und die JVM intern entscheidet, wer als erstes an die Reihe kommt. F¨ur Threads gibt es weitere Methoden, die den Umgang mit Threads erm¨oglichen, unter anderem: • eine sleep-Methode, die den Thread eine gewisse Zeit warten l¨aßt: ping.sleep(10) l¨aßt den Thread ping 10 Zeiteinheiten warten; • eine join-Methode, die auf das Zuendegehen eines Thread wartet: ping.join() sorgt daf¨ur, daß erst bei Beendigung von ping an dieser Stelle weitergemacht wird; • eine yield-Methode, die den Thread kurzzeitig unterbricht, um andere Threads zum Zuge kommen zu lassen. • getpriority, welches die Priorit¨at des Prozesses ausgibt, • setpriotity, welches die Priorit¨at setzt, • setname und getname, welches Namen abfragen/setzen, • die Konstanten MIN PRIORITY 1, MAX PRIORITY 10 und NORMPRIORITY 5 (diese Konstanten sind static) • currentThread liefert den gerade aktuellen Thread (static). Ein Beispiel: die folgende Methode started zwei Threads, die mit unterschiedlicher Frequenz ping und pong ausgeben. class StringThread extends Thread{ private String text; private int intervall; StringThread(String text, int intervall){ this.text=text; this.intervall=intervall; } StringThread(String text){ this(text,(int)(10*Math.random())); } public void run(){ while (true){ try{ sleep(intervall); } catch (InterruptedException ie) {

6 ALGORITHMENENTWURF

138

System.out.println("Interrupt"); } System.out.print(text); } } } class mainmethode{ static public void main(String[] args){ StringThread ping= new StringThread("ping ",3); StringThread pong= new StringThread("pong ",5); ping.start(); pong.start(); } } Dieses Programm started die beiden Threads und f¨uhrt zur Ausgabe ping pong ping pong ping ping pong .... Die beiden Thread werden also simultan ausgef¨uhrt, wobei immer, wenn einer der Threads noch schl¨aft, der andere die Gelegenheit zur Ausgabe besitzt. Es kann dabei prinzipiell zu dem Fall kommen, daß beide Threads gleichzeitig aktiv werden k¨onnten. Dann l¨ost die Java Virtual Machine dieses Problem, indem zuf¨allig einer der beiden Threads bevorzugt wird. Welcher das ist, h¨angt genau wie beim obigen Beispiel von der Implementation der JVM ab. In der Regel werden Threads mit h¨oherer Priorit¨at bevorzugt behandelt, so verschiedene Priorit¨aten gesetzt sind. Eine kleine Besonderheit: wir haben hier sogenannte Exceptions benutzt, die im Kapitel Fehlerbehandlung erl¨autert werden. Bei der Methode sleep k¨onnen evtl. Fehler bzw. Besonderheiten der Art InterruptedException w¨ahrend ihrer Abarbeitung auftreten. Diese m¨ussen entweder weitergeleitet oder aufgefangen werden, letzteres durch try und catch. Diese Ausnahme tritt auf, wenn f¨ur den Prozeß die Methode interrupt aufgerufen wird. Dieses ist eine Methode, einen noch laufenden Thread zu benachrichtigen, gegebenenfalls zu beenden. Ein Beispiel: class Stoerenfried extends Thread{ private int intervall = 10000; public void run(){ while (true){ try{ sleep(intervall); } catch (InterruptedException ie) { System.out.println("bla"); } if (Thread.currentThread()==this) Thread.currentThread().interrupt(); } } } Wird dieser Thread aufgerufen, dann schickt er sich selbst (als laufendem Thread) ein Interrupt, reagiert also, solange er am Zug ist, mit der R¨uckmeldung bla; erst, wenn zuf¨allig vor der Umset-

6.6 Nebenl¨aufigkeit

139

zung dieses Interrupts ein anderer Prozeß zum Zuge kommt, geht es weiter. Andere Prozeße st¨oren k¨onnte man mit einem St¨orenfried, der f¨ur sie Interrupts aufruft, wie folgt: class Stoerenfried extends Thread{ private int intervall = 42; private Thread wen; Stoerenfried(Thread wen){ this.wen=wen; } public void run(){ while (true){ try{ sleep(intervall); } catch (InterruptedException ie) { System.out.println("Interrupt"); } wen.interrupt(); } } }

class mainmethode{ static public void main(String[] args){ StringThread ping= new StringThread("ping ",3); StringThread pong= new StringThread("pong ",5); Stoerenfried villy = new Stoerenfried(ping); Stoerenfried alex = new Stoerenfried(pong); ping.start(); pong.start(); villy.start(); alex.start(); } } Hier erhalten wir als Ergebnis die Folge ping pong ping ping pong ping pong ping ping ... regelm¨aßig unterbrochen mit den Meldungen, daß ping bzw. pong unterbrochen wurden. Prinzipiell kann ein Interrupt etwa dazu eingesetzt werden, einen Thread zu beenden. Dazu m¨ußte statt der Zeile System.out.println(¨ Interrupt"); ein return stehen. Threads haben prinzipiell folgende Zust¨ande: • vorhanden, d.h. mit new erzeugt • bereit, d.h. start wurde aufgerufen, aber noch keine Zeit allokiert und als run noch nicht vom System aufgerufen • laufend, d.h. im run • blockiert, d.h. in sleep, oder auf irgendeine Eingabe oder ein Ereignis (z.B. durch join) wartend

6 ALGORITHMENENTWURF

140

• wartend darauf, daß dem Thread weitere Zeit bereitgestellt wird, • fertig. Dabei unterscheiden sich die beiden ersten Zust¨ande nur unwesentlich aus der Sicht des Nutzers. Als Bild erh¨alt man (zusammen mit noch einigen hier nich explizit genannten Methoden) das folgende Zustands¨ubergramm:

Threads, die lange laufen und nicht im wartenden Zustand sind, sollten k¨unstlich um geeignete yield erweitert werden, da sie sonst das System blockieren k¨onnen. Als Beispiel: class StringThread extends Thread{ private String text; private int intervall; StringThread(String text, int intervall){ this.text=text; this.intervall=intervall; } StringThread(String text){ this(text,(int)(10*Math.random())); } public void run(){ while (true){ if (intervall>0) { try{ sleep(intervall); } catch (InterruptedException ie) {

6.6 Nebenl¨aufigkeit

141 System.out.println("Interrupt"); } } System.out.print(text); }

} } class mainmethode{ static public void main(String[] args){ StringThread ping= new StringThread("ping ",3); StringThread pong= new StringThread("pong ",0); ping.start(); pong.start(); } } pong schl¨aft hier gar nicht und kann ping blockieren. Das Einf¨ugen eines yield a¨ ndert das. Dabei ist yield eine rein heuristische Anmerkung, die der JVM anzeigt, daß jetzt mal jemand aneres an die Reihe kommen k¨onnte. Je nach Implementation der JVM kann dieses n¨otig sein, oder auch gar keinen Effekt haben. Scheduling: Wie l¨ost die JVM die Allokation von Zeit an die einzelnen Threads? Prinzipiell melden sich alle Threads, die aktuell Speicherplatz ben¨otigen, und werden in eine Warteschlange geschrieben. Aus dieser Schlange wird je einem Thread Rechenzeit zur Verf¨ugung gestellt. Dies Zeit sollte dabei so verteilt werden, daß • jeder Prozeß drankommt • die verf¨ugbare Rechenzeit voll ausgenutzt wird • Prozesse, die mit Benutzern interagieren, m¨oglichst schnelle R¨uckmeldungen geben • m¨oglichst viele Prozesse pro Zeit fertig werden • die Verteilung der Rechenzeit einen m¨oglichst kleinen Overhead beansprucht Diese Bedingungen sind wiederspr¨uchlich, und unterschiedliche Strategien k¨onnen implementiert werden: • Round robin: Jedem Job wird in der Reihenfolge seines Auftretens in der Warteschlange eine bestimmt Zeit zugeteilt, danach wird der Job (auch vorzeitig) angehalten, und der n¨achste Job kommt dran. Gut: fair, jeder kommt dran, schlecht: evtl. viel zus¨atzliche Aktionen, um den Job vorzeitig anhalten zu k¨onnen, dringende Jobs m¨ussen warten • Priority scheduling: Jeder Job wird nach Priorit¨at gescheduled, wobei die Laufzeit unbegrenzt laufender Jobs w¨ahrend der Laufzeit erniedrigt wird, um andere Jobs dazwischen zu lassen. Gut: Scheduling nach Bedarf, wenig Overhead, Schlecht: kann unfair sein bei falschen Priorit¨aten • Multiple Queues: Pro Priorit¨at gibt es eine eigene Warteschlange, diesen wird der Reihe nach Zeiteinheiten entsprechend ihrer Priorit¨at zugeordnet. Quasi: Round robin mit Priorit¨aten.

142

6 ALGORITHMENENTWURF

• Shortest job first: falls die Laufzeit bekannt ist, kann der k¨urzeste Job preferiert werden (z.B. Herunterladen von Daten) Es gibt viele weitere Strategien, die an die jeweiligen Systeme angepaßt werden k¨onnen. Race conditions: Threads, die zusammenarbeiten und etwa gezielt Informationen austauschen, heißen kooperierend (etwa Auftraggeber und Auftragnehmer); Threads, die um gemeinsame Resourcen k¨ampfen und sonst wenig miteinander zu tun haben heißen konkurrierend (etwa Druckauftr¨age f¨ur einen Drucker). Bei konkurrierenden Prozessen ist darauf zu achten, daß jeder zum Zuge kommt, wie wir schon gesehen haben. Bei kooperierenden Prozessen (und auch bei konkurrierenden, so sie auf dieselben kritischen Resourcen zugreifen) muß zudem eine geeignete Synchronisation realisiert werden: die auszutauschende Information muß in sinnvoller Weise bearbetet werden, so daß keine Inkonsistenzen entstehen. Es gibt also Arten von Bedingungen: • Kausalit¨aten: A → B: B kann nicht vor der Abarbeitung von A beginnen (etwa weil A wichtige Daten zur Verf¨ugung stellt), dieses kann durch ein join realisiert werden. B m¨usste in diesem Beispiel also die Methode A.join beinhalten. Diese partiellen Ordnungen k¨onnen weitergehend gelten, wobei man u¨ ber die Einzelbeziehungen hinaus dann den transitiven Abschluß beachten muß. • Ausschluß: A ↔ B: die beiden Aktionen k¨onnen nicht zusammen stattfinden, da sie dieselben Resourcen brauchen. F¨ur die Aufl¨osung solcher Ausschlußkonflikte gibt es mehrere L¨osungen. Zun¨achst einige Beispiele: Zwei Kunden eines Reiseb¨uros wollen gleichzeitig ein Ferienhaus mieten. Es wird in den Datensatz die Dauer des Aufenthalts, der Name, etc. eingetragen und jeweils direkt nach dem Eintragen eines Teiles abgespeichert. Geschieht dieses parallel, kann es sein, daß f¨ur denjenigen, der zuerst zum Abschluß kommt, das Ferienhaus gebucht wird, allerdings einige Daten nicht von ihm stammen. Eine zweites Beispiel: zwei Threads berechnen gleichzeitig x = F (x) mit F (x) = f 2 , wobei x eine von den Threads geteilte Variable ist, die Funktion F durch die Threads berechnet, und das Ergebnis in x zur¨uckgegeben wird. Es k¨onnen mehrere F¨alle auftreten, je nachdem, ob die beiden Threads zwischenzeitlich (z.B. durch yields) unterbrochen werden: beide Threads lesen zun¨acht x ein, berechnen unabh¨angig voneinander x und schreiben je den sich ergebenden (gleichen) Wert F (x) in die Variable. Ist allerdings der eine Thread schneller und schreibt bereits den Wert x in die Variable, bevor der zweite einliest, ist das Endergebnis F (F (x)). Ein weiteres Beispiel: in einer Bank sind 10000 Accounts mit je 1000 EUR vorliegend, ein Thread berechnet gerade die Gesamtsumme. W¨ahrend der Sumation a¨ ndern sich die auf den Accounts vorhandenen Summen. Die berechnete Endsumme ist in der Regel verschieden von der ¨ tats¨achlichen Summe, da nicht alle Anderungen ber¨ucksichtigt wurden. Generell spricht man von sogenannten race conditions. Diese treten auf, wenn folgendes eintritt: • mindestens zwei Threads teilen sich Daten • die Threads schreiben oder lesen die Daten gleichzeitig • das Endergebnisse ist davon abh¨angig, in welcher Reihenfolge die Aktionen ausgef¨uhrt werden. Zur Aufl¨osung von race conditions gibt es verschiedene (unterschiedlich gute) Techniken. Man identifiziert daf¨ur zun¨achst kritische Bereiche, d.h. Teile des Programms wo auf Daten, die von

6.6 Nebenl¨aufigkeit

143

mehreren Threads benutzt werden, zugegriffen wird. Innerhalb dieser Bereiche k¨onnen Inkonsistenzen auftreten. Prinzipiell muß hier verhindert werden, daß mit den Daten besch¨aftigte Prozesse in kritischen Bereichen durch andere Threads unterbrochen werden oder andere Threads gleichzeitig hier herumwirken. Es gibt prinzipiell verschiedene Konzepte, dieses zu verhindern, unter anderem: • Busy waiting: sobald ein Prozeß einen kritischen Block betritt, setzt er eine (gesharte) Variable. Sobald er den Block verl¨aßt, wird sie zur¨uckgesetzt. Ein anderer Prozess darf nur dann in den Block, wenn die Variable zur¨uckgesetzt ist. Dieses wird wiederholt von Prozessen, die in den Block m¨ochten, getestet. Diese Methode ist sehr einfach, aber sie hat wesentliche Nachteile: – es wird zus¨atzliche Rechenzeit f¨ur das Nachschauen verbraucht, – die Blockiervariable ist selbst eine geteilte Variable, – ein Thread mit h¨oherer Priorit¨at kann durch das Nachschauen der Blockiervariable einen sich im Block befindlichen Thread lahmlegen. • Semaphore: (eingef¨uhrt durch Dijkstra) Ein Semaphore ist eine nichtnegative Integer-Variable mit den Operationen – P : falls die Variable 0 ist, wird gewartet, sonst der Wert erniedrigt, – V : die Variable wird um eins erh¨oht. Dabei sind die Inkrement-/Dekrementoperationen atomar und k¨onnen nicht unterbrochen werden. Schaltet man vor einen kritischen Block ein P , hinter einen kritischen Block ein V , dann ist sichergestellt, daß nur ein Prozeß gleichzeitig auf den kritischen Block zugreift. Semaphore sind eine Verallgemeinerung von Busy waiting in dem Sinn, daß sie durch busy waiting realisiert werden k¨onnen. Da sie aber ein allgemeineres Konzept darstellen, k¨onnen sie aber auch anders realisiert werden. Allerdings haben sie bei der Realisierung durch busy waiting dieselben Nachteile wie dieses. • Monitore: Ein Monitor ist ein noch allgemeineres Konzept als Semaphore. Ein MonitorObjekt kapselt die Resourcen und Operationen, die es manipulieren. Es kontrolliert den Zugang zu kritischen Bl¨ocken und garantiert, daß nur ein Prozeß den Block besitzt und darin arbeiten darf. Zur Kontrolle sind die Operationen wait und notify relevant. wait erm¨oglicht es einem Prozeß, zu warten und den Monitor freizugeben (im Gegensatz zu sleep, das den Monitor beh¨alt). notify bzw. notifyAll benachrichtigt einen/alle Prozesse, sobald der Monitor wieder vom Prozeß verlassen wurde. Dieses ist wieder ein allgemeines Konzept, daß den Schutz von einzelnen Abschnitten erm¨oglicht. Das Konzept der Monitore ist in Java direkt in der Sprache umgesetzt. Alle Objekte (und Klassen) besitzen die Eigenschaft, eine Sperre verwalten zu k¨onnen. Das Schl¨usselwort synchronized erm¨oglicht, einzelne Bl¨ocke in Methoden oder Methoden von Objekten zu sch¨utzen. Die Syntax ist prinzipiell synchronized () { <statement> }

144

6 ALGORITHMENENTWURF

wobei sich zu einem Objekt oder Array auswerten muß und <statement> eine Anweisungsfolge ist. Ist eine ganze Methode gekapselt, steht synchronized bei der Methode. Es kann ein Thread nur dann diese Bereiche ausf¨uhren, wenn er Zugriff auf das entsprechende Objekt hat. Damit kann nur ein Thread gleichzeitig diese Bereich ausf¨uhren. Dabei ist der Zugriff anhand des Objekts und Threads geregelt, d.h. ein Thread, der den Zugriff auf dieses Objekt hat, kann die synchronized Bereiche auch mehrfach ausf¨uhren und muß nicht darauf warten, daß er es selbst wieder frei gibt. Das Freigeben außerhalb der Reihe (also in synchronized Bl¨ocken) kann durch die Methode wait geschehen, die den Zugriff auf ein Objekt freigibt. Der Thread wird dann in eine Lizte von wartenden Threads eingef¨ugt. notify benachrichtigt die wartenden Threads in dieser Liste und wird aufgerufen, wenn das geeignete Ereignis, auf das diese gewartet haben, eingetroffen ist. wait und notify d¨urfen nur inerhalb von synchronized Bl¨ocken gebraucht werden. Ein Beispiel, wo Synchronisation wichtig ist: void swap(int[] array, int index1, int index2){ synchronized(array){ int tmp = array[index1]; array[index1] = array[index2]; array[index2] = tmp; } } Diese Aktionen sollten nicht unterbrochen werden. W¨ahrend der Durchf¨uhrung sollte keine Methode auf das Array zugreifen d¨urfen. Daher wird die Sperre an das zu bearbeitende Feld geh¨angt. wait und notify k¨onnen etwa wie folgt benutzt werden: class queue{ synchronized void push(int i){ .. haenge das Objekt i dran .. this.notify(); } synchronized int pop(){ if (this.empty()){ try { this.wait();} catch (InterruptedException ie){} } int i = ... lese und loesche das oberste Element ... return i; } } Dieser Mechanismus macht ein busy waiting im Fall, daß wichtige Information/Daten noch nicht vorhanden sind, u¨ berfl¨ussig. Hier wird erst dann das oberste Element gelesen, wenn mindestens eins vorhanden ist. Entsprechend sendet die Operation, die Elemente zuf¨ugt, ein notify. Ein notifyall w¨are n¨otig, wenn das Elemnt nicht gel¨oscht wird und alle wartenden Threads es lesen m¨ochten. wait kann durch Exceptions unterbrochen werden genau wie sleep, so daß dieses abgefangen werden muß. Diese Mechanismen erlauben (hoffentlich), einerseits die Sicherheit der parallelen Zugriffe zu garantieren, d.h. racing conditions zu verhindern. Zus¨atzlich muß sogenannte liveness sichergestellt sein: das bedeutet, daß jeder Thread zu jeder Zeit sinnvolle Fortschritte macht. Selbst wenn

6.6 Nebenl¨aufigkeit

145

die JVM alle Threads fair behandelt, kann man sich als Programmierer selbst schachmatt setzen. Dazu ein klassisches Beispiel, die dining philosophers. An einem runden Tisch sitzen f¨unf Philosophen, je zwischen zwei Philosophen liegt eine Gabel. Vor jedem Philosophen steht ein Teller mit (glitschigen) Spaghetthi, die zu essen jeder Philosoph zwei Gabeln braucht. Die Philosophen denken jetzt abwechselnd, werden hungrig, greifen zur Gabel, und essen. Das geschieht nat¨urlich parallel. Dabei kann nur ein Philosoph die Gabel zwischen zwei Philosophen greifen. Als Pseudocode k¨onnte das wie folgt aussehen: initialisiere jede Gabel als Semaphore mit 1 starte parallel fuenf Philosophen i=1..5 als parallele Prozesse: while (true){ think(); gabel[i].P(); gabel[(i+1)%5].P(); eat(); gabel[i].V(); gabel[(i+1)%5].V(); } } Was passiert? Es kann vorkommen, daß alle Philosophen gleichzeitig zun¨achst zur rechten Gabel greifen und dann alle darauf warten, daß die linke Gabel freigegeben wird. Das ist ein sogenannter deadlock, die Prozesse warten wechselseitig darauf, daß Resourcen freigegeben werden. Eine alternative L¨osung ist folgende: class fork{ private int me; /* fork number */ private boolean inuse; /* is in use? */ fork(int me) { this.me=me; inuse=false; } synchronized boolean pick(int phil) { if (!this.inuse){ System.out.println("phil "+phil+" graps "+me); inuse=true; return true; } System.out.println("phil "+phil+" misses "+me); return false; } synchronized void put(int phil) { System.out.println("phil "+phil+" puts "+me); inuse=false; notify(); } synchronized void wait(int phil)

6 ALGORITHMENENTWURF

146 { while (!pick(phil)) try{ wait(); } catch(InterruptedException ie){} } }

class philosopher extends Thread{ private int me; /* ich */ private fork left,right; /* meine Gabeln */ philosopher(int me, fork left, fork right) { this.me = me; this.left = left; this.right = right; } public void run(){ boolean hungry=false; while (true){ System.out.println(me+" is thinking"); try{ /* think */ sleep((int)(Math.random()*4711)); hungry=true; } catch (InterruptedException ie){} System.out.println(me+" is hungry"); while (hungry){ /* hungry */ try{ left.wait(me); /* warte auf linke gabel */ if (right.pick(me)){ hungry=false; System.out.println(me+" eats"); try{ /* eating */ sleep((int)(Math.random()*4711)); } catch (InterruptedException ie){} right.put(me); } } finally{ left.put(me); /* linke gabel zurueck */ yield(); } } } }

public static void main(String[] args) { fork[] forks = new fork[5];

6.7 Fehler

147 for (int i=0;i<5;i++) forks[i]= new fork(i); philosopher[] phils = new philosopher[5]; for (int i=0;i<5;i++) phils[i]= new philosopher(i,forks[i],forks[(i+1)%5]); for (int i=0;i<5;i++) phils[i].start();

} } Es essen und denken die f¨unf Philosophen hier als unabh¨angige Threads, wobei die jeweiligen Zeiten zuf¨allig bestimmt sind. Eine Gabel sorgt durch synchronized daf¨ur, daß ihr Zustand immer konsistent ist. Ein hungriger Philosoph wartet auf seine linke Gabel durch ein wait und wird von ihr im Zweifel benachrichtigt. Falls das Greifen der rechten Gabel fehlgeschlagen hat, legt er die linke sofort zur¨uck, um deadlocks zu verhindern und versucht nach einem yield wieder, die andere und dann die rechte zu greifen, bis er zum Zuge kommt. So werden deadlocks verhindert, weil ja jederzeit andere zum Zuge kommen k¨onnen und die Gabeln vorher beide zur¨uckgekegt wurden. Eine typische Ausgabe ist ... 1 grabs 1 1 misses 2 1 puts 1 2 puts 3 2 puts 2 2 is thinking 1 grabs 1 1 grabs 2 1 eats ... Nacheinander denken, essen oder warten die Philosophen also. Ein kleines Risiko ist aber noch in der Implementation beinhaltet: es kann theoretisch vorkommen, daß sich zwei benachbarte Philosophen gegen den in der Mitte zwischen ihnen sitzenden verb¨unden. Es kann passieren, daß immer abwechselnd der links sitende und der rechts sitzende essen. Da dann immer eine der f¨ur den mittleren ben¨otigten Gabeln belegt ist, kann dieser theoretisch verhungern, das ist das Problem der starvation. Das Risiko ist allerdings recht gering, da die Ess- und Denkzeiten zufallig bestimmt werden, also eine genaue Abstimmung von zwei Philosophen u¨ ber einen langen Zeitraum hinweg gegen die Wahrscheinlichkeit null konvergiert.

6.7 Fehler Sie haben bei dem einen oder anderen Java-Programm, das nicht korrekt implementiert war oder falsch bedient wurde, eine Fehlermeldung der Art runtime exception ... erhalten. Zudem haben wir schon Fehler bei den Methoden sleep, etc. in Java verwandt. Hier m¨ochten wir den zugrundeliegenden Mechanismus erl¨autern: Java bietet eine sehr elegante M¨oglichkeit, Programmfehler bzw. unerw¨unschte Zust¨ande, die z.B. durch falsche Eingaben entstehen, deutlich zu machen und durch geeignete Programmteile abzufangen. Schlagw¨orter sind sogenannte exceptions und exception handling. Exception bedeutet Ausnahme, also im Programm unerw¨unschte Zust¨ande. Bei der Ausf¨uhrung von Methoden und Konstruktoren k¨onnen fehlerhafte Zust¨ande auftreten. Man m¨ochte etwa einen Kreis definieren, hat aber einen negativen Radius angegeben. Was tun? In

148

6 ALGORITHMENENTWURF

den meisten derartigen F¨allen ist es angemessen, die Methode mit einer Fehlermeldung geordnet abzubrechen und evtl. im umgebenden Programm geeignet zu reagieren, etwa durch erneute Abfrage des Radius oder Setzen eines default-Wertes. Exceptions k¨onnen geworfen/angezeigt (throw) und aufgefangen/darauf reagiert (catch) werden. Es sind drei Dinge zu beachten: • Exceptions sind Objekte. Es gibt zwei unterschiedliche Arten von Exceptions: checked exceptions, auf die im Programm eingegangen werden muß, und alternativ unchecked exceptions, die nicht abgefangen werden m¨ussen, da sie typischerweise erst zur Laufzeit auftreten. Java stellt die Klassen Exception (checked Exception), RuntimeException, Error (unchecked Exception) und einige Unterklassen spezieller Fehler zur Verf¨ugung, die direkt benutzt oder f¨ur spezielle Fehler erweitert werden k¨onnen. 22 Diese Klassen u¨ bernehmen im Konstruktor einen String, der den Fehler lokalisiert (und, sofern sich der Fehler bis zur main-Methode fortsetzt, ausgegeben wird.). Eine Erweiterung f¨ur unseren Kreis w¨are etwa class NegativeRadiusException extends Exception{ double radius; NegativeRadiusException(double radius){ super("Der Radius "+radius+" ist negativ."); this.radius=radius; } } Man erweitert Exceptions, wenn spezielle Werte gespeichert werden sollen, spezielle Behandlungen ausgef¨uhrt werden sollen oder die Fehler mit einem speziellen Typ markiert werden sollen. • Throw - Werfen von Exceptions. Checked Exceptions m¨ussen bearbeitet werden, unchecked Exception k¨onnen es, m¨ussen es aber nicht. Eine M¨oglichkeit ist, die Exceptionmeldung weiterzugeben, die Exception zu werfen. Wirft eine Methode eine checked Exception, dann muß das angezeigt werden wie folgt (f¨ur unchecked Exceptions kann es angezeigt werden, muß aber nicht).

void setradius(double radius) throws NegativeRadiusException { if (radius<0) throw new NegativeRadiusException(radius); this.radius=radius; } Es wird im Fall eines negativen Radius die Methode abgebrochen und ein entsprechender Fehler angezeigt, d.h. ein Fehlerobjekt vom Typ NegativeRadiusException zur¨uckgegeben. Eine Methode kann mehrere verschiedene Fehlertypen werfen, angezeigt durch eine durch Kommata getrennte Liste von Fehlertypen. Dabei ist zu beachten, daß in der Methode gebrauchte weitere Methoden ihrerseits Exceptions werfen k¨onnen, die man entweder (sofern checked) abfangen muß oder durch Einbeziehen in die throw-Liste weitergeben kann. 22

Genauer sind dieses Unterklasen von Throwable und man kann auch von dieser ableiten. Das soll uns hier aber nicht interessieren.

149 • Catch - Auffangen von Exceptions. Man kann Exceptions auch dadurch behandeln, daß man sie explizit auff¨angt und f¨ur die Spezialf¨alle Fehlerbehandlungen vorsieht. Der Ablauf dessen ist von der Form try { statements } catch (Exception Typ1 Identifier 1 {statements} catch (Exception Typ2 Identifier 2 {statements} ... finally { statements } Ein Beispiel Kreis meinkreis = new Kreis(); try { meinkreis.setradius(-42); catch (NegativeRadiusException id1) { meinkreis.setradius(-id1.radius) } finally { System.out.println(meinkreis.flaeche())} Es wird zun¨achst der Block try ausgef¨uhrt, bis er entweder erfolgreich bearbeitet wurde oder eine Exception auftrat. Danach werden die catch-Satements der Reihe nach getestet und das erste Statement, dessen Fehlertyp zutrifft, ausgef¨uhrt. Dabei kann man auf das Exception-Objekt und seine Daten zugreifen. Zum Schluß wird, egal ob eine Exception auftrat oder nicht, das finally statement ausgef¨uhrt. Es darf beliebig viele (auch kein) catch Teile f¨ur ein try geben, und finally darf auch weggelassen werden. Beachten Sie: der try Block wird lediglich bis zur ersten Exception abgearbeitet; die try Anweisungen werden nur einmal gepr¨uft, auch wenn innerhalb dessen neue Exceptions auftreten. So ein Block ist also zum Abfangen einer Exception gut, nicht mehrerer evtl. zuammen auftretender (wohl aber mehrerer alternativer Exceptions). Nach Abarbeiten dieses Blocks k¨onnen weitere, außenstehende try - catch - finally stehen, die sukzessive bearbeitet werden. Zu beachten ist, daß in obigem Block theoretisch innerhalb des catch wieder exceptions auftreten k¨onnen, so daß das Oberprogramm eine derartige Exception anzeigen muß, um compiliert werden zu k¨onnen. Bei RuntimeExceptions muß so ein Block nicht vorliegen. Sie f¨uhren, wenn sie nicht abgefangen wedren, zu einer Fehlermeldung w¨ahrend des Interpretierens. Sie sind h¨uafig gebraucht, um z.B. bei nicht vorhanden Files, auf die zugegriffen werden soll und dessen Fehlen sich erst zur Laufzeit herausstellt, etc. das System geordnet zu terminieren.

7 Programmierstile Wir haben, startend von Java, zun¨achst elementare Datenstrukturen, dann komplexe Datenstrukturen, sogenannte abstrakte Datentypen, kennengelernt. F¨ur Java als objektorientierter Programmiersprache ist eine Anlage der Programme um die Datentypen bzw. Klassen nat¨urlich und der Programmiersprache entsprechend. Wir haben in diesem Rahmen bereits einige wichtige Algorithmen f¨ur abstrakte Datentypen kennengelernt, angefangen vom Suchen und Sortieren, u¨ ber die Traversierung von B¨aumen, Wege und Spannb¨aume in Graphen, bis hin zur Realisierung von Automaten. Ein gutes Programm setzt sich immer aus zwei zentralen Teilen zusammen, den ad¨aquaten Datenstrukturen und den gut entworfenen Algorithmen f¨ur diese Datenstrukturen, die dann in einer ad¨aquaten Programmiersprache umgesetzt werden.

150

7 PROGRAMMIERSTILE

7.1 Imperativ – deklarativ – objektorientiert Wir haben bislang Java benutzt. Es gibt viele alternative Programmiersprachen. Folgendes Diagramm wurde von Konrad Zuse erstellt:

Einige wichtige Entwicklungsetappen: • der Einsatz von Rechnern f¨ur numerische Probleme (FORTRAN - Formula Translator, ALGOL - Algortihmic Language) • der Einsatz von Rechnern f¨ur den kommerziellen EDV-Bereich (COBOL - Common Business Oriented Language) • der Einsatz von Programmiersprachen f¨ur die K¨unstlidhe Intelligenz (LISP - List Processing) • Maschinennahe schnelle Hochsprachen statt Assembler (C) • strenge Typkonzepte (PASCAL) • ein strenges Modulkonzept (MODULA) • parallele Programmiersprachen (OCCAM) • Vererbungstechinken (Smalltalk)

7.1 Imperativ – deklarativ – objektorientiert

151

• Objektorientierung (C++, Oberon, ADA95) • Einfache Programmierung graphischer Nutzeroberfl¨achen (VisualBasic, Delphi, JavaBeans) • Verteilte Programmierung, Web (HTML, Java, XML, Jini) Oft bettet man die Entwicklung der u¨ blichen Hochsprachen in vier Generationen von Sprachen ein: Maschinensprachen - erste Generation, Assembler - zweite Generation, Hochsprachen (Java und die oben beschriebenen Sprachen) - dritte Generation, anwendungsspezifische Sprachen (wie Mathematica, SQL, die Gegenstand spezieller anwendungsspezifischer Vorlesungen sind) - vierte Generation. Bezogen auf die Umsetzung von Algorithmen innerhalb von Hochsprachen der dritten Generation, auf die wir uns hier im Wesentlichen beschr¨ankt haben, unterscheidet man zwischen prinzipiellen Programmierstilen, die die verschiedenen Programmiersprachen mehr oder weniger gut unterst¨utzen. Die wichtigsten Stile sind: • Imperative/prozedurale Sprachen (Fortran, Pascal, Modula, C) orientieren sich am Ablauf von Algorithmen. die einen (globalen) Zustand transformieren. Modularisierung geschieht auf der Ebene einzelner Prozeduren. • Logische und funktionale Sprachen (LISP und Prolog) st¨utzen sich auf abstrakte symbolische Grundlagen, Pr¨adikate oder Funktionen, die formal ausgewertet werden. In Prolog ist ein Programm eine Menge logischer Formeln, der Ablauf eines Programms ein logischer Beweis im Resolutionskalk¨ul. In LISP werden Funktionen aufgerufen und formal (auch rekursive) ausgewertet. • Objekt-orientierte Sprachen (C++, Smalltalk, Java) orientieren sich an den informationstragenden Objekten, die Methoden zur Verf¨ugung stellen, lokal ihre Informationen zu a¨ ndern und Messages an andere Objekte zu senden. Die kleinsten Einheiten sind Objekte, auf Programmierebene Klassen. Algorithmische Funktionalit¨aten sind weitestgehend in Methoden versteckt und k¨onnen leicht lokal ausgetauscht werden. Um die Unterschiede zu demonstrieren, stellen wir dem schon behandelten 8-Damen Problem eine imperative (in C) und eine logische (in Prolog) L¨osung entgegen: #include <malloc.h> #include <stdio.h> int* queens; /* Testet, ob 0..j-1 j attackieren */ int canattack(int j) { int i; for (i=j-1;i>=0;i--) if ((queens[i]==queens[j]) || (queens[i]+i==queens[j]+j)|| (queens[i]-i==queens[j]-j)) return 1; return 0; } /* output */ void output(int D) {

152

7 PROGRAMMIERSTILE

int i; for (i=0;i=D) return -1; if (queens[i]=0)) { #ifdef DEBUG fprintf(stderr,"bei %d: %d\n",i,queens[i]); #endif if (canattack(i)){ if (queens[i]
7.1 Imperativ – deklarativ – objektorientiert

153

output(D); free(queens); return(0); } Soweit das imperative C-Programm. Man sieht, die globale Kontrolle liegt im Hauptprogramm, Modularisierung geschieht auf der Ebene der einzelnen Funktionen. Das kann durchaus k¨urzer sein als objektorientierte Programme, aber im Fall von Programmpaketen sehr wartungsunfreundlich ¨ werden, da sich Anderungen etwa in der Datenstruktur global auswirken. Zu Prolog: element(X,[X| ]). element(X,[ |L]):-element(X,L). m(0):-!. m(X):-!,asserta(moeglich(X)),Y is X-1, m(Y). extract([],[]). extract([[X| ]|L],[X|L1]):-extract(L,L1). dame(X,L):-retractall(moeglich( )), m(X),!,d(X,X,[],L1),extract(L1,L). d( ,0,L1,L2):-!,L1=L2. d(N,X,L1,L2):-moeglich(I),\+(element([I, , ],L1)),H1 is I+X, \+(element([ ,H1, ],L1)), H2 is N+I-X, \+(element([ , ,H2],L1)), H3 is X-1, d(N,H3,[[I,H1,H2]|L1],L2). Man sieht, es stehen hier gar keine Kontrollstrukturen, sondern logische Formeln (zusammen mit einigen nicht ’puren’ Prologelementen, dem cut !, der Negation \+, und dynamischen Strukturen asserta, die aber lediglich alle m¨oglichen Zeilen auflisten.) Durch eine Verifikation zusammen mit einer g¨ultigen Antwortsubstitution erh¨alt man automatisch eine L¨osung, wobei der Backtrackingmechanismus durch Prolog u¨ bernomen wird. Die Philosophie unterschiedlicher Programmierstile wird auch oft (und sehr anschaulich mit all ihren Fehlern und typischen Schw¨achen) in Sp¨aßen auf’s Korn genommen. Ein Klassiker sind die unterschiedlichen Arten, einen L¨owen in der W¨uste zu fangen: Die-Prolog-L¨owensuche. . . suche(L¨ owe,W¨ uste, ) :- var(W¨ uste),!,fail. % In einer nicht instantiierten W¨ uste % lassen sich keine L¨ owen fangen. uste). owe,W¨ uste), gefunden(L¨ uste) :- atomic(W¨ uste,W¨ owe,W¨ suche(L¨ % Wenn die W¨ uste atomar ist, % muß dort der L¨ owe sein. suche(L¨ owe,[], ):- !, fail. % Wenn die W¨ uste leer ist, ist auch owe drin. % kein L¨ suche(L¨ owe,[HEAD],HEAD) :- gefunden(L¨ owe,HEAD). owe im ersten Element % Wenn der L¨ % der W¨ uste ist, dann fertig. suche(L¨ owe,[ |T],X) :- suche(L¨ owe,T,X). % Sonst weiter schauen.

7 PROGRAMMIERSTILE

154

fange(Was,Wo,Womit) :fange(Was,Wo,WoGenau), bewege(Womit,WoGenau). gefunden(Was,Worin) :- member(Was, Worin). bewege(Was, ) :- retract(position(Was, )), fail. bewege(Was,Wohin) :- asserta(position(Was,Wohin)). test W¨ uste([W¨ uste 1, W¨ uste 2, W¨ uste 3, W¨ uste 4, W¨ uste 5, W¨ uste 6, W¨ uste 7, [W¨ uste 8, L¨ owe], W¨ uste 9, W¨ uste A, [W¨ uste B, wagen], W¨ uste C, W¨ uste D]). fange L¨ owe test :bewege(K¨ afig,wagen), test W¨ uste(W¨ uste), afig). uste,K¨ owe,W¨ fange(L¨ Eine sch¨one imperative Pascal-L¨osung: program Test Loesung; type W¨ uster Typ= Array[1..Max X,1..Max Y] of Index; Inhalt = { weiß nicht } K¨ afig Typ = record voll : Boolean; Inhalt : Tier; end; L¨ owen Typ = Tier; var W¨ uste : W¨ uster Typ; K¨ afig : K¨ afig Typ; Tiere : Array[1..Max Tiere] of Tier; { Falls noch Kamele in der W¨ uste sind.} procedure L¨ owen Fang; var i,j:Word; begin; K¨ afig.voll:=false; for i:=1 to Max X do { W¨ uste nach L¨ owe absuchen } for j:=1 to Max Y do if W¨ uste[i,j]=L¨ oweN INDEX then begin; K¨ afig.Inhalt:=Tiere[W¨ uste[i,j]]; K¨ afig.voll:=true; uste[i,j]:=KEINER INDEX; W¨ exit; { Da der K¨ afig schon voll } end; { ist.Man k¨ onnte aber auch } { mit dieser Procedure alle L¨ owen einfangen. } WriteLn(’Kein L¨ owe gefunden, wie w¨ ars mit einem Kamel ?’); end; begin; Init; { W¨ uste, Tiere werden eingestellt. } L¨ owen Fang; if (K¨ afig.voll) then WriteLn(’ Ok,der L¨ owe ist im K¨ afig.’) else WriteLn(’Achtung ! Kein L¨ owe gefunden, durch "+ ’Ab¨ anderung in KAMEL INDEX w¨ are vielleicht"+ #10#13’ein Kamel m¨ oglich ?’); end. In der objektorientierten C++ L¨osung bringen die Objekte die Fangmethoden nat¨urlich mit:

7.2 Ein paar Schlagworte

155

int fang(string str) { object ob1,ob2,ob3; if (!str || str!=L¨ owe mit K¨ afig") { write("WEN willst du mit WAS fangen ?\n"); return 1; } ob1=clone object("/obj/W¨ uste"); /* W¨ uste enth¨ alt L¨ owe s.Aufgabe */ ob2=clone object("/obj/K¨ afig"); if (ob3 = present(L¨ owe",ob1)) == NULL) { write(¨ Es ist kein L¨ owe in der W¨ uste !\n"); /* Falls weggerannt */ return 1; } ob3->move(ob2); write("Der L¨ owe befindet sich jetzt im K¨ afig.\n"); return 0; } Zur weiteren Erheiterung: das Shell-Script: #!/bin/sh for $tier in $W¨ uste do owe ] if [ $tier = $L¨ afig; exit 0 then mv $tier $K¨ fi done Die L¨osung als Pseudocode, wobei, wie u¨ blich, einige unwesentliche Details weggelassen wurden: MODULE Fang; FROM Problem IMPORT Loesung; BEGIN; Loesung; END Fang.

Es gibt weitere L¨osungen, informatorische, aber auch Beitr¨age der Mathematik und Physik, sehen Sie z.B. http://www.uni-graz.at/imawww/pages/humor/lions.html

7.2 Ein paar Schlagworte Es ist Zeit, ein paar technische Terme im Zusammenhang mit Programmiersprachen, die wir teilweise schon gebraucht haben, zu erl¨autern. • Compiler/Interpreter: Sprachen, die nicht selbst Maschinensprache sind, werden entweder compiliert, d.h. ein und f¨ur alle Mal in Maschinensprache u¨ bersetzt, oder interpretiert, d.h. erst w¨ahrend des Ausf¨uhrens St¨uck f¨ur St¨uck in Maschinensprache umgewandelt. Compilierte Programme sind in der Regel schneller, da einige Optimierungen gemacht werden k¨onnen. Interpretierte Programme sind dagegen plattformunabh¨angiger, und erlauben eine ¨ Anderung des Programmtexts zur Laufzeit. Java wird in eine Zwischensprache compiliert und dann interpretiert.

156

7 PROGRAMMIERSTILE

• Skriptsprache/Hochsprache/Maschinensprache/Anwendungssprache: Es gibt verschiedene Ebenen der Programmierung mit jeweils unterschiedlichen Anforderungen. Maschinensprache ist direkt, sehr elementar und f¨ur den Menschen schwer verst¨andlich. Maschinennahe Sprachen werden in zeitkritischen und Hardware-nahen Bereichen verwendet. Hochsprachen sind multi-purpose Programmiersprachen wie etwa Java, die u¨ bliche Algorithmen wie Sortieren, Rechnen, . . . umsetzen k¨onnen. Skriptsprachen sind mit den wichtigsten Kontrollstrukturen versehene Sprachen meist auf Betriebssystemebene, die ein einfaches Automatisieren von Systemaufrufen erm¨oglichen, wie etwa den mehrfachen Start eines Java-Programms mit unterschiedlichen Parametern und die Auswertung der Ergebnisdateien. Skriptsprachen beinhalten Systembefehle und einige M¨oglichkeiten, Terme zu manipulieren, allerdings meist keine modularen oder prozeduralen Elemente oder Typen. Anwendungssprachen wie etwa Mathematica und Matlab sind speziell f¨ur Anwendungsbereiche wie etwa mathematische Symbolmanipulation oder Darstellung mathematischer Mannigfaltigkeiten geschrieben. Sie beinhalten umfassende fertige Algorithmen des jeweiligen Anwendungsgebietes (z.B. L¨osen linearer Gleichungssysteme), dazu u¨ bliche Kontrollstrukturen, aber nur wenig Modularisierung und Typen. • Typenbindung: Typengebundene Sprachen verwenden Variablen strikt nur f¨ur den Typen, f¨ur den sie deklariert wurden, z.B. Integer. Bei nicht typengebundenen Sprachen kann man Variablen benutzen und ihnen im Laufe des Programms einen beliebigen Inhalt zuweisen. Skriptsprachen sind u¨ blicherweise nicht typengebunden. In maschinennahen Sprachen wie C ist der vermischte Gebrauch mehrerer Typen (etwa Zeiger und Arrays) m¨oglich, da man diekten Speicherzugriff hat. Logische Sprachen erlauben (in purer Form) teilweise nur Symbole (sogenannte Herbrandalgebra). • Speicherverwaltung: In klassischen Hochsprachen ist der Programmierer in der Regel selbst f¨ur die Speicherverwaltung zust¨andig. D.h. er muß f¨ur Variablen, deren Gr¨oße nicht klar ist (Listen etc.) geeigneten Speicherplatz explizit reservieren und wieder freigeben. Das ist eine sehr schnelle und effiziente M¨oglichkeit, da man unter anderem direkt an den Speicherpl¨atzen rechnen kann, aber auch eine stete Quelle f¨ur Programmierfehler, wenn man auf unzul¨assigen Speicherplatz zugreift (die ber¨uhmten segmentation faults in C. . . ). Java nimmt dem Programmierer die Arbeit ab. Der Befehl new reserviert entsprechenden ben¨otigten Speicherplatz und liefert einen Verweis auf den Speicher. Java sorgt selbst daf¨ur, daß nicht mehr ben¨otigter Speicher freigegeben wird. Nicht ben¨otigter Speicher ist dabei solcher, auf den keine im Programm noch ben¨otigte Referenz verweist. Der sogenannte garbage collector ist ein stetig je nach Systemauslastung im Hintergrund laufender Prozess, der diesen freien Speicher entdeckt, aufsammelt und wieder freigibt. • call by value/call by reference: Variablen¨ubergabe f¨ur Methoden oder Prozeduren kann auf zwei verschiedene Arten geschehen: durch eine Kopie einer Referenz auf ein Objekt, oder durch eien Kopie des im Objekt stehenden Inhalts. Die Auswirkungen sind unterschiedlich, ¨ da Anderungen des Objekts Auswirkungen auf das gesamte Programm haben oder nicht. In Java sind alle Variablen call-by value, also als Inhalt u¨ bergeben, wobei sich dieses bei Referenztypen als call by reference auswirkt, da die Variablen nur als Referenz tats¨achlich vorliegen. • Debugging: nennt man den Prozess der Fehlersuche. Da das einen großen Teil der Entwicklungszeit einnimmt, gibt es hierf¨ur m¨achtige Tools, f¨ur Java etwa den Java Debugger jdb als Kommandozeilenorientierte Version oder graphische Pendants.

7.3 Prolog

157

• Dokumentation: eine gute Dokumentation von Programmen ist essentiell insbesondere f¨ur ihre Wiederverwendung oder f¨ur die Benutzung durch andere Leute. Unumg¨anglich ist eine angemessene Dokumentation auch beim Zusammenspiel mehrerer Programmst¨ucke von verschiedenen Programmierern. Wir wissen, wie man Kommentare in Java integriert. Ein Benutzer m¨ochte allerdings nicht in den Code schauen m¨ussen, um den prinzipiellen Aufbau eines Programms zu vesrtehen. Java stellt hier eine elegante M¨oglichkeit, automatisch aus Code Kommentare in Form geeigneter html-Seiten (also mit einem Internet-browser betrachtbarer Seiten) zu extrahieren. Javadoc ist in Java integriert und extrahiert aus dem Programmcode html-Texte, sofern sie mit einem doppelten ∗ (statt nur einfachem ∗) gekennzeichnet sind. Zus¨atzlich zur Extraktion dieser gekennzeichneten Bereiche extrahiert javadoc selbst¨andig eine Visualisierung der Klassen: jede Klasse wird in der durch die Unified Modeling Language (UML) vereinbarten Weise charakterisiert, d.h. ihre Methoden und ariablen werden zusammen mit der Sichtbarkeit (und etwaigen Kommentaren) dargestellt. Klassendiagramme und weitere Abh¨angigkeiten sind ebenfalls integriert.

7.3 Prolog Wir haben jetzt nur einen sehr kurzen Blick auf andere Sprachen geworfen. Diesen wollen wir f¨ur eine fundamental von Java verschiedene Sprache etwas ausweiten: Prolog, einer logischen Programmiersprache. Prolog basiert auf Logikkonzepten und ist tats¨achlich aus Entwicklungen entstanden, logische Aussagen automatisch zu beweisen. Der Kern hinter Prolog ist das sogenannte Resolutionskalk¨ul, ein Logikkalk¨ul zum Beweis von Aussagen. Es gibt verschiedenste Prolog-Systeme, bekannt sind etwa Quintus-Prolog oder das freie und mit Quintus weitgehend kompatible SWI-Prolog (siehe etwa http://www.swi-prolog.org/). Wir f¨uhren hier die Grundlagen von Prolog ein, wobei wir im Hinterkopf haben, daß es um logische Formeln in den Programmen geht. Programme bestehen tats¨achlich aus logischen Formeln in spezieller Form. Entsprechend wiederholen wir vieles, was wir im Zusammenhang mit logischen Formeln schon geh¨ort haben. Variablen Variablen und Variablenbelegungen in Prolog sind die Grundeinheiten von Formeln: Terme. Ein Term ist entweder eine • Variable, in Prolog entweder ein mit einem Großbuchstaben anfangendes Wort wie X oder Aha, oder eine sogenannte anonyme Variable, die nur einmal auftaucht und daher gar keinen Name braucht, markiert durch . • Konstantensymbole, in Prolog mit einem Kleinbuchstaben beginnende W¨orter oder bekannte Konstantensymbole wie Zahlen 0, 1, 42, . . . • zusammengesetzte Terme der Form f (t1 , . . . , tn ) mit einem Funktionssymbol f (mit Kleinbuchtsaben beginnend) und Subtermen ti , etwa f (X, g(h(Y, ))), es gibt die u¨ blichen Funktionen +, ∗, . . . , die auch infix geschrieben werden k¨onnen. Wir haben gelernt, daß man Variablen und Symbole auswerten kann u¨ ber gegebenen Algebren. Prolog verwendet (bis auf einige F¨alle, die wir noch bekommen) eine spezielle Algebra mit einer trivialen Auswertung: die sogenannte Herbrandalgebra. Diese Algebra lebt u¨ ber Zeichenketten und interpretiert den Wert solcher Terme als die Zeichenkette, die diesen Tem beschreibt. Man l¨aßt also de facto die Terme so stehen, wie sie sind, und rechnet rein symbolisch weiter (das kennen Sie evtl. schon aus symbolischen mathematischen Systemen, etwa Maple kann rein symbolisch

7 PROGRAMMIERSTILE

158

Funktionen ableiten oder umwandeln, ohne irgendetwas tats¨achlich zu einer Zahl auszuwerten). Diese prinzipielle Sichtweise macht manches einfacher: statt komplizierten Datenstrukturen und deren Darstellung nachzugehen, nimmt man Zeichenketten, wie sie kommen, und k¨ummert sich nicht um etwaige Bedeutungen. Dieser Standpunkt ist gerechtfertigt, da es in Prolog um den Test geht, ob Formelmengen Modelle haben. Man kann zeigen, daß eine Formelmenge dann und nur dann ein Modell besitzt, wenn sie ein Herbrandmodell besitzt. Im Klartext also: wir brauchen uns nicht um aufwendige Algebren und Grundbereiche zu sorgen, die Symbole selbst reichen v¨ollig aus! Horn-Klauseln Wir erinnern uns: logische Formeln bestehen aus • atomaren Formeln, das sind entweder die Konstanten true und false (in Prolog fail), oder Pr¨adikatssymbole mit eingesetzten Termen, also etwa X < Y , oder p(X,Y), falls p ein Pr¨adikatssymbol ist, • negierte Formeln ¬ϕ • und-, oder-Verkn¨upfungen, folgt, oder a¨ quivalent, • quantisierte Formeln. Wir lassen erstmal Quantoren weg. Wir erinnern uns: jede Formel kann man in konjunktiver Normalform schreiben, d.h. als Konjunktion von Disjunktionen von Literalen, wobei ein Literal eine atomare oder negierte atomare Formel ist. Oder-Vekn¨upfungen von Literalen nennt man auch Klauseln, und man sagt, daß. eine Klausel gilt, falls die oder-Verkn¨upfung gilt. Eine Menge von Klauseln wird als die und-Verkn¨upfung der Klauseln interpretiert, sie gilt also, wenn jede Klausel gilt. Damit kann man (¨uber die konjunktive Normalform) jede quantorenfreie Formel in Klauselform bringen. Prolog-Programme bestehen aus logischen Formeln einer speziellen Form, sogenannten Horn-Klauseln. Horn-Klauseln sind Klauseln mit maximal einem positiven Literal. Es sind • Fakten: genau ein positives Literal. In Prolog wird das etwa als likes(john,mary). geschrieben. • Regeln: ein positives und mehrere negative Literale. Also so etwas wie a ∨ ¬b ∨ ¬c. Beachten Sie, daß man dieses auch als (b ∧ c) → a schreiben kann. Genauso notiert Prolog solche Regeln, mit dem Kopf a und dem Rumpf (b, c), einfach durch Komma statt durch und getrennt. Aus historischen Gr¨unden schreibt man − : statt → und den Kopf vorne, also a : −b, c. oder auch likes(mary,X):-human(X),honest(X). • Anfragen: sie enthalten nur negative Literale, etwa ¬b ∨ ¬c. man schreibt das in Analogie zu Regeln als ? − b, c.. Anfragen werden an ein Prolog Programm gestellt, und Prolog versucht, die Anfrage aus dem Wissen, also den bekannten Fakten und Regeln herzuleiten. Etwa ?-likes(mary,john).

7.3 Prolog

159

Ein m¨ogliches Prologprogramm w¨are also etwa die Wissensbasis likes(john,mary). honest(john). human(john). likes(mary,X):-human(X),honest(X). Durch die Einschr¨ankung auf Horn-Klauseln hat man tats¨achlich eine Teilmenge der logischen Formeln ausgezeichnet, man erh¨alt so nicht mehr alle m¨oglichen Formeln. Der Vorteil ist, daß man mit Hornklauseln logische Schl¨usse gezielt in einer normierten Reihenfolge und sehr effizient vornehmen kann. F¨ur allgemeine Formeln w¨are das nicht so einfach der Fall. Programmablauf Ein Programmablauf besteht rein formal in dem Versuch, zu zeigen, daß aus einem gegebenen Programm eine nachgefragte Formel folgt, etwa aus obigem Programm folgt likes(mary,john). Formal zeigt man das, indem man zeigt, daß die Formelmenge des Programms und das Negat der nachgefragten Sache kein Modell besitzt (das ist a¨ quivalent dazu, daß die Formel selbst folgt). Daher Anfragen (negierte Formeln). Die spezielle Form von Prologprogrammen macht es jetzt m¨oglich gezielt vorsugehen. Entweder ist das Nachgefragte ein Fakt in der Wissensbasis, d.h. man findet die Nachfrage als Tatsache, mehrere Schritte durch Regeln hergeleitet werden. Dazu muß das Nachgefragte Kopf einer Regel sein, und Prolog versucht, statt dem Kopf (der ja eigentlich zu zeigen ist), alle Literale im K¨orper zu zeigen (was ausreicht, da daraus ja der Kopf folgte). Dieses Vorgehen nennt man auch Resolution. In obigem Fall ergibt das: ?-likes(mary,john). ?-human(john),honest(john). ?-honest(john). yes

+ + +

likes(mary,X):-human(X),honest(X). human(john). honest(john).

Prolog hat also alles der Reihe nach nachgewiesen, wobei X am Anfang durch das zu betrachtende Individuum john ersetzt wurde. Heraus kam die leere Menge, d.h. die leere Klausel, die kein Modell hat. Die Aussage muß also aus der Regelmenge folgen, Prolog quittiert dieses mit yes. Fragen wir etwas anderes: ?-likes(mary,tweety). Prolog quittiert mit no, denn es kann die Frage zwar auf ?-human(tweety),honest(tweety). zur¨uckf¨uhren, aber dann ist Schluß, es ist nicht bekannt, ob tweety ein Mensch oder evtl. doch eher ein Pinguin ist, und die Ehrlichkeit ist auch fraglich. Beachten Sie, daß diese Abgleich mit Regelk¨opfen nur deswegen m¨oglich ist, weil man sich auf Hornklauseln beschr¨ankt hat. Mehr als ein positives Literal w¨urde zwei oder mehr Elemente im Kopf verursachen, man k¨onnte sich also nicht sicher sein, welches der beiden man inferieren kann. In Hornklauseln ist man sich dessen sicher. Logisch entspricht das dem Faktum, daß Hornformeln immer zu einem eindeutigen kleinsten Herbrandmodell f¨uhren, das Prolog auf diese Art berechnet. Kleinst bedeutet dabei, daß Prolog u¨ ber Sachen,¨uber die es nichts sicher weiß, negativ bescheidet (tweety k¨onnte ja durchaus ehrlich sein, nur weiß Prolog das nicht und verneint deswegen.) Backtracking Es kann sein, daß der erste Versuch einer Regel nicht unbedingt zum Erfolg f¨uhrt, oder daß es mehr als eine M¨oglichkeit zum Erfolg gibt. Prolog testet tats¨achlich der Reihe nach alle Fakten oder Regeln durch, bis entweder Erfolg aufgetreten ist, oder keine weitere M¨oglichkeit mehr u¨ brig ist. Das Backtracking bezieht sich dabei auf alle Zwischenschritte. Ein Beispiel: Pfade in einem azyklischen Graphen finden. Wir haben die folgende Regelbasis:

7 PROGRAMMIERSTILE

160 edge(a,b). edge(a,e). edge(b,c). edge(b,f). edge(e,f). edge(e,d). edge(g,d). edge(g,h). path(X,X). path(X,Y) :- edge(X,Z), path(Z,Y).

Die ersten acht Fakten beschreiben den Graphen, das Fakt path(X,X) sagt, daß es immer einen Pfad zu sich selbst gibt, und die Regel beschreibt die transitive H¨ulle, die man u¨ ber Zwischenknoten enth¨alt. Auf die Anfrage ?-path(a,c). hin wird folgender Suchbaum aufgebaut: ?−path(a,c).

?−path(b,c).

?−path(c,c)

?−path(e,c).

?−path(f,c).

?−path(f,c).

?−path(d,c).

Der linkeste Pfad f¨uhrt zum Erfolg, die anderen hier nicht. Prolog sucht in diesem Baum per Tiefensuche von links nach rechts nach einer L¨osung. Es kann dabei auch mehrere geben (die Prolog dann der Reihe nach findet, Eingabe ist ’;’), oder auch gar keine (der ganze Baum f¨uhrt zu Mißerfolg). Die Reihenfolge der Regeln bestimmt die Reihenfolge, in der der Baum aufgebaut wird, also auch das zuerst gefundene Ergebnis. Achtung: es kann unendliche Pfade geben! Trifft Prolog vor einem Erfolgspfad einen unendlichen Pfad, terminiert es nicht. Ein Beispiel: betrachten Sie die Erweiterung obigen Programms um das Faktum edge(b,a). Der Graph wird damit zyklisch! Wenn jetzt die Anfrage ?-path(a,g). gestellt wird, terminiert das Programm nicht, obwohl es offensichtlich ist, daß es so einen Pfad nicht geben kann. Was ist das Problem? Wir haben einen unendlichen Programmablauf bekommen: Die Anfrage f¨uhrt u¨ ber den Zyklus von a nach b zu folgender Abarbeitung: ?-path(a,g). ?-edge(a,Z),path(Z,g). ?-path(b,g). ?-edge(b,Z),path(Z,g). ?-path(a,g). Dieses muß man im Programm verhindern. Wie, sehen wir sp¨ater.

7.3 Prolog

161

Variablen/Unifikation Bisher haben wir Variablen nur marginal und implizit benutzt. Was ist die Rolle von Variablen? Prolog kennt keine Existenzquantoren, alle auftauchenden Variablen sind impliziert allquantifiziert. Etwa die Regel p(X) : −q(Y ), c(Z). bedeutet also in Formeln ∀X∀Y ∀Z((q(Y ∧ c(Z)) → p(X)). Dieses bedeutet keine Einschr¨ankung, da man in einer Formel Quantoren immer ganz nach vorne ziehen kann, und man auf Existenzquantoren verzichten kann (durch die sogenannte SkolemNormalform, auf die wir hier nur hinweisen). Es stehen also implizit allquantifizierte Formeln in Prolog. Es kommt in Prolog vor, daß man zwei Terme ’gleich machen’ m¨ochte, d.h. man m¨ochte Variablen in den Termen so belegen, daß zwei betrachtete Terme u¨ bereinstimmen. Dieses dient dazu, Wissen innerhalb von Formeln zu propagieren. Wir haben das tats¨achlich in kleinem Rahmen die ganze Zeit getan: wir haben Variablen Konstanten zugewiesen. Das ganze k¨onnte bei komplexeren Termen aber auch schwieriger aussehen. ’Gleich machen’ von Termen nennt man Unifikation. Mathematisch sucht man dabei f¨ur gegebene Terme t1 und t2 eine Substitution σ der Variablen in den Termen, so daß t1 σ = t2 σ gilt. Ein Beispiel macht dieses sofort klar: Gegeben seien die Terme f (X, g(b, c)) und f (d, g(Z, C)). Wir sehen sofort: ersetzen wir X durch d, Z durch b und C durch c, dann sind die beiden Terme gleich. Zudem gibt es keine andere Substitution, die dasselbe liefert. Unifikation einer Variablen X und einer Konstanten c ersetzt X durch c. Was ist ¨ mit g(Z, f (A, 17, B), A + B, 17) und g(C, f (D, D, E), C, E). Ein wenig Uberlegung zeigt: wir m¨ussen Z durch 17 + 17, A durch 17, B durch 17 ersetzen. Es gibt auch die Situation, daß Terme nicht unifizierbar sind, etwa g(X) und f (Y ) – die Funktionssymbole sind unterschiedlich, also n¨utzen alle Variablenbelegungen nichts. Oder auch X und f (X) – bei jeder Bekegung von X w¨urden wir dasselbe im rechten Term auch tun, sind also mit dem lonken immer ’einen Schritt zur¨uck’. Solche Terme heißen nicht unifizierbar. Es gibt den weiteren Fall, daß Terme auf mehr als eine Weise unifizierbar sind. Ein Beispiel: f (X, Y ) und g(Z, Y ). Hier k¨onnte man X = Y = Z setzen. Es reichte aber auch, nur X = Y zu setzen. Die letztere Unifkation ist allgemeiner, als die erste, denn man kann die erste aus der zweiten durch weiteres Substitutieren erhalten. Die zweite substituiert quasi nur das, was ebene gerade n¨otig ist, um die gleichen Terme zu nerhalten, aber nicht mehr. Man kann zeigen, daß dieser allgemeinste Unifikator von zwei Termen, so es ihn gibt, bis auf Variabkenumbenennung eindeutig ist. Es idt der sogenannte most general unifier (mgu). Zu seiner Berechnung gibt es einen Algorithmus, der sukzessive die Variablen ersetzt, um alles gleich zu machen. Unifikationsalgorithmus ist in Prolog eingebaut, wenn Prolog die K¨opfe von Regeln betrachtet, und seine genaue Form braucht uns hier nicht zu interessieren. Wenn Prolog K¨opfe mit Anfragen abgleicht, unifiziert es also und setzt die sich ergebenden Variablen an alle anderen Stellen der Formel. Die im Endeffekt berechneten Variablen einer Anfrage werden am Schluß von Prolog ausgegeben und k¨onnen verwendet werden, um Informationen zu berechnen. Termauswertung Bevor wir uns Unifkation und Variablenbelegungen zunutze machen, eine weitere Konstruktion. Prolog rechnet u¨ ber Herbrandalgebren, was im Zuge von arithmetischen Ausdr¨ucken sehr l¨astig ¨ werden kann. Betrachten Sie etwa 42 und 2 ∗ 21. Uber einer Herbrandalgebra sind die beiden Terme weder gleich noch unifizierbar, da sie sich ja zu den (v¨ollig verschiedenen) Zeichenketten auswerten. Im wirklichen Leben m¨ochte man h¨aufig solche arithmetischen Ausdr¨ucke tats¨achlich auswerten (und zwar u¨ ber den nat¨urlichen oder reellen Zahlen!). Man muß Prolog hierzu explizit anhalten durch das Wort is. Die Aussage X is 2*21 f¨uhrt dazu, daß der rechte Term ausgewertet und der Wert X zugewiesen wird.

162

7 PROGRAMMIERSTILE

Kommen wir mit dieser Zusatzinformation an eines unserer ersten Programme, den ggt. In Prolog k¨onnen wir den ggt durch folgende Wissensbasis berechnen: ggt(X,0,X). ggt(0,X,X). ggt(X,Y,Z) :- Y>0, X1 is X-Y, X1 >= 0, ggt(X1,Y,Z). ggt(X,Y,Z) :- X>0, Y1 is Y-X, Y1 >= 0, ggt(X,Y1,Z). Diese vier Regeln besagen, daß der ggt von einer Zahl und Null die Zahl gibt, und im anderen Fall man den ggt nicht a¨ ndert, wenn man von der gr¨oßeren Zahl die kleinere abzieht (wie wir beim euklidischen Algorithmus gesehen haben). Die Anfrage ggt(15,5,X). f¨uhrt zu der Antwort yes mit Wert X=5. Dabei wurde dreimal Regel 1 angewandt und je der ggt von 10 und 5, 5 und 5, bzw. 0 und 5 nachgefragt. f¨ur 0 und 5 trifft das zweite Faktum zu, das dann auch Z auf 5 setzt. Man kann auch Anfragen der Form ?-ggt(1,2,3). stellen, die mit no quittiert werden. Anfragen der Form ?-ggt(X,2,2). sind hier nicht gestattet, da bei der Auswertung von is die beteiligten Variablen belegt sein m¨ussen (Symbole kann man nicht arithmetisch auswerten). Was w¨are passiert, wenn wir unser Programm abgewandelt h¨atten zu ggt(X,0,X). ggt(0,X,X). ggt(X,Y,Z) :- Y>=0, X1 is X-Y, X1 >= 0, ggt(X1,Y,Z). ggt(X,Y,Z) :- X>=0, Y1 is Y-X, Y1 >= 0, ggt(X,Y1,Z). Das Programm ist logisch immer noch richtig, wie man leicht sieht, doch f¨uhren Anfragen der Form ?-ggt(1,2,3). zu einer Endlosschleife, wie folgt: ?-ggt(1,2,3). ?-ggt(1,1,3). ?-ggt(1,0,3). ?-ggt(1,0,3). ?-ggt(1,0,3). ... Listen Datenstrukturen in Prolog sind per default Symbole in der Herbrandalgebra oder, wenn man es explizit verlangt, arithmetische Ausdr¨ucke, wie wir gesehen haben. Eine der wichtigsten Datenstrukturen, die man in Prolog verwendet, sind Listen von Objekten, f¨ur die daher eine spezielle Notation existiert. Eine Liste ist generell eine endliche Folge von Objekten, die man in Prolog in eckige Klammern einschließt: [a,b,c,a,e,f] bezeichnet die Liste mit Elementen a, b, c, d, a, e, f, [ ] bezeichnet die leere Liste. Man darf Listen auch beliebig schachteln, etwa [a,[a,b],c,[a,[e,f]]] bezeichnet die Liste mit Elementen a, [a,b], c und [a,[e,f]]. Man kann solche Listen direkt in Prolog verwenden, wobei sie durchaus auch Variablen enthalten d¨urfen;etwa

7.3 Prolog

163

[X,Y,X,Y] referiert auf irgendeine Liste mit vier Elementen, wobei das erste und dritte, und das zweite und vierte Element gleich sind. Allgemein ist eine Liste entweder die leere Liste, oder sie ist zusammengesetzt aus einem ersten Element und einer darauf folgenden (evtl. leeren) Restliste. Auf dieser rekursiven Notation basierend stellt Prolog weitere Techniken bereit, die Elemente einer Liste anzusprechen: [X|L] referiert auf die Liste mit erstem Element X und Restliste L. Dabei wird vereinbart: [a|[]] ist die Liste [a], es a¨ ndert also nichts, wenn die leere Liste an eine bereits bestehende geh¨angt wird. Man kann so etwa die Elemente einer Liste der Reihe nach durchgehen. Als Beispiel betrachten wir ein Programm, das testet, ob ein gegebenes Element in einer Liste vorhanden ist: iselement(X,[X|_]). iselement(X,[_|L]):-iselement(X,L). Ein Element ist in einer Liste vorhanden, wenn es entweder das erste Element ist, oder in der Restliste vorhanden ist. Ein zweites Beispiel, wie berechnet man aus einer gegebenen Liste von Zahlen das Maximum? max(X,L):-hilfsmax(-100000,X,L). hilfsmax(X,X,[]). hilfsmax(X,M,[A|L]) :- A>X, hilfsmax(A,M,L). hilfsmax(X,M,[A|L]) :- X>=A, hilfsmax(X,M,L). Dieses Vorgehen berechnet iterativ das Maximum der Listenelemente, wobei in einer Hilfsvariablen das Maximum des schon besuchten Anfangsst¨ucks mitgef¨uhrt wird. Die beiden Regeln zu der Hilfsfunktion unterscheiden die F¨alle, ob aktuell ein noch gr¨oßeres Element gefunden wurde. Sobald die Liste abgearbeitet wurde, ist das bis dahin gefundene Maximum auch das gesamte, d.h. der Wert wird in die ’R¨uckgabevariable’ X geschrieben. Wir k¨onnen Listen auch dazu verwenden, das Problem der unendlichen Pfaden bei zyklischen Graphen zu l¨osen: wir f¨uhren einfach jeweils in einer Liste alle schon auf dem aktuellen Versuch besuchten Knoten mit und testen nur solche, die noch neu sind. Als Programm: path(X,Y) :- legalpath(X,Y,[]). legalpath(X,X,_). legalpath(X,Y,H):- edge(X,Z), legal(Z,H), legalpath(Z,Y,[Z|H]). legal(_,[]). legal(Z,[H|T]) :- Z\==H, legal(Z,T). begin{verbatim} Wir haben hier also das Hilfspr¨adikat legalpath verwendet. Dieses speichert je alle schon besuchten Ecken und f¨ugt nur neue legale an, d.h. solche, die noch nicht Element der Besuchtliste sind. Dazu testet man die Ungleichheit f¨ur jedes Element der Liste. Ungleichheit ist in purem Prolog eigentlich nicht vorgesehen, da man in den zugrundeliegenden Hornklauseln mehr als ein positives Literal erhalten w¨urde. Die eingebaute Funktion X\==Y ist dann und nur dann wahr, wenn X und Y nicht unifizierbar sind. F¨ur bereits instanziierte Variablen ist das tats¨achlich ein Test auf Ungleichheit.

164

7 PROGRAMMIERSTILE

Negation as failure Prolog bedingt durch die Einschr¨ankung auf Hornklauseln eine echte Einschr¨ankung allgemeiner logischer Aussagen, das nur ein positives Literal pro Regel existieren darf. Um manche Sachen zu formulieren, kommt man daher um eine Art der Erweiterung um mehr als ein positives Literal nicht herum. Realisiert wird dieses durch eine spezielle Art der Negation, die auf der rechten Seite von Regeln erlaubt ist. \+ aussage bedeutet das Negat von Aussage. Dabei ist dieses nicht die streng logische Negation, sondern Prolog interpretiert dieses operational durch sogenanntes negation as failure. Sobald eine solche Negation angetroffen wird, versucht Prolog, die Aussage zu beweisen. Falls dieses fehlschl¨agt, wird das Negat als g¨ultig angesehen. Es werden bei diesem Versuch grunds¨atzlich keine Variablen zur¨uckgegeben. Es kann also bei der Abarbeitung von \+ aussage dreierlei passieren: • aussage kann aus der Wissensbasis abgeleitet werden (mit irgendeiner Variablenbelegung). Dann schl¨agt \+ aussage fehl. • aussage kann aus der Wissensbasis nicht abgeleitet werden. Dann ist \+ aussage wahr, aber es werden keine neuen Variablenbelegungen zur¨uckgegeben. • Der Versuch, aussage abzuleiten, f¨uhrt zu einer Endlosschleife. Das Programm \+ aussage terminiert dann nicht. Dieses ist kein logisches Negat, selbst wenn die Aussage abgeleitet werden kann, da es von der sogenannten closed world assumption ausgeht: alles, was nicht ableitbar ist, gilt nicht (obwohl wir das ja eigentlich gar nicht wissen k¨onnen). Ein Beispiel f¨ur die Anwendung: wir h¨atten obiges eingebautes Zeichen \== ersetzen k¨onnen durch legal(Z,L) :- \+ iselement(X,L). Zwei Demonstrationen der closed world assumption: guilty(X) :- \+ innocent(X). innocent(peter_pan). innocent(winnieh_the_pooh). Die Anfrage ?- guilty(tweety) f¨uhrt zu yes. good_hotel(goedels). good_hotel(freges). expensive_hotel(goedels). reasonable_hotel(X) :- \+ expensive_hotel(X). Die Anfrage ?-good hotel(X),reasonable hotel(X). liefert yes mit der Belegung X=freges. Das liegt daran, daß zun¨achst X mit goedels initialisiert wird, und dann der Nachweis reasonable hotel(goedels) fehlschl¨agt. Danach wird X mit freges belegt, und das Programm ist erfolgreich. Die Anfrage ?-reasonable hotel(X),good hotel(X). hingegen liefert no. Das liegt daran, daß zuerst mit nicht initialisiertem X die Anfrage reasonable hotel(X) gestellt wird. Dieses wird (noch ohne Wahlm¨oglichkeiten) zur Anfrage \+ expensive hotel(X) resolviert. Prolog versucht also, expensive hotel(X) zu beweisen, was mit X als goedels gelingt. Der Versuch schl¨agt also fehl und es steht auch keine Alternative zur Verf¨ugung, denn X ist ja uninstanziiert in das negation as failure gegangen – daß es eine weitere Belegung g¨abe, f¨ur die alles gelten w¨urde, interessiert hier nicht. Sie sehen also, es kann innerhalb dieses nicht mehr puren Prolog merkw¨urdige Effekte geben, daher sollte man solche Elemente m¨oglichst gering halten.

7.3 Prolog

165

Cut Cut, geschrieben als ’!’, ist ein weiteres prozedurales Element, das u¨ ber die logische Grundlage von Prolog hinausgeht. ’!’ ist ein Pr¨adikat, das immer verifiziert werden kann. Es hat den Effekt, daß mit Abarbeiten von ’!’ alle m¨oglichen Backtrackingm¨oglichkeiten f¨ur die gerade betrachtete Regel annuliert werden; das betrifft alternative Aufrufe zur gerade betrachteten Regel und innerhalb der Regel selbst schon gespeicherte Backtrackingm¨oglichkeiten. Es k¨onnen nur noch der jetzt betretene Pfad, Backtrackingm¨oglichkeiten bezogen auf eine andere Regel vor Aufruf der jetzigen Regel oder neu entstehende Backtrackingm¨oglichkeiten begangen werden. Alle schon bestehenden Backtrackingm¨oglichkeiten bezogen auf die Regel selbst werden abgeschnitten. Der Effekt von ’!’ kann bezogen auf den Ableitungsbaum graphisch so dargestellt werden: cut−Regel: A :− B1, B2, ..., Bn, !, C1, C2, ..., Cm.

?−A, rest.

backtracking vor dem Aufruf von A durch cut abgeschnitten

Versuche, A ohne cut−Regel abzuleiten

?− B1, B2, ..., Bn, !, C1, C2, ..., Cm, rest

durch cut abgeschnitten Versuche, B1, ... abzuleiten ?− !, C1, ..., Cm, rest.

backtracking von B1, ..., Bn

?−C1, ..., Cm, rest.

Betrachten wir als ein Beispiel das Programm liebt(X,Y):-male(X),female(Y). liebt(a,b). female(hanna). female(mary):-!. female(sarah). male(joe). male(john):-!. male(007). L¨osungen sind

weitere Versuche, A abzuleiten

166

7 PROGRAMMIERSTILE

• joe, hannah • joe, mary • john, hanna • john, mary • a, b Der ’!’ bei male(john):-!. f¨uhrt dazu, daß kein weiterer Versuch, male(X) anders zu beweisen, mehr unternommen wird. Ein gleiches gilt f¨ur female(mary):-!. liebt ist ein den Regeln mit ’!’ u¨ bergeordnetes Pr¨adikat, das noch weiter abgetestet wird und durch den ’!’ nicht beeinflusst ist. ’!’ wird aus verschiedenen Gr¨unden verwandt. Ein Grund ist etwa, ein nicht-deterministisches Pr¨adikat in ein deterministisches zu verwandeln, wo es nur eine M¨oglichkeit der Verifikation gibt, nicht mehrere. Als Beispiel: wir haben ein Pr¨asikat geschrieben, das testet, ob ein Element in einer Liste vorhanden ist. Ist ein Element mehrfach vorhanden, dann kann man dieselbe Aussage auf mehrere Weisen verifizieren. Prolog geht diese im Zweifel alle durch. Das ist sehr n¨utzlich, wenn man alle Elemente der Liste der Reihe nach aufz¨ahlen will, aber eher l¨astig, wenn man nur testen will, ob ein Element enthalten ist. ’!’ schafft Abhilfe: elcheck(X,[X|_]):-!. elcheck(X,[_|L]):-elcheck(X,L). Der ’!’ verhindert, daß ein einmal gefundenes Element nochmal gefunden werden kann. Ein anderer Einsatz von ’!’ ist, Exklusionen elegant zu erkennen. Das Programm max(X,Y,X) :- X>=Y. max(X,Y,Y) :- X=Y,!. max(_,Y,Y). M¨ochte man so das Maximum berechnen, dann kann der zweite Fall nur dann eintreten, wenn der erste fehlgeschlagen hat, also nur im richtigen Fall. Es ist allerdings extreme Vorsicht beim Gebrauch von ’!’ geboten, da dieser Operator stark ins logische Geschehen eingreift und unerwartete Effekte haben kann. Als ein Beispiel, stellen wir an obiges Maximum die Anfrage ?-max(10,0,0). Die Antwort lautet yes! Das liegt daran, daß diese (nicht erw¨unschte, da mit initialisiertem dritten Argument angefragte) Nachfrage nicht mit der ersten Regel unifizierbar ist, also gar nicht bis zum ’!’ kommt, und die zweite Regel hier dann nat¨urlich gilt. Abhilfe: max(X,Y,Z) :- X>=Y,!,Z=X. max(_,Y,Y).

7.3 Prolog

167

Assert/Retract Wir haben zur Behebung unendlicher Zyklen bei der Pfadsuche in zyklischen Graphen die in diesem Versuch bereits besuchten Knoten mitgef¨uhrt. Das verhindert Zyklen, ist allerdings trotzdem noch ziemlich ineffizient: beim Backtracking werden ja die besuchten Knoten der Liste zur¨uckgenommen, und es wird ein Knoten in einem neuen Versuch evtl. nochmal besucht. Prinzipiell kann also eine nicht erfolgreiche Suche so lange dauern, wie es zyklenfreie Pfade im Graphen gibt (das k¨onnen viele sein). Was wir hier br¨auchten, w¨are eine globale Markierung der schon besuchten Knoten. Prolog l¨aßt f¨ur solche Zwecke zu, die Wissensbasis dynamisch zu a¨ ndern. Das Pr¨adikat asserta(fakt). f¨ugt fakt. vorne an die Wissensbasis an (assertz(fakt). f¨ugt hinten an). Entsprechend l¨oscht retract(fakt). das erste unifizierbare fakt der Wissensbasis, retractall(fakt. l¨oscht alle. Wir erhalten so eine effizienter L¨osung unserer Pfadsuche path(X,Y) :- retractall(besucht(_)),!,legalpath(X,Y). legalpath(X,X):-!. legalpath(X,Y):- edge(X,Z), \+besucht(Z), asserta(besucht(Z)),legalpath(Z,Y). asserta und retract haben u¨ ber Backtracking hinausgehende permanente Wirkung f¨ur die Wissensbasis, sie k¨onnen also zur Umsetzung globaler Informationen (etwa bei dynamischem Programmieren) benutzt werden. Effizienz Prolog basiert massiv auf Backtrcking und Symbolmanipulation und ist damit besonders geeignet f¨ur Probleme, die sich mit solchen Paradigmen l¨osen lassen. Dazu geh¨oren insbesondere Algorithmen der symbolischen K¨unstlichen Intelligenz, etwa Logikalgorithmen (Beweiser) oder Planungsstrategien. Prolog kann aber sehr schnell sehr ineffizient werden, wenn zu viele Backtrackinglevel gespeichert werden m¨ussen. Daher haben viele Systeme Optimierungsstrategien eingebaut. Eine wichtige Optimierung bei quasi iterativ laufenden Regelableitungen ist die Optimierung der sogenannten tail-Rekursion. Betrachten wir dazu unser vorheriges Programm zum Berechnen des Maximums in Listen: max(X,L):-hilfsmax(-100000,X,L). hilfsmax(X,X,[]). hilfsmax(X,M,[A|L]) :- A>X, hilfsmax(A,M,L). hilfsmax(X,M,[A|L]) :- X>=A, hilfsmax(X,M,L). Wir h¨atten stattdessen auch schreiben k¨onnen maximum(X,Y,X):-X>=Y. maximum(X,Y,Y):-X
168

8 INFORMATION

Allokieren von Speicher ausgef¨uhrt, ist daher wesentlich effizienter und vorzuziehen. Man sollte sich bem¨uhen, m¨oglichst alle nicht tats¨achlich inh¨arent rekursiven Berechnungen, also alle reinen Iterationen als tail-Rekursion zu formulieren.

8 Information Wir haben Programme zur automatischen Verarbeitung von Information behandelt. Was ist u¨ berhaupt Information und wie kann man den Informationsgehalt von gegebenen Daten messen? Wie kann man Information außer in den durch Java bereitgestellten Klassen und Datentypen repr¨asentieren? Wir streifen eine m¨ogliche Formalisierung des Informationsbegriffes mithilfe der sogenannten Entropie und werfen einen kurzen Blick auf Darstellungen von Information in komprimierter oder kodierter Form.

8.1 Entropie Die Informationstheorie ist eine auf Claude Shannon zur¨uckgehende mathematische Theorie, die sich um Begriffe wie Information, Entropie, Informations¨ubertragung, Datenkompression, Kodierung und Kryptographie dreht. Information wird in unterschiedlichen Disziplinen wie der Informatik, Physik, Semiotik, Nachrichtentechnik, den Gesellschafts- und Wirtschaftswissenschaften unterschiedlich spezifisiert, doch es geht immer um eine Form von Inhalt oder Bedeutung (was allerdings ein ebenfalls ‘schwammiger’ Begriff ist). Eine Leistung von Shannon ist, den Informationsbegriff rein axiomatisch im Rahmen der Wahrscheinlichkeitstheorie zu betrachten und so fundamentale Einsichten in optimale Informations¨ubertragung z.B. in einem allgemeinen Nachrichtenkanal zu erhalten. Die Aussagen sind dabei weitgehend unabh¨angig von spezifischer zugrundeliegender Semantik. Wir nehmen an, wir m¨ochten in einem Nachrichtenkanal Informationen u¨ bermitteln, etwa zwischen Rechnern, bei einem Telefongespr¨ach oder als kodierte streng geheime Meldung eines Sicherheitsdienstes. Die Informationen werden von einem Ursprung ausgesendet, den Ursprung nennen wir Source S. Das kann einfach ein einen Rechner bedienender Mensch sein, der mehr oder weniger sinnvoll die Tastatur bearbeitet. Die Source S liefert W¨orter der Form s = s i1 si2 . . . u¨ ber einem Alphabet S. Wir nehmen an, S sei endlich, z.B. die Buchstaben unseres Alphabets oder alle W¨orter des W¨orterbuchs. Jedes einzelne Element si ∈ S = {s1 , . . . , sr } hat eine gewisse Grundwahrscheinlichkeit f¨ur das Auftreten, d.h. S sendet si mit einer gewissen Wahrscheinlichkeit aus. Von den Buchstaben des Alphabets etwa benutzen wir ’e’ recht h¨aufig, ’y’ seltener. Wir nehmen an, diese Grundwahrscheinlichkeit ist konstant pi f¨ur das Element si , egal wann genau es von der Source im speziellen Fall ausgestoßen w¨urde. Wir haben hier nicht definiert, was ’Wahrscheinlichkeit’ bedeuten soll. Eine Wahrscheinlichkeitsverteilung u¨ ber den Buchstaben si des Alphabets P S ist nichts anderes als eine Zuordnung eines nichtnegativen Werts pi ≥ 0 f¨ur jedes si mit i pi = 1. pi gibt die Wahrscheinlichkeit des Auftretens von si an. Wir nehmen jetzt an, wir sind irgendein Zuh¨orer f¨ur die Source, und wir verstehen nichts von dem, was sie uns mitteilt. (Es kann sich etwa um eine Fremdsprache, uns nicht bekannte Maschinensprache, oder kodierte Nachrichten eines Geheimdienstes handeln.) Zum Zeitvertreib fangen wir an, uns allein auf abstrakter Ebene Gedanken zu machen, wieviel Information die Source uns mitteilt, ohne daß wir die W¨orter irgendwie verstehen und u¨ bersetzen k¨onnten. Die Wahrscheinlichkeiten pi wissen wir oder k¨onnen wir schnell sch¨atzen: sie entsprechen den relativen H¨aufigkeiten der Buchstaben, wenn wir der Quelle nur lange genug zuh¨oren. Wenn die Quelle konkret zu einem Zeitpunkt si ausgibt, was ist dann unser Informationsgewinn? Wir bezeichnen mit I(s i ) die

8.1 Entropie

169

in dem Ereignis si steckende Information in Abh¨angigkeit von der H¨aufigkeit von s i . I charakterisieren wir axiomatisch: • I(si ) ist monoton fallend mit wachsender Wahrscheinlichkeit pi . Die Information eines sicheren Ereignis, d.h. pi = 1, ist 0, denn wir wissen sowieso, daß es eintreten muß. (Etwa eine bloß tutende Leitung, die immer weitertutet.) • Wenn die Ereignisse s1 und s2 nacheinander auftreten, haben wir die summierte Information I(s1 s2 ) = I(s1 ) + I(s2 ) zur Verf¨ugung. Die Wahrscheinlichkeit des Ereignis s1 s2 ist das Produkt p1 · p2 , wenn die Ereignisse s1 und s2 alleine die Wahrscheinlichkeiten p1 und p2 haben; in der Wahrscheinlichkeitstheorie spricht man von unabh¨angigien Ereignissen. Wir sehen aufgrund der letzten Anforderung I(s1 ) = I(s1 s1 )/2 = I(s1 s1 s1 s1 )/4 = . . . Wir haben also folgenden Zusammenhang der Wahrscheinlichkeit und Information: wenn sich die Wahrscheinlichkeit quadriert, halbiert sich die Information. Die Tatsache, daß ein wahrscheinlicherer Ereignis eingetreten ist, beinhaltet also weniger Information; der genaue Verlauf dieser Kurve ist wie oben angegeben. Wir suchen also eine Funktion f (pi ) mit f (p2i )/2 = f (pi ). Das ist gegeben, wenn wir 1 I(si ) = − log2 pi = log2 pi durch den Logarithmus definiert w¨ahlen. Dabei setzen wir − log 2 0 := ∞. (W¨urde ein Ereignis, das Wahrscheinlichkeit Null hat, eintreten, h¨atten wir unendlichen Informationsgewinn.) Die Wahl der Basis ist hierbei egal. Wir w¨ahlen hier den Logarithmus zur Basis 2, da er sich sehr gut mit bin¨arer Information vertr¨agt. Was ist die Information, die in der Source S im Mittel steckt? si wird mit Wahrscheinlichkeit pi ausgegeben. Wir erhalten also die mittlere Information durch die gewichtete Summe Hr (S) =

r X i=1

pi I(si ) = −

r X

pi log2 pi

i=1

wobei wir 0 · log2 0 := 0 setzen. Diese Gr¨oße heißt auch Entropie der Source S. Wenn die Anzahl verschiedener Symbole r klar ist, wird r auch weggelassen. F¨ur die Entropie gelten einige Eigenschaften: P • Stetigkeit: die Entropie ist stetig in den Werten pi mit pi ≥ 0, pi = 1. (Intuition: die Natur macht keine Spr¨unge) • Monotonie bei Gleichverteilung: Sei S1 eine Source u¨ ber r Buchstaben mit Wahrscheinlichkeiten 1/r und S2 eine Source u¨ ber r + 1 Buchstaben mit Wahrscheinlichkeiten 1/(r + 1) (Gleichverteilung). Dann ist Hr (S1 ) < Hr+1 (S2 ). (Intuition: wenn man aus mehr verschiedenen M¨oglichkeiten den tats¨achlichen Wert erf¨ahrt, ist die gewonnene Information gr¨oßer) • Normierung: Ist S auf einem zweiwertigen Alphabet gleichverteilt, dann ist H 2 (S) = 1. • Partitionierung: Sei S eine Source u¨ ber einem Alphabet der Gr¨oße s mit Wahrscheinlichkeiten pi , Die Wahrscheinlichkeit der ersten r1 Symbole wird mit P1 := p1 +. . .+pr1 abgek¨urzt, die Wahrescheinlichkeit der letzten Symbole als P2 = 1 − P1 = pr1 +1 + . . . + pr . S1 eine Source nur u¨ ber den ersten r1 Zahlen mit induzierten Wahrscheinlichkeiten pi /P1 und S2 eine Source nur u¨ ber den letzten r − r1 Zahlen mit induzierten Wahrscheinlichkeiten pi /P2 . Dann gilt folgendes: Hr (S) = P1 · ·Hr1 (S1 ) + P2 · ·Hr−r1 (S2 ) + H2 (S 0 ) mit einer Source S 0 u¨ ber einem bin¨aren Alphabet mit Wahrscheinlichkeiten P1 und P2 , also einer die beiden Einzelsourcen S1 und S2 ausw¨ahlenden Source. (Intuition: Die Information einer Quelle

8 INFORMATION

170

kann man zerlegen. Zerlegt man die Quelle in zwei einzelne Teile f¨ur den ersten bzw. zweiten Part, dann ist die Summe der Informationen der beiden einzelnen Quellen gewichtete mit der Wahrscheinlichkeit ihres Auftretens und die Information, welche der beiden Quellen eingetreten ist, die Gesamtinformation.) Man kann nachrechnen, daß die Entropie diese Axiome erf¨ullt. Zudem kann man nachweisen, daß die Entropie die einzige Funktion ist, die diese Axiome erf¨ullt. Man kann durch diese Vorschriften die Funktion H also axiomatisch festlegen. Es gelten weitere Eigenschaften • H ver¨andert sich nicht, wenn man zus¨atzliche Buchstaben mit Wahrscheinlichkeit Null ins Alphabet nimmt. • Hr ist maximal f¨ur die Gleichverteilung auf r Buchstaben. Hier erh¨alt man durch den Bericht, welches Ereignis eingetreten ist, am meisten Information. Diese Begriffsbildung erlaubt also, ohne auf die hinter der Quelle liegende Semantik zu schauen, den Informationsgehalt der Quelle zu quantifizieren. Als ein Beispiel betrachten wir etwa eine Source u¨ ber einem bin¨aren Alphabet mti gleichverteilten Pk Buchstaben 0 und 1. Ein u¨ bertragenes Wort der L¨ange n entspricht dem Informationsgehalt i=1 − log2 (1/2) = k, also genau k Bits! Der mittlere Informationsgehalt der Quelle bei einem Buchstaben ist 1, ein Bit. W¨are die 1 h¨aufiger, etwa deren Wahrscheinlichkeit 0.9, h¨atten wir noch die Entropie 0.469, denn wir k¨onnen mit ziemlicher Sicherheit das Ereignis 1 voraussagen. Die Entropie ist ein in der Informatik h¨aufig gebrauchtes Hilfsmittel. Zur Illustration betrachten wir hier ihren Zusammenhang mit einfacher Kodierung.

8.2 Kodierung Wir stellen uns vor, die Nachricht der Source S soll u¨ ber einen Datenkanal an einen anderen Ort geschickt werden. Der Datenkanal stellt ein endliches Alphabet T = {t 1 , . . . , tk } zur Verf¨ugung, das von S verschieden sein kann. Um die Nachricht zu verschicken, m¨ussen wir also die Symbole in S in Symbole in T umwandeln. Definition 8.1 Zu einer Menge T bezeichne T + die Menge der endlichen nichtleeren W¨orter u¨ ber T . T ∗ bezeichne die Menge aller W¨orter, das leere Wort. Ein Code von S ist eine injektive Vorschrift C : S → T + . Es bezeichne C das Bild von C in T + . Das Bild von si ∈ S, wi := C(si ) ∈ T + ist das Codewort von si . C ∗ ist die Fortsetzung von C auf W¨orter in S ∗ : C ∗ : S ∗ → T ∗ mit C ∗ () = und C ∗ (si1 . . . sit ) = C(si1 ) . . . C(sit ).23 Ein Code transformiert also jeden Buchstaben eindeutig in ein Wort u¨ ber T . Es kann dabei sein, daß die Codew¨orter lang werden m¨ussen, wenn T nur wenige Buchstaben hat. Um z.B. alle 26 Buchstaben in einem bin¨aren Alphabet zu kodieren, ben¨otigen wir eine Maximall¨ange der Gr¨oßenordnung log2 26. Eine einfache Codierung der Einzelbuchstaben n¨utzt uns allerdings noch nicht viel. Wir m¨ochten als Empf¨anger der Nachricht u¨ ber den Kanal das Original rekonstruieren. Nehmen wir an, die Eingabe ist 1234 mit dem Code 0 f¨ur 1, 1 f¨ur 2, 10 f¨ur 3 und 11 f¨ur 4. Der Code ist also 011011. Das kann allerdings auch f¨ur 122122 und andere Kombinationen stehen. Wir definieren daher Definition 8.2 Ein Code heißt eindeutig, wenn die Funktion C ∗ injektiv ist, also keine unterschiedlichen W¨orter zu einem gleichen Code f¨uhren. 23

Zur Erinnerung: Injektiv bedeutet, daß nicht zwei Eingaben auf denselben Wert abgeboldet werden.

8.2 Kodierung

171

Wir sind nur an eindeutigen Kodierungen interessiert, da wir bei mehrdeutigen Kodierungen die originale Nachricht nicht unbedingt entschl¨usseln k¨onnnen. Obige Kodierung war nicht eindeutig. Sie w¨are eindeutig gewesen, h¨atten wir 1 als 00 und 2 als 01 geschrieben. Allgemein gilt: Theorem 8.3 Kodierungen, wobei jedes Codewort dieselbe La¨ nge hat, sind eindeutig. Das einzusehen, ist einfach. Derartige Kodierungen weren z.B. in ASCII oder Unicode verwendet, wo eine feste Anzahl Bits f¨ur die Kodierung eines Buchstabens oder Zeichens zur Verf¨ugung gestellt wird. ASCII und Unicode haben zus¨atzliche Vorteile: man kann schon anfangen, zu dekodieren, wenn man nur die Anfangsst¨ucke der Nachricht empfangen hat. Bei sequentieller Nachrichten¨ubertragung spart das Zeit. Formal definieren wir Theorem 8.4 Eine Kodierung heißt instantan, falls sich jede Anfangssequenz einer Nachricht wi1 wi2 wi3 . . . win . . . sicher zu si1 si2 si3 . . . sin . . . dekodieren l¨aßt. ¨ Offensichtlich ist ein instantaner Code auch immer eindeutig dekodierbar. Ist eine instantane Ubersetzung nicht der Fall, kann dieses unter Umst¨anden bei sequentieller Nachrichten¨ubertragung fatale Folgen haben. Betrachten Sie etwa folgenden englischen, instantan ins Russische zu u¨ bersetzenden Satz: RUSSIANS DECLARE WAR... ... RINGTON VODKA TO BE EXCELLENT ¨ Nach der ersten Zeile tritt dabei z.B. durch Ubertragungsschwierigkeiten eine kleine Pause ein. ¨ Eine instantane Ubersetzung (inklusive des WAR in WARRINGTON) und Reaktion darauf kann hier fatale Folgen haben. Code, der eine feste Codewortl¨ange verwendet, ist instantan. Es macht aber nicht immer Sinn, nur feste Codewortl¨angen zu verwenden, etwa wenn einige Buchstaben in S sehr viel h¨aufiger sind als andere. Denken Sie an das Morsealphabet, in dem sich wichtige und h¨aufige Buchstaben k¨urzer, also schneller u¨ bertragen lassen, als seltener gebrauchte. M¨ußte man ¨ f¨ur die Ubertragung von SOS wesentlich mehr Codebuchstaben verwenden, w¨are man evtl. schon gesunken. Wann ist ein Code instantaner Code? Theorem 8.5 Instantane Codes sind genau die sogenannten Pr¨afixcodes, d.h. Codes so daß kein Codewort wi Anfangsst¨uck eines anderen Codewortes wj 6= wi ist. Um das einzusehen, zeigen wir zwei Richtungen: • Ein instantaner Code muß Pr¨afixcode sein: Angenommen, wir haben keinen Pr¨afixcode, also wi = wj w 0 f¨ur Codew¨orter wi 6= wj . Dann ist der Code wj nicht sicher zu sj dekodierbar, denn folgt w 0 , k¨onnte das si ergeben. • Ein Pr¨afixcode ist instantan: startet eine Nachricht mit wi , muß das sich zu si dekodoeren, da sonst wi Pr¨afix eines anderen Codewortes w¨are. Wir k¨onnen also von einer Nachricht das (eindeutig dekodierbare) Anfangsst¨uck wegstreichen und erhalten mit Induktion die eindeutige Dekodierbarkeit des restlichen Anfangsst¨ucks. Wie erh¨alt man gute Pr¨afixcodes? Es hilft, sich einen Pr¨afixcode als Teil eines Baums darzustellen. Nehmen wir an, das Alphabet T habe k = 2 Elemente. Dann kann man die W¨orter u¨ ber T startend vom leeren Wort als Baumstruktur anordnen, wobei auf der Ebene i W¨orter der L¨ange i stehen und ein Elter je zu seinen um 1 l¨angeren Kindern verweist. Etwa wie folgt:

8 INFORMATION

172 000

001

00

010

011

100

01

101

110

10

111

11 1

0

Ein Wort ist Pr¨afix eines anderen dann und nur dann wenn es im Baum auf einem Pfad von der Wurzel zu diesem anderen erreichbar ist. Die Codew¨orter eines pr¨afixfreien Codes entsprechen daher den Bl¨attern eines solchen (nicht notwendig vollst¨andig besetzten) Baumes. Man kann pr¨afixfreie Codes erhalten, indem man einen Baum mit der gew¨unschten Anzahl Bl¨atter und je maximal k Nachfolgern je innerem Knoten erzeugt, und dann die Bl¨atter als Codew¨orter interpretiert. Man m¨ochte einen Code finden, so daß die zu u¨ bertragenden W¨orter m¨oglichst kurz sind. Die L¨ange eines Codewortes wi ist die Anzahl der Buchstaben in dem Wort und wird im folgenden mit li referenziert. Die Wortl¨angen sollten m¨oglichst kurz sein, wobei wahrscheinliche Buchstaben s i auch k¨urzere Wortl¨angen haben sollten. Man kann die sogenannte Kraft’sche Ungleichung zeigen: Theorem 8.6 Sei |T | = k. Es gibt einen instantanen Code mit Wortla¨ ngen l1 , . . . , lr dann und nur dann, wenn r X 1 ≤1 li k i=1 gilt.

Wir verzichten auf den Beweis, der in einem etwas verzwickten Abz¨ahlen von Bl¨attern in obigem Baum besteht. Was sind m¨oglichst kurze L¨angen? Wie vorhin nehmen wir an, die Source S gibt mit Wahrscheinlichkeit pi den Buchstaben si aus. Dann ist die mittlere Wortl¨ange einer Codierung C unter der Source S die Gr¨oße r X L(C, S) = p i · li i=1

Definition 8.7 Ein optimaler Code von S ist ein instantaner Code mit minimaler mittlerer Wortl a¨ nge L(C, S). Zun¨achst eien Feststellung: Theorem 8.8 Zu jeder Source S gibt es einen optimalen Code. Das ist nicht von vorneherein klar, da es ja unendlich viele (beliebig lange) W¨orter u¨ ber T gibt und also auch unendlich viele Codes. Diese k¨onnen aber nicht beliebig gut werden. Man sieht schnell, daß es zu einem gegebenen Code C nur endlich viele bessere C 0 geben kann (und von denen ist dann mindestens einer optimal): sei C 0 instantaner Code mit L(C 0 , S) < L(C, S). Sei p = min{pi |i, pi > 0}. Es muß f¨ur die Wortl¨angen li0 von C 0 f¨uP r Symbole mit Wahrscheinlichkeit pi > 0 gelten li0 ≤ L(C, S)/p, denn sonst h¨atten wir L(C 0 , S) = pj lj0 ≥ pli0 > p·L(C, S)/p = L(C, S). Da die Symbole mit Wahrscheinlichkeit Null nichts zum Code beitragen, gibt es also nur endlich viele verschiedene bessere Werte als L(C, S) entsprechend diesen endlich vielen verschiedenen W¨ortern begrenzter L¨ange. Wie bekommen wir konkret optimale Codes? Eine sehr bekannte Methode sind sogenannte Huffman-Codes. Wir beschr¨anken uns hier der Einfachheit halber auf bin¨are Huffmann-Codes. ¨ Diese werden iterativ konstruiert und beruhen auf folgenden zwei Uberlegungen:

8.2 Kodierung

173

• Wir identifizieren die Buchstaben sn−1 und sn mit einem einzigen Buchstaben s0 . Sei w1 , . . . , wn−1 ein instantaner Code von s1 , . . . , sn−2 , s0 . Dann ist w1 , . . . , wn−2 , wn−1 0, wn−1 1 instantaner Code von s1 , . . . , sn−2 , sn−1 , sn . (Dieses sieht man leicht mithilfe der Pr¨afixeigenschaft.). • Die Buchstaben mit geringer Wahrscheinlichkeit d¨urfen l¨angere Codeworte haben. Ein Huffmann-Code identifiziert sukzessive die zwei Buchstaben mit den kleinsten Wahrscheinlichkeiten miteinander, bis nur noch ein Symbol zu kodieren ist. F¨ur dieses wird ein Codewort, n¨amlich das leere Wort verwendet (das eigentlich nicht zul¨assig ist, aber hier trotzdem verwandt wird, um den Algorithmus elegant zu formulieren). Zum Originalalphabet kommt man, indem man die Codeworte wie oben f¨ur die jeweils zusammengef¨ugten Symbole durch Zuf¨ugen von 0 und 1 erweitert. Ein Beispiel: die Zahlen 1 bis 5 haben die Wahrscheinlichkeiten 0.3, 0.2, 0.2, 0.2, 0.1. Man erh¨alt: (1 − 0.3)

(2 − 0.2)

(3 − 0.2)

10

00

(4 − 0.2) 010

11

(5 − 0.1) 011

(4’ − 0.3) (2’ − 0.4)

(1’ − 0.6)

01

1 0 (1’’ − 1)

Die Symbole werden zun¨achst sukzessive vereinigt, so daß ein Baum entsteht. Entlang dieses Baums k¨onnen die Codierungen mit der beschriebenen Vorschrift gew¨ahlt werden. Theorem 8.9 Der Huffman-Code ist optimal. Es ist bereits klar, daß ein instantaner Code ensteht. Es muß also nur die Optimalit¨at gezeigt werden. Dazu zwei Hilfslemmata: • Sei ein Code C 0 f¨ur r Symbole und Source S 0 aus C f¨ur r − 1 Symbole und Source S wie im Huffman-Code durch Zuf¨ugen von 0 bzw. 1 gewonnen. Sei p = p i + pj die Wahrscheinlichkeit des ’vereinigten’ Symbols aus S 0 in S. Dann ist (mit li = lj = l + 1 f¨ur ein l nach Konstruktion) L(C 0 , S 0 ) − L(C, S) = pi (l + 1) + pj (l + 1) − pl = pi + pj = p. • Jede Source S hat einen optimalen bin¨aren Code, in dem zwei der l¨angsten Codew¨orter im Baum Kinder desselben Elter sind. Beweis: Sei C optimaler Code und xt l¨angstes Codewort mit einem Buchstaben t und einem Wort x. Sei t¯ die Zahl 1 − t (also 0 f¨ur t = 1 und umgekehrt). Wenn xt¯ auch Codewort ist, sind wir fertig. Wenn es nicht Codewort ist, dann ist das einzige Codewort mit Anfangsst¨uck x das Wort xt selbst. Wir k¨onnen also xt durch x ersetzen und behalten einen Pr¨afixcode, der allerdings k¨urzere mittlere L¨ange hat. Widerspruch. Jetzt k¨onnen wir die Optimalit¨at des Huffman-Code mit vollst¨andiger Induktion u¨ ber die Anzahl der zu kodierenden Symbole beweisen: • F¨ur ein Symbol ist der Code optimal.

8 INFORMATION

174 • Gelte die Aussage f¨ur Sourcen mit r − 1 Symbolen.

• Sei S 0 die aus S erhaltene Source, indem man zwei Symbole si und sj mit kleinster Wahrscheinlichkeit vereinigt. Sei C Huffmancode f¨ur S und C 0 Huffmancode f¨ur S 0 . Wir finden L(C, S) − L(C 0 , S 0 ) = p mit p = pi + pj . Sei D ein optimaler Code f¨ur r Symbole, und x0, x1 l¨angste Codew¨orter, die nach unserem Hilfslemma existieren m¨ussen. Wir zeigen, daß man diese Worte als Codew¨orter von si und sj w¨ahlen kann. Zun¨achst zu si , das OE kleinste Wahrscheinlichkeit pi hat. Falls das Codewort von si nicht x0 oder x1 ist, sondern etwa x0 Codewort von sk , dann tauschen wir die Codew¨orter von sk und si . Wir ersetzen damit in der L¨ange von D den Ausdruck pk |D(sk )|+pi |D(si )| durch pk |D(si )|+pi |D(sk )|. Es gilt pk |D(sk )|+pi |D(si )|−pk |D(si )|− pi |D(sk )| = (pk − pi )(|D(sk )| − |D(si )|). Das ist nicht negativ, da pi kleinste Wahrscheinlichkeit und D(sk ) l¨angstes Codewort ist. Es ist also auch der neue Code optimal und der Ausdruck notwendigerweise null. Genauso sehen wir, daß wir x1 als Code von s j w¨ahlen k¨onnen. Aus D l¨aßt sich ein Code D 0 f¨ur S 0 gewinnen, indem wir das Codewort des neuen Symbols als x nehmen. Wie wir gesehen haben, ist L(D, S) − L(D 0 , S 0 ) = p. Also L(D, S) − L(D 0 , S 0 ) = L(C, S) − L(C 0 , S 0 ). C 0 ist Huffmancode f¨ur S 0 und nach Induktionsvoraussetzung optimal. Daher ist L(C 0 , S 0 ) ≤ L(D 0 , S 0 ) und also L(C, S) ≤ L(D, S). Damit ist also auch C optimal, da es D ist. Das zeigt die Behauptung. Wir haben also einen optimalen Code konstruiert, wissen aber noch nichts u¨ ber seine tats¨achliche L¨ange in Abh¨angigkeit von S. Die L¨ange ist optimal, aber wie groß kann sie konkret werden, d.h. wieviel Zeit und Bandbreite muß man konkret f¨ur ein gegebenes S zur Verf¨ugung stellen? Hier hilft uns der Begriff der Entropie. Jedes Symbol, das von S emittiert wird, beinhaltet im Mittel H(S) Informationseinheiten. Falls das kodiert werden soll, ohne Information zu verlieren, ben¨otigt man im Mittel durch diese Zahl gegebene Codel¨ange geteilt durch den Informationsgehalt der Codes. Jedes Einzelsymbol des Codes bei r (gleichverteilten) Symbolen hat den Informationsgehalt − log2 1/r = log2 r. F¨ur Sources, die sehr informativ sind, ben¨otigt man also l¨angere Codeworte. Formal ist dieses in folgendem Theorem festgehalten: Theorem 8.10 Sei C instantaner Code u¨ ber r Symbolen zur Source S. Dann gilt L(C, S) ≥ H(S)/ log2 r Um das zu beweisen, zun¨achst eine Feststellung: f¨ur x > 0 ist ln x ≤ x − 1, Gleichheit gilt genau f¨ur x = 1. Das beweisen wir nicht, sondern schauen uns einfach die Graphen der beiden Funktionen an:

x−1

ln x

8.2 Kodierung

175

Damit erhalten wir folgende Aussage: P P • Sei xi ≥ 0, yi > 0, xi = yi = 1. Dann ist X X − xi log2 xi ≤ − xi log2 yi

P P P Die Differenz der beiden Seiten ergibt x log (y /x ) = x ln(y /x )/ ln 2 ≤ xi (yi /xi − i i i i i i 2 P P 1)/ ln 2 = ( xi − yi )/ ln 2 = 0 mit Gleichheit nur f¨ur yi /xi = 1.

Seien die Wortl¨angen des Codes C die Zahlen l1 , . . . , lr . Wir finden P H(S) = − P pi log2 pi P −li −li ≤ − p log r / i 2 P P −li r li = P pi log2 (r · r P ) P = P pi li log2 r + log2 (P r −li ) · pi = P pi li log2 r + log2 ( r −li ) ≤ pi li log2 r = L(C, S) log2 r P −li wobei wir die Kraft’sche Ungleichung verwendet haben, also r ≤ 1. Damit gilt die UngleiP −li chung log2 ( r ) ≤ 0. Codel¨angen sind also immer nach unten durch die Entropie der Quelle beschr¨ankt. Optimale Codes haben genau diese L¨ange, falls oben an allen Stellen Gleichheit werden EiP erreicht P kann. −li −li −li nerseits das (erste Ungleichung und Hilfssatz) pi = r / r und log2 ( r ) = 0 P bedeutet also r −li = 1. Da heißt pi = r −li bzw. − logr (pi ) = li ist eine nat¨urliche Zahl. Ist umgekehrt − logr (pi ) eine P P nat¨urliche Zahl, und setzen wir (was dann geht) li = − logr (pi ), dann finden wir 1/r li = pi = 1, es ist also die Kraft’sche Ungleichung erf¨ullt und es gibt Codes mit dieser L¨ange. D.h. L(C, S) = H(S)/ log2 r gilt dann und nur dann, wenn − logr (pi ) eine nat¨urliche Zahl ist f¨ur alle i. Ansonsten ist ein optimaler Code l¨anger als die untere Grenze angibt. Je nachdem, wie weit die Ausdr¨ucke − log r (pi ) von einer nat¨urlichen Zahl abweichen, kann das erheblich l¨anger sein, als die untere Schranke durch die Entropie angibt. Man kann auch obere Schranken f¨ur die L¨ange optimaler Codes finden. Sogenannte Shannon-Fano-Codes bieten eine M¨oglichkeit dazu. Shannon-Fano Codes sind solche, die die Wortl¨ange l i als die n¨achstbeste Wahl nehmen: als kleinste nat¨urliche Zahl li ≥ − logr (pi ). Wir wissen, daß es solche Codes geben muß aufgrund der Kraft’schen Ungleichung. (Wie auch immer sie konkret aussehen; das haben wir hier nicht behandelt. Wir wissen lediglich, daß es sie gibt!) Diese Codes sind nicht unbedingt P optimal, aber − log r pi ≤ li ≤ − logr pi +1, also − pi logr pi ≤ P solch ein PCode C erf¨ullt Pdie Ungleichung P pi li ≤ − pi logr pi + p1 = − pi logr pi + 1. Wegen logr pi = log2 pi / log2 r finden wir also H(S)/ log2 r ≤ L(C, S) ≤ H(S)/ log2 r + 1 Das gibt uns eine obere Schranke f¨ur optimale Codes. Man kann diese Schranken noch weiter betrachten, um Aussagen im Mittel bzw. f¨ur immer l¨angere Wiederholungen der Nachrichten¨ubertragung zu erhalten. Der Unterschied von 1 verschwindet tats¨achlich, wenn man immer l¨angere zu kodierende Texte betrachtet. Sei S n die n-fache Iteration der Source S. Sei Cn ein optimaler Code von S n mit mittlerer L¨ange Ln . Dieser Code kodiert implizit auch S selbst und ben¨otigt daf¨ur die mittlere L¨ange L n /n. Dann gilt: lim Ln /n = H(S)/ log2 r

n→∞

Das ist Shannons erstes Theorem. (F¨ur dessen Beweis uns lediglich noch die Feststellung H(S 1 S2 ) = H(S1 ) + H(S2 ) fehlte.) Sehr lange Nachrichten lassen sich also optimal kodieren mit einer durch die Entropie der Quelle determinierten mittleren Wortl¨ange.

176

8 INFORMATION

¨ Das ist ein erster Schritt in die durch Shannon begr¨undete Informationstheorie, die die Ubertragung von Informationen auf rein formalem, axiomatischem Wege untersucht und zu interessanten Aussagen u¨ ber Machbarkeit, Aufwand, Kodierung, etc. sowie konkret einsetzbaren Verfahren kommt.

8.3 Kompression und Kryptographie Im Zuge der Kodierung sind weitere Formalisierungen f¨ur die Praxis von Belang: Bisher sind wir von einer zuverl¨assigen Daten¨ubertragung ausgegangen. In der Praxis ist das nicht der Fall, Daten k¨onnen durch technische St¨orungen zuf¨allig ge¨andert werden, so daß eine verrauschte Kodierung ankommt. Bewegen sich die Fehler in Maßen, kann man sie mit hoher Wahrscheinlichkeit durch geeignete Kodierungen und Checks korrigieren. Das ist der Bereich der Nachrichten u¨ bertragung unter Rauschen und fehlerkorrigierender Codes. Wichtig in diesem Zusammenhang sind eta CRCCodes, d.h. eine sehr leistungsf¨ahige und effiziente Fehlererkennung f¨ur bin¨are Daten. Die Idee ist, neben den Daten Pr¨ufbits zu verwenden, die anzeigen, ob ein oder mehrere Bits ver¨andert wurden (und die Nachricht evtl. nochmal versendet werden muß). Die Berechnung entsprechender Pr¨ufbits kann dabei sehr effizient in digitalen Schaltungen realisiert werden. Besonders relevant ist dieses Thema bei sehr großen Datenmengen, wo einerseits leicht Fehler auftreten und andererseits die Schnelligkeit der u¨ bertragung gew¨ahrt werden soll. H¨aufig werden Daten dabei zudem komprimiert u¨ bertragen – in gewissem Rahmen haben wir bereits das Gebiet der Kompression gestreift, einer Darstellung der Daten mit m¨oglichst kurzen W¨ortern. Dabei k¨onnen Zusatzbedingungen gestellt werden, wie etwa einer m¨oglichst einfachen Dekompressionsvorschrift, um dieses online (z.B. beim Laden von Webseiten u¨ ber das Internet) darstellen zu k¨onnen. H¨aufig ist man an einer verlustfreien Daten¨ubertragung interessiert. Es kann aber auch das Ziel sein, die Daten m¨oglichst kompakt darzustellen (mit einem optimalen Code), so daß alles Wesentliche rekonstruiert werden kann. Zul¨assig sind dann geringf¨ugige, f¨ur den Betrachter irrelevante Abweichungen, also eine verlustbehaftete Kompression. Kompression ist insbesondere bei großen Bilddaten wichtig. Es gibt viele prominente Formate: • GIF-Bilder sind verlustfrei komprimiert mit einem Algorithmus, der h¨aufig vorkommende Muster (insbesondere Farbmuster) durch k¨urzere Darstellungen ersetzt. • JPEG-Bilder sind verlustbehaftet abgespeichert, wobei ein menschlicher Wahrnehmer die Unterschiede nicht merkt. Die Kompression besteht aus einer Kosinustransformation, einer geeigneten auf die menschliche Wahrnehmung angepasste Quantisierung, und einer Kodierung. Wir sehen also, die theoretischen Informationsbegriffe haben sehr praktische Anwendungen und beinhalten Algorithmen, die zur generellen Informations¨ubertragung z.B. im Internet gebraucht werden – und programmiert werden m¨ussen. Wir haben bisher zugelassen, daß jeder die Nachricht empfangen und dekodieren kann. Es kann sein, daß es um geheime Dokumente geht, die verschl u¨ sselt werden sollen. Dann bewegt man sich in das Gebiet der Kryptographie, der Entwicklung von Codes, so daß nur autorisierte Benutzer sie verstehen k¨onnen. In diesem Bereichen gibt es sehr interessante und h¨aufig nicht triviale Theorie. In diesem Zusammenhang tauchen auch insbesondere in Multimedia und Internet einige Schlagworte auf: • Data Encryption Standard: Ein 1977 von IBM durch die US-Regierung u¨ bernommenes Verschl¨usselungsprogramm, das heute aber nicht mehr als sicher gilt. Es verschl¨usselt je 64Bit-Bl¨ocke mit einem 56-Bit-Schl¨ussel in 19 Stufen, d.h. es verwendet grunds¨atlich eine einfache Ersetzung von St¨ucken des Originals in gleich lange Codew¨orter.

177 • Kerberos, der mehrk¨opfige H¨ollenhund des Hades, lieh seinen Namen einem am MIT entwickelten Authentifizierungsverfahren, das in Rechnernetzwerken oft eingesetzt wird. • Digitale Signaturen ersetzen Unterschriften etwa in der Finanzwelt. Sie basieren auf geeigneten Kombinationen von private- oder public-key Verfahren um sicherzustellen, daß der Empf¨anger den Sender sicher identifizieren kann, der Sender nicht die Nachricht r¨uckg¨angig machen kann und der Empf¨anger nicht die Nachricht a¨ ndern kann. • Secure socket layer (SSL) ist ein von Netscape entwickelter Protokollstandard zur Netzkommunikation, der Verschl¨usselung und Authentifizierung beinhaltet und so u¨ ber das Web bereitgestellte Informationen und Informations¨ubertragung sicherer machen soll. • Public key RSA Kryptoverfahren sind heute ein weit verbreiteter Standard, da man den Schl¨ussel, d.h. die Codew¨orter nicht auszutauschen braucht. RSA ist eines der gebr¨auchlich¨ sten Verfahren, basierend auf relativ einfachen zahlentheoretischen Uberlegungen. Prinzipiell ist es so, daß ein Empf¨anger einen o¨ ffentlichen Verschl¨usselungsschl¨ussel bereitstellt und den privaten und nur ihm bekannten Entschl¨usselungsschl¨ussel f¨ur sich beh¨alt. Ein Knackpunkt, dessen Erkenntnis wesentlich zur Entwicklung dieser Verfahren beigetragen hat, ist offensichtlich, daß man Verschl¨usselung und Entschl¨usselung v¨ollig unabh¨angig voneinander berechnen kann. Dieses macht sich besondere Eigenschaften der nat¨urlichen Zahlen und der (bisher noch) nur ineffizient berechenbaren Primfaktorzerlegung von großen Zahlen zunutze. Eine der essentiellen Stellen ist dabei, daß mit einem Rechner sehr schnell große zuf¨allige Primzahlen erzeugt werden k¨onnen (wie wir gesehen haben), aber Primfaktoren aus Produkten nur sehr ineffizient zur¨uckgewonnen werden k¨onnen (bzw. hier kein effizienter Algorithmus mit standard-Rechnern bekannt ist. Einer der Gr¨unde, warum die Forschung an sogenannten Quantencomputern sehr interessant ist, besteht in der Tatsache, daß f¨ur solche Rechenmodelle efiziente Primfaktorzerlegungen bekannt sind – nur die entsprechenden Quantencomputer sind technisch noch nicht realisierbar).

9 Informationsverarbeitung im Rechner Wie wird die Information im Rechner prinzipiell verarbeitet und vorgehalten? Logisch teilt man die auf einem Rechner angesiedelten Programme und informationsverarbeitenden Einheiten in mehrere Ebenen auf: • Die Hardwareebene bestehend aus – Physikalischen integrierten Schaltungen, Kabeln, Stromversorgung, Speicher, . . . – der Mikroarchitekturebene, in der die physikalischen Einheiten zu kleinen logischen Einheiten, wie etwa der CPU oder der arithmetisch logischen Einheit zusammengefasst sind, – der Maschinensprache, die mit typischerweise 50 bis 300 Basisinstruktionen die physikalischen Einheiten steuert. • Die Ebene der Systemprogramme, bestehend aus – Betriebssystem – Compiler, Editoren, Kommandozeileninterpreter • Die Ebene der Anwendungsprogramme wie Web-Browser, Datenbanksystem, spezielle Firmensoftware, . . .

178

9 INFORMATIONSVERARBEITUNG IM RECHNER

Wir haben uns bereits mit speziellen Sprachen (Java und Prolog) und darin gechriebenen Anwendungsprogrammen (etwa Sortieren von Zahlen) besch¨aftigt, und auch im Rahmen Boolescher Funktionen einen (sehr kurzen) Blick auf Schaltungen, also den Hardware-Bereich geworfen. Das Betriebssystem ist eine Schnittstelle zwischen Hardware und Anwendungssoftware und regelt die Verteilung von Ressourcen wie etwa Speicherplatz, Rechenzeit, etc. und die Kommunikation und Synchronisation der Prozesse. Je nach Gegebenheiten unterscheidet man zwischen verschiedenen Modi: • Mainframe-Systeme unterscheiden sich von u¨ blichen B¨urocomputern durch die wesentlich gr¨oßere LEistung und hohe I/O-Kapazit¨at, entsprechend sind die Betriebssysteme daraufhin optimiert, sehr viele Ein-/Ausgabe-intensive Prozesse gleichzeitig bedienen zu k¨onnen. Relevant sind Mainframes etwa als Großrechner in großen kommerziellen Betrieben zur Verwaltung zentraler Datenbanken oder Web-Seiten. • Server, h¨aufig leistungssf¨ahige PCs, workstations oder gr¨oßere Maschinen, stellen NetzDienste bereit, etwa die Verwaltung von Druck-Jobs, Dateien, Webdienste, etc. Relevant ist hier ein robuster und sicherer Betrieb f¨ur viele Anfragen. • Multiprozessor-Systeme durch Integration mehrerer CPUs oder physikalischer Rechner nehmen f¨ur umfangreiche Rechnungen einen immer h¨oheren Stellenwert ein. Wichtig sind in diesem Kontext gute Scheduling-Algorithmen, um Jobs auf den Prozessoren zu verteilen. • Personal Computer haben die Aufgabe, f¨ur einzelne Benutzer komfortable und gleichzitig kosteng¨unstige Kompaktl¨osungen bereitzustellen. • Real-time Systeme etwa in industriellen Prozessen haben strikte Anforderungen an die Einhaltung von zeitlichen Bedingungen. • Eingebettete Systeme wie etwa ein palmtop Computer stellen reduzierte Funktionalit¨aten auf kleinem Raum bereit. • SmartCards treiben dieses ins Extreme, mit oft sehr spezifizierten Funktionen auf kleinstem Raum und g¨unstiger Fertigung. Die Entwicklung von Betriebssystemen f¨ur heutige Rechner wird h¨aufig in vier Phasen eingeteilt: in der ersten Generation (1945-55), Computer bestanden noch aus Elektronenr¨ohren, wurden Programme manuell via Steckleisten eingegeben. In der zweiten Generation u¨ bernehmen Transistoren die Arbeit, jetzt m¨ogliche Batch-Jobs sind auf Magnetb¨andern gespeichert. Die dritte Phase (19651980) setzt auf integrierte Schaltkreise, so daß mehrere Teile ausgelagert werden k¨onnen, Spooling = Simultaneous Peripheral Operation On Line. Zweitens kann man mehrere Programme/Benutzer gleichzeitig bedienen, Multiprogramming und Time-sharing werden relevant. Die vierte Generation ist durch VLSI-Chips (very large scale integration) bestimmt. Es entstehen die heute bekannten PCs und Workstations mit komfortabler Oberfl¨ache und Multitasking, desweiteren Netzwerksysteme und verteilte Systeme. Was u¨ berwachen Betriebssysteme? Auf der Hardware-Seite stehen folgende Stichpunkte: • Fetch-Execution-Zyklus des Prozessors: im Inneren eines Rechners werden im Prinzip lediglich iterativ Basisanweisungen vom Anweisungsstack geholt und ausgef¨uhrt. Die Anweisungen sind dabei maschinenspezifisch, und enthalten typische Anweisungen wie Register lesen/schreiben, Speicher adressieren, etc. Jede Anweisung enth¨alt alle ben¨otigte Information.

9.1 Prozesse

179

• Auf dieser Ebene steuern Interrupts das Zusammenspiel insbesondere bezogen auf Eingaben und (durch Maskierung, d.h. Deaktivierung bestimmter Interrupts) bezogen auf monolithisch zu verarbeitende kritische Bl¨ocke. • Die Ein-/Ausgabe ist u¨ ber verschiedene Buse realisiert, je nach Art des anh¨angenden Ger¨ates. Es gibt hier verschiedene K¨urzel: ISA, PCI, USB, SCSI, IEEE1394, . . . . Besonders interessant ist die Kommunaktion bei sich a¨ ndernder Konfiguration (etwa eingestecktem USB Stick). Hier ist das von Microsoft entwickelte plug and play-Konzept n¨utzlich: es werden w¨ahrend des Betriebs Informationen u¨ ber die sich evtl. ver¨andernden Zusta¨ande gesammelt und vom System-BIOS (Basic Input Ouput Systems) direkt per low-level Software verwaltet. • Informationen werden einerseits in unterschiedlichen Registern gespeichert, andererseits muß man auf weniger schnelle (aber g¨unstige und damit gr¨oßere) Medien zugreifen: mehrere Caches speichern h¨aufig gebrauchte Information, der Hauptspeicher l¨adt einen großen Teil der Daten eines Programms zur weiteren Verarbeitung, die Festplatte dient f¨ur die u¨ bliche Information u¨ ber alle m¨oglichen Daten und persistente Speicherung, und dann kann man noch auf verschiedenste externe Speicher ausweichen. Das Betriebssystem hat die Aufgabe, Informationen auf h¨oherer Ebene, etwa vom Benutzer gegeben Eingaben, auf diese Ebene herunterzubrechen. Konzeptuell kann man es dazu in drei Bereiche einteilen: Kommandozeileninterpreter und/oder graphische Benutzeroberfl¨ache, low-level Funktionalit¨aten, und den Kern, das Herz eines Betriebssystems.

9.1 Prozesse Ein paar Grundbegriffe sind f¨ur jedes Betriebssystem relevant. Die Aufgabe eines Betriebssystems ist die, w¨ahrend eines Programmablaufs logischen Einheiten gegeben durch Prozesse zu verwalten. Ein Prozeß ist ein Programm in der Ausf¨uhrung. Prozesse leben in einem gewissen Adressraum, d.h. Platz des Speichers, den der Prozeß beschreiben und l¨oschen darf. Prozesse werden charakterisiert durch einen Prozesskontrollblock, der folgendes beinhaltet: • die Nummer des Prozeß, • den Zustand des Prozeß (running, sleeping, . . . ), • der gespeicherte Zustand der Prozeßregister, • Scheduling Information wie etwa die Priorit¨at, • Verweise auf Datei- oder Netzwerkverbindungen des Prozeß, • Besitzerinformation (Gruppen und User id des Benutzers), die verwandt werden, um Zugriffsrechte zu u¨ berwachen, • Zeiger zu anderen Prozessen, etwa Kindern oder Eltern. Ein Prozeß kann einen anderen Prozeß abspalten (in Unix durch fork), dieser Kindprozeß erbt dann die Rechte des Vaterprozeß. Viele Betriebssysteme speichern alle aktuellen Prozeße in einer Prozeßtabelle zusammen mit ihrem aktuellen Zustand, der ben¨otigten Zeit, etc. Diese Tabelle wird genutzt, Prozesse geordnet zu schedulen: die CPU-Zeit wird nach berits vergebener Rechenzeit und Priorit¨at des Prozeß gescheduled. Wird ein Prozeß unterbrochen, muß sein aktueller Zustand (etwa Dateiverbindungen und Register) gespeichert und der Prozeß sp¨ater an der gleichen Stelle fortgesetzt werden. Dabei

180

9 INFORMATIONSVERARBEITUNG IM RECHNER

k¨onnen, wie wir es schon aus Threads kennen, Racing consitions, starvation oder deadlocks auftreten, die vom Betriebssystem m¨oglichst verhindert werden sollten (aber es nicht immer werden, der Befehl kill unter Unix leistet in einem solchen Fall gute Dienste). Threads unterscheiden sich von Prozessen dahingehend, daß sie keinen eigenen Speicher besitzen, sondern als Teilst¨ucke eines Prozeß parallel laufen. Trotzdem gelten die bereits zu Threads genannten Aspekte des Scheduling (etwa round-robin Scheduling oder Scheduling mit Priorit¨aten) f¨ur Prozesse analog.

9.2 Speicher Eng mit Prozessen verkn¨upft ist die Frage des Memory-Management. Ein Prozeß greift auf Speicher zu, wobei die Speichermedien unterschiedlich schnell sind, angefangen von Registern u¨ ber Cache zur Festplatte. Zun¨achst ist bei Betriebssystemen ein Bereich des Hauptspeichers immer f¨ur den Kern des Betriebssystems sowie Ger¨atetreiber und weitere Dinge reserviert und kann weder von einzelnen Benutzerprozessen beschrieben noch ausgelagert werden, der sogenannte kernel space. F¨ur Prozesse wird der user space verwandt, wo entsprechend der Systemauslastung zugegriffen, beschleunigt, oder auch ausgelagert werden kann. In vielen Betriebssystemen wie Unix erh¨alt jeder Prozeß seinen eigenen getrennten Bereich des user space, den er verwaltet. Da in Benutzerprozessen der Speicherbedarf nicht vorausgesagt werden kann und in vielen Anwendungen gr¨oßer als der verf¨ugbare Hauptspeicher wird, wird heute meist die Technik des virtuellen Speichers verwandt. Das bedeutet, daß Speicherzellen nur indirekt referenziert werden und nach Bedarf in schnellen Medien gelagert oder auch auf die Festplatte ausgelagert werden k¨onnen. Da der Ort dieses Speichers wechseln kann, greift der Kern eines Betriebssystems nie direkt darauf zu. Die von Programmen erzeugten Speicheradressen werden bei variablem Memory nicht direkt an den Memory Bus geschickt, sondern an die MMU (Memory Management Unit). Diese rechnet virtuellen in tats¨achlichen Speicher um. Eine gebr¨auchliche Technik ist die Fragmentierung: es wird je sukzessive st¨uckweise auf noch freie Bl¨ocke geschrieben und der jeweils anschließende logisch dazugeh¨orende Speicherplatz gespeichert. Diese Technik nutzt den gesamten Platz aus, hat aber den Nachteil, daß sie zu langen Zugriffszeiten f¨uhren kann und Systeme durch eine u¨ berm¨aßige Fragmentierung (das heißt nur sehr gest¨uckelte Nutzung des Speichers) in die Knie zwingt – eine explizite Defragmentierung ist dann n¨otig. Eine der gebr¨auchlichsten neueren Techniken, virtuellen Speicher effizient zu verwalten, ist das paging. Beim Paging ist die Grundidee, physikalischen Speicher und logischen Speicher in gleich großen Bl¨ocken zu organisieren, wobei man virtuelle Pl¨atze sehr schnell in physikalische umrechnen kann. Dieses verhindert eine Fragmentierung des Speichers und erlaubt zudem, ganze Seiten auf einmal aus- und einzulagern. Die Seiten werden in einer Paging-Tabelle gespeichert, die den Index der benutzten Seiten und ihre physikalische Adresse speichert. Logische Adressen und physikalische Adressen werden dann durch Tupel charakterisiert, gegeben durch den Index f¨ur Pages bzw. den physikalischen Startpunkt f¨ur tats¨achliche Seiten sowie den (identischen) Offset des Eintrags zur tats¨achlichen Speicherstelle. Dabei muß darauf geachtet werden, daß der Zugriff auf die Paging-Tabelle sehr schnell ist. Paging kann mehrfach hintereinander angewendet werden, um gr¨oßere Bl¨ocke effizient auszulagern oder kleinere Einheiten zu erreichen (die Sparc 32-bit Architektur etwa erlaubt dreifaches Paging), was aber sehr langsam werden kann. Paging Strategien bieten sich besonders an, Speicher auszulagern, da man ganze Bereiche auf einmal umschreiben kann. Die Entgscheidung, welche Information wo am effizientesten gespeichert werden soll, verlangt passende Strategien, die einerseits schnell und robust implementiert werden k¨onnen, andererseits die h¨aufig gebrauchten Speicherzellen m¨oglichst in schnellen Spei¨ chermedien belassen. Ubliche Strategien sind etwa • First in first out, mit dem Hintergrung, daß die aktuellsten Ergebnisse hoffentlich die zur Zeit

9.3 Filesystem

181

am meisten gebrauchten sind; • Ersetzen der am wenigsten gebrauchten Page; • Ersetze die am l¨angsten nicht mehr gebrauchte Page; • Ersetze die Page, die in Zukunft als sp¨atestes gebraucht wird (was man dann aber irgendwie absch¨atzen muß, etwa durch die Laufzeiten der aktuellen Prozesse und deren bisherige Zugriffe.)

9.3 Filesystem Dateien sind persistente Container f¨ur Daten, die meist beliebige Informationen enthalten k¨onnen. H¨aufig wird durch das Dateiende das Format des Inhalts nahegelegt und eine Verkn¨upfung mit einem entsprechenden Anzeigeprogramm realisiert (.gz f¨ur gezippte Dateien, .tar f¨ur Archive, .ps f¨ur Postscript, .pdf f¨ur Portable Document Formate, . . . ). Gelegentlich werden einige (in Unix alle) weiteren Objekte als Dateien behandelt: Peripherie (/dev/mouse), Prozesse (/proc), Internetverbindungen (/net/tcp), . . . . Dateien sind logisch innerhalb hierarchischer Namensr¨aume angesiedelt, als Bl¨atter in einer Baumstruktur von Verzeichnissen und Dateien. Ihre absoluten Pfade (also die Hintereinanderh¨angung aller Verzeichnis- und Dateinamen angefangen von der Wurzel) m¨ussen dabei eindeutig sein. Eine strikte Baumstruktur kann durch symbolische Links (also Verkn¨upfungen zu anderen Dateien oder Verzeichnissen) durchbrochen werden. Verzeichnisse k¨onnen entweder als spezielle Objekte oder als normale Dateien mit speziellem Inhalt realisiert werden. In Linux und Unix k¨onnen ganze Verzeichnisse partiell in den Dateibaum eingebunden (gemounted) werden, etwa beim Lesen einer CD oder eines Memory-Stick. Dateien k¨onnen durch ihre absoluten Namen (mit vollem Pfad) oder die relativen Namen bezogen auf das aktuelle Verzeichnis identifiziert werden. Da Dateien groß werden k¨onnen, sind sie nicht unbedingt physikalisch zusammenh¨angend gespeichert, sondern in mehreren St¨ucken mit Verweisen auf die je nachfolgenden St¨ucke; der Benutzer sieht diese physikalische Zerst¨uckelung nicht. Dateien werden durch spezielle Informationen charakterisiert, die zu den Dateien abgespeichert sind und den Namen, Zugriff, etc. regeln. Diese Information unterscheidet sich je nach Betriebsssysten. F¨ur Linux und Unix wird im sogenannten i-node (der Ursprung dieses Namens ist dabei ein R¨atsel auch f¨ur die Unix-Pioniere) vorgehalten • die L¨ange in Bytes, • die Identifikation des Mediums, auf dem die Datei existiert, • die Identifikation des Besitzers, • die Gruppe des Besitzers, • eine eindeutige Kennziffer (inode number) der Datei, • der Zugriffsmodus, darstellbar als sieben-Tupel mit x-Bit (ausf¨uhrbar), Lese-/Schreib- und Ausf¨uhrungsrechte f¨ur Besitzer, Gruppe, und Welt (etwa -rw-r–r–), ¨ • Zeitstempel der Erzeugung, der letzten Anderung, und des letzten Zugriff, • die Anzahl der auf die Datei verweisenden anderen Dateien oder Verzeichnisse.

182

9 INFORMATIONSVERARBEITUNG IM RECHNER

In anderen Systemen gibt es andere (mitunder sehr viel unkomfortablere) Vereinbarungen. Es kann auftreten, daß Dateien oder wichtige Informationen verloren gehen, etwa bei einem Systemcrash oder unvorsichtigem Abschalten des Rechners. Daf¨ur sind in den Betriebssystemen mehrere Sicherheiten eingebaut. Etwa in Linux werden inzwischen sogenannte jorunaling files¨ systems verwandt. Das bedeutet, daß Anderungen (etwa L¨oschoperationen) in einem separaten Block dokumentiert werden, bevor sie tats¨achlich vorgenommen werden. Passiert etwa innerhalb ¨ der Anderungen ein Crash, dann kann das System anhand der Protokolle den urspr¨unglichen Zustand wieder herstellen. Betriebssysteme beschr¨anken sich dabei h¨aufig auf eine Dokumentation der Metadaten und nicht des tats¨achlichen Inhalts, da dieses leicht zu kostspielig wird. Metadaten beinhalten etwa die Adressr¨aume, Erweiterungen, etc. die dann immerhin noch ein bedingtes Reparieren aufgetretener Fehler gestatten. Eine zweite Kontrolle, die bei un¨uberlegtem Abschalten oder Crashs automatisch beim n¨achsten Bootvorgang aufgerufen wird, ist ein Check der inode-Zahlen auf Konsistenz, um etwa fehlende Dateien (nicht benutzte, aber nicht als frei deklarierte Bl¨ocke) zu entdecken.

9.4 IO Die Ein- und Ausgabe wird je nach Ger¨at und Betriebssystem unterschiedlich behandelt. Charakteristisch f¨ur Windows ist etwa die einfache (aber manchmal fehlschlagende – ’plug and pray’) plug-and-play-Realisierung. In Unix k¨onnen Ein-/Ausgaben universell als Datenstr¨ome mithilfe von Pipes behandelt werden. Einige Stichpunkte sollten in diesem Rahmen erw¨ahnt werden: Ein-/Ausgabe sind h¨aufig langwierigere Prozesse. Um nicht f¨ur jedes Zeichen den Benutzer (bzw. Benutzerprozess) zu bem¨uhen, werden Eingaben in St¨ucken in einem Puffer zwischengespeichert, bevor sie angezeigt oder in eine Datei geschrieben werden. Verwandt wird dabei meist ein double buffeering, d.h. zwei Bl¨ocke sind im Hauptspeicher reserviert, von denen je ein aktueller von der I/O beschrieben und der andere weiterverarbeitet (abgespeichert oder ausgegeben) wird. Auch bei der Ein- und Ausgabe k¨onnen Daten falsch geschrieben werden, oder es kann unpassend unterbrochen werden. Sogenanntes stable storage liest und schreibt Dateien mit anschließendem Pr¨ufvergleich, so daß Fehler auffallen und die Aktion evtl. wiederholt werden kann. Die Performanz von I/O hat sich technisch gesehen nicht in demselben Rahmen entwickelt wie etwa CPU-Zeit. Sichere und g¨unstige, schnell beschreibbare Medien sind daher heute h¨aufig durch einen Trick realisiert: RAIDs (Redundant Array of Inexpensive Disks), d.h. eine Ansammlung von g¨unstigen und schnell zugreifbaren einfachen Medien, in diesem Fall schnellen kleineren Platten. Diese k¨onnen entweder direkt ausschließlich in Hardware oder u¨ ber entsprechende Software und mehrere Rechner realisiert werden. Es gibt verschiedene Ans¨atze, Daten m¨oglichst effizient verteilt abzulegen und dabei auch gegebenenfalls m¨ogliche Ausf¨alle von einzelnen Platten zu kompensieren. Einfaches Striping zerlegt die Daten in Bl¨ocke, die auf mehreren sukzessiven Platten gespeichert werden. Damit kann parallel geschrieben und gelesen werden, allerdings ist keinerlei Redundanz eingebaut, also keine Reparatur bei Ausfall von Platten m¨oglich. Redundanz erh¨alt man, indem man diesen Ansatz dahingehend erweitert, jede Information zweimal abzuspeichern, allerdings wird der Plattenplatz damit effektiv halbiert. Einen Kompromiß bildet, zu den Daten Pr¨ufbits abzuspeichern. In der Regel verwendet man zus¨atzlich zur gespeicherten verteilten Information u¨ ber die Platten hinweg berechnete Parity-Bits, die eine Korrektur gestatten, solange nur eine Platte gleichzeitig ausf¨allt. Dabei sollten die Parity Bits nicht auf einer Platte gelagert sein!

9.5 Kern

183

9.5 Kern Der Kern eines Betriebssystems organisert den sicheren Zugriff von Computerprogrammen auf die Maschinenhardware, und zwar sowohl bezogen auf die Zeitaufteilung als auch bezogen auf den prinzipiellen Zugriff. Vieole Aspekte haben wir bereits diskutiert. Beim prinzipiellen Design, d.h. der Implementation von Kernen wird zwischen verschiedenen Sichtweisen unterschieden. Klassisch sind monolithische Kerne, startend mit Unix, welches ein (das erste) effizientes funktionsf¨ahiges und elegantes Betriebssystem offerierte. Die Grundidee von Unix war, alle Operationen einfach als Dateioperationen zu realisieren und dem Benutzer durch Dateimanipulationen mit dem System kommunizieren zu lassen. Alle Operationen speichern und/oder liefern Werte. Das Umlenken dieser Str¨ome und Verketten erlaubt komplexe Funktionalit¨aten. Umlenken der Einund Ausgabe geschieht u¨ ber Pipes, die die Daten zwischenpuffern und weitergeben. Mithilfe diser prinzipiellen Ansicht k¨onnen Benutzer mit nur sehr wenigen Befehlen (Befehle als Ein-/Ausgabe und Pipes) das gesamte Betriebssystem beherrschen. Mit der Entwicklung neuer Medien und insbesondere graphischer Benutzeroberfl¨achen br¨ockelte dieses Konzept; monolithische Kerne sprengten die urspr¨unglichen etwa 100000 Zeilen Code von Unix zu u¨ ber 33 Millionen f¨ur Linux. An der Carnegie Mellon University wurde mit dem Mach-Kern der Prototype f¨ur ein neues schlankeres Kerneldesign gelegt und die T¨ur zu sogenannten Mikrokernen aufgestoßen. Die Grundidee f¨uhrt dabei die Unix-Realisierung von Pipes weiter: Systeme bestehen aus kleinen Einheiten, die durch Pipes miteinander kommunizieren, durch die jetzt aber jede Art von Information (nicht nur Dateiformate) geschickt werden kann. So entstanden die Bausteine, um die sich derartige Betriebssysteme gruppieren: • ein Task besteht aus Resourcen, welche erm¨oglichen, daß Threads laufen, • ein Thread ist eine Einheit von Code, die auf einem einzelnen Prozessor l¨auft, • ein Port definiert die Schnittstelle zwischen Prozessen mittels einer sicheren Pipe, • Messages beliebieger Art k¨onnen u¨ ber diese Pipes geschickt werden. Der Mach Kern war insbesondere der einzige, der erlaubte eine einzelne Task durch mehrere Threads zu realisieren, heute der Standard. Das verschob die Sicht von einem monolithisch agierenen Betriebssystem zu einer verteilten Implementation mithilfe von einzelnen Servern f¨ur spezielle Aufgaben, die mithilfe von Ports komunizieren. Mit der tats¨achlichen Nutzung des Mach-Kerns tauchten allerdings fundamentale Effizienzprobleme auf: Zugriff auf Speicher und das Umschreiben von Information zwischen Prozessen ist extrem teuer, aber extensiv genutzt insbesondere bei Prozeßkommunikation und dem Systemaufruf von Prozessen durch andere u¨ ber Server hinweg. Paging-Mechanismen, die in einem monolithischen System noch an die konkreten Bed¨urfnisse angepasst werden konnten, m¨ussen in verteilten Systemen allgemein und entsprechend ineffizient gehalten werden. Das von Unix u¨ bernommene Konzept beruht aber extensiv auf der Interprozesskommunikation und dem Umschalten zwischen verschiedenen Servern (und Adressr¨aumen). Mikrokernel wurden erst wieder popul¨ar mit der Verkn¨upfung der Idee einzelner Server und aus der Windows-Welt stammenden Konzepten: gibt es nur einen großen Addressraum, m¨ussen die Daten nicht zwischen verschiedenen R¨aumen umgeshiftet werden, und ein Großteil des Overheads des Mach-Kerns f¨allt weg. Sicherheitsaspekte k¨onnen in die einzelnen Anwendungsprogramme verlagert werden, statt in jedem Port integriert sein. Mit diesen Verschlankungen ist das Mikrokernel-Konzept insbesondere f¨ur verteilte low-level Anwendungen attraktiv.

184

9 INFORMATIONSVERARBEITUNG IM RECHNER

9.6 Good bye! Wir m¨ochten zum Schluß in Java ein kleines Fenster programmieren, das den Text ’Good bye!’ ausgibt. Das Ganze soll als applet in einem Browser laufen. Ein Applet ist nichts anderes als ein Java-Programm, das von der Klasse Applet abgeleitet ist und einige Konventionen ber¨ucksichtigt. Die Klasse kann dann direkt in html-Code eingef¨ugt werden und auf anderen Rechnern u¨ ber das Internet gestartet werden. Dazu m¨ussen einige Konventionen befolgt werden: der fremde Rechner muß dieses Programm ausf¨uhren k¨onnen. Einerseits kann es dabei Probleme geben, weil nicht dieselbe Version von Java auf dem fremden Rechner implementiert ist, andererseits hat das Programm in der Regel sehr beschr¨ankte Rechte, kann also keine Dateien manipulieren, Netzverbindungen aufbauen oder a¨ hnliches. Unser erstes Applet hat einfach folgende Form: import java.applet.Applet; import java.awt.Graphics; public class Goodbye extends Applet { public void paint(Graphics g) { g.drawString("Good bye!", 50, 25); } } Dieses Applet benutzt zwei Pakete, die Java liefert, applet, um Applets auszuf¨uhren, und die Graphik des abstract windowing toolkit (awt), um ein Fenster zu zeichnen. Das obige Programm implementiert die Methode paint. Jedes Applet muß eine der Methoden init, start oder paint implementieren, damit etwas passiert. Applets brauchen nicht die Methode main zu implementieren, die f¨ur Applets nicht aufgerufen wird. Obige Methode u¨ bernimmt ein Graphikobjekt (genauer den Kontext des aktuellen Applets) und zeichnet mit dessen Hilfe ein Fenster mit dem String "Good bye!", wobei die Position der linken unteren Ecke angegeben wurde. Benutzt wird dieses Applet durch Einbinden in ein html-Dokument mithilfe des Tag . Good bye!
Good-bye applet

Es muß der Klassenname angegeben werden, und es wird erwartet, daß der Code der Klasse im selben Verzeichnis wie das html-Dokument steht, sofern das nicht durch codebase=<wo> spezifiziert ist. Zudem muß die Gr¨oße des Applets (in Punkten) angegeben werden. Nicht Java-f¨ahige Browser stellen den unter alt angegebenen Text dar. Man kann Parameter an das Applet geben, induziert durch das Tag param mit angegebenem Namen und Wert (als String). Die Klasse muß wie u¨ blich mit javac u¨ bersetzt werden. Ein Aufruf dieser Seite f¨uhrt dann zur Ausf¨uhrung des Programms. Java offeriert auch die M¨oglichkeit, sich die Funktion von Applets im Appletviewer anzusehen. Das geschieht durch den Aufruf java sun.applet.AppletViewer gefolgt vom Namen der html-Seite.

9.6 Good bye!

185

Das obige Applet ist sehr simpel, es stellt lediglich einen Text dar (impliziter Aufruf der ¨ paint Methode), sonst passiert nichts. Ublicherweise berechnen Applets w¨ahrend ihres gesamten Lebenszyklus etwas, daher werden meist komplexere Methoden implementiert. Der u¨ bliche Lebenszyklus von Applets wird durch die im Original noch leeren Methoden init (Initialisierung), start (Start beim neuen oder ersten Betrachten der Webseite), stop (beim Iconifizieren oder Verlassen der Webseite) und destroy (beim L¨oschen des Applet) bestimmt. In obigem Applet wird allerdings keine einzige dieser Methoden u¨ berschrieben, sondern lediglich die Graphikmethode paint ver¨andert und der Text auf die Seite geschrieben. Den Lebenszyklus eines Applets kann man gut in folgendem Beispiel sehen: import java.applet.Applet; import java.awt.Graphics; public class Lifecycle extends Applet { StringBuffer buffer; public void init() { buffer = new StringBuffer(); addItem("initializing... "); } public void start() { addItem("starting... "); } public void stop() { addItem("stopping... "); } public void destroy() { addItem("preparing for unloading..."); } void addItem(String newWord) { System.out.println(newWord); buffer.append(newWord); repaint(); } public void paint(Graphics g) { g.drawString(buffer.toString(), 5, 15); } } In einem gepufferten String werden hier pro Aufruf Messages hinzugef¨ugt und ausgegeben. Man sieht sehr sch¨on, wie sich bei jedem Iconifizieren und Deiconifizieren des Fensters der Text verl¨angert, da stop und start aufgerufen werden. Ein explizites stop und destroy ist insbesondere dann n¨otig, wenn man innerhalb eines Applets mehrere Threads startet – diese werden nicht automatisch gestoppt und verschwenden daher Speicherplatz oder Rechenzeit, auch wenn die Seite des Applets u¨ berhaupt nicht betrachtet wird. Applets sind sehr m¨achtig, man kann etwa: • pro Webseite mehrere Applets erzeugen und diese gegenseitig ansprechen, • von Webseiten Parameter einlesen, • mit einem Applet eine neue Webseite aufrufen, • auf Aktionen des Benutzers wie Eingaben oder Mousebewegungen reagieren,

10 LITERATUR

186 • Multimediadateien abspielen • u¨ ber awt oder swing Oberfl¨achen einbinden, • etc.

Das soll hier nicht mehr Thema sein. Wir wollen lediglich zum Schluß das obige Applet Goodbye so ver¨andern, daß wir einen Knopf dr¨ucken k¨onnen, woraufhin sich der Text (auf dem Button) zu "Hello world!" a¨ ndert und umgekehrt. Dazu ben¨otigen wir ein Objekt Button, das von Java zur Verf¨ugung gestellt wird. Ein Listener horcht auf Ereignisse, etwa auf den Knopfdruck. Das Applet ist: import java.applet.*; import java.awt.*; import java.awt.event.*; public class goodbyebutton extends Applet implements ActionListener{ Button byebutton; private int status = 0; public void init(){ byebutton = new Button("Good bye!"); add(byebutton); byebutton.addActionListener(this); } public void actionPerformed(ActionEvent event){ if (event.getSource() == byebutton){ if (status == 0) byebutton.setLabel("Hello world!"); else byebutton.setLabel("Good bye!"); status = 1-status; repaint(); } } public void start(){ } public void stop(){ } public void destroy(){ } }

10 Literatur • Java-Online-Referenz: http://java.sun.com/j2se/1.4.2/download.html • Einf¨uhrungen mit Java: – Einf¨uhrung in die Informatik: Objektorientiert mit Java, Wolfgang K¨uchlin, Andreas Weber, Springer, mehrere Auflagen – Algorithmen in Java, Hans Werner Lang, Oldenbourg, 2003

187 – Java: eine Einf¨uhrung, Martin Schader, Lars Schmidt-Thieme, Springer, 2003 • Algorithmen-Klassiker: – Algorithmen und Datenstrukturen, Ottmann/Wiedmayer, Spektrum Verlag, mehrere Auflagen – Agorithms in C (Java), Sedgewick, Addison Wesley • Theoretische Informatik: Theoretische Informatik - eine problemorientierte Einf¨uhrung, Sperschneider/Hammer, Springer, 1996, online auf meiner homepage http://www.informatik.uni-osnabrueck.de/barbara/papers/pub hammer.html • Boolesche Algebren, Schaltalgebren, Zahldarstellung: – Grundz¨uge der Digitaltechnik, Hentschke, Teubner, 1988 – Informatik: Rechenanlagen, Hotz, Teubner, 1972 • Floating Point und Numerik: – Numerische Mathematik, Stoer, Springer, mehrere Auflagen – Numerical Recipes in C, Press et al., Cambridge, mehrere Auflagen • Parallele Prozesse, Betriebsysteme: – Modern Operating Systems, Tanenbaum, Prentice Hall – Concurrent Programming in Java, Lea, Addison-Wesley • Prolog und Logik: – Clause and Effect, Clocksin, Springer – Logic – A Foundation for Computer Science, Sperschneider/Antoniou, Addison-Wesley • Historie: – Der Computer Mein Lebenswerk, Zuse, Springer, 1984 – Vom Abakus zum Internet: die Geschichte der Informatik, Friedrich Naumann, Wissenschaftliche Buchgesellschaft, 2001 • Informationstheorie: Informations- und Kodierungstheorie, Herbert Klimant, Rudi Piotraschke, Dagmar Sch¨onefeld, Teubner, 2003 (2te Auflage) • Zwei sehr gute online-Skripten zur Informatik, es gibt viele weitere – aus Magdeburg: http://ivs.cs.uni-magdeburg.de/sw-eng/agruppe/lehre/ead.shtml – aus Princeton: http://www.cs.princeton.edu/introcs/home/ • und alles weitere k¨onnen Sie selbst im Internet suchen http://www.google.de

Informatik III 001.ps.gz

Read more

Grundlagen theoretischer Informatik 001

Read more

Theoretische Informatik 001.ps.gz

Read more

Informatik 001.ps.gz

Read more

Logische Systeme der Informatik 001

Read more

Theoretische Grundlagen der Informatik 001

Read more

Analysis I III 001

Read more

Ausgewaehlte Kapitel der th Informatik 001.ps.gz

Read more

Logische Systeme der Informatik 001.ps.gz

Read more

Theoretische Informatik

Read more

Theoretische Informatik

Read more

Kursbuch Informatik

Read more

Theoretische Informatik

Read more

Informatik: Aufgaben und Losungen, Begleitbuch zu Blieberger et al.: Informatik (Springers Lehrbucher der Informatik)

Read more

Theoretische Informatik - kurzgefaßt

Read more

Historische Notizen zur Informatik

Read more

Historische Notizen zur Informatik

Read more

Iii

Read more

Algorithmentechnik 001

Read more

Compilertechnik 001

Read more

Laplacetransformation 001

Read more

Gruppentheorie 001

Read more

Makrooekonomik 001

Read more

Hydromechanik 001

Read more

Kontinuumsmechanik 001

Read more

Spieltheorie 001

Read more

Elektrodynamik 001

Read more

Lebensversicherungsmathematik 001

Read more

Statistics 001

Read more

Kryptographie 001

Read more

Recommend Documents

Informatik III 001.ps.gz

Grundlagen theoretischer Informatik 001

Grundlagen Theoretischer Informatik I / II Wintersemester 2005/2006 — Dr. Norbert Müller — Universität Trier Basis: Skri...

Theoretische Informatik 001.ps.gz

Informatik 001.ps.gz

Logische Systeme der Informatik 001

Logische Systeme der Informatik Hubert Wagner Universit¨at Dortmund FB Informatik LS1 D-44221 Dortmund Wintersemester 20...

Theoretische Grundlagen der Informatik 001

Theoretische Grundlagen der Informatik 1 Wintersemester 2005/2006 Skript von Hans-Jo¨rg Burtschick und Dirk Siefkes unte...

Analysis I III 001

Skript Analysis I - III Wintersemester 2001/2002 - Wintersemester 2002/2003 LATEX Jens Rckert 2004 2 Vorlesungsskrip...

Ausgewaehlte Kapitel der th Informatik 001.ps.gz

Logische Systeme der Informatik 001.ps.gz

Theoretische Informatik

Theoretische Informatik Eine Einführung in Berechenbarkeit, Komplexität und formale Sprachen mit 101 Beispielen Pear...

Report "Informatik I+II 001"

Your name

Email

Reason

Description

Copyright © 2024 EPDF.MX. All rights reserved.
About Us | Privacy Policy | Terms of Service | Copyright | DMCA | Contact Us | Cookie Policy

Sign In

Email

Password

Remember me Forgot password?

Login with Facebook

Our partners will collect data and use cookies for ad personalization and measurement. Learn how we and our ad partner Google, collect and use data. Agree & close