9runxuv ,qirupdwln - Vorkurs Informatik

9RUNXUV,QIRUPDWLN
Prof. Dr. Heinrich Müller
Informatik VII
Universität Dortmund
http://ls7-www.cs.uni-dortmund.de
© Informatik VII, Universität Dortmund
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
1
Organisatorisches zum Vorkurs Informatik
Vorlesung: von Montag,13.09.2004, bis Dienstag, 28.09.2004,
14-16 Uhr
Hörsaalgebäude I, Hörsaal 6, Campus Süd
Dozent: Prof. Dr. Heinrich Müller
Übungen: von Dienstag, 14.09.2004, bis Mittwoch, 29.09.2004,
von 12-14 Uhr beziehungsweise 16-18 Uhr
Rechnerpool 006 im Kellergeschoss von GB IV, Campus Süd
Betreuer: Dipl.-Inform. Frank Weichert
Tutoren: Martina Vaupel und Olaf Hengesbach
Einteilung der Übungsgruppen nach dieser Vorlesung
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
2
Inhaltsverzeichnis
Organisatorisches ................................................................................
5
Teil I. Einführung...................................................................................
9
Teil II. Programmierung........................................................................ 23
1. Vom Problem über den Algorithmus zum Programm ................... 25
2. Grundkonzepte von Algorithmen .................................................. 41
3. Grundkonzepte der Programmierung ........................................... 53
4. Beispiel: Mittelwert einer Menge von Zahlen................................ 67
5. Grundkonzepte der Programmierung: Gleitkommazahlen ........... 71
6. Beispiel: Sortieren einer Menge von Zahlen
durch Minimumsuche ................................................................... 73
7. Grundkonzepte der Programmierung: Funktionen ....................... 82
8. Beispiel: Sortieren einer Menge von Zahlen durch Mischen
(„Merge-Sort“) .............................................................................. 87
9. Prinzip der Rekursion ................................................................... 100
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
3
Inhaltsverzeichnis
10. Beispiel: Suchen in einem Datenbestand ...................................
11. Grundkonzepte der Programmierung: Klassen und Objekte ......
12. Beispiel: Suchen in einer verzeigerten linearen Liste .................
13. Mehr zur objektorientierten Programmierung .............................
14. Andere Programmierstile ............................................................
102
106
118
145
150
Teil III. Algorithmen und Datenstrukturen ..........................................
1. Asymptotische Aufwandsanalyse .................................................
2. Sortieren .......................................................................................
3. Suchen..........................................................................................
153
155
161
179
Teil IV. Vom Programm zum Rechner .................................................
1. Von-Neumann-Rechner ................................................................
2. Schaltungen ..................................................................................
3. Compiler und formale Sprachen ...................................................
215
218
226
244
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
4
Organisatorisches zum Vorkurs Informatik
Informationsmaterial:
Skript zur Vorlesung
- ist eine Kopie dieser Präsentation
- wird hier verkauft
Erstsemester-CD
- enthält eine Programmierumgebung (Java) zur Installation zuhause
- enthält noch andere nützliche Information
- gibt es hier umsonst
Übungsblätter
- enthalten Aufgaben zum Stoff der Vorlesung
- sollten zuhause gelöst werden und, soweit es Programmieraufgaben
sind, bei den Übungen im Rechner-Pool zum Laufen gebracht werden
- gibt es hier umsonst
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
5
Zum Vorkurs
Zielgruppe:
- Studienanfängerinnen und -anfänger der Informatikstudiengänge und
andere Interessierte, die nicht oder nur wenig Informatik in der Schule
hatten und mit der Programmierung noch nicht vertraut sind
Ziel:
- Vermittlung von Informatik-Grundwissen, das aus der Schule verfügbar
sein sollte und das die erfolgreiche Teilnahme an den einführenden
Informatik-Vorlesungen erleichtern soll.
Nicht Ziel:
- Vorwegnahme von konkreten Vorlesungen -> in die Vorlesungen gehen
- Einführung ins Universitätsleben -> O-Phase der Fachschaft
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
6
Organisatorisches zum Vorkurs Informatik
Informationsmaterial:
Internet-Seite zur Vorlesung:
http://ls7-www.cs.uni-dortmund.de/Vorkurs-Informatik
- enthält das Skript zum Herunterladen
- enthält die Übungsaufgaben zum Herunterladen
- wird Korrekturen zum Skript enthalten
- wird möglicherweise weitere nützliche Information anbieten
Bitte beachten: Dieses Skript unterscheidet sich teilweise von den
Skripten der Vorkurse der vergangenen Jahre
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
7
Zum Vorkurs
Inhalt:
Teil I: Einführung
13.09.
Teil II: Programmierung
14.09.-20.09.
Teil III: Datenstrukturen und Algorithmen
Teil IV: Vom Programm zum Rechner
21.09.-24.09.
27.09.-28.09.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
8
Teil I. Einführung
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
9
Was ist Informatik?
Typische Begriffe der Informatik:
Information, Informationssysteme, Computer, EDV, Rechner,
Programmierung, Programmiersprache, Software, Hardware,
Internet, Textverarbeitung, Computerspiele
Definition 1:
Informatik ist die Wissenschaft von der systematischen
Verarbeitung von Information, besonders der automatischen,
mit Hilfe von Computern.
Definition 2:
Informatik ist die Wissenschaft, Technik und Anwendung der
maschinellen Verarbeitung und Übermittlung von Information.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
10
Was ist Informatik?
Information:
abstraktes Abbild (Modell) von Objekten der realen Welt
Informationsverarbeitung:
Abstraktion (Modellbildung) - das Wesentliche vom
Unwesentlichen trennen
Informationsverarbeitung: Algorithmen und Systeme
Informatiker(innen) müssen
- von den Objekten und Vorgängen der realen Welt abstrahieren
- mit abstrakten Objekten umgehen.
Dazu gibt es Methoden - ganz praktische, die manchmal
aber auch ziemlich „mathematisch“ aussehen können.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
11
Einige Teilgebiete der Informatik
Technische Informatik
Rechnerarchitektur
Betriebssysteme
Software-Technologie
Informationssysteme
Theoretische Informatik
Systemanalyse
Compilerbau
Mensch-Rechner-Interaktion
Algorithmenentwurf
Simulation
Rechnernetze
Computational Intelligence
Computergraphik
Künstliche Intelligenz
Anwendungen der Informatik
Informatik und Gesellschaft
Didaktik der Informatik
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
12
Eine grobe Einteilung der Informatik
Technische Informatik:
setzt sich mit der inneren Struktur und dem Bau von
Computern und allen damit zusammenhängenden technischen
Fragen auseinander
Praktische Informatik:
umfasst die Prinzipien und Techniken der Programmierung
Angewandte Informatik:
bildet die Brücke zwischen den Methoden der Informatik und
Anwendungsproblemen
Theoretische Informatik:
entwickelt mathematische Modelle von Computern und
Hilfsmittel zu ihrer präzisen Beschreibung
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
13
Literatur
P. Rechenberg, G. Pomberger (Hrsg.):
Informatik-Handbuch,
Carl Hanser Verlag, München, Wien,
2. Auflage, 1999
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
14
Rechnereinführung
- Übungsrechner am FBI
- PCs
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
15
Übungsrechner am Fachbereich Informatik
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
16
Übungsrechner am Fachbereich Informatik
SunRays mit Server
SunRay-Hardware:
Bildschirm, Tastatur, Maus
SunRay
SunRay
SunRay
SunRay
SunRay
SunRay
Ausgaberechner
Server 1
Server 2
Server 3
Server 4
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
17
Übungsrechner am Fachbereich Informatik
Software:
Betriebssystem: Unix (Sun Solaris)
Softwaresystem, das den Rechner verwaltet, z.B.
die Ausführung von Programmen oder die Verwaltung von
Datenbeständen (Dateien)
Editor: Emacs
Software-System, das die Eingabe und Bearbeitung von
Textdateien erlaubt.
Java-Programmiersystem: JDK 1.4.2
Software-System, das es erlaubt, eigene Programme
auf einem Rechner ablaufen zu lassen.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
18
Privat: • Personal Computer (PC)
• Laptop/Notebook
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
19
Personal Computer (PC)
Hardware:
Rechner:
Gehäuse: Tower (Midi oder Maxi)
Prozessor: ab 2.4 GHz, Intel oder AMD
Hauptspeicher(RAM): Minimum 256 MB, 512 MB gut
Festplatte: mindestens 80 GB
Combi-Laufwerk: DVD‘s & CD‘s lesen, und CD‘s brennen,
Diskettenlaufwerk: 3 1/2 Zoll-Laufwerk und evtl. ein ZIP-Laufwerk
Graphikkarte: NVidia-GeForce oder ATI Radeon, min. 128 MB
Soundkarte: Soundblaster
Tastatur
Maus: 3 Tasten mit Rad (Wheel)
Monitor: 17 Zoll TFT-Monitor, alternativ 19 Zoll Röhrenmonitor
Internet: ISDN- bzw. DSL-Zugang
Drucker: Tintenstrahldrucker
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
20
Laptop/Notebook
Prozessor: Centrino (ab 1.5 GHz) oder Mobile-Version (ab 2.0 GHz)
Hauptspeicher(RAM): Minimum 256 MB, 512 MB gut
Display: 15,1‘‘ TFT, Auflösung mindestens 1024x768
Festplatte: mindestens 60 GB
Combi-Laufwerk: DVD‘s & CD‘s lesen, und CD‘s (DVD‘s) brennen
Graphikkarte: NVidia-GeForce oder ATI Radeon, Mobile, 64 MB
-> keine shared Memory Version
Anschlüsse: USB 2.0, PCMCIA, IrDa, LAN, Modem, Parallel, Firewire
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
21
Personal Computer (PC)
Software (Standard):
Betriebssystem: Microsoft Windows XP
Editor: Sun Net Neans 3.6
Java-Programmiersystem: JDK 1.4.2 (aktuell Version 5.0 Beta 2)
Software (Alternative):
Betriebssystem: Linux, z.B. SuSE, Debian
Editor: XEmacs, Net Beans 3.6
Java-Programmiersystem: JDK 1.4.2 (aktuell Version 5.0 Beta 2)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
22
Teil II. Programmierung
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
23
Inhalt:
1. Vom Problem über den Algorithmus zum Programm
2. Grundkonzepte von Algorithmen
3. Grundkonzepte der Programmierung
4. Beispiel: Mittelwert einer Menge von Zahlen
5. Grundkonzepte der Programmierung: Gleitkommazahlen
6. Beispiel: Sortieren einer Menge von Zahlen durch Minimumsuche
7. Grundkonzepte der Programmierung: Funktionen
8. Beispiel: Sortieren einer Menge von Zahlen durch Mischen
9. Prinzip der Rekursion
10. Beispiel: Suchen in einem Datenbestand
11. Grundkonzepte der Programmierung: Klassen und Objekte
12. Beispiel: Suchen in verzeigerten linearen Listen
13. Mehr zur objektorientierten Programmierung
14. Andere Programmierstile
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
24
1. Vom Problem über den Algorithmus
zum Programm
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
25
Vom Problem über den Algorithmus zum Programm
reale Welt
Problem
Abstraktion
abstrakte Objekte
Algorithmus
Darstellung
informationsverarbeitendes System
Darstellung in formalisierter Sprache
für Ausführung durch Rechner
Programm
Realisierung
Rechner
Problemanalyse
funktionale Spezifikation
Algorithmenentwurf
Umsetzung in
Elementarschritte
einer Maschine
Maschine
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
26
Vom Problem über den Algorithmus zum Programm
Algorithmus
Endliche Vorschrift zur eindeutigen Zuordnung von Ausgabegrößen
zu Eingabegrößen in einer endlichen Zahl von Schritten.
Bsp.: Backrezept, Kochrezept, Montageanleitung
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
27
Vom Problem über den Algorithmus zum Programm
Bsp.: Backrezept „Krustelkuchen“
Zutaten: 1 kg Kartoffeln, 1 mittelgroße Zwiebel, 2 EL Mehl, 2 Eier, Salz,
Pfeffer, Majoran, 300 g geräucherte Mettwürstchen, 60 g Butter,
2-3 EL Semmelbrösel, 125 ml saure Sahne
Zubereitung:
Backofen auf 200 Grad vorheizen.
Kartoffeln schälen, waschen, trockentupfen, fein reiben, in einem
Passiertuch Flüssigkeit sorgfältig herausdrücken.
Zwiebel schälen, fein würfeln.
Zwiebel, Mehl und Eier zu den Kartoffeln geben, mit Salz, Pfeffer
und Majoran würzen und aller gut mischen.
Mettwürstchen in Scheiben schneiden.
Eine Kastenform (1 l Füllmenge) mit etwas flüssiger Butter ausfetten.
Kartoffelmasse und Mettwürstchen hineinschichten und Oberfläche
mit der restlichen Butter begießen
1 Stunde backen, nach 30 Min. Oberfläche mit Semmelbröseln
bestreuen und saure Sahne daraufgießen.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
28
Vom Problem über den Algorithmus zum Programm
Algorithmus (ausführlicher)
Eine Folge „einfacher“ Anweisungen, die folgende Eigenschaften hat:
- Endlichkeit: die Beschreibung ist endlich lang
- Terminierung: nach Durchführung endlich vieler Operationen kommt
das Verfahren zum Stillstand
- Reihenfolge: die Reihenfolge, in der die Operationen
anzuwenden sind, ist festgelegt
- eindeutige Wirkung: die Wirkung jeder Anweisung der
Anweisungsfolge und damit der gesamten Folge ist eindeutig
festgelegt.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
29
Vom Problem über den Algorithmus zum Programm
Vorgehensweise bei der Lösung von Problemen
1. Problem formulieren
2. Problemanalyse, Problemabstraktion, Problemspezifikation
3. Algorithmenentwurf
4. Nachweis der Korrektheit, Verifikation
5. Aufwandsanalyse
6. Programmierung
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
30
Vom Problem über den Algorithmus zum Programm
Beispiel: Jüngster Studierender
1. Problem formulieren
Möglichkeiten:
1. Finde den jüngsten Studierenden.
2. Finde das Alter des jüngsten Studierenden.
Was ist gemeint? Eins von beiden? Beides?
Entscheidung: Möglichkeit 1 erscheint passend.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
31
Vom Problem über den Algorithmus zum Programm
Beispiel: Jüngster Studierender
2. Problemanalyse, Problemabstraktion, Problemspezifikation
Problemanalyse:
Fragen:
Gibt es eine Lösung? Gibt es genau eine Lösung?
Antwort:
Für die Möglichkeit 2: beide „ja“
Für die Möglichkeit 1:
Es kann mehr als einen Studierenden geben, der die
Anforderung erfüllt.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
32
Vom Problem über den Algorithmus zum Programm
Beispiel: Jüngster Studierender
2. Problemanalyse, Problemabstraktion, Problemspezifikation
Problemabstraktion:
Was ist Alter?
Ganze positive Zahl
Was ist „jüngster“? Definiert auf der Ordnungsrelation von Zahlen
Was heißt „finde“? Die Altersangaben müssen verfügbar sein.
(Bei der Möglichkeit 1 müssten
Personenkennung und Alter verfügbar sein)
Entscheidungskorrektur: Möglichkeit 2, weil einfacher.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
33
Vom Problem über den Algorithmus zum Programm
Beispiel: Jüngster Studierender
2. Problemanalyse, Problemabstraktion, Problemspezifikation
Problemspezifikation:
Problem: Minimum einer Menge von Zahlen
Gegeben: eine Folge a0 ,..., an von positiven ganzen Zahlen,
n ≥ 0.
Gesucht: der kleinste Wert a der gegebenen Zahlen, d.h.
a = min{ a0 ,..., an }.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
34
Vom Problem über den Algorithmus zum Programm
Beispiel: Jüngster Studierender
3. Algorithmenentwurf
Vorgehensweisen bei der Entwicklung eines Lösungsalgorithmus
für ein Problem
Top-Down-Strategie:
Zerlegen des Problems in ganz einfache Teilprobleme, die dann
gelöst werden („Divide & Conquer“).
Bottom-Up-Strategie:
Aus Lösungen von Teilproblemen wird eine Lösung des
Gesamtproblems zusammengefügt.
Der Algorithmusentwurf wird in diesem Kapitel behandelt.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
35
Vom Problem über den Algorithmus zum Programm
Beispiel: Jüngster Studierender
4. Nachweis der Korrektheit (Semantik, Verifikation)
Fragen: Terminiert der Algorithmus?
Liefert er immer das richtige Ergebnis?
wird im Teil „Vom Programm zum Rechner“ behandelt.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
36
Vom Problem über den Algorithmus zum Programm
Beispiel: Jüngster Studierender
5. Aufwandsanalyse
wird im Teil „Datenstrukturen und Algorithmen“ behandelt.
6. Programmierung
wird in diesem Kapitel behandelt.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
37
Algorithmenentwurf
Beispiel:
Minimum einer Menge von Zahlen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
38
Minimum einer Menge von Zahlen
Gegeben: a0,a1,...,an
Gesucht: Kleinster Wert der Eingabemenge
Algorithmus Minimum(a0,a1,...,an)
Durchlaufe die Elemente der Menge und merke den bisher kleinsten Wert.
Pseudocode:
Kurzschreibweise:
Setze merker auf a0;
Setze i auf 0;
Solange i < n ist, führe aus:
Erhöhe i um 1;
Wenn ai < merker, dann
Setze merker auf ai;
Gib merker zurück;
merker := a0;
i := 0;
Solange i < n ist, führe aus:
{i := i+1;
Wenn ai < merker, dann
merker := ai;}
Gib merker zurück;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
39
Minimum einer Menge von Zahlen
11, 7, 8, 3, 15, 13, 9, 19, 18, 10, 4
merker := a0 ;
i := 0;
Solange i < n ist, führe aus:
{i := i+1;
Wenn ai < merker, dann
merker := ai;}
Gib merker zurück;
n=10
i
ai
merker
0
1
2
3
4
5
6
7
8
11
7
8
3
15
13
9
19
18
11
7
7
3
3
3
3
3
3
9
10
10
4
3
3
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
40
2. Grundkonzepte von Algorithmen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
41
Grundkonzepte von Algorithmen
Kurzschreibweise:
merker := a0;
i := 0;
Solange i < n ist, führe aus:
{i := i+1;
Block
Wenn ai < merker, dann
merker := ai ;}
Gib merker zurück;
Wertzuweisung an Variable
Schleife
Bedingte Anweisung
Rückgabeanweisung
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
42
Grundkonzepte von Algorithmen
Algorithmus:
Folge von Anweisungen: Anweisung 1; Anweisung 2; ...
Ablaufdiagramm:
Anw. 1
Anw. 1
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
43
Grundkonzepte von Algorithmen
Variable:
- hat einen Namen, über den sie angesprochen wird
- speichert Information
Bsp: merker, a0 , i, n
- Verwendung der gespeicherten Information durch Verwendung des
Variablennamens: Anstelle des Variablennamens wird die
gespeicherte Information eingesetzt
Bsp: i < n
ai < merker
merker := a0 ;
i := 0;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
44
Grundkonzepte von Algorithmen
Wertzuweisung:
- Anweisung, mit der einer Variablen ein Wert gegeben wird
- Schreibweise: Variablenname := Ausdruck
Bsp.: merker := a0 ;
i := 0;
i := i+1;
merker := ai ;
- Ausführung einer Wertzuweisung:
1. Werte den Ausdruck auf der rechten Seite aus.
2. Speichere den Wert in der Variablen der linken Seite.
Bsp.: i:=0;
i:=i+1;
i
0
i
1
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
45
Grundkonzepte von Algorithmen
Bedingte Anweisung:
Anweisung, mit der man Alternativen in einem Algorithmus
formulieren kann
- Schreibweise: Wenn Bedingung, dann Anweisung 1;
Sonst Anweisung 2;
Bsp.: Wenn ai < merker, dann merker := ai ;
Ausfühung einer bedingten Anweisung:
1. Werte die Bedingung aus.
2. Wenn die Bedingung erfüllt ist, dann führe Anweisung 1 aus.
3. Wenn die Bedingung nicht erfüllt ist, dann führe Anweisung 2 aus.
Wenn der Sonst-Teil fehlt, wird so verfahren, wie wenn er da wäre,
aber Anweisung 2 nichts tut („leere Anweisung“).
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
46
Grundkonzepte von Algorithmen
Bedingte Anweisung:
Wenn Bedingung, dann Anweisung 1;
Sonst Anweisung 2;
Ablaufdiagramm:
wahr
Bed.
falsch
Anw. 1
Anw. 2
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
47
Grundkonzepte von Algorithmen
Schleife:
- Anweisung, mit der man eine andere Anweisung mehrmals
wiederholen kann.
- Schreibweise: Solange Bedingung, führe aus: Anweisung
Bsp.: Solange i < n ist, führe aus:
{i := i+1;
Wenn ai < merker, dann merker := ai ;}
Ausfühung einer Schleife:
1. Werte die Bedingung aus.
2. Wenn die Bedingung erfüllt ist, dann führe Anweisung aus
und fahre mit 1. fort.
3. Wenn die Bedingung nicht erfüllt ist, dann beende die Schleife.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
48
Grundkonzepte von Algorithmen
Schleife:
Solange Bedingung, führe aus: Anweisung
Bed.
falsch
wahr
Anw.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
49
Grundkonzepte von Algorithmen
Block:
- Zusammenfassung einer Folge von Anweisungen zu einer einzigen
Anweisung
- Schreibweise: {Anweisung 1; .... Anweisung n;}
Bsp.: {i := i+1;
Wenn ai < merker, dann merker := ai ;}
Ausführung eines Blocks:
Führe die Anweisungen des Blocks nacheinander in der angegebenen
Reihenfolge aus.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
50
Grundkonzepte von Algorithmen
Rückgabeanweisung:
- gibt einen Wert an die aufrufende Instanz zurück
(mehr dazu später)
- Schreibweise: Gib Ausdruck zurück;
Bsp.: Gib merker zurück;
Druckanweisung:
Analog zur Rückgabeanweisung, nur dass das Ausgabeziel ein
Ausgabegerät wie Bildschirm oder Drucker ist.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
Grundkonzepte von Algorithmen
Darstellung des Algorithmus
als Ablaufdiagramm:
51
Start
merker := a0
i:=0
i<n
falsch
wahr
i:= i + 1
falsch
merker := a0 ;
i := 0;
Solange i < n ist, führe aus:
{i := i+1;
Wenn ai < merker, dann
merker := ai;}
Gib merker zurück;
ai < merker
wahr
merker:=aj
Gib merker zurück
Ende
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
52
3. Grundkonzepte der Programmierung
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
53
Grundkonzepte der Programmierung
Programmierung:
Überführung eines Algorithmus- oder Systementwurfs in
maschinenverständliche Form durch Formulieren in einer
Programmiersprache.
Programmiersprachen:
hier: Java als Beispiel
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
54
Grundkonzepte der Programmierung
Programmiersprache Java:
- entwickelt von der Firma Sun Ende der Neunzigerjahre
- objektorientiert
- ermöglicht rechnerplattformunabhängige Programme
- hat außerordentlich umfangreiche Klassenbibliotheken für
zahlreiche Anwendungen
- ist zur Entwicklung von Internet-Anwendungen besonders geeignet
Literatur: Es gibt sehr viele Bücher. Bsp.:
Guido Krüger: Go To Java 2, Addison-Wesley.
(im Internet verfügbar, siehe auch Erstsemester-CD)
Bruce Eckel: Thinking in Java.
(im Internet verfügbar, siehe auch Erstsemester-CD)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
55
Grundkonzepte der Programmierung
Struktur eines einfachen Java-Programm vom Typ „Applikation“:
public class Programm{
// hier können noch Variablen und Funktionen deklariert werden
public static void main(String[] args){
// hier steht der Text des Hauptprogramms, der aus
// Anweisungen besteht, die mit ; enden.
}
}
Alles, was auf einer Zeile hinter // kommt, wird vom Rechner ignoriert.
Dies dient zur Kommentierung durch den Programmierer.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
56
Grundkonzepte der Programmierung
Java-Programm zur Suche des Minimums:
public class ProgrammMinSuche{
public static void main(String[] args){
int[] a = {11,7,8,3,15,13,9,19,18,10,4};
int merker = a[0]; // damit hat merker den Wert 11
int i = 0;
int n = a.length-1; // gibt den letzten Index der
// Folge a
while (i<n){
i = i+1;
if (a[i]<merker)
merker = a[i];
}
System.out.println(merker); // druckt das Ergebnis
}
}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
57
Grundkonzepte der Programmierung
Variablendeklaration:
- Variablen müssen vor ihrer Verwendung deklariert werden.
- Eine Variablendeklaration besteht aus der Angabe ihres Namens und
ihres Datentyps.
Bsp.: int merker; int i;
Datentyp: Menge von Daten gleicher Art
Bsp.: ganze Zahlen, reelle Zahlen, Wahrheitswerte
- Bei der Deklaration kann einer Variablen auch ein Wert zugewiesen
werden, dies muss jedoch nicht sein. Dann muss dies vor der ersten
Verwendung des Werts der Variablen durch eine Wertzuweisung
geschehen.
Bsp.: int[] a = {11,7,8,3,15,13,9,19,18,10,4};
int merker = a[0];
int i = 0;
int n = a.length;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
58
Grundkonzepte der Programmierung
Variablendeklaration:
Bsp.: int[] a = {11,7,8,3,15,13,9,19,18,10,4};
int merker = a[0]
// damit hat merker den Wert 11
int i = 0;
int n = a.length-1; // gibt den letzten Index der
// Folge a
int steht für integer und bezeichnet den Datentyp der ganzen Zahlen.
int[] steht für den Datentyp einer Folge von ganzen Zahlen („Array“).
Mit a[i] kann auf die i-te Komponente zugegriffen werden.
Mit a.length wird die Länge der Folge erhalten.
„= “ bezeichnet die Wertzuweisung (entspricht := bei den Algorithmen).
Wenn in Java das Gleichheitszeichen zum Vergleichen zweier Werte
gebraucht wird, muss „== “ geschrieben werden.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
59
Grundkonzepte der Programmierung
While-Schleife:
- hat die Form while (Bedingung) Anweisung
- entspricht der Schleife „Solange ... führe aus ...“ bei den Algorithmen.
Bsp.: while (i<n){
i = i+1;
if (a[i]<merker)
merker = a[i];
}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
60
Grundkonzepte der Programmierung
Bedingte Anweisung:
- hat die Form if (Bedingung) Anweisung 1 else Anweisung 2,
wobei der else-Teil fehlen darf.
- entspricht der bedingten Anweisung „Wenn ... dann ... sonst“ bei den
Algorithmen.
Bsp.: if (a[i]<merker)
merker = a[i];
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
61
Grundkonzepte der Programmierung
Ausdrücke:
- sind Formeln zur Berechnung von Werten
arithmetische Ausdrücke:
- Formeln mit Zahlenwerten, die unter anderem die üblichen Operationen
(+,-,*,/) verwenden und geklammert sein können.
Bsp.: i+1
3*(2+i)
3/(2*i+5)
(5+2)/(-3)
- Bei den Operatoren gelten die üblichen Regeln der Bindungsstärke
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
62
Grundkonzepte der Programmierung
Boolesche Ausdrücke:
- Formeln, die Vergleiche zwischen arithmetischen Ausdrücken
oder logische Verknüpfungen enthalten und die als Wert „richtig“ (true)
oder „falsch“ (false) liefern
Bsp.: 3 < 7 hat den Wert true
- werden als Bedingungen bei bedingten Anweisungen und Schleifen
verwendet
- Vergleichsoperatoren:
kleiner als <, größer als >, gleich ==, ungleich !=,
kleiner oder gleich <=, größer oder gleich >=
Bsp.: 3 == 7 hat den Wert false
3 != 7 hat den Wert true
a[i]<merker
i < n
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
63
Grundkonzepte der Programmierung
- Boolesche Operatoren:
nicht !, und &&, oder ||, mit folgenden Regeln:
x
true
false
!x
false
true
x
false
false
true
true
y
false
true
false
true
x&&y
false
false
false
true
x
false
false
true
true
y
false
true
false
true
x||y
false
true
true
true
- Boolesche Werte: true (wahr, richtig), false (false)
Bsp.: (3 < 7) && (3==7) hat den Wert false
((3 == 7) || (3 != 7)) && (2<=2) hat den Wert true
- Deklaration Boolescher Variablen: boolean Variablenname
Bsp.: boolean w;
- Wertzuweisung: w = (3<7)
w bekommt den Wert true
- mathematische Symbole: und ∧, oder ∨, nicht ¬
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
64
Grundkonzepte der Programmierung
Block:
- fasst eine Folge von Anweisungen zu einer neuen Anweisung zusammen
- hat die Form { Anweisung 1 ... Anweisung n }
Bsp.: {
i = i+1;
if (a[i]<merker)
merker = a[i];
}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
65
Grundkonzepte der Programmierung
Ausgabe:
- geschieht mit Methoden, die die Java-Programmierumgebung zur
Verfügung stellt.
- Ausgabe auf dem Standardausgabegerät (üblicherweise Bildschirm):
System.out.println(aktuelle Parameterliste);
Bsp.: System.out.println(merker);
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
66
4. Beispiel:
Mittelwert einer Menge von Zahlen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
67
Mittelwert einer Menge von Zahlen
Gegeben: a0 , a1 , ..., an
Gesucht: (a0 +...+ an )/(n+1)
Algorithmus Mittelwert(a0 , a1 , ..., an )
Durchlaufe die Elemente der Menge und addiere sie dabei auf.
Teile das Ergebnis durch die Anzahl der Elemente.
Pseudocode:
Kurzschreibweise:
Setze ak auf a0 ;
Setze i auf 0;
Solange i < n ist, führe aus:
Erhöhe i um 1;
addiere ai zu ak;
Setze m auf ak/(n+1);
Gib m zurück;
ak := a0 ;
i := 0;
Solange i < n ist, führe aus:
{i := i+1;
ak := ak + ai ;}
m := ak/(n+1);
Gib m zurück;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
68
Mittelwert einer Menge von Zahlen
11, 7, 8, 3, 15, 13, 9, 19, 18, 10, 4
ak := a0 ;
i := 0;
Solange i < n ist, führe aus:
{i := i+1;
ak := ak + ai ;}
m := ak/(n+1);
Gib m zurück;
n=10
i
ak
0
1
2
3
4
5
6
7
8
11
18
26
29
44
57
66
85
103
9
10
113
117
m
10.64
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
69
Mittelwert einer Menge von Zahlen
Java-Programm zur Berechnung des Mittelwerts:
public class ProgrammMittelwert{
public static void main(String[] args){
int[] a = {11,7,8,3,15,13,9,19,18,10,4};
float ak = a[0]; // damit hat ak den Wert 11.0
int i = 0;
int n = a.length-1; // gibt (Größe der Menge a)-1
while (i<n){
i = i+1;
ak = ak+a[i];
}
float m = ak/(n+1);
System.out.println(´´Mittelwert ´´+m);
// druckt das Ergebnis
}
}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
70
5. Grundkonzepte der Programmierung:
Gleitkommazahlen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
71
Grundkonzepte der Programmierung
Gleitkommazahlen:
- sind Zahlen der Form 1.73 oder 1.71 * 1015
- lassen sich in Java von ganzen Zahlen dadurch unterscheiden, dass
- ein Exponent existiert (1E13 oder 1.71E15)
- die Grundzahl einen Dezimalpunkt enthält (1.73)
- ein f (für „float“) angefügt ist (2f) (es gibt auch noch „d“ für „double“).
Bsp.: float ak = a[0];
float m = ak/(n+1);
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
72
6. Beispiel:
Sortieren einer Menge von Zahlen
durch Minimumsuche
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
73
Sortieren einer Menge von Zahlen durch Minimumsuche
Gegeben: a0 , a1 , ..., an
Gesucht: Anordnung der Eingabewerte nach steigendem Wert
Algorithmus MinSort(a0 , a1 , ..., an )
Suche ein Element ak der Menge mit dem kleinsten Wert.
Füge ak an das Ende einer neuen Folge an, die am Anfang leer ist.
Entferne ak aus der Eingabemenge und verfahre mit der Restmenge
genauso.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
74
Sortieren einer Menge von Zahlen durch Minimumsuche
Suche ein Element ak der Menge mit dem kleinsten Wert.
Füge ak an das Ende einer neuen Folge an, die am Anfang leer ist.
Entferne ak aus der Eingabemenge und verfahre mit der Restmenge
genauso.
Pseudocode:
Weise restfolge die gegebene
Folge zu;
Solange restfolge nicht leer, führe aus:
- suche ein Element ak mit dem
kleinsten Wert in restfolge;
- füge ak an ergebnisfolge an;
- entferne ak aus restfolge;
gib ergebnisfolge zurück;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
75
Sortieren einer Menge von Zahlen durch Minimumsuche
gegebenefolge 11, 7, 8, 3, 15, 13, 9, 19, 18, 10, 4
restfolge
11, 7, 8, 3, 15, 13, 9, 19, 18, 10, 4
11, 7, 8, 15, 13, 9, 19, 18, 10, 4
11, 7, 8, 15, 13, 9, 19, 18, 10
11, 8, 15, 13, 9, 19, 18, 10
11, 15, 13, 9, 19, 18, 10
11, 15, 13, 19, 18, 10
11, 15, 13, 19, 18
15, 13, 19, 18
15, 19, 18
19, 18
19
ak
3
4
7
8
9
10
11
13
15
18
19
ergebnisfolge
3
3,4
3, 4, 7
3, 4, 7, 8
3, 4, 7, 8, 9
3, 4, 7, 8, 9, 10
3, 4, 7, 8, 9, 10, 11
3, 4, 7, 8, 9, 10, 11, 13
3, 4, 7, 8, 9, 10, 11, 13, 15
3, 4, 7, 8, 9, 10, 11, 13, 15, 18
3, 4, 7, 8, 9, 10, 11, 13, 15, 18, 19
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
76
Sortieren einer Menge von Zahlen durch Minimumsuche
Suche ein Element ak der Menge mit dem kleinsten Wert.
Füge ak an das Ende einer neuen Folge an, die am Anfang leer ist.
Entferne ak aus der Eingabemenge und verfahre mit der Restmenge
genauso.
Pseudocode:
Kurzschreibweise:
Weise restfolge die gegebene
restfolge := gegebenefolge;
Folge zu;
Solange restfolge nicht leer, führe aus:
Solange restfolge nicht leer, führe aus:
{ak := MinSuche(restfolge);
FügeAn(ak , ergebnisfolge);
- suche ein Element ak mit dem
kleinsten Wert in restfolge;
Enferne(ak , restfolge);}
gib ergebnisfolge zurück;
- füge ak an ergebnisfolge an;
- entferne ak aus restfolge;
gib ergebnisfolge zurück;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
77
Sortieren durch Minimumsuche ohne Hilfsmenge
Gegeben: a0 , a1 , ..., an
Gesucht: Anordnung der Eingabewerte nach steigendem Wert
Algorithmus MinSort2(a0 , a1 , ..., an )
- Ordne die Menge zu einer Folge an.
- Suche ein Element der Folge mit dem kleinsten Wert.
Vertausche das erste Element der Folge mit diesem Element.
- Suche in der Restfolge ab dem zweiten Element ein Element
mit kleinstem Wert. Vertausche das zweite Element der Folge
mit diesem Element.
- Führe dieses Verfahren mit der Restfolge ab dem dritten Element,
dem vierten Element und so weiter bis zum vorletzten Element aus.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
78
Sortieren einer Menge von Zahlen durch Minimumsuche
gegebenefolge 11, 7, 8, 3, 15, 13, 9, 19, 18, 10, 4
ak
11, 7, 8, 3, 15, 13, 9, 19, 18, 10, 4
3,
7, 8, 11, 15, 13, 9, 19, 18, 10, 4
3, 4,
8, 11, 15, 13, 9, 19, 18, 10, 7
3, 4, 7,
11, 15, 13, 9, 19, 18, 10, 8
3, 4, 7, 8,
15, 13, 9, 19, 18, 10, 11
3, 4, 7, 8, 9,
13, 15, 19, 18, 10, 11
3, 4, 7, 8, 9, 10,
15, 19, 18, 13, 11
3, 4, 7, 8, 9, 10, 11,
19, 18, 13, 15
3, 4, 7, 8, 9, 10, 11, 13,
18, 19, 15
3, 4, 7, 8, 9, 10, 11, 13, 15,
19, 18
3, 4, 7, 8, 9, 10, 11, 13, 15, 18,
19
3, 4, 7, 8, 9, 10, 11, 13, 15, 18, 19
3
4
7
8
9
10
11
13
15
18
19
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
79
Sortieren einer Menge von Zahlen durch Minimumsuche
Java-Programm zur Sortierung durch Minimumsuche:
public class ProgrammMinSort{
static int MinSuche(int[] r, int s)
{ // gibt den Index eines Elements von r mit kleinstem
// Wert im Bereich ab Index s zurück
int wmerker = r[s]; // merkt den kleinsten Wert
int imerker = s; // merkt einen Index zum kleinsten Wert
int i = s;
int n = r.length-1;
while (i<n){
i = i+1;
if (r[i] < wmerker){
wmerker = r[i]; imerker= i;}
}
return imerker;
}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
80
Sortieren einer Menge von Zahlen durch Minimumsuche
public static void main(String[] args){
int[]a = {11,7,8,3,15,13,9,19,18,10,4};
int n = a.length-1;
int i = 0;
int k;
// speichert den Minimumsindex
while (i < n){
k = MinSuche(a,i);
int merker = a[i]; // vertausche a[k] und a[i]
a[i] = a[k];
// ...
a[k] = merker;
// ...
i=i+1;}
i=0;
while (i <= n){
System.out.println(a[i]);
i=i+1;}
}
}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
81
7. Grundkonzepte der Programmierung:
Funktionen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
82
Grundkonzepte der Programmierung
Funktionen („statische Methoden“):
- bestimmen aufgrund von Eingabeparametern einen Rückgabewert
- werden deklariert durch
static Rückgabetyp Funktionsname(formale Parameterdeklaration)
{ Anweisungsfolge }
Bsp.: static int MinSuche(int[] r, int s){
}
- werden aufgerufen durch Funktionsname(aktuelle Parameter)
Bsp.: k = MinSuche(a,i);
- geben den Rückgabewert über eine return-Anweisung zurück:
return Rückgabewert;
Nach Ausführung einer return-Anweisung wird die Bearbeitung der
Funktion abgebrochen und an der Aufrufstelle fortgefahren.
Bsp.: return imerker;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
83
Grundkonzepte der Programmierung
Funktionen („statische Methoden“):
- spezieller Rückgabetyp: leerer Rückgabetyp void
Es wird kein Wert zurückgegeben.
Bei Rückgabetyp void wird return an der Rücksprungstelle ohne
Angabe eines Rückgabewerts aufgerufen.
Sichtbarkeitsbereich von Namen:
grobe Regel: Ein Name ist in dem Block, in dem er deklariert ist, und in
allen Unterblöcken dieses Blocks sichtbar.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
84
Sortieren einer Menge von Zahlen durch Minimumsuche
Java-Programm zur Sortierung durch Minimumsuche:
public class ProgrammMinSort{
static int MinSuche(int[] r, int s)
{ // gibt den Index eines Elements von r mit kleinstem
// Wert im Bereich ab Index s zurück
int wmerker = r[s]; // merkt den kleinsten Wert
int imerker = s; // merkt einen Index zum kleinsten Wert
int i = s;
int n = r.length-1;
while (i<n){
i = i+1;
if (r[i] < wmerker){
wmerker = r[i]; imerker= i;}
}
return imerker;
}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
85
Sortieren einer Menge von Zahlen durch Minimumsuche
public static void main(String[] args){
int[]a = {11,7,8,3,15,13,9,19,18,10,4};
int n = a.length-1;
int i = 0;
int k;
// speichert den Minimumsindex
while (i < n){
k = MinSuche(a,i);
int merker = a[i]; // vertausche a[k] und a[i]
a[i] = a[k];
// ...
a[k] = merker;
// ...
i=i+1;}
i=0;
while (i <= n){
System.out.println(a[i]);
i=i+1;}
}
}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
86
8. Beispiel:
Sortieren einer Menge von Zahlen
durch Mischen („Merge-Sort“)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
87
Sortieren einer Menge von Zahlen durch Mischen
Gegeben: a0 , a1 , ..., an
Gesucht: Anordnung der Eingabewerte nach steigendem Wert
Algorithmus MischSort(a0 , a1 , ..., an )
- Wenn die Menge nur ein Element hat (n=0), dann gib die Menge
unverändert zurück.
- Sonst zerlege die Menge in zwei Teilmengen, die beide etwa gleich
groß sind, und sortiere beide Teilmengen nach diesem Verfahren;
- Mische die sortierten Teilmengen und gib das Ergebnis zurück.
Rekursion
Beispiel für das Mischen (Verschmelzen) von zwei sortierten Folgen:
3, 7, 8, 11, 15
3, 4, 7, 8, 9, 10, 11, 13, 15, 18, 19
4, 9, 10, 13, 18, 19
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
88
Sortieren einer Menge von Zahlen durch Mischen
11, 7, 8, 3, 15, 13, 9, 19, 18, 10, 4
11, 7, 8, 3, 15
11, 7
11
8, 3, 15
7
8
3, 15
3
15
3, 15
7, 11
3, 8, 15
3, 7, 8, 11, 15
Auflösung der
Rekursion
13, 9, 19, 18, 10, 4
13, 9, 19
9, 19
13
9
19
9, 19
9, 13, 19
18, 10, 4
18
10, 4
10
4
4, 10
4, 10, 18
4, 9, 10, 13, 18, 19
3, 4, 7, 8, 9, 10, 11, 13, 15, 18, 19
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
89
Sortieren einer Menge von Zahlen durch Mischen
Gegeben: a0 , a1 , ..., an
Gesucht: Anordnung der Eingabewerte nach steigendem Wert
Algorithmus MischSort(a0 , a1 , ..., an )
- Wenn die Menge nur ein Element hat (n=0), dann gib die Menge
unverändert zurück.
- Sonst zerlege die Menge in zwei Teilmengen, die beide etwa gleich
groß sind, und sortiere beide Teilmengen nach diesem Verfahren;
- Mische die sortierten Teilmengen und gib das Ergebnis zurück.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
Rekursion
90
Rekursives Mischen zweier sortierter Folgen
Algorithmus Mischen(folge1,folge2)
Wenn eine der beiden Folgen leer ist, gib die andere als
ergebnisfolge zurück. Sonst führe folgendes aus:
Wenn das erste Element f von folge1 kleiner oder gleich dem ersten
Element von folge2 ist, dann entferne es aus folge1.
Sonst entferne das erste Element f von folge2 aus folge2.
Setze ergebnisfolge als einelementige Folge mit dem entfernten Element f.
Wende den Algorithmus auf die entstandenen folge1 und folge2 an,
wodurch sich eine sortierte Folge ergebnisrestfolge ergibt.
Füge ergebnisrestfolge an ergebnisfolge an.
Rekursion
Gib ergebnisfolge zurück.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
91
Rekursives Mischen zweier sortierter Folgen
Algorithmus Mischen(folge1,folge2)
3, 7, 8, 11, 15
4, 9, 10, 13, 18, 19
7, 8, 11, 15
7, 8, 11, 15
4, 9, 10, 13, 18, 19
9, 10, 13, 18, 19
8, 11, 15
11, 15
9, 10, 13, 18, 19
9, 10, 13, 18, 19
11, 15
11, 15
15
15
10, 13, 18, 19
13, 18, 19
13, 18, 19
18, 19
18, 19
3
4, 7, 8, 9, 10, 11, 13, 15, 18, 19
4
7, 8, 9, 10, 11, 13, 15, 18, 19
7 8, 9, 10, 11, 13, 15, 18, 19
8
9, 10, 11, 13, 15, 18, 19
9 10, 11, 13, 15, 18, 19
10
11, 13, 15, 18, 19
11
13, 15, 18, 19
15, 18, 19
13
18, 19
15
18, 19
3, 4, 7, 8, 9, 10, 11, 13, 15, 18, 19
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
92
Iteratives Mischen zweier sortierter Folgen
Algorithmus Mischen(folge1,folge2)
n := Länge von folge1 plus Länge von folge2;
folge := eine leere Folge;
Solange folge1 und folge2 nicht leer ist:
Wenn das erste Element f1 von folge1 nicht größer
als das erste Element f2 von folge2 ist, dann
füge f1 an folge an und entferne f1 aus folge1;
sonst
füge f2 an folge an und entferne f2 aus folge2;
Solange folge1 nicht leer ist:
füge das erste Element f1 von folge1 an folge an
und entferne f1 aus folge1;
Solange folge2 nicht leer ist:
füge das erste Element f2 von folge2 an folge an
und entferne f2 aus folge2;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
93
Iteratives Mischen zweier sortierter Folgen
Algorithmus Mischen(folge1,folge2)
3, 7, 8, 11, 15
4, 9, 10, 13, 18, 19
3
7, 8, 11, 15
4, 9, 10, 13, 18, 19
7, 8, 11, 15
8, 11, 15
11, 15
9, 10, 13, 18, 19
9, 10, 13, 18, 19
9, 10, 13, 18, 19
3, 4
3, 4, 7
11, 15
11, 15
15
15
10, 13, 18, 19
13, 18, 19
13, 18, 19
18, 19
18, 19
3, 4, 7, 8
3, 4, 7, 8, 9
3, 4, 7, 8, 9, 10
3, 4, 7, 8, 9, 10, 11
3, 4, 7, 8, 9, 10, 11, 13
3, 4, 7, 8, 9, 10, 11, 13, 15
3, 4, 7, 8, 9, 10, 11, 13, 15, 18, 19
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
94
Iteratives Mischen zweier sortierter Folgen
Algorithmus Mischen(folge1,folge2)
3, 7, 8, 11, 15
4, 9, 10, 13, 18, 19
3
3, 7, 8, 11, 15
4, 9, 10, 13, 18, 19
3, 7, 8, 11, 15
3, 7, 8, 11, 15
3, 7, 8, 11, 15
3, 7, 8, 11, 15
4, 9, 10, 13, 18, 19
4, 9, 10, 13, 18, 19
4, 9, 10, 13, 18, 19
4, 9, 10, 13, 18, 19
3, 4
3, 4, 7
3, 7, 8, 11, 15
3, 7, 8, 11, 15
3, 7, 8, 11, 15
3, 7, 8, 11, 15
4, 9, 10, 13, 18, 19
4, 9, 10, 13, 18, 19
4, 9, 10, 13, 18, 19
4, 9, 10, 13, 18, 19
3, 4, 7, 8, 9, 10, 11
3, 4, 7, 8, 9, 10, 11, 13
3, 4, 7, 8, 9, 10, 11, 13, 15
3, 4, 7, 8, 9, 10, 11, 13, 15, 18
3, 7, 8, 11, 15
4, 9, 10, 13, 18, 19
3, 4, 7, 8, 9, 10, 11, 13, 15, 18, 19
i1
3, 4, 7, 8
3, 4, 7, 8, 9
3, 4, 7, 8, 9, 10
i2
i
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
95
Iteratives Mischen zweier sortierter Folgen
public class ProgrammMischSort{
static int[] mische(int f1[],int f2[]){
int n1=f1.length; int n2=f2.length;
int n=n1+n2;
int[] f=new int[n];
int i1,i2,i;
i=0; i1=0; i2=0;
while (i1<n1 & i2<n2){ // f1 und f2 nicht leer:
if (f1[i1]<=f2[i2]){ // erstes Element aus f1
f[i]=f1[i1]; i1=i1+1;i=i+1; // übernehmen
}
else {
// erstes Element aus f2
f[i]=f2[i2]; i2=i2+1;i=i+1; // übernehmen
}
}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
96
Iteratives Mischen zweier sortierter Folgen
while (i2<n2){
f[i]=f2[i2];
i2=i2+1; i=i+1;
}
// f2 anfügen,
// falls f2 nicht leer
while (i1<n1){
f[i]=f1[i1];
i1=i1+1; i=i+1;
}
// f1 anfügen
// falls f1 nicht leer
return f;
}
// mische
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
97
Sortieren durch Mischen
static int[] MischSort(int f[]){
int n = f.length;
if (n>1)
{int nl=n/2; int nr=n-nl;
int hlinks[] = new int[nl];
int i=0;
while (i<nl)
{hlinks[i]=f[i]; i=i+1;}
int flinks[]=MischSort(hlinks);
int hrechts[] = new int[nr];
i=0;
while (i<nr)
{hrechts[i]=f[nl+i]; i=i+1;}
int frechts[]=MischSort(hrechts);
return mische(flinks,frechts);
}
else return f;
} // MischSort
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
// Rekursion
// Rekursion
98
Sortieren durch Mischen
public static void main(String[] args){
int[]a = {11,7,8,3,15,13,9,19,18,10,4};
int n = a.length;
int[]b = MischSort(a);
int i = 0;
while (i<n)
{ System.out.println(b[i]);
i=i+1;
}
} // main
} // ProgrammMischSort
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
99
9. Prinzip der Rekursion
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
100
Prinzip der Rekursion
1. Zerlege ein großes Problem in kleinere Versionen des Problems und löse
diese auf die gleiche Weise.
2. Füge die Lösungen kleinerer Versionen des Problems zu einer Lösung des
großen Problems zusammen.
3. Löse kleine Versionen des Problems direkt.
Bsp.: Sortieren durch Mischen
1. Zerlege die gegebene Menge von Zahlen in zwei Teilmengen etwa
gleicher Größe und sortiere die beiden Teilmengen auf die gleiche Weise.
2. Mische die beiden sortierten Teilfolgen.
3. Falls die gegebene Menge nur ein Element umfasst, gib die einelementige
Folge, bestehend aus diesem Element, zurück.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
101
10. Beispiel:
Suchen in einem Datenbestand
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
102
Suchen in einem Datenbestand
Stuhl
Verweise, Referenzen, Zeiger:
Tisch
Regal
Bett
Regal
Stuhl
Tisch
Bett
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
103
Suchen in einem Datenbestand
Gegeben: d0 , d1 , ..., dn , wobei die di auf Studierendendatensätze
mit folgender Information verweisen:
Name, Matrikelnummer, Geburtsjahr
Gesucht: Für eine gegebene Matrikelnummer m ein Verweis auf
denjenigen Datensatz, der diese Matrikelnummer enthält.
Falls es keinen solchen Datensatz gibt, wird ein „leerer“
Verweis zurückgegeben.
Ergebnis für m=88633:
d0
d1
Thorsten Meier
88188
1980
Monika Schmidt
88633
1981
d2
Monika Schneider
88755
1980
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
104
Suchen in einem Datenbestand
Algorithmus Suche(d0 , d1 , ..., dn ,m)
- Durchlaufe die Elemente der Menge und vergleiche die Komponente
„Matrikelnummer“ des Datensatzes des aktuellen Elements mit m.
- Wenn beide übereinstimmen, dann gib den Verweis auf das aktuelle
Element zurück und breche die Suche ab.
- Falls bei keinem Datensatz Gleichheit gefunden wurde, gib einen leeren
Verweis zurück.
Pseudocode:
i := 0;
Solange i <= n und di.gibMatrikelnummer() != m, führe aus:
i := i+1;
Wenn i <= n, dann
Gib di zurück;
Sonst
Gib null zurück.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
105
11. Grundkonzepte der Programmierung:
Klassen und Objekte
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
106
Grundkonzepte von Algorithmen
Datentyp:
Menge von Daten gleicher Art
Bsp.: ganze Zahlen, reelle Zahlen, Wahrheitswerte, Zeichenketten,
Studierendendaten
Zusammengesetzter Datentyp oder Klasse:
ist aus Datenkomponenten zusammengesetzt und bietet Operationen
zur Manipulation der Datenkomponenten an.
Bsp.: Studierendendaten
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
107
Grundkonzepte von Algorithmen
Bsp.: Studierendendaten
Komponenten („Attribute“):
Studname (Typ Zeichenkette),
Matrikelnummer (Typ ganze Zahl),
Geburtsjahr (Typ ganze Zahl)
d0
Thorsten Meier
88188
1980
Operationen („Methoden“): gibStudname(), setzeStudname(name),
gibMatrikelnummer(), setzteMatrikelnummer(nummer),
gibGeburtsjahr(), setzeGeburtsjahr(jahr), gibAlter()
Ein konkreter Datensatz einer Klasse wird auch als „Objekt“ oder
„Instanziierung einer Klasse“ bezeichnet.
Bsp.:
d0 .gibStudname() liefert Thorsten Meier.
d0 .setzeMatrikelnummer(20002) liefert d0
d0 .gibAlter() liefert 21.
Thosten Meier
20002
1980
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
108
Suchen in einem Datenbestand
Deklaration einer Java-Klasse „Studierendendaten“:
class Studierendendaten
{
String studname;
int matrikelnummer;
int geburtsjahr;
void setzeMatrikelnummer(
int nummer)
{ matrikelnummer = nummer; }
int gibGeburtsjahr()
{ return geburtsjahr; }
String gibStudname()
{ return studname; }
void setzeGeburtsjahr(int jahr)
{ geburtsjahr = jahr; }
void setzeStudname(
String name)
{ studname = name; }
int gibAlter()
{ return 2001-geburtsjahr; }
}
int gibMatrikelnummer()
{ return matrikelnummer; }
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
109
Grundkonzepte der Programmierung
Deklaration von Klassen in Java:
- besteht aus der Angabe eines Klassennamens, von Attributen,
von Methoden und von Konstruktoren. Syntax:
class Klassenname
{ Attributdeklaration Konstruktordeklaration Methodendeklaration }
Attribute werden wie Variablen deklariert.
Methoden werden wie Funktionen deklariert.
- bilden zusammen ein Java-Programm, d.h.
ein Java-Programm besteht aus einer Menge von Klassen.
In einer Klasse muss die Methode main deklariert sein. Mit dieser
Methode startet das Gesamtprogramm.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
110
Grundkonzepte der Programmierung
Deklaration von Klassen in Java:
- Konstruktor: Ein Programmstück, das ausgeführt wird, wenn ein
Objekt des Typs der Klasse instanziiert wird. Syntax:
Klassenname(formale Parameterdeklaration){ Anweisungsfolge }
Falls kein Konstruktor deklariert wird, wird ein vordefinierter („Default“-)
Konstruktor ohne Parameter (Klassenname()) verwendet.
Bsp.: ein expliziter Konstruktor für die Klasse Studierendendaten:
Studierendendaten(String name, int nummer, int jahr)
{ studname = name;
matrikelnummer = nummer;
geburtsjahr = jahr;
}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
111
Suchen in einem Datenbestand
public class Suchprogramm
{
static Studierendendaten Suche(
Studierendendaten d[],int m)
{ int i=0;
int n = d.length-1;
while ((i<=n) && (d[i].gibMatrikelnummer()!=m))
i=i+1;
if (i<=n)
return d[i];
else return null;
}
i := 0;
Solange i < =n und di.gibMatrikelnummer() != m, führe aus:
i := i+1;
Wenn i <= n, dann
Gib di zurück;
Sonst
Gib null zurück.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
112
Suchen in einem Datenbestand
public static void main(String[] args)
{
Studierendendaten testd[] = new Studierendendaten[3];
testd[0] = new Studierendendaten(
´´Thorsten Meier´´,88188,1980);
testd[1] = new Studierendendaten(
´´Monika Schmidt´´,88633,1981);
testd[2] = new Studierendendaten(
´´Monika Schneider´´,88755,1980);
int m = 88633;
boolean gefunden = (Suche(testd,m)!=null);
if (gefunden)
System.out.println(m+´´ gefunden´´);
// hier wird der Wert von m in eine Zeichenfolge gewandelt
// und mit der Zeichenfolge „gefunden“ verkettet.
else System.out.println(m+´´ nicht gefunden´´);
}
}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
113
Grundkonzepte der Programmierung
Deklaration von Java-Objektvariablen:
- wie für Variablen einfachen Datentyps
Bsp.: Studierendendaten a;
Studierendendaten d[];
- Wirkung einer Deklaration:
Es wird eine Variable angelegt, die einen Verweis (Referenz, Zeiger)
auf ein Objekt aufnehmen kann. Der Verweis wird auf den leeren
Verweis null gesetzt.
Bsp: Studierendendaten a;
a
null
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
114
Grundkonzepte der Programmierung
Instanziierung von Java-Objekten:
- erzeugt ein Objekt und gibt den Verweis (Referenz, Zeiger) auf dieses
zurück. Syntax:
new Klassenname(aktuelle Parameter);
Bsp.: new Studierendendaten(´´Thorsten Meier´´,88188,1980);
Thorsten Meier
88188
1980
Der Verweis ist durch den Pfeil angedeutet.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
115
Grundkonzepte der Programmierung
Wertzuweisung an Objektvariable:
- wie für Variable einfachen Datentyps.
- Wirkung einer Wertzuweisung: Der Verweis auf der rechten Seite der
Wertzuweisung „=“ wird in die Variable der linken Seite übernommen.
Bsp.: Studierendendaten a =
new Studierendendaten(´´Thorsten Meier´´,88188,1980);
Studierendendaten b;
b = a;
a
b
Thorsten Meier
88188
1980
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
116
Grundkonzepte der Programmierung
zum Vergleich: Wertzuweisung an Variable einfachen Typs
(z.B. ganze Zahlen, Gleitkommazahlen, Wahrheitswerte (Boolean)):
Bsp.: int a = 5;
int b = a;
a
5
b
5
Beispiele für Klassen, die bereits Bestandteil der Sprache Java sind:
Array, Zeichenfolgen (String)
Bsp.: Studierendendaten testd[] = new Studierendendaten[3];
testd
0
1
2
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
117
12. Beispiel:
Suchen in einer verzeigerten
linearen Liste
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
118
Suchen in einer verzeigerten linearen Liste
Die gleiche Aufgabe wie bei „Suchen in einem Datenstand“, mit dem
Unterschied, dass die Daten nun nicht in einem Array gegeben sind,
sondern in einer verzeigerten linearen Liste.
Array:
d
0
Thorsten Meier
88188
1980
1
2
Monika Schneider
88755
1980
Monika Schmidt
88633
1981
verzeigerte lineare Liste:
dliste
Thorsten Meier
88188
1980
null
Monika Schmidt
88633
1981
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
Monika Schneider
88755
1980
119
Suchen in einer verzeigerten linearen Liste
Deklaration eines Datenttyps Liste dieser Art:
wert
class Liste{
Studierendendaten wert;
Liste naechstes;
naechstes
Thorsten Meier
88188
1980
void setzeWert(Studierendendaten einwert)
{ wert = einwert;}
Liste gibNaechstes()
{ return naechstes;}
void setzeNaechstes(Liste einnaechstes)
{ naechstes = einnaechstes;}
}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
120
Suchen in einer verzeigerten linearen Liste
Anweisungen zum Anlegen einer Liste:
dliste
Liste dliste = new Liste();
null null
Studierendendaten a =
new Studierendendaten(´´Thorsten Meier´´,88188,1980);
a
Thorsten Meier
88188
1980
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
121
Suchen in einer verzeigerten linearen Liste
Anweisungen zum Anlegen einer Liste:
dliste
Liste dliste = new Liste();
null null
Studierendendaten a =
new Studierendendaten(´´Thorsten Meier´´,88188,1980);
dliste.setzeWert(a);
a
dliste
null
Thorsten Meier
88188
1980
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
122
Suchen in einer verzeigerten linearen Liste
aktuell
Anweisungen zum Anlegen einer Liste:
dliste
Bsp.:
Liste aktuell = dliste;
aktuell.setzeNaechstes(new Liste());
null
Thorsten Meier
aktuell = aktuell.gibNaechstes();
88188
1980
a = new Studierendendaten(
´´Monika Schmidt´´,88633,1981);
aktuell.setzeWert(a);
aktuell
dliste
a
Thorsten Meier
88188
1980
Monika Schmidt
88633
1981
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
123
Suchen in einer verzeigerten linearen Liste
Anweisungen zum Anlegen einer Liste:
aktuell.setzeNaechstes(new Liste());
aktuell = aktuell.gibNaechstes();
a = new Studierendendaten(
´´Monika Schneider´´,88755,1980);
aktuell.setzeWert(a);
aktuell
a
dliste
Thorsten Meier
88188
1980
Monika Schmidt
88633
1981
Monika Schneider
88755
1980
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
124
Die Java-Programmierumgebungen
• Windows: Sun NetBeans 3.6
• Unix: Emacs
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
125
Java-Programmierung mit Sun NetBeans
• Installation
• Entwicklungsumgebung starten
• Erstellen eines ersten Programms: „ HelloWorld “
• Compilieren und Ausführen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
126
Vorbereitung – Installation von Java und NetBeans
Programme von der Vorkurs-CD installieren
Windows oder Linux
•
Java installieren: JDK_1.4.2 (Sun)
•
Sun NetBeans 3.6
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
127
NetBeans - Programmstart
1. Windows
Starten des Programms (Doppelklick) über das Icon
„NetBeans IDE 3.6“ von der Windowsarbeitsfläche
2. Linux
In einem geöffneten Shell (=Eingabeaufforderung)
starten Sie Forte über „runide“.
Die folgenden Screenshots stammen von einer
Windows-Umgebung, deshalb kann es geringfügige
Unterschiede im Erscheinungsbild unter Linux geben.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
128
NetBeans – Ansicht nach Programmstart
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
129
„HelloWorld“ – Schritt 1: Neues Projekt anlegen
• Anlegen eines neuen Projektes: Project >> Project Manager
Neues
Projekt
Projekt
öffnen
• Neues Projekt erstellen: New
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
130
„HelloWorld“ – Schritt 2: Projektname bestimmen
• Name für das neue Projekt vergeben: HelloWorld
• Requester mit OK verlassen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
131
„HelloWorld“ – Schritt 3: Projektverzeichnis festlegen
• Verzeichnis auswählen: File >> New
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
132
„HelloWorld“ – Schritt 4: Quelldatei erzeugen
• Neue Datei ergänzen: File >> New
• Java-Klassentyp auswählen: Classes -> Empty
• Abfragedialog mit Next beenden
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
133
„HelloWorld“ – Schritt 5: Klassenname festlegen
• Name der Klasse eingeben: HelloWorld
• Abfragedialog mit Finish beenden
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
134
„HelloWorld“ – Schritt 6: Quellcode eingeben
• Eingeben des Java-Quellcodes:
Das berühmte HelloWorld-Programm
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
135
„HelloWorld“ – Schritt 7: Speichern und Compilieren
Über die rechte Maustaste PullDown-Menü öffnen
• Mit linker Maustaste Save auswählen
• Quellcode übersetzen (Compile)
• Programm ausführen (Execute)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
136
„HelloWorld“ – Schritt 8: Programm ausführen
• Compiliertes Programm mit Execute starten
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
137
Einführung in die Unix-Systemumgebung
• Ausstattung
• Benutzerumgebung
• Das erste Java-Programm
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
138
Ausstattung
SunRays
• keine Workstations wie z.B. PC‘s,
• sondern Terminals, über Ethernet mit PC
- Servern verbunden
• realisieren nur Bildschirmausgabe und Eingabeinteraktionen
• Geschossbau IV
• im Raum 006, Sun
-
Rays (carne[01..12])
• „Einschalten“ bedeutet hier „Einloggen“
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
139
Einloggen: Erste Anmeldung an das Unix-System
Die Anmeldungsmaske
1.) Linke Maustaste auf das Feld Options
2.) Remote Login- >Choose host from list
3.) Rechner auswählen: carne[01..12]
4.) Eingabe von Benutzername und Passwort
5.) Nach der Anmeldung: ändern des Passworts (passwd)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
140
Java-Programmierung unter Unix
Der Editor – emacs – als Entwicklungstool:
1.) Emacs starten mit: emacs &
• Im geöffneten Editor Programm
-
Code eingeben:
class HelloWorld {
public static void main(String argv[]) {
System.out.println("Hello World.");
}
}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
141
Java-Programmierung unter Unix
Der Editor – emacs – als Entwicklungstool:
2.) Programm speichern:
• Pulldown-Menüs mit rechter Maustaste anwählen
• Files -> Save Buffer
• In unterer Statuszeile Name eingeben: HelloWorld.java
3.) Programm compilieren (=übersetzen):
• Über Menü JDE-->Compile Vorgang starten
• Meldung Compilation finished sollte erscheinen
4.) Programm starten:
• Menü: JDE-->RunApp
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
142
Marvin-Account
Rechnerzugang (marvin) für alle Studierende des FBI
1. Reservieren eines Account
• Einloggen unter „marvin“ an Marvin-Pool-Rechner (Campus Süd, Pav. 6)
• Matrikelnummer, Vor- und Nachname eingeben und mit „J“ bestätigen
• Gewünschtes Passwort eingeben
• Accountname und Mailadresse werden berechnet
<vorname>.<nachname>@marvin.cs.uni-dortmund.de
• Bitte Passwort und Accountnamen merken
2. Freischalten des Account
• Beim Operating der IRB (Campus Süd, GB V, R 311)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
143
Links zu Java und Unix
http://irb
-
ww.cs.uni- d
ortmund.de/anleitungen
Anleitungen zu Unix und CDE
http://www.javasoft.com
Informationen zu Java
http://www.java.de
Homepage der deutschen Java User Group
http://www.gnu.org/software/emacs/emacs.html
Informationen zum Editor emacs
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
144
13. Mehr zur objektorientierten
Programmierung
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
145
Vom Problem über den Systementwurf zum Programm
reale Welt
Problem
Abstraktion
Problemanalyse
funktionale Spezifikation
Algorithmenentwurf
Systementwurf
Algorithmus
Darstellung in formalisierter Sprache
Darstellung
für Ausführung durch Rechner
abstrakte Objekte
InformationsverProgramm
arbeitendes System
Realisierung
Rechner
Umsetzung in
Elementarschritte
einer Maschine
Maschine
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
146
Objektorientierter Entwurf
- Modellierung von Systemen durch miteinander interagierende Objekte
Bsp.: Videorekorder
Benutzungsschnittstelle
Systemsteuerung
Tasten für play, stop, fwd,
rwd, rec, eject
Sensor am Kassettenschacht
Operationen:
Kassette einlegen lassen
Band um LS-Kopf wickeln
nach rechts laufen
nach rechts abspulen
nach links abspulen
Schreibkopf aktivieren
Lesekopf aktivieren
Band entwickeln
Kassette auswerfen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
147
Objektorientierter Entwurf
Videorekorder-Software
Objekt
Eingabeverarbeitung
Tastendruck
aktiviert
passende
Interpretationsmethode
von Eingabeverarbeitung
Bsp.: Methode play
Interpretationsmethode führt
eine Sequenz von
Steuermethoden von
Laufwerksteuerung
Objekt
Laufwerksteuerung
Steuermethode
aktiviert
Laufwerk über
Signalleitungen
und bekommt
Rückmeldung
über den Zustand
Bsp.: Methoden
laufeRechts
aktiviereLesen
Vorteil des objektorientierten Entwurfs: direkte Zuordnung von
realen Funktionseinheiten zu Programmteilen (Objekten)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
148
Konzepte der objektorientierten Programmierung
- Objekt = Attribute + Methoden
- Verdeckung von Implementierungsdetails durch Spezifikation der
Sichtbarkeit: public, protected, private
- Vererbung: Deklaration von Unterklassen, die sich durch Hinzunahme
weiterer Attribute und Methoden zu einer Klasse ergeben.
Bsp.: Videorecorder: Laufwerksteuerung_mit_Fastplay
Unterklasse von Laufwerksteuerung
- Polymorphismus durch Überladung: Methoden können den gleichen
Namen haben, aber etwas unterschiedliches tun.
Bsp.: Addition von ganzen Zahlen, Addition von reellen Zahlen,
Addition von komplexen Zahlen.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
149
14. Andere Programmierstile
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
150
Programmierstile
Imperative Programmierung
Programm = eine Folge von Befehlen
Bsp.: Fortran, Basic, Pascal, C
funktionale Programmierung
Programm = eine Schachtelung von Funktionsaufrufen
Bsp.: LISP
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
151
Programmierstile
logische Programmierung
Programm = eine Menge von wenn-dann-Regeln.
Der dann-Teil einer Regel wird ausgeführt, wenn der wenn-Teil erfüllt
ist. Der dann-Teil enthält Aktionen, die dazu führen können, dass andere
weitere Regeln ausgeführt werden können. Die Reihenfolge der
Regelausführung ist nicht festgelegt.
Bsp.: Prolog
objektorientierte Programmierung
Programm = eine Menge von interagierenden Objekten
Bsp.: Smalltalk, C++, Java
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
152
Teil III. Algorithmen und
Datenstrukturen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
153
Inhalt
1. Asymptotische Aufwandsanalyse
2. Sortieren
3. Suchen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
154
1. Asymptotische Aufwandsanalyse
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
155
Zeitaufwandsanalyse
- durch Abschätzen der Anzahl der ausgeführten
Elementaroperationen (E)
Bsp: Minimum Min(a0, a1, ..., an) einer Menge von Zahlen
Algorithmus
Zeitaufwand
Anzahl Durchläufe
1E
1E
1
1
merker := a0 ;
i := 0;
Solange i < n ist, führe aus:
{i := i+1;
Wenn ai < merker, dann
merker := ai;}
Gib merker zurück;
1E
1E
1E
1E
1E
n+1
n
n
min. 0, max. n
1
günstigster Fall: Tmin(n) = 3n + 4
ungünstigster Fall: Tmax(n)=4n + 4
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
156
Zeitaufwandsanalyse
- Aufwandsmaße allgemein:
Sei
E die Menge aller Eingaben des Algorithmus,
En:={e in E | die Größe von e ist n}, wobei die
Größe einer Eingabe e aus E die Anzahl elementarer
Datenelemente von e ist,
A(e) der Aufwand des Algorithmus bei der Eingabe e.
Dann ist
Amax(n):= max { A(e) | e in En } der maximale Aufwand
Amin(n):= min { A(e) | e in En } der minimale Aufwand.
Speziell
für den Zeitaufwand: A := T
für den Speicheraufwand: A := S
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
157
Zeitaufwandsanalyse
- asymptotische Aufwandsanalyse
Beobachtung: die Elementaroperationen haben unterschiedliche
Ausführungszeiten, d.h. das genaue Zählen lohnt sich nicht.
Vorgehensweise für die Abschätzung des schlechtesten Falls:
- Angabe einer oberen Zeitschranke, d.h. einer Funktion,
die für jedes Argument größer oder gleich dem korrekten Wert
ist.
- Beschränkung der Angabe auf die Größenordnung, d.h.
Unabhängig von den konkreten Konstanten.
Bsp: Tmax(n) = 4n + 4 hat die Größenordnung n,
oder: Tmax(n) = 4n + 4 wächst mit der Ordnung n.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
158
Zeitaufwandsanalyse
c0 g
- asymptotische Aufwandsanalyse
f
„groß-Oh-Notation“:
Seien f: IN->IR, g: IN->IR zwei Funktionen.
n0
f wächst mit der Ordnung g ( f ist von der Größenordnung g),
Schreibweise f=O(g), wenn gilt:
Es gibt ein n0 in IN und ein dazu passendes c0 > 0, c0 in IR,
so dass f(n) < c0 * g(n) für alle n > n0.
Bsp.: Für Tmax(n) = 4n+4 gilt:
Tmax(n) = O(n), da Tmax(n) < 5n für n > 4
Tmax(n) = O(n2), da Tmax(n) < n2 für n > 4
Tmax(n) nicht O( n)
Tmax(n) nicht O(1)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
159
Speicheraufwandsanalyse
- durch Abschätzen der Anzahl der während der Algorithmusausführung
belegten Elementardateneinheiten (e)
Bsp: Minimum Min(a0, a1, ..., an) einer Menge von Zahlen
Algorithmus:
merker := a0;
i := 0;
Solange i < n ist, führe aus:
{i := i+1;
Wenn ai < merker, dann
merker := ai;}
Gib merker zurück;
Speicherbedarf:
a0, a1, ..., an
merker, i, n:
Smax(n) = Smin(n) = n + 4,
d.h. Smax(n) = Smin(n) = O(n)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
160
2. Sortieren
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
161
Sortieren einer Menge von Zahlen
Gegeben: a0, a1, ..., an
Gesucht: Anordnung der Eingabewerte nach steigendem Wert
Bedeutung:
Sortieren großer Datenbestände ist eine der Hauptaufgaben kommerziell
eingesetzter Rechnersysteme
im folgenden:
Analyse des Zeitaufwands der Verfahren „Sortieren durch Minimumsuche“
und „Sortieren durch Mischen“
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
162
Sortieren durch Minimumsuche
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
163
Sortieren einer Menge von Zahlen durch Minimumsuche
Algorithmus MinSort(a0,a1,..., an)
restfolge := gegebenefolge;
Solange restfolge nicht leer, führe aus:
{ak:= MinSuche(restfolge);
FügeAn(ak, ergebnisfolge);
Enferne(ak, restfolge);}
gib ergebnisfolge zurück;
Zeitaufwand
O(n)
O(1)
O(n)
O(1)
O(1)
O(n)
Anzahl Durchläufe
1
n+2
n+1
n+1
n+1
1
Maximaler Zeitaufwand: Tmax(n)= (n+1) * O(n) + (3n+4) * O(1) + 2*O(n) = O(n2)
Annahme: 1 Nanosekunde = 10-9 Sekunden pro Elementaroperation,
n2 Elementaroperationen
dann: Sortieren von 100 000=105 Werten benötigt 10 Sekunden
Sortieren von 1 000 000=106 Werten benötigt 1 000 Sekunden
Sortieren von 5 000 000=5*106 Werten benötigt 25 000 Sekunden,
d.h. fast 7 Stunden
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
164
Sortieren einer Menge von Zahlen durch Minimumsuche
Mit Hilfsmengen:
restfolge := gegebenefolge;
Solange restfolge nicht leer, führe aus:
{ak := MinSuche(restfolge);
FügeAn(ak, ergebnisfolge);
Enferne(ak, restfolge);}
gib ergebnisfolge zurück;
Speicheraufwand beim i-ten
Durchlauf:
gegebenefolge (n+1) E
restfolge
(n+1-i) E
ergebnisfolge
i E
1E
ak
MinSuche,FügeAn,
Entferne
cE
Ohne Hilfsmengen: Die Datenstruktur
Summe:
(2n+3+c) E
gegebenefolge wird schrittweise so
verändert, dass sie am Ende das
Ergebnis enthält. Dies benötigt (n+d) E,
Hier kann eine
wobei d eine von n unabhängige
nichtasymptotische
Konstante ist.
Betrachtung praktisch
relevant sein.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
165
Sortieren durch Mischen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
166
Iteratives Mischen zweier sortierter Folgen
Algorithmus Mischen(folge1,folge2)
n1
n2
n := Länge von folge1 plus Länge von folge2;
folge := eine leere Folge;
n=n1+n2
O(1)
O(n)
Solange folge1 und folge2 nicht leer ist:
Wenn das erste Element f1 von folge1 nicht größer
als das erste Element f2 von folge2 ist, dann
füge f1 an folge an und entferne f1 aus folge1;
sonst
füge f2 an folge an und entferne f2 aus folge2;
Solange folge1 nicht leer ist:
füge das erste Element f1 von folge1 an folge an
und entferne f1 aus folge1;
Solange folge2 nicht leer ist:
füge das erste Element f2 von folge2 an folge an
und entferne f2 aus folge2;
O(1)
O(1)
O(n)
O(1)
O(n1)
O(n)
O(n2)
O(n)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
167
Sortieren einer Menge von Zahlen durch Mischen
Algorithmus MischSort(a0,a1,..., an)
T(n)
Wenn die Menge nur ein Element hat (n = 0), dann gib die Menge
unverändert zurück.
Sonst zerlege die Menge in zwei Teilmengen, die beide
etwa gleich groß sind, und sortiere beide Teilmengen
nach diesem Verfahren;
Mische die sortierten Teilmengen und gib das Ergebnis zurück.
c0
T(n/2)+T(n/2)
O(n)
Zeitaufwand: T(0) = c0,
T(n) = T(n/2)+T(n/2)+O(n) für n > 0.
Behauptung: T(n) = O(n log n)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
168
Sortieren einer Menge von Zahlen durch Mischen
Algorithmus MischSort(a0,a1,..., an)
Zeitaufwand:
T(0) = c0,
T(n) = T(n/2)+T(n/2)+O(n) für n>0.
T(n/2) = T(n/4)+T(n/4)+O(n/2)
c n/2
c n/4
c n/8 c n/8
...
... ... ...
cn
cn
+c n
c n/2
c n/4
c n/8 c n/8
... ... ... ...
c n/4
c n/4
+c n
c n/8 c n/8
... ... ... ...
c n/8 c n/8
... ... ... ...
+c n
...
=c n (log n +1))
i Stufen, wobei i minimal mit n/2i < 1, d.h. log n < i
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
169
Sortieren einer Menge von Zahlen durch Mischen
Algorithmus MischSort(a0,a1,..., an)
Zeitaufwand:
T(0) = c0,
T(n) = T(n/2)+T(n/2)+O(n) für n>0.
cn
c n/2
c n/4
...
c n/8 c n/8
... ... ...
T(n/2) = T(n/4)+T(n/4)+O(n/2)
cn
+c n
c n/2
c n/4
c n/8 c n/8
... ... ... ...
c n/4
c n/4
+c n
c n/8 c n/8
... ... ... ...
c n/8 c n/8
... ... ... ...
+c n
...
i Stufen, wobei i minimal mit n/2i < 1, d.h. log n < i
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
=c n (log n +1))
170
Sortieren einer Menge von Zahlen durch Mischen
Algorithmus MischSort(a0,a1,..., an)
Zeitaufwand:
T(0) = c0,
T(n) = T(n/2)+T(n/2)+O(n) für n>0.
T(n/2) = T(n/4)+T(n/4)+O(n/2)
T(n/4) = T(n/8)+T(n/8)+O(n/4)
cn
cn
c n/2
c n/4
+c n
c n/2
c n/4
c n/4
c n/4
+c n
c n/8 c n/8
... ... ... ...
c n/8 c n/8
... ... ... ...
+c n
...
T(n/8) = T(n/16)+T(n/16)+O(n/8)
c n/8 c n/8
...
... ... ...
c n/8 c n/8
... ... ... ...
i Stufen, wobei i minimal mit n/2i < 1, d.h. log n < i
=c n (log n +1))
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
171
Sortieren einer Menge von Zahlen durch Mischen
Algorithmus MischSort(a0,a1,..., an)
Zeitaufwand:
T(n) = T(n/2)+T(n/2)+O(n) für n>0.
Behauptung: T(n) = O(n log n), wobei log den Logarithmus zur Basis 2
bezeichnet.
Beweis: induktiv über n.
Exkurs: Vollständige Induktion
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
172
Beweisprinzip der vollständigen Induktion
Behauptung: Die Aussage B(n) ist für alle natürlichen Zahlen n ≥ k richtig.
Beweis:
Induktionsanfang: (n=k)
Es wird bewiesen, dass die Aussage B(k) richtig ist,
d.h. B(n) gilt für n=k.
Induktionsschritt:
Es wird bewiesen, dass unter der Annahme, dass die Aussagen
B(n-1), B(n-2), ..., B(k) richtig sind, auch die Aussage B(n) richtig ist.
Warum reicht das?
B(k) Induktionsschritt
mit n=k+1
richtig
B(k), B(k+1)
richtig
Induktionsschritt
mit n=k+2
B(k),
B(k+1),B(k+2)
richtig
...
Induktionsanfang
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
173
Beweisprinzip der vollständigen Induktion
Bsp:
Behauptung: Die Summe S(n) der Zahlen von 1 bis n, n ≥ 1, ist
gleich n(n+1)/2.
B(n): S(n)=n(n+1)/2
Beweis:
Induktionsanfang: (n=1)
Es ist zu beweisen, dass S(1)=1(1+1)/2 richtig ist. Dies stimmt
offensichtlich.
Induktionsschritt:
Es wird bewiesen, dass unter der Annahme, dass
S(n-1)=(n-1)n/2, S(n-2)=(n-2)(n-1)/2, ..., S(1)=1(1+1)/2 richtig sind,
auch S(n)=n(n+1)/2 richtig ist. Das folgt aus
S(n) = S(n-1)+n=(n-1)n/2+n = (n+1)n/2=n(n+1)/2
Induktionsannahme
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
174
Beweisprinzip der vollständigen Induktion
Bsp:
Behauptung: Die Summe S(n) der Quadratzahlen von 1 bis n, n ≥ 1, ist
gleich n(n+1)(2n+1)/6.
B(n): S(n)=n(n+1)(2n+1)/6
Beweis:
Induktionsanfang: (n=1)
Es ist zu beweisen, dass S(1)=1(1+1)(2+1)/6=1 richtig ist. Dies stimmt
offensichtlich.
Induktionsschritt:
Es wird bewiesen, dass unter der Annahme, dass
S(n-1)=(n-1)n(2n-1)/6, S(n-2)=(n-2)(n-1)(2n-3)/6, ... richtig sind,
auch S(n)=n(n+1)(2n+1)/6 richtig ist. Das folgt aus
2
2
S(n) = S(n-1)+n =(n-1)n (2n-1)/6+n = n(n+1)(2n+1)/6
Induktionsannahme
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
175
Sortieren einer Menge von Zahlen durch Mischen
Algorithmus MischSort(a0,a1,..., an)
Zeitaufwand:
T(n) = T(n/2)+T(n/2)+O(n) für n>0.
Behauptung: T(n) = O(n log n), wobei „log“ den Logarithmus zur Basis 2
bezeichnet.
Beweis: induktiv über n.
Es wird gezeigt, dass es eine Konstante c>0 gibt, so dass
T(n) < c n(1+log n) für n>0.
Induktionsanfang: Nachweis für n=1.
Sei c1 eine obere Schranke für den Zeitbedarf für Eingaben mit n=1.
Dann gilt T(1)= c1 < c 1 (1+log 1) für alle c> c1.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
176
Sortieren einer Menge von Zahlen durch Mischen
Algorithmus MischSort(a0,a1,..., an)
Induktionsschritt: Nachweis für n>1 unter der Annahme, dass die Aussage
für n-1, n-2,...,0 gilt.
Aufgrund der Induktionsannahme gilt T(n/2) < c n/2 (1+log (n/2)).
Mit T(n) = T(n/2)+T(n/2)+O(n) für n>1 folgt damit
T(n) < T(n/2)+T(n/2)+ c2 n
< c n/2 (1+log n/2) + c n/2 (1+ log n/2) + c2 n
Induktionsannahme
< c n (1+log (n) -1) + c2 n < c n (1+log n),
Umformung
falls c > c2
Mit c>max{c1, c2} gilt die Behauptung.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
177
Sortieren einer Menge von Zahlen
Einige Bemerkungen zum Sortierproblem:
- Es kann bewiesen werden, dass jeder Sortieralgorithmus, der nur Vergleiche
und Speicherzugriffe verwendet, asymptotisch mindestens c n log n
Operationen, c eine Konstante, benötigt. Damit ist „Sortieren durch Mischen“
optimal, wenn es geeignet implementiert wird.
- Es gibt zahlreiche andere Sortierverfahren mit Zeitaufwand O(n log n).
- Ein schnelles Verfahren ist Quicksort. Quicksort hat einen Zeitaufwand von
O(n2) im schlechtesten Fall, im Mittel jedoch von O(n log n).
Annahme: 1 Nanosekunde = 10-9 Sekunden pro Elementaroperation
n2
n log n
100 000=105
10 Sek.
< 2*10-3 Sek.
1 000 000=106
1 000 Sek.
< 24*10-3 Sek.
25 000 Sek.
< 24*10-3 Sek.
n
5 000 000=5*106
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
178
3. Suchen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
179
Operationen auf Mengen
Gegeben: Eine Menge S= {s0, s1, ..., sn} von Zahlen.
Operation „Suchen“:
Gesucht: Die Antwort „ja“, falls eine gegebene Zahl s in S enthalten
ist, sonst „nein“.
Operation „Einfügen“:
Gesucht: Für eine gegebene Zahl s, die Erweiterung der Menge S um s
Operation „Entfernen“:
Gesucht: Für eine gegebene Zahl s, die um s reduzierte Menge S, falls
s in S, sonst bleibt S unverändert.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
180
Operationen auf Mengen
im Folgenden:
Lösungen mit
- unsortiertem Array
- sortiertem Array
- ausgeglichenem binärem Suchbaum
- Hashing
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
181
Lösung mit unsortiertem Array
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
182
Lösung mit unsortiertem Array
Datenstruktur:
Index i:
Daten S[i]:
0 1
2
3
5
6
7
11 7 8 3 15 13
9
19 18 10 4
Variable füllstand:
4
8
9
10 11 12 13 14
11
enthält den Index des ersten nicht zur Menge S gehörigen Array-Elements
Algorithmus Suche(s)
i:=0;
solange i < füllstand und nicht S[i] = s, führe aus
i := i + 1;
wenn i<füllstand, dann gib „ja“ zurück
sonst „nein“
Zeitaufwand: T(n)=O(n), wobei n die Größe der Menge (=füllstand)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
183
Lösung mit unsortiertem Array
Datenstruktur:
Index i:
0 1
5
6
7
Daten S[i]: 11 7 8 3 15 13
9
19 18 10 4
Variable füllstand:
2
3
4
8
9
10 11 12 13 14
11
Algorithmus Fügeein(s)
wenn füllstand < Länge von S[ ], dann
{S[füllstand] := s;
füllstand := füllstand+1;}
sonst gib „Überlauf“ zurück;
Zeitaufwand: T(n)=O(1), wobei n die Größe der Menge (=füllstand)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
184
Lösung mit unsortiertem Array
Datenstruktur:
Index i:
0 1
5
6
7
Daten s[i]: 11 7 8 3 15 13
9
19 18 10 4
Variable füllstand:
2
3
4
8
9
10 11 12 13 14
11
Algorithmus Entferne(s)
i := 0;
solange i<füllstand und nicht s[i]=s, führe aus
i := i + 1;
wenn i<füllstand, dann
{ s[i]:=s[füllstand-1];
füllstand:=füllstand-1; }
// suche s
// entferne s
Zeitaufwand: T(n)=O(n), wobei n die Größe der Menge (=füllstand)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
185
Lösung mit sortiertem Array
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
186
Lösung mit sortiertem Array
Datenstruktur:
Index i:
0 1
Daten S[i]:
3
Variable füllstand:
2
3
4
5
6
7
8
9
10 11 12 13 14
4 7 8
9
10
11 13 15 18 19
Zeitaufwand:
T(n) = T(n/2)+O(1) für n>0
-> T(n) = O(log n),
11
Algorithmus Suche(s,l,r) binäre Suche:
Bsp.: s=13
Suche im Intervall [0,10]:
s > S[(0+10) div 2] = S[5] ->
Suche im Intervall [6,10]:
s nicht > S[(6+10) div 2]=S[8]->
Suche im Intervall [6,8]:
s nicht > S[(6+8) div 2]=S[7]->
Suche im Intervall [6,7]:
s > S[(6+7) div 2] = S[6]->
Suche im Intervall [7,7]: gefunden
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
l
187
r
m
Lösung mit sortiertem Array
Algorithmus Suche(s,l,r)
// binäre Suche
wenn r < l, dann gib „nein“ zurück;
sonst
wenn l = r und S[l] = s, dann gib „ja“ zurück, sonst „nein“;
m:= (l+r) div 2;
// ganzzahlige Division
Wenn S[m] < s, dann
wenn Suche(s,m+1,r) = „ja“, dann gib „ja“ zurück;
sonst gib „nein“ zurück;
sonst
wenn Suche(s,l,m) = „ja“, dann gib „ja“ zurück;
sonst gib „nein“ zurück;
T(n)
O(1)
O(1)
T(n/2)
O(1)
T(n/2)
O(1)
T(n) = T(n/2)+O(1) für n>0
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
188
Lösung mit sortiertem Array
Zeitaufwand: T(n) = T(n/2)+O(1) für n>0, n die Mächtigkeit der Menge S.
Behauptung: T(n)=O(log n)
Beweis: induktiv über n.
Es wird gezeigt, dass es eine Konstante c>0, so dass T(n) < c(1+ log n)
für n>1.
Induktionsanfang: n=1
Sei c1 eine obere Schranke für die Rechenzeit von Eingaben mit n=1.
Dann gilt T(1)= c1 < c(1+ log 1) für c> c1.
Induktionsschritt: Nachweis, dass die Behauptung für n>1 unter
der Annahme gilt, dass sie für n-1,n-2,...,1 richtig ist.
Es gilt:
T(n)<T(n/2)+ c2 < c (1+log n/2)+ c2 < c (1+log n),
wobei c2 eine Konstante für O(1) und falls c> c2 gilt.
Mit c>max{c1, c2} gilt die Behauptung.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
189
Lösung mit sortiertem Array
Datenstruktur:
Index i:
0 1
Daten S[i]:
3
2
3
4
5
6
4 7 8
9
10
11 13 15 18 19
Variable füllstand:
7
8
9
10 11 12 13 14
11
Algorithmus Fügeein(s)
Wenn füllstand gleich der Array-Länge (im Bsp. 15) ist, gib „Überlauf“
zurück.
Sonst durchlaufe das Array aufsteigend bis zu ersten Index i, für den
S[i+1] nicht kleiner s ist.
Wenn S[i+1] nicht gleich s, dann verschiebe die Array-Elemente von
i+1 bis füllstand um 1 nach rechts und setzte S[i+1] auf s.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
190
Lösung mit sortiertem Array
Index i:
0 1
Daten S[i]:
3
Variable füllstand:
2
3
4
5
6
7
8
9
10 11 12 13 14
4 7 8
9
10
11 13 15 18 19
11
Algorithmus Entferne(s)
wenn füllstand>0, dann
i := 0;
// suche s
solange i<füllstand und nicht s =S[i], führe aus
i := i+1;
wenn nicht i=füllstand, dann
{ j:=i;
// verschiebe den Rest
solange j<füllstand-1, führe aus
{ S[j] := S[j+1]; j:=j+1;}
füllstand := füllstand-1;}
Zeitaufwand: T(n) = O(n), wobei n=füllstand
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
191
Lösung mit ausgeglichenem binärem
Suchbaum
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
192
Lösung mit ausgeglichenem binärem Suchbaum
Datenstruktur:
10
15
7
4
3
9
13
8
19
11
18
Bsp.: Suche(11) :10 ->15 ->13 ->11
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
193
Lösung mit ausgeglichenem binärem Suchbaum
Definitionen
gerichteter Graph:
eine Struktur aus Knoten und Kanten. Eine Kante e wird durch ein
Paar (p,q) von Knoten definiert, d.h. e=(p,q).
Schreibweise: G=(V,E), wobei
G der Graph
V eine endliche Menge von Knoten
E eine Teilmenge von VxV.
Bsp.: G=(V,E) mit V={1,2,3,4}, E={(1,2),(2,2),(1,3),(3,4),(4,3)}
2
1
3
4
zusammenhängender Graph:
zu je zwei Knoten gibt es eine Folge von Knoten, in der je zwei
aufeinanderfolgende Knoten durch eine Kante verbunden sind.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
194
Lösung mit ausgeglichenem binärem Suchbaum
binärer Baum:
ein zusammenhängender gerichteter Graph B, der eine der folgenden
Eigenschaften hat:
1. B hat nur einen Knoten.
2. Falls B mehr als einen Knoten hat, gibt es einen Knoten w, die
sogenannte Wurzel, der nur auswärts gerichtete Kanten hat.
Wird w inklusive seiner Kanten weggenommen, so entstehen
genau zwei zusammenhängende Graphen, die 1. oder 2. erfüllen.
Die Endknoten der weggenommen Kanten sind Wurzeln in den
entstehenden Graphen.
w
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
195
Lösung mit ausgeglichenem binärem Suchbaum
Bsp:
10
15
7
4
3
9
8
13
11
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
19
18
196
Lösung mit ausgeglichenem binärem Suchbaum
Schlussfolgerung: Jeder Knoten in einem binären Baum ist Wurzel eines
binären Baums, der von allen Knoten induziert wird, die direkter
oder indirekter Nachfolger des Knotens längs einer gerichteten
Folge von Kanten (einem Pfad) sind.
Blatt eines binären Baums: ein Knoten ohne Auswärtskanten
innerer Knoten eines binären Baums: ein Knoten, der nicht Blatt ist.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
197
Lösung mit ausgeglichenem binärem Suchbaum
ausgeglichener binärer Baum zu einer endlichen Menge S von
Zahlen (eine mögliche Definition):
ein binärer Baum, bei dem für jeden inneren Knoten gilt, dass die beiden
Teilbäume, die von seinen Nachfolgern gebildet werden, etwa gleich
viele Knoten enthalten.
10
15
7
4
3
9
8
13
11
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
19
18
198
Lösung mit ausgeglichenem binärem Suchbaum
binärer Suchbaum zu einer endlichen Menge S von Zahlen:
ein binärer Baum, dessen innere Knoten mit den Zahlen aus S markiert
sind, so dass
- es für jede Zahl genau einen Knoten gibt
- die maximal zwei Teilbäume, die durch die Nachfolger eines Knotens p
induziert werden, die Eigenschaft haben, dass die Knotenmarkierungen
des einen Teilbaums alle kleiner als die Markierung von p sind
und die Knotenmarkierungen der andere Teilbaums alle größer sind.
ausgeglichener binärer Suchbaum:
ein binärer Suchbaum, der ein ausgeglichener binärer Baum ist.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
199
Lösung mit ausgeglichenem binärem Suchbaum
ausgeglichener binärer Suchbaum zu einer endlichen Menge S von
Zahlen:
Bsp.:
10
15
7
4
3
9
8
13
11
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
19
18
200
Lösung mit ausgeglichenem binärem Suchbaum
Datenstruktur:
Verweise auf Blätter durch
null-Zeiger repräsentiert
10
15
7
4
3
9
13
8
19
11
18
Algorithmus Suche(s)
Vergleiche s mit dem Wert s‘ der Wurzel. Wenn beide übereinstimmen,
dann wird „ja“ zurückgegeben. Wenn nicht, wird im Fall s<s‘ zum linken
Nachfolger gegangen und mit diesem Teilbaum genauso verfahren.
Im Fall s>s‘ geschieht dies mit dem rechten Teilbaum. Falls es den
entsprechenden Teilbaum nicht gibt (null-Pfeil), wird „nein“ zurückgegeben.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
201
Lösung mit ausgeglichenem binärem Suchbaum
Datenstruktur:
10
15
7
4
3
9
8
13
11
19
18
Algorithmus Suche(s)
Bsp.: Suche(11): 10->15->13->11
Suche(7): 10->7
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
202
Lösung mit ausgeglichenem binärem Suchbaum
Datenstruktur:
10
15
7
4
3
9
8
13
11
19
18
Algorithmus Suche(s)
Bsp.: Suche(11): 10->15->13->11
Suche(7): 10->7
Suche(12): 10->15->13->11->null
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
203
Lösung mit ausgeglichenem binärem Suchbaum
Zeitaufwand des Algorithmus Suche(s): T(n) = O(log n)
Beweis:
Der Zeitaufwand ist proportional zu der Anzahl durchzuführender
Vergleiche.
Die Anzahl durchzuführender Vergleiche ist durch die Höhe des
Baums beschränkt.
Die Höhe des Baums ist durch O(log (2n+3)) = O(log n) beschränkt
(siehe Behauptungen 1-3 im folgenden.)
Länge eines Pfades: die Anzahl der Knoten auf dem Pfad
Höhe eines binären Baumes: die maximale Pfadlänge von der
Wurzel zu den Blättern.
Vollständiger binärer Baum: alle Pfade haben die gleiche Länge.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
204
Lösung mit ausgeglichenem binärem Suchbaum
Behauptung 1: Für die Höhe h(m) eines ausgeglichenen binären
Suchbaums mit m Knoten gilt h(m)=O(log m), d.h. es gibt
Konstante c und d, so dass h(m) < c log m + d.
Beweis: induktiv über m.
Induktionsanfang: m=1: Die Behauptung gilt für alle d>1.
Induktionsschritt: Nachweis der Behauptung für m>1 unter der
Annahme, dass die Behauptung für m-1, m-2, ..., 1 richtig ist.
Da die Höhe eines ausgeglichenen Baums gleich 1 plus die Höhe
der beiden Unterbäume der Wurzel ist (die beide etwa m/2 Knoten
haben), gilt
Induktionsannahme
h(m) = 1 + h(m/2) < 1 + c log (m/2) + d = c log m –c + d + 1
<= c log m + d für c >= 1 und d > 0.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
205
Lösung mit ausgeglichenem binärem Suchbaum
Behauptung 2: Die Anzahl m der Knoten eines binären Suchbaums für
eine Menge mit n+1 Elementen ist m=2n+3.
Beweis: Anzahl der Knoten = Anzahl innerer Knoten + Anzahl Blätter
= Anzahl innerer Knoten + Anzahl innerer Knoten + 1
= 2(n+1)+1 = 2n+3.
Die zweite Zeile folgt aus der Tatsache, dass für binäre Bäume
Anzahl Blätter = Anzahl innere Knoten + 1
gilt (vgl. Behauptung 3).
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
206
Lösung mit ausgeglichenem binärem Suchbaum
Behauptung 3: Für binäre Bäume gilt m b=m i +1, wobei
m b die Anzahl der Blätter und m i die Anzahl der inneren Knoten
bezeichnet.
Beweis: Induktiv über die Anzahl m der Knoten.
Induktionsanfang: m = 1:
Hier ist m b = 1, m i = 0, so dass die Behauptung gilt.
_
Induktionsschritt: Nachweis der Behauptung für m > 1 unter der
Annahme, dass die Behauptung für m-1, m-1,..., 1 gilt.
Die Wurzel ist ein innerer Knoten. Für ihre beiden Unterbäume
gilt die Beziehung aufgrund der Induktionsannahme, also
m b,l = m i,l+1, m b,r = m i,r+1.
Damit gilt
m b = m b,l + m b,r = m i,l +1+ m i,r+1 = m i +1.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
207
Lösung mit ausgeglichenem binärem Suchbaum
Einfügen und Entfernen:
Es gibt Klassen ausgeglichener binärer Suchbäume und Algorithmen
dazu, die folgenden Zeitaufwand haben (ohne Beweis):
Suchen: T(n) = O(log n)
Einfügen: T(n) = O(log n)
Entfernen: T(n) = O(log n)
Zum Vergleich:
Unsortierte Arrays:
Sortierte Arrays:
Suchen: T(n) = O(n)
Einfügen: T(n) = O(1)
Entfernen: T(n) = O(n)
Suchen: T(n) = O(log n)
Einfügen: T(n) = O(n)
Entfernen: T(n) = O(n)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
208
Lösung mit Hashing
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
209
Lösung mit Hashing
Datenstruktur: Bsp.: S={110,119,150, 127, 164, 147, 173}
Index i:
0 1
2
3
4
5
6
7
8
9
10 11 12 13
h[i]:
127
173
119
150
147
164
110
Hashfunktion: ordnet einer Zahl s einen Index i(s) zu, unter dem sie
abgelegt wird.
Bsp.: i(s)=s mod k, k die Länge des Arrays (hier 14)
Definition: a mod b, wobei a, b ganze Zahlen:
Rest der ganzzahligen Division, z.B. 9 mod 4 = 1, 12 mod 3 = 0
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
210
Lösung mit Hashing
Datenstruktur: Bsp.: S={110,119,150, 127, 164, 147, 173}
Index i:
0 1
2
3
4
5
6
7
8
9
10 11 12 13
h[i]:
127
173
119
150
147
164
110
Algorithmus Suche(s)
Berechne i(s). Durchlaufe die Liste von h[i(s)]. Wenn ein Element
mit dem Wert s auftritt, gib „ja“ aus, sonst „nein“.
Zeitaufwand: im schlechtesten Fall T(n)=O(n) (alle Elemente in einer Liste)
im günstigsten Fall T(n)=O(1) (ein Element in einer Liste).
Es kann gezeigt werden, dass eher der gute Fall
erwartet werden kann.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
211
Lösung mit Hashing
Datenstruktur: Bsp.: S={110,119,150, 127, 164, 147, 173}
Index i:
0 1
2
3
4
5
6
7
8
9
10 11 12 13
h[i]:
127
173
119
150
147
164
110
Algorithmus Fügeein(s)
Berechne i(s). Füge s am Anfang der Liste von h[i(s)] ein.
Zeitaufwand: T(n)=O(1).
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
212
Lösung mit Hashing
Datenstruktur: Bsp.: S={110,119,150, 127, 164, 147, 173}
Index i:
0 1
2
3
4
5
6
7
8
9
10 11 12 13
h[i]:
127
173
119
150
147
164
110
Algorithmus Entferne(s)
Berechne i(s). Durchlaufe die Liste von h[i(s)]. Wenn ein Element
mit dem Wert s auftritt, entferne es aus der Liste.
Zeitaufwand: im schlechtesten Fall T(n)=O(n) (alle Elemente in einer Liste)
im günstigsten Fall T(n)=O(1) (ein Element in einer Liste).
Es kann gezeigt werden, dass eher der gute Fall
erwartet werden kann.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
213
Lösung mit Hashing
Bemerkungen zum Hashing:
Bei dem vorgestellten Verfahren wird das Array nicht gut genutzt.
Alternative: Die Werte werden im Array abgelegt. Beim Auftreten
einer Kollision wird der Wert nach einem vorgegebenen Verfahren
in einem noch leeren Array-Element untergebracht, z.B. das erste
freie Element nach aufsteigendem Index.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
214
Teil IV. Vom Programm zum Rechner
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
215
Ebenen heutiger Rechner
Problemorientierte Programmiersprache
Assemblersprache
Maschinensprache
Registertransfer
Schaltungen
Hardware-Ebene
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
216
Inhalt
1. Von-Neumann-Rechner
2. Schaltungen
3. Compiler und formale Sprachen
4. Semantik und Verifikation
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
217
1. Von-Neumann-Rechner
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
218
Grundstruktur heutiger Rechner
- von-Neumann-Rechnerarchitektur
- Rechner = Prozessor + Speicher + Ein-/Ausgabe
- Programm und Daten im Speicher
- Abarbeiten des Programms durch den Prozessor
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
219
von-Neumann-Architektur
Möglichkeiten der Integration der Funktionseinheiten:
- Einzelverbindungswege
Speicherperipherie
Prozessor
Interaktionsperipherie
Ein-/Ausgabe
Hauptspeicher
Direct Memory Access (DMA)
Datenkommunikationsperipherie
- Bus (Sammelschiene)
Prozessor
Hauptspeicher
Interaktionsperipherie
Bussteuerung
Speicherperipherie
Datenkommunikationsperipherie
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
220
von-Neumann-Architektur
(Haupt-)Speicher:
- setzt sich aus Speicherzellen zusammen, die unter Adressen ansprechbar
sind:
0
1
2
3
4
...
...
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
221
von-Neumann-Architektur
Prozessor:
- führt Maschinenbefehle aus. Die Befehle sind im Befehlssatz festgelegt.
Einteilung eines typischen Befehlssatzes:
Befehlssatz
Zuweisen
(Transport)
Rechnen
(arithm./log. Verknüpfungen)
Steuern
(Ablauforganisation)
Register- RegisterRegisterarithmetische logische Sprungbefehle Gerätesteuerung
Register Hauptspeicher Ein-/Ausgabe Befehle
Befehle
Aufbau eines typischen Maschinenbefehls: Operationscode Operanden
Bsp.: addiere r4, r3, r2; hole r5, a1; multipliziere r6, r5, r4;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
222
von-Neumann-Architektur
Prozessor:
- Funktionsgruppen eines Prozessors:
Leitwerk: steuert die Abarbeitung des Programms
Rechenwerk: führt die arithmetischen und logischen Befehle sowie
eventuelle Dienstleistungen (z.B. Adressrechnungen) für das Leitwerk aus
Register: Speicherzellen im Prozessor für Operanden und
Zwischenergebnisse - sind schneller als als der Hauptspeicher zugreifbar
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
223
von-Neumann-Architektur
Prozessor:
Hauptspeicher
...
SAR
SDR
Prozessor
Leitwerk
BZ
BR
+1
opcode
Operand
Reg.
Rechenwerk
SAR: Speicheradressregister
BZ: Befehlszeiger
SDR: Speicherdatenregister
BR: Befehlsregister
addiere r4, r3, r2; hole r5, a1;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
224
von-Neumann-Architektur
Prozessor:
- Befehlsausführungszyklus:
Wiederhole
hole den nächsten Befehl vom Hauptspeicher (Adresse im BZ) in das
Befehlsregister (BR);
erhöhe den Befehlszeiger (BZ);
führe den Befehl aus, der im Befehlsregister (BR) steht;
bis ein Halte-Befehl auftritt.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
225
2. Schaltungen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
226
Zweiwertige Informationsdarstellung
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
227
Zweiwertige Informationsdarstellung
Bit:
- kleinste Informationseinheit
- zwei mögliche Werte: 0 oder 1
- Realisierung: Transistor: auf/zu
Byte:
- Informationseinheit aus 8 Bits:
Bsp: 00100001
Anwendung: Codierung von Zeichen (Textzeichen und Steuerzeichen)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
228
Zweiwertige Informationsdarstellung
positive ganze Zahlen:
- Darstellung als Dualzahl:
z = zn 2n + zn-1 2n.1+zn-2 2n-2 + ... z020
1 22 + 1 21+1 20
Bsp.: dezimal 7 ist dual 111
dezimal 14 ist dual 1110
1 23 + 1 22+1 21+ 0 20
- Dualzahlen sind ein Spezialfall der p-adischen Darstellung (p=2):
z = zn pn + zn-1 pn.1+zn.2 pn-2+ ... z0 p0
Bsp.: Hexadezimalsystem: p=16, „Ziffern:“ 0-9,A-F
dezimal 15 ist hexadezimal F
dezimal 16 ist hexadezimal 10
dezimal 27 ist hexadezimal 1B
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
229
Zweiwertige Informationsdarstellung
positive ganze Zahlen:
Berechnung der p-adischen Darstellung einer Dezimalzahl d:
zi = (d div pi) mod p
wobei „div“ die ganzzahlige Division ohne Rest
und „mod“ (modulo) die Berechnung des Rests bezeichnet.
Bsp.:
Dezimal 14 in Dualdarstellung:
z0 = (14 div 1) mod 2 = 14 mod 2 = 0
z1 = (14 div 2) mod 2 = 7 mod 2 = 1
z2 = (14 div 4) mod 2 = 3 mod 2 = 1
z3 = (14 div 8) mod 2 = 1 mod 2 = 1
(z4 = (14 div 16) mod 2 = 0 mod 2 = 0)
14 = 1 23 + 1 22+1 21+ 0 20
14 div 1 = 1 23 + 1 22+1 21+ 0 20
14 div 2 = 1 22 + 1 21+1 20
14 div 4 = 1 21 + 1 20
14 div 8 = 1 20
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
230
Zweiwertige Informationsverarbeitung:
Boolesche Funktionen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
231
Zweiwertige Informationsverarbeitung
Berechnung Boolescher Funktionen
n-stellige Boolesche Funktion:
Definitionsbereich: Menge der 0/1-Folgen der Länge n
Wertebereich: {0,1}
Definition boolescher Funktionen durch Wertetabellen:
a b c f (a,b,c)
Bsp.:
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
0
0
1
0
1
1
1
f ist genau dann gleich 1,
wenn die Mehrzahl der
Bitstellen des Arguments
gleich 1 ist.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
232
Zweiwertige Informationsverarbeitung
Berechnung Boolescher Funktionen:
Boolesche Formeln:
Darstellung einer Booleschen Funktion durch Verknüpfung von elementaren
Booleschen Funktionen.
Beispiele für elementare Boolesche Funktionen: and, or, nand, nor, not
a
b
and
a
b
or
a
b
nand
a
b
nor
0
0
1
1
0
1
0
1
0
0
0
1
0
0
1
1
0
1
0
1
0
1
1
1
0
0
1
1
0
1
0
1
1
1
1
0
0
0
1
1
0
1
0
1
1
0
0
0
a not
0
1
1
0
nand = nicht and, nor = nicht or, 1 = „true“, 0=„false“
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
233
Zweiwertige Informationsverarbeitung
Berechnung Boolescher Funktionen:
Verfahren zur Herleitung einer Booleschen Formel, der sogenannten
disjunktiven Normalform, aus and-, or- und not-Verküpfungen:
Bsp.:
a
b
c
f (a,b,c)
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
0
0
1
0
1
1
1
* entspricht and (math. ∧)
+ entspricht or (math. ∨)
entspricht not (math. ¬)
a*b*c
a*b*c
a*b*c
a*b*c
Ergebnis: f = a*b*c + a*b*c+a *b* c+a*b*c
math.: (¬ a ∧ b ∧ c) ∨ (a ∧ ¬ b ∧ c) ∨ (a ∧ b ∧ ¬ c) ∨ (a ∧ b ∧ c)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
234
Zweiwertige Informationsverarbeitung
Berechnung Boolescher Funktionen:
Verfahren zur Herleitung einer Booleschen Formel, der sogenannten
disjunktiven Normalform, aus and-, or- und not-Verküpfungen:
1. Für alle Zeilen der Tabelle, die den Wert 1 liefern, forme eine
Boolesche Formel, die alle Eingabeparameter direkt oder negiert
enthält.
Ein Parameter genau dann negiert wird, wenn sein Wert auf der Zeile
=0 ist.
Die Parameter werden mit and verknüpft.
2. Verknüpfe die Formeln aus 1. mit or.
Optimierung:
Die resultierenden Formeln können häufig noch verkürzt werden
(weniger Operationen). Hierfür gibt es Optimierungsverfahren.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
235
Zweiwertige Informationsverarbeitung:
Schaltungen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
236
Zweiwertige Informationsverarbeitung
Boolescher Schaltkreise:
Darstellung einer Booleschen Funktion durch Verknüpfung von Gattern.
Gattern entsprechen den elementaren Booleschen Funktionen
Beispiele für elementare Boolesche Funktionen: and, or, nand, nor, not
and-Gatter
or-Gatter
nand-Gatter
nor-Gatter
not-Gatter
and
or
nand
nor
not
and
or
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
237
Zweiwertige Informationsverarbeitung
Boolesche Schaltkreise:
Bsp.:
f = a*b*c + a*b*c+a *b* c+a*b*c
a
and
not
and
b
or
not
f
and
c
not
and
a b
c ¬a ¬b ¬c
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
238
Schaltungen
1. Zweiwertige Informationsdarstellung: Bit, Byte, positive ganze Zahl
2. Zweiwertige Informationsverarbeitung: Boolesche Funktionen
a
b
S
0
0
1
1
0
1
0
1
0
1
1
0
a*b
a*b
S= a*b + a*b
3. Zweiwertige Informationsverarbeitung: Schaltungen
not
and
a
b
or
not
S
and
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
239
Zweiwertige Informationsverarbeitung
Beispiel: 1-Bit-Addierer
011
+ 101
11
1000
Addierer:
Halbaddierer:
a
b
S
Ü
0
0
1
1
0
1
0
1
0
1
1
0
0
0
0
1
a
xor
b
S
Ü
Üout
0
0
0
0
1
1
1
1
0
1
1
0
1
0
0
1
0
0
0
1
0
1
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
HA S‘
b
Üin
xor: entweder oder
S
Ü‘
a
and
a b Üin
a
b
Ü
S
Ü‘‘
OR
HA S‘‘
Üout
S
HA: Halbaddierer
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
240
Zweiwertige Informationsverarbeitung
Speicher:
Bsp.: RS-Flipflop: R=„reset“, S=„set“, speichert 1-Bit-Information
Lösung: Realisierung durch rückgekoppelte Schaltung:
S
Q
R
nor
S
nor
R
Q
Gespeicherter Wert: Q
Setzen des Speichers auf 1: S=1, R=0
Setzen des Speichers auf 0: S=0, R=1
Ausgabe des gespeicherten Werts: S=0, R=0, d.h. Q=0 oder Q=1
nicht verwendet: S=1, R=1
Problem: Zwei Werte (Q=0/1) für die gleiche Eingabe (S=0, R=0)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
241
Zweiwertige Informationsverarbeitung
Speicher:
Qalt
RS-Flipflop: Analyse des Verhaltens
S
Zustand
0
1
2
3
4
5
6
7
R
S
Qalt
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
Qneu
0
1
1
1
0
0
0
0
Qneu
nor
R
nor
Q
stabil, gibt den gespeicherten Wert aus
stabil, gibt den gespeicherten Wert aus
instabil, speichert den Wert 1 („set“), ->3
stabil, wird auf 1 gesetzt („set“)
stabil, wird auf 0 gesetzt („reset“)
instabil, wird auf 0 gesetzt („reset“), ->4
stabil, für Speicherfunktion nicht verwendet
instabil, ->6
Stabiler Zustand: Qalt = Qneu
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
242
Zweiwertige Informationsverarbeitung
Beispiel für einen
schwingenden Schaltkreis:
bneu
balt
a
Zustand
0
1
2
3
a
balt
bneu
0
0
1
1
0
1
0
1
1
1
1
0
b
nand
Ergebnis:
instabil, ->1
stabil, ->1, b=1
instabil, ->3
instabil, ->2
Eingabe a=0:
Ausgabe b=1
Eingabe a=1:
Ausgabe b schwingt
zwischen 0 und 1
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
243
3. Compiler und formale Sprachen
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
244
Compiler und Interpreter
Compiler:
übersetzt ein Programm, das üblicherweise in einer höheren
Programmiersprache geschrieben ist, in ein Programm in einer anderen,
üblicherweise einfacheren Sprache, z.B. Assembler oder Maschinensprache
Interpreter:
arbeitet ein gegebenes Programm schrittweise ab und führt es dabei
gleich aus
Bsp. Java
- Übersetzung des Java-Programms (.java-Datei)
in ein Java-Byte-Code-Programm (.class-Datei),
das rechnerunabhängig ist, durch den Java-Compiler
- Interpretation des Java-Byte-Code-Programms auf dem Zielrechner
durch die Java Virtual Machine (JVM)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
245
Compiler und Interpreter
Vorgehensweise:
Analyse der syntaktischen Struktur des Programms und Zusammensetzen
des übersetzten Programms aus Bausteinen, die Sprachelementen zugeordnet
sind (compilieren = zusammensetzen)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
246
Inhalt
Grammatiken
Sprachtypen nach Chomsky
Übersetzung
endlicher Automat
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
247
Grammatiken
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
248
Formale Sprachen
Sprache:
- Menge von Worten über einem Alphabet
Alphabet:
- endliche Menge von Zeichen
Wort:
- endliche Folge von Zeichen
Bsp.: Alphabet A = {b}
Sprache L = {b, bb, bbb, bbbb, ...}
Syntax: struktureller Aufbau der Worte, z.B. beschrieben durch eine Grammatik
Semantik: Bedeutung der Worte der Sprache
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
249
Satz -> Subjekt Prädikat Objekt
Formale Sprachen
Subjekt -> Vorwort Hauptwort
Grammatik:
...
- Regelwerk, das den Aufbau der Worte einer Sprache beschreibt.
Bsp.: Grammatikregeln für L = {b, bb, bbb, bbbb, ...} :
S -> b, S->Sb
Ableitung von Worten durch Ersetzen von Zeichen:
S=>b
Anwendung der ersten Regel
S=>Sb=>bb
Anwendung der zweiten Regel, dann der ersten Regel
S=>Sb=>Sbb=>bbb zweimal die zweite Regel, dann die erste Regel
usw.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
250
Formale Sprachen
Grammatik:
3*(b+7)+c
Bsp.: Grammatik für geklammerte arithmetische Ausdrücke
Alphabet: { a,+,*,(,) }
a*(a+a)+a
Hilfszeichenmenge: { E,T,F }
Startsymbol: E
Produktionsregeln: { E->T, E->E+T, T->F, T->T*F, F->a, F->(E) }
Bsp.: a*(a+a)+a gehört zur Sprache dieser Grammatik
E => E+T => T+T => T*F+T => F*F+T => a*F+T => a*(E)+T
=>a*(E+ T)+T => a*(T+T)+T => a*(F+T)+T => a*(a+T)+T
=> a*(a+F)+T => a*(a+a)+T => a*(a+a)+F => a*(a+a)+a
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
251
Formale Sprachen
Grammatik:
Definition: ein 4-Tupel G=(N,T,P,S), wobei
N eine endliche Menge von Variablenzeichen („Nichtendzeichen“)
T eine endliche Menge von Endzeichen („Terminalzeichen“),
wobei N und T disjunkt sind
P eine endliche Menge von Produktionsregeln der Form y -> y‘, wobei
y und y‘ endliche Folgen aus Zeichen („Worte“) aus N oder T sind,
y mindestens ein Zeichen enthalten muss und
y‘ auch leer sein kann („leeres Wort“ lambda λ).
S ein Zeichen aus N, Startvariable genannt.
Bsp.; Grammatik auf der vorigen Seite: G=(N,T,P,E) mit
N={ E,T,F }, T={ a,+,*,(,) } , P={ E->T, E->E+T, T->F, T->T*F, F->a, F->(E) }
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
252
Formale Sprachen
Grammatik:
unmittelbare Ableitung u=>v: „u geht unmittelbar in v über“, wenn gilt:
u und v sind Worte aus Zeichen aus N oder T,
u hat die Form xyz, v hat die Form xy‘z, wobei x,y,y‘,z Worte sind,
y->y‘ ist eine Produktionsregel in P.
Ableitung u => *v: „u geht in v über“ oder „v wird aus u abgeleitet“, wenn gilt:
Es gibt eine Folge w1, ..., wn von Worten mit u = w1 und v = wn,
sodass wi => wi+1, i = 1,..., n-1.
von G erzeugte (definierte) Sprache L(G):
die Menge aller Worte w aus Zeichen aus T, die aus dem Startsymbol
ableitbar sind:
L(G) = { w | S => *w, w enthält nur Endzeichen oder ist das leere Wort}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
253
Sprachentypen nach Chomsky
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
254
Formale Sprachen
Sprachtypen:
Chomsky-Typ-i-Sprache, i = 0,... 3:
Es gibt eine Chomsky-Typ-i-Grammatik, die die Sprache erzeugt.
Typ 1: kontextsensitive Sprache
Typ 2: kontextfreie Sprache
Typ 3: reguläre Sprache
Bsp.: L = {b, bb, bbb, bbbb, ...} ist regulär.
Die Sprache der arithmetischen Ausdrücke ist kontextfrei.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
255
Formale Sprachen
Grammatik G=(N,T,P,E) :
Bsp.: Grammatik für geklammerte arithmetische Ausdrücke
Alphabet: T={ a,+,*,(,) }
a*(a+a)+a
Hilfszeichenmenge: N={ E,T,F }
Startsymbol: E
Produktionsregeln: P={ E->T, E->E+T, T->F, T->T*F, F->a, F->(E) }
Bsp.: a*(a+a)+a gehört zur Sprache dieser Grammatik
E => E+T => T+T => T*F+T => F*F+T => a*F+T => a*(E)+T
=>a*(E+ T)+T => a*(T+T)+T => a*(F+T)+T => a*(a+T)+T
=> a*(a+F)+T => a*(a+a)+T => a*(a+a)+F => a*(a+a)+a
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
256
Formale Sprachen
Grammatik:
spezielle Grammatiken nach Chomsky:
Chomsky-Typ-0-Grammatik: alle Grammatiken
Chomsky-Typ-1-Grammatik (kontextsensitive Grammatiken):
Für alle Regeln w->w‘ ist w nicht länger als w‘.
Chomsky-Typ-2-Grammatik (kontextfreie Grammatiken):
Typ-1-Grammatiken, für die alle Regeln die Form X->w haben, wobei
X ein Variablenzeichen ist.
Chomsky-Typ-3-Grammatik:
Typ 2-Grammatiken, für die alle Regeln die Form X->x oder X->Yx haben,
wobei X, Y Variablenzeichen und x ein Endzeichen sind.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
257
Formale Sprachen
Bedeutung der Sprachtypen:
Die Syntax der meisten existierenden Programmiersprachen lässt sich im
Wesentlichen durch kontextfreie Grammatiken beschreiben.
Teilsprachen, wie die Menge der Namen oder die Menge der ganzen Zahlen
sind regulär.
Bsp.: Java
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
258
Formale Sprachen
Bedeutung der Sprachtypen:
Bsp.: Java-Gleitpunktzahlen in Java-Grammatik-Notation
Linke Seite der Produktionsregeln
FloatingPointLiteral:
Rechte Seiten der
Digits . Digits_opt ExponentPart_opt FloatTypeSuffix_opt
. Digits ExponentPart_opt FloatTypeSuffix_opt
Digits ExponentPart FloatTypeSuffix_opt
Digits ExponentPart_opt FloatTypeSuffix
Produktionsregeln:
jede Zeile definiert eine
alternative Regel;
„opt“ bedeutet, dass das
Symbol auch fehlen darf
ExponentPart:
ExponentIndicator SignedInteger
ExponentIndicator: one of
e E
Endzeichen
SignedInteger:
Sign_opt Digits
Sign: one of
+ FloatTypeSuffix: one of
f F d D
Bsp.: 1.E-14
.12e13F
5d
andere, ähnliche, gebräuliche Grammatikdarstellung,
z.B. bei Pascal: Backus-Naur-Form (BNF-Form)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
259
Übersetzung
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
260
Formale Sprachen
Übersetzung (nur zur Illustration):
Zuweisung von Übersetzungsaktionen an Produktionsregeln
Bsp.: geklammerte arithmetische Ausdrücke mit n Variablen
Alphabet: T={ a1, ..., an,+,*,(,) }
Startsymbol: E
Hilfszeichenmenge: N={ E,T,F }
Produktionsregeln: P={ E->T, E->E+T, T->F, T->T*F,
F->ai, i = 1,...n, F->(E) }
Befehlsatz der Zielsprache:
hole a,b (a=b), addiere a,b,c (a=b+c), multipliziere a,b,c (a=b*c)
Zuweisung von Aktionen:
E->T
T->F
F->ai
ek := ti ;
tk := fi ;
fk := ai ;
E->E+T
T->T*F
F->(E)
ek := ei + tj ;
tk := ti * fj ;
fk := ei ;
wobei ei , fi , ti Programmvariable sind.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
261
Formale Sprachen
Übersetzung:
- Bestimme eine Ableitung für das gegebene Wort (Programm).
Wenn dies nicht möglich ist, gib eine Fehlermeldung aus (Syntaxfehler).
Wenn dies möglich ist, fahre wie folgt fort:
- Arbeite die Ableitung von hinten nach vorne ab.
- Gib die zugeordneten Anweisungen der Produktionsregeln aus.
- Tritt links ein Index auf, der rechts nicht vorhanden ist, gib
diesem den kleinsten bisher nicht verwendeten Indexwert.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
262
Formale Sprachen
Übersetzung:
E->T
T->F
F->ai
ek = ti ;
tk := fi ;
fk := ai ;
E-> E+T
T-> T*F
F-> (E)
ek := ei + tj ;
tk := ti * fj ;
fk := ei ;
Bsp.: a1*(a2 + a3) + a4
Ableitung
Ersetzung
E
Ableitung
Ersetzung
=>a1*(T+T)+T
=> a1 *(F + T)+T
=> a1 *(a2 + T)+T
=> a1 *(a2 + F)+T
=> a1 *(a2 + a3)+T
=> a1 *(a2 + a3)+ F
=> a1 *(a2 + a3)+ a4
=>E+T
=>T+T
=>T*F+T
=>F*F+T
=>a1*F+T
=> a1 *(E)+T
=> a1 *(E+T)+T
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
263
Formale Sprachen
Übersetzung:
E->T
T->F
F->ai
ek = ti ;
tk := fi ;
fk := ai ;
E-> E+T
T-> T*F
F-> (E)
ek := ei + tj ;
tk := ti * fj ;
fk := ei ;
Bsp.: a1*(a2 + a3) + a4
Ableitung
E
=>E+T
=>T+T
=>T*F+T
=>F*F+T
=>a1*F+T
=> a1 *(E)+T
=> a1 *(E+T)+T
Ersetzung
Ableitung
=>a1*(T+T)+T
=> a1 *(F + T)+T
=> a1 *(a2 + T)+T
=> a1 *(a2 + F)+T
=> a1 *(a2 + a3)+T
=> a1 *(a2 + a3)+ F
=> a1 *(a2 + a3)+ a4
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
Ersetzung
f5 := a4 ;
264
Formale Sprachen
Übersetzung:
E->T
T->F
F->ai
ek = ti ;
tk := fi ;
fk := ai ;
E-> E+T
T-> T*F
F-> (E)
ek := ei + tj ;
tk := ti * fj ;
fk := ei ;
Bsp.: a1*(a2 + a3) + a4
Ableitung
Ersetzung
Ableitung
E
=>a1*(T+T)+T
=> a1 *(F + T)+T
=> a1 *(a2 + T)+T
=> a1 *(a2 + F)+T
=> a1 *(a2 + a3)+T
=> a1 *(a2 + a3)+ F
=> a1 *(a2 + a3)+ a4
=>E+T
=>T+T
=>T*F+T
=>F*F+T
=>a1*F+T
=> a1 *(E)+T
=> a1 *(E+T)+T
Ersetzung
t6 := f5 ;
f5 := a4 ;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
265
Formale Sprachen
Übersetzung:
E->T
T->F
F->ai
ek = ti ;
tk := fi ;
fk := ai ;
E-> E+T
T-> T*F
F-> (E)
ek := ei + tj ;
tk := ti * fj ;
fk := ei ;
Bsp.: a1*(a2 + a3) + a4
Ableitung
E
Ersetzung
e18 := e17 + t6 ;
=>E+T
e17 := t16 ;
=>T+T
t16 := t15 * f13;
=>T*F+T
t15:= f14 ;
=>F*F+T
f14:= a1 ;
=>a1*F+T
f13:= e12 ;
e12:= e11+ t8 ;
=> a1 *(E)+T
=> a1 *(E+T)+T e11:= t10 ;
Ableitung
=>a1*(T+T)+T
=> a1 *(F + T)+T
=> a1 *(a2 + T)+T
=> a1 *(a2 + F)+T
=> a1 *(a2 + a3)+T
=> a1 *(a2 + a3)+ F
=> a1 *(a2 + a3)+ a4
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
Ersetzung
t10 := f9;
f9 := a2;
t8:= f7 ;
f7 := a3
t6 := f5 ;
f5 := a4 ;
266
Formale Sprachen
Übersetzung:
E
Kopie von voriger Seite
e18 := e17 + t6 ;
=>E+T
e17 := t16 ;
=>T+T
t16 := t15 * f13;
=>T*F+T
t15:= f14 ;
=>F*F+T
f14:= a1 ;
f13:= e12 ;
=>a1*F+T
e12:= e11+ t8 ;
=> a1 *(E)+T
=> a1 *(E+T)+T e11:= t10 ;
=>a1*(T+T)+T
=> a1 *(F + T)+T
=> a1 *(a2 + T)+T
=> a1 *(a2 + F)+T
=> a1 *(a2 + a3)+T
=> a1 *(a2 + a3)+ F
=> a1 *(a2 + a3)+ a4
t10 := f9;
f9 := a2;
t8:= f7 ;
f7 := a3
t6 := f5 ;
f5 := a4 ;
Ergebnis:
f5 := a4;
t6 := f5;
f7 := a3;
t8 := f7;
f9 := a2;
t10 := f9;
e11 := t10;
e12:=e11 + t8;
f13:=e12;
f14:=a1;
t15:=f14;
t16:=t15* f13;
e17:=t16;
e18:=e17+ t6;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
267
Formale Sprachen
Übersetzung:
Ergebnis (Kopie von voriger Seite):
f5 := a4;
t6 := f5;
f7 := a3;
t8 := f7;
f9 := a2;
t10 := f9;
e11 := t10;
e12:=e11 + t8;
f13:=e12;
f14:=a1;
t15:=f14;
t16:=t15* f13;
e17:=t16;
e18:=e17+ t6;
Optimierung: Entfernen von Zuweisungsketten
t6 := a4;
t8 := a3;
e11 := a2;
f13:=e11+t8;
t15:=a1;
e17:=t15*f13;
e18:=e17+t6;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
268
Formale Sprachen
Übersetzung:
Kopie von voriger Seite
t6 := a4;
t8 := a3;
e11 := a2;
f13:=e11+t8;
t15:=a1;
e17:=t15*f13;
e18:=e17+t6;
Registerzuweisung:
r2
r3
r1
t6
t8
e11
r4
r5
r6
r7
f13
t15
e17
e18
a1, a2, a3, a4
stehen für
Hauptspeicheradressen
Ergebnis:
r4:=r3 + r2;
r5 := a1;
r6:=r5*r4;
r7:=r6 + r1;
r1 := a4;
r2 := a3;
r3 := a2;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
269
Formale Sprachen
Übersetzung:
Kopie von voriger Seite
r1:=a4;
r2:=a3;
r3:=a2;
r4:=r3+r2;
r5:=a1;
r6:=r5*r4;
r7:=r6+r1;
Übersetzung in Assembler oder Maschinensprache durch
eins-zu-eins-Ersetzung:
hole r1, a4;
hole r2, a3;
hole r3, a2;
addiere r4, r3, r2;
hole r5, a1;
multipliziere r6, r5, r4;
addiere r7, r6, r1;
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
270
Formale Sprachen
Teilaufgabe der Sprachübersetzung durch Compiler:
Bestimmung einer Ableitung für ein gegebenes Programm (= „Wort“ der
Sprache.
Lösung: Automaten
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
271
Formale Sprachen
korrespondierende Automatentypen für Sprachen:
für Typ-0-Sprachen: (nichtdeterministische) Turingmaschinen
für Typ-1-Sprachen: bandbeschränkte Turingmaschinen
für Typ 2-Sprachen: (nichtdeterministische) Kellerautomaten
für Typ 3-Sprachen: endliche Automaten
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
272
Endlicher Automat
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
273
Formale Sprachen
endlicher Automat:
Eingabewort
Zustandsübergangsdiagramm:
a
z0
Zustand
a
b
z3
Ausgabe:
akzeptiert/nicht akzeptiert
Abarbeitung einer Eingabe:
abab: z0 => z1 => z2 => z1 => z2
a
b
a
b
a
b
z1
b
b
a
z2
z0, ..., z3: Zustände
z0 : Startzustand
z2: Endzustand
Alphabet: {a, b}
akzeptierte Sprache: L = {ab, abab, ababab, ...}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
274
Formale Sprachen
endlicher Automat:
spezifiziert durch ein 5-Tupel M = (Z, T, G, z0, E), wobei
Z eine endliche Menge von Zuständen
T ein endliches Eingabealphabet
G eine Überführungsfunktion, die einem Paar aus Zustand z und
Eingabezeichen a einen neuen Zustand z‘ = G(z, a) zuordnet
z0 der Anfangszustand
E eine Menge von Endzuständen, die Teilmenge von Z ist.
Bsp.:
a
z0
a
b
z3
a
b
b
z1
b
a
G (z0, a) = z1,
G(z0, b) = z3,
G(z1, a) = z3,
G(z1, b) = z2,
G(z2, a) = z1,
G(z2, b) = z3,
G(z3, a) = z3,
G(z3, b) = z3.
z2
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
275
Formale Sprachen
endlicher Automat:
Ein Automat M akzeptiert ein Wort a1 a2 ... an, genau dann
wenn der Automat beim Abarbeiten des Worts beginnend mit dem
Startzustand z0 eine Folge z0, z1, ..., zn von Zuständen durchläuft,
wobei
a
z0
z1
z{i+1} = G(zi,a{i+1} ), i = 0, ..., n-1,
a
b
b
a
zn ein Endzustand ist.
z3
z2
b
a
Bsp.: abab: z0 => z1 => z2 => z1 => z2
b
G(z0,a) = z1, G(z1, b) = z2, G(z2, a) = z1, G(z1, b) = z2 mit G definiert durch
G(z0, a)= z1,
G(z0, b)= z3,
G(z1, a)= z3,
G(z1, b)= z2,
G(z2, a) = z1,
G(z2, b) = z3,
G(z3, a) = z3,
G(z3, b) = z3.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
276
Formale Sprachen
endlicher Automat:
- Von einem Automaten M akzeptierte Sprache L(M):
die Menge aller Worte, die M akzeptiert.
- Eine von einem endlichen Automaten akzeptierte Sprache ist vom
Chomsky-Typ 3, d.h. regulär.
Eine entsprechende reguläre Grammatik kann aus der Überführungsfunktion
konstruiert werden.
Bsp. (nicht durch Konstruktion erhalten): L = {ab, abab, ababab, ...}
G = {N,T,P,S} mit T={a,b}, N={X,B,S}, P={S->aB, S->aX, X->bS, B->b}
S=>aX=>abS=>abaB=>abab
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
277
Formale Sprachen
endlicher Automat:
- Zu jeder regulären Sprache L gibt es einen endlichen Automaten,
der L akzeptiert.
Die Überführungsfunktion eines entsprechenden endlichen Automaten
kann aus der Grammatik konstruiert werden.
Bsp. (nicht durch Konstruktion erhalten): L = {b, bb, bbb, bbbb, ...}
z0
b
z1
b
T = {b}, Z={z0,z1}, Startzustand z0, E = {z1},
G(z0, b) = z1, G(z1, b) = z1
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
278
Semantik und Verifikation
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
279
Semantik
Sprache: Syntax und Semantik
Struktur des
Gesprochenen/Geschriebenen
Inhalt/Bedeutung des
Gesprochenen/Geschriebenen
Formaler Ansatz zur Syntaxdefinition: Grammatik
Formale Ansätze zur Semantikdefinition:
- operationelle Semantiken
- denotationelle Semantiken
- axiomatische Semantiken
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
280
Semantik
Repräsentation:
Information, Begriffe:
reale Welt:
Apfel
„Apfel“
apple
....
Syntax
Semantik
Abstraktion
Semantikschema: (R,I,[ . ]) mit
- R: Menge der Repräsentationen
- I: Menge der Informationen
- [ . ] Teilmenge von R x I: Semantikrelation oder Interpretation:
ist (r,i) in [ . ], dann ist i eine Information zur Repräsentation r.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
281
Semantik und Verifikation
Vorgehensweise bei der Lösung von Problemen
1. Problem formulieren
2. Problemanalyse, Problemabstraktion, Problemspezifikation
3. Algorithmenentwurf
4. Nachweis der Korrektheit, Verifikation
Formale Spezifikation
im Informationsraum
5. Aufwandsanalyse
6. Programmierung
Beweis der Korrektheit
eines Programms über
seine formale Semantik,
indem gezeigt wird, dass
die formale Spezifikation
erfüllt ist.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
282
Operationelle Semantik
Prinzip:
Repräsentation des aktuellen Zustands des Informationsraums
durch die aktuelle Belegung der Programmvariablen
Definition der Semantik eines Programms durch sukzessive
Transformationen gemäß des Programmaufbaus
Dazu: Zuordnung von Zustandstransformationen zu Konstrukten
der Programmsyntax
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
283
Operationelle Semantik
Beispiel:
Programme mit zwei Variablen a, b, die Inkrementierungen,
Additionen und Wertzuweisungen durchführen können:
Bsp.: a=1; b=a+1; a=b+a;
Syntax:
Var -> a | b
Inkr -> Var + 1
Sum -> Var + Var
Wert -> Inkr | Sum
Wertzuw -> Var = Wert
Programm = Wertzuw; | Wertzuw; Programm
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
284
Operationelle Semantik
Syntax:
Semantik:
Zustand σ: {a,b} −> ΙΝ
Var -> a | b
[Var](σ) = σ(Var) für Var = a oder Var = b
Inkr -> Var + 1
[Inkr](σ) = [Var](σ) + 1
Sum -> Var + Var
[Sum](σ) = [Var](σ) + [Var](σ)
Wert -> Inkr | Sum
[Wert](σ) = Inkr(σ) bzw.
[Wert](σ) = Sum(σ)
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
285
Operationelle Semantik
Semantik:
Syntax:
Wertzuw -> Var = Wert
[Wertzuw](σ) = σ[[Wert](σ)/Var]
d.h. der Wert von Var in σ
wird auf [Wert](σ) gesetzt
Programm = Wertzuw; |
Wertzuw; Programm
[Programm](σ) = [Wertzuw](σ)
[Programm](σ) = [Programm‘](σ´),
wobei σ´ = [Wertzuw](σ)
und Programm‘ das Restprogramm,
das der Syntaxvariable
„Programm“ auf der rechten
Seite der Produktionsregel
entspricht
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
286
Operationelle Semantik
Bsp.: a=1; b=a+1; a=b+a;
Beh.: Wenn die Variablen a und b zu Beginn beide auf 0 gesetzt sind,
dann hat a nach Ausführung des Programms den Wert 3 und b den
Wert 2.
Bew.:
Programm => a=1; Programm‘
[Programm](0,0) = [Programm‘](1,0), da [a=1](0,0)=(1,0);
Programm‘ => b=a+1; Programm‘‘
[Programm‘](1,0) = [Programm‘‘](1,2), da
[b=a+1](1,0) = (1,0)[[a+1](1,0)/b]) = (1,2) wegen
[a+1](1,0) = [a](1,0)+1 = 1+1 = 2
Programm‘‘ => a=b+a;
[Programm‘‘](1,2) = [a=b+a](1,2) = (1,2)[[b+a](1,2)/a]) = (3,2) wegen
[b+a](1,2) = [b](1,2) + [a](1,2) = 2+1 = 3
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
287
Operationelle Semantik
Gebräuchliche Darstellung der Regeln der operationellen Semantik:
Prämisse
[Regelname]
Nebenbedingung
Konklusion
Bsp.:
[Wertzuweisung]
<Var = Wert,σ > => σ [[Wert](σ)/Var]
<Prog1, σ> =>σ´
[Komposition]
<Prog1;Prog2,σ> => <Prog2,σ´>
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
288
Axiomatische Semantik
Nachteil der operationellen Semantik:
- detaillierter, als häufig benötigt
- aufgrund der Details sind die Beweise sehr lang
Ausweg:
- axiomatische Semantik: explizite Zustandsangaben werden durch
Zustandsbeschreibungen in einer Sprache der Logik ersetzt:
Bsp: Hoare-Kalkül:
{P} Prog {Q}
P: Vorbedingung, Q: Nachbedingung
Wenn vor Ausführung von Prog die Aussage P gilt, gilt nach Ausführung
von Prog die Aussage Q.
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
289
Axiomatische Semantik
Gebräuchliche Darstellung der Regeln der axiomatischen Semantik
nach Hoare:
Prämisse
[Regelname]
Konklusion
Bsp.:
[Wertzuweisung]
{Q[Wert/Var]} Var = Wert {Q}
{P} Prog1 {Q}, {Q} Prog2 {R}
[Komposition]
{P} Prog1;Prog2 {R}
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
290
Ein paar allgemeine Hinweise
zum Studium
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
291
Informationen zu den Vorlesungen
- Vorlesungsverzeichnis WS 2004/2005 der Universität Dortmund
im Buchhandel
- LSF
http://www.lsf.uni-dortmund.de/
- INPUD: Informationsseiten für das Grundstudium Informatik
http://www.inpud.de
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
292
Informationen zur Planung des Studiums
- Diplomprüfungsordnung Informatik
- Diplomprüfungsordnung Angewandte Informatik
- Studienordnung für das Lehramt Informatik Sek II
- Studienführer des Fachbereichs Informatik
http://zuse.informatik.uni-dortmund.de /Studium/Studiengaenge.html
oder über die Internet-Seite des Fachbreichs Informatik (deutsche Version):
http.//www.cs.uni-dortmund.de
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
293
Informationen zur Planung des Studiums und darüber hinaus
- Studienberater des Fachbereichs Informatik:
http://inpud.cs.uni-dortmund.de/stinfo/stteam_de.html
E-Mail: [email protected]
- Fachschaft Informatik:
http://fsinfo.cs.uni-dortmund.de/
- Studienberatung anderer Fachbereiche:
bei den Dekanaten erfragen
- Beratungseinrichtungen der Universität und des Studentenwerks:
siehe Vorlesungsverzeichnis und Internet
-Beratungseinrichtung des Arbeitsamtes:
Hochschulteam des Arbeitsamts Dortmund:
Mensa Campus Nord, Raum E12, Tel. 842 1850/51
Vorkurs Informatik, LS VII, Universität Dortmund, WS 2004/2005
294