Grundlagen der Informatik - Hochschule Ravensburg

Grundlagen der Informatik
Wolfgang Ertel
WS 2005/06
Inhaltsverzeichnis
1 Was ist Informatik?
1.1 Informatik . . . . . . . . . . . . .
1.2 Computer . . . . . . . . . . . . .
1.3 Information . . . . . . . . . . . .
1.4 Teilgebiete der Informatik? . . . .
1.5 Programm, Algorithmus, Software
1.6 Betriebssysteme . . . . . . . . . .
1.7 Softwaretechnologie . . . . . . . .
1.8 Datensicherung . . . . . . . . . .
1.9 Datensicherheit . . . . . . . . . .
1.10 Datenschutz . . . . . . . . . . . .
1.11 Datenbanken . . . . . . . . . . .
1.12 Das Informatikstudium . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2 Geschichte der Informatik
2.1 Wichtige Quellen . . . . . . . . . . . . .
2.2 Geschichte der Zahlen und des Rechnens
2.3 Zahlendarstellung . . . . . . . . . . . . .
2.4 Geschichte der Bauelemente . . . . . . .
2.5 Geschichte der Rechenmaschinen . . . .
2.6 Geschichte der Programmiersprachen . .
2.7 Geschichte des Internet . . . . . . . . . .
2.8 Große Informatiker . . . . . . . . . . . .
2.9 Frauen in der Informatik . . . . . . . . .
2.10 Wichtige Institute und Firmen . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
4
4
5
5
6
6
8
10
11
12
12
13
.
.
.
.
.
.
.
.
.
.
14
14
14
14
16
18
25
26
28
34
36
3 Endliche Automaten
37
3.1 Endliche Automaten zur Worterkennung . . . . . . . . . . . . . . . . . . . . . . 37
3.2 Automaten mit Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3 Formale Beschreibung von Automaten . . . . . . . . . . . . . . . . . . . . . . . 38
4 Sortieralgorithmen
4.1 Sortieren durch Einfügen . . . . .
4.2 Quicksort . . . . . . . . . . . . .
4.3 Sortieren mit Bäumen (Heapsort)
4.4 Sortieren in linearer Zeit . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
41
41
46
51
56
5 Algorithmen auf Graphen
58
5.1 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
5.2 Eulerkreise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
2
5.3
5.4
5.5
5.6
Datenstrukturen für Graphen . . . .
Kürzeste Wege . . . . . . . . . . . .
Das Problem des Handlungsreisenden
Planare Graphen . . . . . . . . . . .
6 Übungen
6.1 Geschichte der Informatik
6.2 Endliche Automaten . . .
6.3 Sortieren . . . . . . . . . .
6.4 Graphen . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
61
62
65
72
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
73
73
73
74
76
7 Lösungen zu den Übungsaufgaben
7.1 Geschichte der Informatik . . . .
7.2 Endliche Automaten . . . . . . .
7.3 Sortieren . . . . . . . . . . . . . .
7.4 Graphen . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
79
79
79
80
83
.
.
.
.
.
.
.
.
.
.
.
.
Literaturverzeichnis
86
3
Kapitel 1
Was ist Informatik?
1.1
Informatik
Definition 1.1 Informatik ist die Wissenschaft der automatischen Verarbeitung von In
formationen mit Hilfe von Computern.
(Am.: Computer Science)
Verschiedene Aspekte der Informatik:
•
Spaß am Programmieren (Erfolgserlebnisse)
•
Spaß an der Beherrschung der Maschine
•
Teilweise sehr abstrakte Wissenschaft (Mathematik)
•
Ohnmachtgefühl von Laien
1.2
Computer
k Definition 1.2 Programmierbare Rechenmaschinen werden als Computer bezeichnet.
früher wurden Menschen, die “rechnen” als Computer bezeichnet.
Computer
•
machen unser Leben bequemer
•
helfen beim Beschaffen von Informationen
•
vereinfachen die Kommunikation
•
können süchtig machen
•
können zum Pseudopartner werden
•
vernichten Arbeitsplätze
•
schaffen Arbeitsplätze
•
Wem nützt die Informatik?
•
Wem schadet die Informatik?
⇒
Soziale Verantwortung des Informatikers!
4
1.3
Information
Information: Wissen, Gegenteil von Unsicherheit.
Definition 1.3 Als elementare Maßeinheit für Information dient das Bit. Eine Nachricht
(z.B. ein Text od. eine Zahl) hat einen Informationsgehalt von n Bit, wenn die minimale Zahl
von Ja/Nein Fragen, zur exakten Ermittlung der Information genau n ist.
Ein Computer-Wort besteht aus 8, 16, 32, oder 64 Bit.
Beispiel 1.1
1
0
0
1
1
0
1
0
1 · 27 + 0 · 26 + 0 · 25 + 1 · 24 + 1 · 23 + 0 · 22 + 1 · 21 + 0 · 20 =
128 +
16 +
8+
2
=
154
1.4
Teilgebiete der Informatik?
Informatik
Theoretische Informatik
•
•
•
•
•
•
•
•
Logik (logisch!)
Berechenbarkeit (ist jedes Problem berechenbar?)
Komplexität (Rechenaufwand)
Formale Sprachen (Programmiersprachen)
Informationstheorie (Datenübertragung)
Kryptographie (Datensicherheit)
Formale Spezifikation und Verifikation (Korrektheitsbeweise von Programmen)
...
Technische Informatik
•
•
•
•
•
Hardware
Rechnernetze
Schaltungen
Schnittstellen
Peripheriegeräte
Praktische Informatik
Bereitstellen von Hilfsmitteln für die Arbeit mit Computern
•
•
Rechnerarchitektur
Betriebssysteme (DOS, Windows, Unix, . . . )
5
•
•
•
•
•
•
•
Datenbanken
Künstliche Intelligenz
Software-Entwicklung
Datenkommunikation
Prozeßsteuerung
Bildverarbeitung
...
Angewandte Informatik
•
•
•
•
•
•
1.5
Wirtschaftsinformatik
Medizinische Informatik
Medieninformatik (Multimedia)
Kommunikationstechnik
Automatisierungstechnik
Künstliche Intelligenz
Programm, Algorithmus, Software
Definition 1.4 Algorithmus: Allgemeines Schema zur Lösung einer Klasse von Problemen.
Programm: Folge von Befehlen in einer festen Programmiersprache
Softwareentwicklung:
•
Problemanalyse
•
Problemlösung (Algorithmierung)
•
Programmierung (Kodierung)
•
Test
•
Inbetriebnahme
Softwaretechnologie:
Systematische Untersuchung der Softwareentwicklung und Bereitstellung von Entwicklungswekrzeugen.
1.6
Betriebssysteme
1.6.1
Betriebssysteme: Aufgaben
•
Laden u. Starten von Programmen
•
Verwalten des Hauptspeichers
◦
◦
Schützen der Speicherbereiche von Programmen
Verwaltung des virtuellen Speichers (paging, swapping)
Paging: Auslagern von Programmteilen
Swapping: Auslagern ganzer Programme
6
•
Verwaltung von Dateien
◦
◦
•
Ein- und Ausgabe
◦
◦
◦
•
Verwaltung von Dateiattributen (Größe, Datum, Rechte)
Verwaltung von Verzeichnissen
zeichenorientiert: Tastatur, Bildschirm, Drucker, serielle Schnittstelle
blockorientiert: Festplatte, Diskette, CD-Rom, Streamer
Verwaltung von Warteschlangen, z.B. f. Drucker
Zeitgeberfunktionen: Datum, Uhrzeit, verzögerter Programmstart
1.6.2
Betriebssysteme: Bestandteile
Betriebssystemkern: (Kernel)
allgemeine Module f. Ein/Ausgabe, Speicherverwaltung, etc.
Dienstprogramme:
kopieren, löschen v. Dateien, formatieren v. Disketten, ...
Bootprogramme:
zum Hochfahren des Rechners benötigte Programme
ladbare Treiber:
z.B. f. Netzwerkanbindung, Streamer
1.6.3
Betriebssysteme: Beispiel
program tabelle(input,output);
var
tabelle : text;
x, xmax : integer;
begin
open(tabelle, ...);
rewrite(tabelle);
write(’Gib Wert xmax ein:’);
readln(xmax);
writeln(tabelle,’
x | x^2 ’);
writeln(tabelle,’------------’);
Datei öffnen
Dateizeiger z. schr. a. Anf.
Bildschirmausgabe
Zahl von Tastatur lesen
auf Datei schreiben
”
for x := 1 to xmax do
begin
writeln(tabelle,x:4, ’ | ’, x*x:4); ”
end;
close(tabelle);
Datei schliessen, d.h. freigeben
end.
7
1.6.4
Betriebssysteme: Vergleich
Produkt
CP/M
MS-DOS
MS-Windows 3.11
MS-Windows 95
MS-Windows 98
Windows NT
OS/2
Novell/Windows
Unix
Linux
VMS (Digital)
VM/CMS (IBM)
BS 2000 (Siemens)
1.6.5
PC
Work- Mainstation frame
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
.
X
X
X
X
X
X
X
X
X
X
X
X
X
UNIX Shellprogrammierung, ein Beispiel:
#!/bin/tcsh
####!/usr/local/bin/tcsh
# Control C causes a jump to interrupt:
onintr interrupt
start:
while(1)
# export latex $1
latex $1
if ($status == 0) then
xdvi -geometry 750x880+0-0 -paper a4 -install $1
if ($status != 0) then
echo "@@@@@@@@@@@@@@@@@@@@@@@ xdvi Fehler! @@@@@@@@@@@@@@@@@@@@@@@@@@@"
exit
endif
endif
end
interrupt:
set kbinput = "0"
while($kbinput != "q")
echo "|||||||| Drucken (lj5_t011): ’d [RETURN]’"
echo "|||||||| Drucken (lj4mplus): ’2 [RETURN]’"
echo "|||||||| Drucken (lj5m):
’farbig [RETURN]’"
echo "|||||||| Drucken (lj5m):
’farbfolien [RETURN]’"
echo "|||||||| Ghostview:
’g [RETURN]’"
echo "|||||||| Latex:
’l [RETURN]’"
echo "|||||||| Bibtex:
’b [RETURN]’"
echo "|||||||| Exit:
’q [RETURN]’"
set kbinput = $<
if ($kbinput == "d") then
dvips -o "\!lp -d lj5_t011" $1
else if ($kbinput == "2") then
dvips2 $1
else if ($kbinput == "farbig") then
dvips $1 -o "\!lp -d lj5m"
else if ($kbinput == "farbfolien") then
dvips $1 -o "\!lp -d lj5m -o tray2"
else if ($kbinput == "b") then
bibtex $1
else if ($kbinput == "g") then
dvips $1 -o; ghostview -magstep -1 -a4 $1.ps; rm $1.ps
else if ($kbinput == "l") then
goto start
endif
end
1.7
multi multi
Netzuser tasking anbind.
Softwaretechnologie
Kosten von Hard- und Software:
Früher: 90% Hardware, 10% Software
8
X
X
X
X
?
X
Heute: 10% Hardware, 90% Software
⇒
Informatik als Ingenieursdisziplin mit der Aufgabe der Softwareentwicklung!
Definition 1.5 Beim Softwareengineering laufen folgende Prozesse parallel nebeneinander ab:
Softwareentwicklung
Projektmanagement
Qualitätssicherung
Projektverwaltung
1.7.1
Softwareentwicklung
Wichtige Begriffe:
•
Softwarelebenszyklus (software life cycle)
•
Phasenmodell der Softwareentwicklung
•
Wasserfallmodell
Planung
Der Softwarelebenszyklus
Spezifikation
Entwurf
Kodierung
Test
Betrieb
Stillegung
1.7.2
Moderne Softwareentwicklung
Wichtige Schritte im Entwicklungsprozess:
Use Cases: Typische Benutzer-Programm Interaktionen
9
Verteilungsmodell: Verteilung von Objekten/Prozessen auf einzelne Rechner, bzw. teilnetze
Datenflußdiagramm: Graphische Darstellung des Datenflusses. Führt zu Schnittstellendefinitionen.
Beispiel 1.2
ps
Prozeßliste
sort
sortierte Liste
Unix-Pipe: ps | sort | lp
lp
druckbare Daten
Drucker
Ausdruck auf Papier
1.7.3
CASE: Computer Aided SW-Engineering
CASE-Tools sind Werkzeuge, die teilweise automatisch den ganzen Entwicklungsprozeß unterstützen.
1.8
Datensicherung
Definition 1.6 Datensicherung (engl. Dump) ist das regelmäßige Speichern von Daten
von der Festplatte auf einen anderen Datenträger mit dem Ziel der Rekonstruktion bei Da
tenverlust.
klassisches Verfahren: inkrementeller Dump
Level 0 Dump: 1× pro Monat wird die gesamte Platte (inklusive Betriebssystem) auf dem
Magnetband gesichert. (in den ungeraden Monaten auf Band M-1, in den geraden Monaten auf Band M-2.)
Level 1 Dump: 1× pro Woche werden die Benutzerdaten von der Platte auf dem Magnetband
gesichert. (in den ungeraden Wochen auf Band W-1, in den geraden Wochen auf Band
W-2.)
Level 2 Dump: täglich werden die Benutzerdaten von der Platte auf dem Magnetband inkrementell gesichert. (in den ungeraden Wochen auf die Bänder Mo-1, . . . , Fr-1, in den
geraden Wochen auf die Bänder Mo-2, . . . , Fr-2)
10
Bemerkungen:
•
insgesamt werden 14 Magnetbänder für die Datensicherung benötigt!
•
während des Dumps sollte kein Benutzer auf dem Rechner arbeiten.
•
die gesicherten Medien (Bänder) sollten in einem anderen Gebäude sicher verwahrt werden.
modernes Verfahren:
Daten werden monatlich, wöchentlich, täglich auf je eine monatliche, eine wöchentliche, bzw.
eine tägliche Festplatte (im Wechsel) gespiegelt, nach ähnlichem Verfahren wie oben.
1.9
Datensicherheit
Asymmetrische Kryptographie
Verschlüsseln (E), Entschlüsseln (D)
M
E P (M)
EP
B
B
DS
B
M
unsicherer Kanal
Alice
Bob
Digitale Signatur
M
ES
(M, ES (M))
A
A
DP M
A
Bob
Alice
1.9.1
Speicherung des geheimen Schlüssels
•
auf der Festplatte des PCs
•
auf Diskette, CD, USB-Stick
•
auf Chipkarte
•
auf Chipkarte, berührungslos lesbar
Problem: Big Brother is watching you!
Beispiele:
•
RFID-Chips (RFID = radio frequency identification), teilweise schon in Alltagsgegenständen
eingebaut
•
Ubiquitous Computing (allgegenwärtiger Computer)
•
•
•
•
das Handy führt mich überall hin
über das Handy bin ich immer lokalisierbar
über das Handy kann ich immer gestört werden
...
11
1.10
Datenschutz
Bundesdatenschutzgesetz (BGBL. 1 2003, S. 66) § 1, Abs. 1:
“Zweck dieses Gesetzes ist es, den Einzelnen davor zu
schützen, dass er durch den Umgang mit seinen personenbezogenen Daten in seinem Persönlichkeitsrecht beeinträchtigt
wird.”
Beispiel:
Die Veröffentlichung von Fotos von Mitarbeitern ist nur erlaubt, wenn der Mitarbeiter freiwillig und schriftlich sein Einverständnis erklärt.
1.11
Eva Müller
Mitarbeiterin des Monats
Datenbanken
Beispiele:
•
Literaturdatenbank
•
Personaldatenbank
•
Gefahrstoffdatenbank
•
Buchunssystem für Reisebüros/Fluggesellschaften
•
...
Definition 1.7 Eine Datenbank ist eine systematisch strukturierte, langfristig verfügbare
Sammlung von Daten einschließlich der zur sicheren und schnellen Manipulation dieser Daten
erforderlichen Software.
Vorteile einer Datenbank:
•
Mehrbenutzerbetrieb möglich
•
Unterschiedliche Sichten auf die Daten sind möglich
•
Daten sind unabhängig von Nutzerprogrammen; Nutzung ist unabhängig von der Art der
Speicherung.
•
Vollständigkeit (Integrität) und Korrektheit (Konsistenz) werden automatisch gewährleistet.
Eine Datenbank besteht aus
Datenbasis: die (z.B. als Tabellen) in Dateien gespeicherten Daten.
Datenbankmanagementsystem (DBMS): Programm für Aufbau, Verwaltung und Anwendung der Datenbank.
Datenbanksprache: formale Sprache zur Formulierung von Benutzeranfragen an die Datenbank. (Beispiel: SQL (Structured Query Language))
12
1.12
Das Informatikstudium
Leonardo da Vinci:
Studium ohne Hingabe schadet dem Gehirn
Der Studienerfolg wird statistisch u.a. bestimmt durch folgende Variablen:

Schnitt
falls Abitur

Schnitt − 0.5 falls FH-Reife direkt
Note: Note =

Schnitt − 1 falls FH-Reife auf 2. Bildungsweg
Interesse (für Informatik): Ich wollte schon immer wissen, wie (intelligente Roboter, Verschlüsselung, Internet, . . . ) funktioniert (0|1)
Biss (Wille): Wenn nötig arbeite ich auch am Abend und am Wochenende (0|1)
SozUm: Finanziell gesichert, Wohnen vor Ort, Partnerschaft o.k. (0|1)
1.12.1
Entscheidungsbaum
Variablenwerte für Interesse, Biss, SozUm:
1: trifft voll zu;
0: trifft nicht oder nur teilweise zu
Studienerfolg: −: keine Abschluss;
+: Bachelor;
++: Bachelor, sehr gut
Note
>3
Biss
0
Biss
0
1
+
<1.5
1.5-2.5
Interesse
2.5-3
1
0
1
+
Biss
Interesse
0
Interesse
0
0
1
0
1
+
++
+
++
SozUm
0
1
0
1
+
Biss
0
+
1.12.2
1
+
Score (einfach)
Score = (3 − Note) + 3 · Biss + 2 · Interesse + SozUm

 ++ falls Score > 3.5
+ falls Score > 0
Studienerfolg =

− falls sonst
13
++
SozUm
Interesse
1
1
Kapitel 2
Geschichte der Informatik
2.1
Wichtige Quellen
•
http://de.wikipedia.org
•
www.computerhistory.org
•
F. Naumann, Vom Abakus zum Internet [2]
•
H. Matis, Die Wundermaschine[3]
•
W. de Beauclair, Rechnen mit Maschinen – eine Bildgeschichte der Rechentechnik[4]
Viele der folgenden Informationen und Bilder stammen aus diesen Quellen.
2.2
Geschichte der Zahlen und des Rechnens
30000 v. Chr. erste Zeichensysteme für Zahlen in Ägypten und Mesopotamien
3500 v. Chr.
Zeichen auf Tontafeln in Pakistan
Additive Zahldarstellung in Rom, Mexiko (Maya), China, Ägypten, Sumerer
200 v. Chr
Erfindung der Null in Indien ⇒ Stellenwertsystem
0
Römische Schriftzeichen
1200
Fibonacci führt negative Zahlen ein (Schuld)
2.3
Zahlendarstellung
Additive Zahlendarstellung:
14
additiv (ohne Null) mit Null (binär) dezimal
–
0
0
1
1
1
11
10
2
111
11
3
1111
100
4
11111
101
5
111111
110
6
1111111
111
7
11111111
1000
8
111111111
1001
9
1111111111
1010
10
...
...
...
1111111111111111111111111111111111111111
110010
50
...
...
...
additive Zahlendarstellung ist für große Zahlen nicht brauchbar!
Mit n Stellen lassen sich darstellen:
additiv:
die Zahlen 1 . . . n
binär:
die Zahlen 0 . . . 2n − 1
dezimal:
die Zahlen 0 . . . 10n − 1
Ziffern 0 . . . b: die Zahlen 0 . . . bn − 1
Wieviele Stellen braucht man, um eine große Zahl z darzustellen?
binär:
z = 2n
⇔
n = log2 z
allgemein:
additiv:
binär:
dezimal:
Ziffern 0 . . . b:
Zahl d. Stellen um die Zahlen 0 . . . m darzustellen
m+1
≤ log2 m + 1
≤ log10 m + 1
≤ logb m + 1
Die Zahl der Stellen bei Stellenwertsystemen wächst nur logarithmisch mit der Größe
der darzustellenden Zahl (dank der Null).
15
2.4
2.4.1
Geschichte der Bauelemente
Rechenlogik
Elektrische Rechenmaschine braucht elektrische Schalter!
Mechanik
Antike bis heute
Relais
1835 – 1950, J. Henry
Röhre
1904 – 1970, J.A. Fleming
(Engl.)
Transistor
1947 – heute, Bell Labs
(USA)
Integrierter
Schaltkreis
1958, heute bis zu 1 Milliarde Transistoren auf unter 1
cm2
16
Pentium 4
2.4.2
Intel, 2000, bis 3.8 GHz
Taktfrequenz, 2 CPUs auf
einem Chip
Speichertechnologie 1956, IBM-RAMAC
•
erste Festplatte
•
50 Platten, je 60 cm Durchmesser, 1200 Umdr./min
•
pro Platte 2 × 100 Spuren mit je 500 Zeichen
•
⇒ pro Platte 100 kB Speicher
•
gesamt: 5 MB Speicher
2.4.3
Speichertechnologie 2005
•
4 Gigabit pro cm2
•
Spurabstand ≈ . . .
•
Köpfe fliegen 10-15 Nanometer über d. Platte
17
2.4.4
2.5
Speichertechnologie 1956–2005
Geschichte der Rechenmaschinen
2.5.1
Kerbhölzer und Knotenschnüre
•
Speicherung von Zahlen
•
Additition und Subtraktion
2.5.2
Mechanische Rechenmaschinen (Mittelalter)
???: Abakus +, −
Schickard (1623, lange unbekannt): +, −, ×, /
Pascal (1641): +, −
18
Leibniz (1675) +, −, ×, /
Babbage (1823), Difference Engine
Analytical Engine
Die grundlegend neuen Ideen bestehen:
1.
In der Programmierbarkeit einer Maschine durch
Verwendung von Jacquard‘schen Lochkarten.
2.
In der Weiterverwendung von
Zwischenergebnissen. („the engine eating its
own tail“)
3.
Der Aufteilung des Gerätes in Speicher(Store)
und Rechenwerk (Mill). Zahnstangen dienten der
Übertragung von Zahlenwerten zwischen Store
und Mill (Rechnerbus).
Babbage Bis
(1833–?),
Analytical Engine John
(pro1948 (Speicherprogrammierbarkeit,
von
Neumann)
gibt
es
keine
grundlegende
grammierbar!)
Weiterentwicklung dieses Konzepts! Die
ersten „modernen“ Rechner hatten eine
einfachere Architektur.
Die Analytical Engine war ein Papiercomputer. Nur
einzelne Komponenten (Teile des Rechenwerks)
wurden wirklich gebaut.
Informatikgeschichte, E. Ehses 2003
2.5.3
Der Abakus (ca. 2000 v.Chr. bis heute!)
•
die universale Rechenmaschine schlechthin!
•
verwendet in Griechenland, Rom, Japan, China (bis
Datenblatt der Analytical Engine
heute), Rußland (bis heute)
•
heute in Japan: Wettbewerbe Abakus – TaschenSpeicher für rund 100 Variable zu je 30-40 Stellen.
rechner
Chinesischer
Vorrichtung zur Wiederholung von Operationen
(„mechanical means have been provided for backing
up or advancing the operation cards to any extend“)
Abakus:
Stanzer für Zahlenkarten (Massenspeicher).
19
Drucker.
Zeichengerät.
17
2.5.4
Die Analytical Engine
Revolutionäre Ideen:
•
Programmierbarkeit einer Maschine durch Verwendung von Jacquard’schen Lochkarten.
•
Weiterverwendung von Zwischenergebnissen. (“the engine eating
its own tail”)
•
Aufteilung des Gerätes in Speicher(Store) und Rechenwerk (Mill).
Zahnstangen dienten der Übertragung von Zahlenwerten zwischen
Store und Mill (Rechnerbus).
Die Analytical Engine war ein Papiercomputer. Nur einzelne Komponenten (Teile des Rechenwerks) wurden wirklich gebaut. Bis 1948 (Speicherprogrammierbarkeit, John von Neumann)
gibt es keine grundlegende Weiterentwicklung dieses Konzepts! Die ersten modernen Rechner
hatten eine einfachere Architektur.
2.5.5
Zuse Z1, Z2
•
Baujahr 1938, 1939
•
Bleche schieben Stifte, Relais (Z2)
•
binär-dezimal Konvertierung, Operationen:
√
+, −, ×, /, ,
20
2.5.6
Zuse Z3
•
Baujahr 1941
•
programmierbar über Lochstreifen
•
Ausgabe über Lampenfeld
•
Binäre Schaltlogik
•
“RISC”-Architektur: wenige Befehle
•
Gleitpunktarithmetik
•
Multiplikationszeit: 3 sec.
•
Hauptspeicher: 64 Worte à 22 Bit
2.5.7
ASCC (MARK 1)
•
H. Aiken will Rechner zum Lösen von DGLs
•
erster Rechner mit konsequenter vonNeumannArchitektur
•
Baujahr 1944, Univ. Harvard und IBM
•
programmierbar über Lochstreifen
•
Multiplikationszeit: 6 sec.
•
in Betrieb bis 1959
•
760 000 Einzelteile
•
15 m lang, 2.5 m hoch
2.5.8
Colossus
•
entwickelt u.a. von Alan Turing zum Knacken
deutscher Enigma-Codes
•
Baujahr 1943,
•
programmierbar über Lochstreifen
•
photoelektr. Leser (5000 Zeichen/sec.)
•
Multiplikationszeit: 6 sec.
•
1500 Röhren
21
Nachbau von Colossus
2.5.9
Die Chiffriermaschine Enigma
•
1923: Erfindung durch Arthur Scherbius zum
Gebrauch für Geschäftsleute.
•
1925: Deutsche Wehrmacht kauft Enigmas.
•
mehrfach geknackt (Polen) und wieder verbessert.
•
1939: Der Großangriff der Briten auf die Enigma in Bletchley Park.
•
1942: Neue Enigma mit vier Walzen ist wieder
sicher und wird im U-Boot-Krieg eingesetzt.
•
1943: Nach fast einem Jahr wird die 4-WalzenEnigma geknackt. Hier kam Colossus zum
Einsatz.
•
1945: Entschlüsseln der Enigma-Codes war am
Sieg der Alliierten mit beteiligt. ca. 10 000 Personen arbeiteten in drei Schichten rund um die
Uhr.
2.5.10
Eniac (electronical numerical integrator and computer)
•
Baujahr 1946, Univ. Pennsylvania, USA
•
universell eingesetzt, in Betrieb bis 1955
•
Dezimalrechner, 10 Dezimalstellen
•
Taktfrequenz 100 kHz (Addition 0,2 ms)
•
18000 Röhren, 1500 Relais
•
Multiplikationszeit: 3 sec.
•
?????? Programmierung ??????
22
2.5.11
IBM 360
•
Baujahr 1964
•
Erster kommerziell erfolgreicher Großrechner
•
MTS: Michigan Time sharing system, 1966
2.5.12
Control Data CDC 6600
•
Erbaut 1964 von S. Cray
•
3 MIPS
•
verteilte Architektur, 10 I/O-Prozessoren
2.5.13
Telefunken TR 440
•
Baujahr 1970
•
Breite 6,50 m, Tiefe 0,55 m, Höhe 1,81 m
•
Gewicht ca. 1250 Kg
•
Taktfrequenz 20 MHz
•
Prozessorleistung 1,2 MIPS
•
1,5 MB Kernspeicher mit virtueller Adressierung
Lochkartenstanzer
23
2.5.14
Cray 1
•
Baujahr 1976
•
Vektorrechner
•
Supercomputer für numerische Berechnungen
•
64 parallel arbeitende 64-Bit Prozessoren
•
166 Mega-FLOPS
•
Gewicht: 2.5 Tonnen
2.5.15
Connection Machine
•
Baujahr 1986, D. Hillis of Thinking Machines Corp
•
Massiv parallel: 16000 parallele Prozessoren
•
Milliarden Operationen pro sec.
•
Anwendung in der KI, u.a. Neuronale Netze
2.5.16
PCs
Commodore Pet, 1977, Kassettenlaufwerk, 4/8
kB Hauptspeicher 2
Apple 2, 1977, 1 Mainboard, Farbgrafik
24
IBM PC, 1981, 4.77 MHz Intel 8088, MS-DOS
(Microsoft disc operating system)
Commodore 64, 1981, für 595 US$ viel billiger
als die Konkurrenz, TV-Bildschirm, Kassettenlaufwerk, 64 KB RAM
2.5.17
Zitate
“I think there is a world market for about five computers.”
Thomas J. Watson Jr., chairman of IBM (1943)
“Where a calculator on the ENIAC is equipped with 18,000 vacuum tubes and weighs 30 tons,
computers in the future may have only 1,000 vacuum tubes and perhaps weigh 1 12 tons.”
Popular Mechanics (March 1949)
“640 K [of computer memory] ought to be enough for anybody.”
2.6
Geschichte der Programmiersprachen
•
Heute gibt es über 2500 verschiedene Programmiersprachen
•
Siehe Aushang, bzw. www.levenez.com
prozedural: Assembler, Fortran (1954), PL/1, Basic, Simula, APL, C, Pascal, Cobol, Perl,
sh, awk, SQL, PHP
funktional: Lisp (1958), Haskell, Miranda, Mathematica
logisch: Prolog (1970)
objektorientiert: Smalltalk (1969), C++, Oberon, Java, C#
2.6.1
Fakultät in C, Prolog, Mathematica
C (prozedural):
25
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int fakultaet(int n)
{
int ergebnis;
if (n == 1) return 1;
ergebnis = n * fakultaet(n-1);
return(ergebnis);
}
int main (int argc,char *argv[])
{
int n;
if(argc != 2)
{
printf("usage: fakultaet <n>\n");
return 1;
}
n = atoi(argv[1]);
printf("Fakultät(%d) = %d\n", n, fakultaet(n));
}
Mathematica (funktional):
1
2
Fac[0] := 1;
Fac[n_] := n * Fac[n - 1]
Prolog (logisch):
1
2
2.7
fakultaet(1,1).
fakultaet(N,Res) :- N1 is N-1, fakultaet(N1,Res1), Res is N * Res1,
Geschichte des Internet
•
Gegründet 1962 durch die Advanced Research Projects Agency (ARPA) der USA.
•
Bob Kahn und Vint Cerf erfinden 1973 das Transmission Control Protocol (TCP) und
1976 das TCP/IP Protokoll.
•
Bob Kahn und Vint Cerf erfinden 1973 das Transmission Control Protocol (TCP).
•
Erstes Email-Netz 1977 an der Univ. Wisconsin.
•
TCP/IP wird weltweit eingeführt
•
Tim Berners-Lee erfindet 1989 das World Wide Web (WWW)
26
“In the Beginning, ARPA created the ARPANET.
And the ARPANET was without form and void.
And darkness was upon the deep.
And the spirit of ARPA moved upon the face of the network and ARPA said, ’Let there be a
protocol,’ and there was a protocol. And ARPA saw that it was good.
And ARPA said, ’Let there be more protocols,’ and it was so. And ARPA saw that it was good.
And ARPA said, ’Let there be more networks,’ and it was so.”
– Danny Cohen
2.7.1
Das Semantic Web
•
Neben Text und Bildern soll der Inhalt (Semantik) von Webseiten in Zukunft durch
Annotationen formal beschrieben werden.
•
Anfrage: Wie viele Tore hat Michael Ballack im Jahre 1998 geschossen?
•
Google kann die Anfrage nicht beantworten.
•
Das Semantic Web soll das demnächst können.
•
Resource Description Framework (RDF) und Web Ontology Language (OWL) zur Beschreibung von Metainformation über Webseiten
•
Unter Verwendung von Automatischen Theorembeweisern sollen semantische Anfragen beantwortet werden.
2.7.2
Aktuelle Trends (2005)
27
2.8
Große Informatiker
2.8.1
•
Blaise Pascal (Frankreich, 1623–1662)
baute als 18 jähriger für seinen Vater die erste funktionierende
mechanische Rechenmaschine zur Addition sechsstelliger Zahlen.
(Digitalrechner)
2.8.2
Gottfried Wilhelm Leibniz (Leipzig, 1646–1716)
•
Philosoph, Mathematiker
•
baut eine Rechenmaschine für alle vier Grundrechenarten.
2.8.3
Charles Babbage (England, 1791-1871)
•
Entwickelt die Difference Engine zur Ableitung von Polynomen
(1823)
•
Entwickelt die Analytical Engine (1833)
2.8.4
Kurt Gödel (Österreich, 1906–1978)
Der Österreicher Kurt Gödel zeigt 1931
•
dass in der Prädikatenlogik erster Stufe alle wahren Aussagen
herleitbar sind.
•
In Logiken höherer Stufe hingegen gibt es wahre Aussagen, die
nicht beweisbar sind. Es lassen sich also nicht alle Berechnungsaufgaben automatisieren.
Zusammen mit Einstein arbeitet er auch an der Relativitätstheorie und
Kosmologie.
28
Denken Sie nach über die Aussage:
Ich bin nicht beweisbar
oder über
Die Menge aller Barbiere die sich nicht selbst rasieren.
oder über die Menge {x|x ∈
/ x}.
2.8.5
Alan Turing (England, 1912–1954)
Der Brite Alan Turing leistet u.a. folgendes
•
Er erfindet 1935 das bis heute universelle Berechnungsmodell, die
“Turingmaschine”.
•
Er zeigt, dass es viele Funktionen gibt, die nicht berechenbar sind.
•
Er beweist das Halteproblem: Es kann kein Programm geben, das
in endlicher Zeit entscheidet, ob ein beliebiges Programm auf einer
Eingabe hält oder eine Endlosschleife hat.
•
Er definiert den Begriff der Intelligenz über den “Turing Test”.
•
Ende der Dreißiger Jahre macht er schon Vorschläge für lernfähige
Computer.
•
Er ist im 2. Weltkrieg führend beteiligt an der Dechiffrierung der
Enigma.
•
Er ist beteiligt am Bau von Colossus, dem ersten britischen Computer für die Dechiffrierung der Enigma (1944).
Denken Sie nach über das Programm:
unmöglich(int i)
{
if( hält(unmöglich,0))
while( TRUE ) printf(‘‘das kann noch dauern ...’’);
else
printf(‘‘0’’);
}
Die Turingmaschine:
Lesekopf
HAL LO
Z
29
Zustand
2.8.6
Claude Shannon (Michigan, 1916–2001)
•
A Mathematical Theory of Communication (1948)
•
Informationstheorie, Entropie als Informationsmaß
•
Formale Grundlagen der Kryptographie (Konfusion und Diffusion, 1949)
•
Entwickelt einen Schachcomputer (1960)
2.8.7
Alonzo Church (Washington, 1903–1995)
•
Berechenbarkeit
•
Lambda Kalkül
•
Church’sche These: Die Turingmaschine kann alles berechnen, was
wir intuitiv für berechenbar halten.
2.8.8
John von Neumann (Polen, 1903–1957)
•
Spieltheorie, Minimax Algorithmus (1928)
•
Quantenmechanik, Entwicklung der Atombombe
•
von Neuman Architektur von Rechnern (EDVAC)
•
genial, lebenslustig, trinkfest
2.8.9
Die vonNeumann-Architektur
CPU
Speicher
(RAM)
Rechenwerk Steuerwerk
Datenbus
Adressbus
•
Zentraleinheit (CPU)
◦
◦
Rechenwerk
Steuerwerk
30
I/O
•
Speicher (Hauptspeicher)
•
Bus (Busse)
•
Ein/Ausgabesysteme (I/O) ⇒ Peripheriegeräte
2.8.10
Edsger Dijkstra (Rotterdem, Holland, 1930–)
•
Algorithmen auf Graphen
•
Kürzeste Wege Algorithmen
•
Korrektheit von Programmen
2.8.11
Donald Knuth (Milwaukee, 1938–)
•
Meister der Algorithmen, u.a.: Zufallszahlen, Sortieren, Suche, ...
•
Autor der 5-bändigen Bibel: “The Art of Computer Programming”
•
Erfinder des Textsatzsystems TEX
spielt eine selbstgebaute Orgel
•
Zitate:
“Computer Programming is an art form, like the creation
of poetry or music.”
“I got into compilers because I thought the most amazing
thing you could do with computers was to have them write
their own programs. When computing is applied to computing, that’s when computer science reaches an ultimate
completeness.”
2.8.12
Stephen A. Cook (Buffalo, New York, 1939–)
•
Begründer der modernen Komplexitätstheorie
•
NP-Vollständigkeit
31
2.8.13
Leslie Lamport (New York, 1941–)
•
Theorie verteilter Systeme
•
Lamport clock: partielle Ordnung der Zeit, keine globale Zeit
•
Enwickler von LATEX(TEX-Macropaket)
Zitat:
“When I look back on my work, most of it seems like dumb
luck – I happened to be looking at the right problem, at the
right time, having the right background.”
2.8.14
Ken Thompson, Dennis Ritchie (New Orleans, 1943–, New
York, 1941–)
•
1969: Erfindung von UNIX (Bell Laboratories, New Jersey, später AT&T)
•
Erfinder von C
•
Viele innovative Konzepte:
◦
◦
◦
◦
Pipelining
verteilte Prozesse
Sockets
Timesharing und Prozesse mit Prioritäten (auch
auf PCs)
32
2.8.15
Nikolaus Wirth (Winterthur, Schweiz, 1934–)
•
Erfinder der Programmiersprachen Pascal (1970) und Modula
(1975)
•
Erfinder der Objektorientierten Sprache Oberon (1987)
2.8.16
Bill Gates (Seattle, 1955–)
•
zus. mit Paul Allen Gründer von Microsoft
•
mit dem Kauf von MS-DOS 1980 beginnt die Erfolgsstory von
Microsoft
•
reichster Mann der Welt (fast 50 Mrd. US$)
2.8.17
Tim Berners-Lee (London, 1955–)
•
1989 schlug Berners-Lee seinem Arbeitgeber CERN (Europäisches
Kernforschungslabor) ein Projekt vor, das auf dem Prinzip des
Hypertexts beruhte und den weltweiten Austausch sowie die
Aktualisierung von Informationen zwischen Wissenschaftlern vereinfachen sollte.[1]
•
entwickelte den ersten Webbrowser
•
baute die erste Webseite
2.8.18
Der Turing Award
siehe www.acm.org/awards/taward.html
ACM’s most prestigious technical award is accompanied by a prize of $ 100,000.
Financial support of the Turing Award is provided by the Intel Corporation.
ACM: Association of Computing Machinery
1966
1967
1968
1969
1970
1971
1972
1973
A.J. Perlis
Maurice V. Wilkes
Richard Hamming
Marvin Minsky
J.H. Wilkinson
John McCarthy
E.W. Dijkstra
Charles W. Bachman
Compilerbau
EDSAC, erster Computer mit internem Programmspeicher
Kodierung, Hamming-Distanz
Perzeptron, Neuronale Netze
Numerik
Künstliche Intelligenz, LISP
Graphenalgorithmen, ALGOL
Datenbanken
33
1974 Donald E. Knuth
1975 Allen Newell
Herbert A. Simon
1976 Michael O. Rabin
Dana S. Scott
1977 John Backus
1978 Robert W. Floyd
1979 Kenneth E. Iverson
1980 C. Antony R. Hoare
1981 Edgar F. Codd
1982 Stephen A. Cook
1983 Ken Thompson
Dennis M. Ritchie
1984 Niklaus Wirth
1985 Richard M. Karp
1986 John Hopcroft
Robert Tarjan
1987 John Cocke
1988 Ivan Sutherland
1989 William (Velvel) Kahan
1990 Fernando J. Corbato
1991 Robin Milner
1992 Butler W. Lampson
1993 Juris Hartmanis,
Richard E. Stearns
1994 Edward Feigenbaum
Raj Reddy
1995 Manuel Blum
1996 Amir Pnueli
1997 Douglas Engelbart
1998 James Gray
1999 Frederick P. Brooks
2000 Andrew Chi-Chih Yao
2001 Ole-Johan Dahl,
Kristen Nygaard
2002 Ronald L. Rivest,
Adi Shamir,
Leonard M. Adleman
2003 Alan Kay
2004 Vinton G. Cerf,
Robert E. Kahn
2.9
Algorithmen, “The Art of Computer Programming”
Erfinder des Textsatzsystems TEX
Künstliche Intelligenz
General Problem Solver
Automaten, Algorithmen, Nichtdeterminismus
randomisierte Algorithmen
FORTRAN, Backus-Naur-Form Grammatik
formale Methoden zur Software Entwicklung
Programmiersprachen, APL
Programmiersprachen
Relationale Datenbanken
Komplexität, NP-Vollständigkeit
Betriebssystem UNIX
MODULA, PASCAL, Oberon
NP-Vollständigkeit
Algorithmen und Datenstrukturen (Lehrbuch)
Compilerbau, RISC-Computer
Computergraphik
Numerik, Floating Point Arithmetik
Time sharing
Logik, funktionale Progarmmierung: ML
PC-Entwicklung (Microsoft)
Komplexitätstheorie
Künstliche Intelligenz, prakt. Umsetzung
Komplexitätstheorie, Kryptographie
Temporallogik, Programmverifikation
Maus, Fenster
Datenbanktechniken
Rechnerarchitaktur, IBM 360
Zufallszahlen, Kryptographie
Simula, OOP
Public Key Kryptographie, RSA-Algorithmus
Objektorientierte Programmierung, Smalltalk
Vernetzung, TCP/IP
Frauen in der Informatik
Warum gibt es so wenige Frauen in der Informatik?1
1
teilweise entnommen aus Olga Goldmann Seminar: Geschichte der Informatik, www.virtosphere.de/
schillo/teaching/WS2001/Geschichts-Seminar.html
34
•
Intelligenztests zeigen minimale Unterschiede ausschließlich bei:
◦
◦
•
Vorstellung räumlicher Drehungen von Figuren zugunsten der Männer
Sprachkompetenzen zugunsten der Frauen
Es gibt keine Intelligenz und Begabungsunterschiede die die geringe Beteiligung der Frauen erklären können!
2.9.1
Frauenanteil am Informatik-Studium.
Land
England
Italien, Frankreich, Spanien, Portugal
frühere Sowjetunion
Bulgarien
Griechenland
Indien, Malaysia, Singapur
Deutschland
2.9.2
Frauenanteil [%]
35
40–50
50
60–70
59
50
8
Frauen in der Geschichte der Informatik
Ada Augusta von Lovelace (1815-1852)
•
arbeitet mit Ch. Babbage an der Analytical Engine
•
Mutter von vier Kindern
•
Sie erfand Unterprogramme, Schleifen und bedingte Sprünge!
•
publizierte unter dem Kürzel A.A.L.
Die Analytical Engine
Die wesentliche Neuerung der Analytical Engine ist ihre Programmierbarkeit.
store: Arbeitsspeicher, in dem Speicherplatz für bis zu 1000 Werte mit maximal 50 Dezimalstellen sein sollte,
mill: Central Processing Unit (CPU), die im wesentlichen aus der Difference Engine bestehen
sollte.
Eingabeschnittstelle für Lochkarten, unterschieden nach operation cards für die Befehlseingabe, variable cards zur Eingabe von Variablen und ihrer Speicheradresse, sowie den
number cards.
eigene Bibliothek die die Analytical Engine sich aus den errechneten Tabellenwerten aufbaut
Ausgabeschnittstelle entweder für einen Drucker oder für Lochkarten die in die Bibliothek
eingereiht werden.
35
Grace Murray Hopper (1906-1992)
•
beteiligt an Entwicklung von Mark 1, Mark 2, Univac 1
•
entwickelt 1952 einen der ersten Compiler
•
“Debugging”: Eine tote Motte (bug) blockiert ein Relais im Rechner. Zitat: First actual case of a bug being found.
•
Zitat: Wenn du eine gute Idee hast, dann tu es einfach, denn es
ist viel einfacher sich hinterher zu entschuldigen, als vorher um
Genehmigung zu bitten.
•
Über 40 Ehrendoktorwürden, National Medal of Technology der
USA als erste Frau.
Bis etwa 1960 waren viele Frauen in der Informatik tätig:
•
Beim Knacken der Enigma in Bletchley Park (England)
•
Bei der Bedienung und Programmierung früher Rechner
◦
◦
◦
2.10
Colossus (G.B.)
Eniac (USA)
nach dem Krieg in Deutschland
Wichtige Institute und Firmen
IAS: Institute for advanced studies, Princeton, New Jersey, USA
MIT: Massachusettes Institute for Technology, Cambridge, Massachusetts, USA
SRI: Stanford Research Institute, Palo Alto, USA
Stanford University, Palo Alto, California, USA
Harvard University, Cambridge, Massachusetts, USA
UCB: Univ. of California, Berkeley, USA
AT&T Bell Labs: New Jersey, USA
36
Kapitel 3
Endliche Automaten
Alle gängigen Programmiersprachen sind Turingmächtig. Das heißt, Programme in diesen Sprachen können alles berechnen, was wir intuitiv als berechenbar ansehen. Diese Sprachen sind also
sehr “mächtig”. Für einfache Aufgabenstellungen in der Softwareentwicklung möchte man ein
einfacheres Programmiermodell um die Programmierung zu vereinfachen.
3.1
Endliche Automaten zur Worterkennung
Ein derartiges einfaches Modell ist der endliche Automat. Anschaulich ist ein endlicher Automat
ein Rechenelement, welches auf einem Eingabeband beginnend mit dem ersten Zeichen der
Eingabe das eingegebene Wort Zeichen für Zeichen liest. In jedem diskreten Rechenschritt macht
der Automat einen Zustandsübergang. Abhängig vom aktuellen Zustand und dem gelesenen
Zeichen geht der Automat in einen neuen Zustand über. Die Zahl der Zustände ist endlich.
Erreicht der Automat nach Lesen des letzten Zeichens einen Endzustand, so hat er das Wort
erkannt.
Lesekopf
HAL LO
Z
Zustand
Beispiel 3.1 Der durch folgende Regeln beschriebene Automat akzeptiert alle Zeichenketten
(Worte) bestehend aus einer beliebigen Anzahl a-s gefolgt von einer beliebigen Anzahl b-s,
mindestens jedoch ein a und ein b. Die Regelmenge des Automaten mit den Zuständen A, B
und dem Endzustand e ist
δ = {S, a → S; S, a → T ; T, b → T ; T, b → e}
Die Zustandsübergangsrelation δ läßt sich übersichtlich durch die Zustandsübergangstabelle
darstellen
T
e
δ S
a {S, T }
b
{T, e}
Man beachte, dass die Zustandsübergangsrelation δ nicht eindeutig ist, denn zum Beispiel kann
der Automat nach Lesen eines a im Zustand S nach S oder nach T übergehen. Dies zeichnet
den nichtdeterministischen Automaten aus.
Besonders anschaulich ist der zugehörige Zustandsgraph:
a
S
b
a
T
37
b
e
Der beschriebene Automat kann nur passiv Eingaben akzeptieren oder abweisen. Er löst also
ein binäres Entscheidungsproblem. Man kann solch einen Automaten einfach erweitern durch
eine Ausgabefunktion.
3.2
Automaten mit Ausgabe
Beispiel 3.2 Es soll ein Getränkeautomat mit Hilfe eines endlichen Automaten programmiert
werden. Der Automat kann mit bis zu 4 Dosen Mineralwasser gefüllt werden. Wenn eine 1Euro-Münze eingegeben wird, soll er eine Dose Wasser ausgeben. Bei Eingabe einer anderen
Münze soll er die eingegebene Münze wieder ausgeben, aber kein Getränk. Wenn der Automat
leer ist soll er anhalten und per Funk den Service benachrichtigen.
Ein endlicher Automaten (mit Ausgabe) für diese Aufgabe ist gegeben durch folgende Tabelle
mit den Zuständen z0 , z1 , z2 , z3 , z4 , den erlaubten Eingabezeichen e, f, m. Im Zustand zi enthält
der Automat i Flaschen Mineralwasser. e steht für die Eingabe eines Euro, f für Eingabe einer
falschen Münze. m steht für eine Flasche Mineralwasser. m kann sowohl eingegeben werden
(durch den Betreiber) als auch ausgegeben werden (an den Kunden). Jedes Paar x, y in der
Tabelle besteht aus dem Eingabezeichen x und dem Ausgabezeichen y.
z0
m z1 , ε
e z0 , e
f z0 , f
z1
z2 , ε
z0 , m
z1 , f
z2
z3 , ε
z1 , m
z2 , f
z3
z4
z4 , ε
z2 , m z3 , m
z3 , f z4 , f
Das Zustandsdiagramm zu diesem Automaten sieht so aus:
f
z0
f
m
e
z1
f
m
e
z2
f
m
e
z3
f
m
e
z4
e
Dieser Automat akzeptiert alle Eingabesequenzen (Worte), die zum leeren Automaten (d.h. zu
z0 ) führen.
3.3
Formale Beschreibung von Automaten
Genau wie bei allen Programmiersprachen wird auch für endliche Automaten eine streng formale Beschreibung benötigt. Diese ist aber auch noch für theoretische Überlegungen in der Theorie
der formalen Sprachen notwendig ( ⇒ Theoretische Informatik, Master). Wir beginnen ganz
elementar:
k Definition 3.1 Ein Alphabet Σ ist eine endliche nicht leere Menge von Zeichen.
Sprachen sind noch einfacher als Lego-Baukästen. Es gibt genau vier Möglichkeiten, zwei Alphabetzeichen a und b miteinander zu verknüpfen, nämlich aa, ab, ba, oder bb. Diese Verknüpfung
heißt Konkatenation und ist nicht vertauschbar. Damit kann man beliebig lange endliche Worte
38
bauen, ähnlich wie bei den Legos.
Definition 3.2 Die Menge Σ∗ aller Worte ist wie folgt rekursiv definiert.
• Σ ⊂ Σ∗ und auch das leere Wort ε ist in Σ∗ enthalten.
• Für jedes Wort w ∈ Σ∗ und jedes Zeichen x ∈ Σ ist auch wx ∈ Σ∗ . wx ist die Zeichenkette,
die entsteht, wenn man das Zeichen x an das Wort w anhängt.
Jede Teilmenge von Σ∗ wird Sprache genannt.
Beispiel 3.3
Σ = {0, 1}
Σ∗ = {0, 1, ε, 00, 01, 10, 11, 001, 000, 011, 010, . . .}
Beispiel 3.4
Σ
Σ∗
T erme
T erme
=
=
=
⊂
{+, −, ·, /, (, ), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, x, y, a, b}
{. . . , ) + − · 567ax, . . .}
{x, y, a, b, (a), . . .}
Σ∗
Die Menge aller korrekten arithmetischen Terme ist eine kleine Teilmenge von Σ∗ . Ein Affe,
der zufällig auf einer entsprechenden Tastatur tippt würde viele Versuche benötigen, um einen
korrekten Term zu erzeugen.
Nun kennen wir einige reguläre Sprachen. Wir stellen uns die Frage ob es eine möglichst einfache
und effiziente Rechenmaschine gibt, mit der man für ein beliebiges Wort w entscheiden kann,
ob dieses zu einer vorgegebenen regulären Sprache gehört.
Definition 3.3 Die Aufgabe, zu entscheiden, ob ein Wort w zu einer Sprache L gehört, heißt
Wortproblem.
Grammatik
erzeugt
erkennt
−→
Sprache
←−
Automat
Das Wortproblem für reguläre Sprachen kann durch endliche Automaten effizient gelöst
werden.
39
Formal wird der Automat wie folgt definiert:
Definition 3.4 Ein endlicher Automat M besteht aus einem 5-, bzw. 7-Tupel
M = (Z, Σ, δ, z0 , E)
bzw.
M = (Z, Σ, δ, z0 , E, γ, Θ)
mit
Z : endliche Zustandsmenge
Σ : endliches Eingabealphabet, Σ ∩ Z = φ
δ : Z × Σ → P(Z), die Zustandsübergangsfunktion
z0 : Startzustand
E : Menge der Endzustände
γ : Z × Σ → Θ, die Ausgabefunktion
Θ : Ausgabealphabet
Definition 3.5 Ein Wort w = w1 . . . wn mit wi ∈ Σ wird akzeptiert von dem endlichen
Automaten M genau dann wenn M gestartet im Startzustand auf w1 nach n Anwendungen
der Funktion δ, d.h. nach Lesen von wn , einen Endzustand z ∈ Σ erreichen kann.
Die von M akzeptierte (erkannte) Sprache L(M ) ist
L(M ) = {w ∈ Σ∗ | M akzeptiert w}
Beispiel 3.5 Der Automat aus Beispiel 3.1 wird beschrieben durch das 5-Tupel
M = ({S, T, e}, {a, b}, δ, S, {e})
mit
δ = {S, a → S; S, a → T ; T, b → T ; T, b → e}.
Beispiel 3.6 Der Getränkeautomat aus Beispiel 3.2 wird beschrieben durch das 7-Tupel
({z0 , z1 , z2 , z3 , z4 }, {e, f, m}, δ, z0 , {z0 }, γ, {e, f, m})
wobei δ und γ gegeben sind durch die angegebene Automatentabelle.
Definition 3.6 Beim nichtdeterministischen endlichen Automaten (NFA) sind (im Gegen
satz zum deterministischen endlichen Automaten (DFA)) für jeden Zustand Z und Eingabe
zeichen a mehrere Regeln
z, a → z1
..
.
z, a → zn
erlaubt.
Satz 3.1 NFAs und DFAs sind gleich mächtig, d.h. zu jedem NFA gibt es einen DFA, der die
gleiche Sprache erkennt.
40
Kapitel 4
Sortieralgorithmen
4.1
Sortieren durch Einfügen
Beispiel 4.1 7 4 8 3 5 1
4 7 8 3 5 1
4 7 8 3 5 1
3 4 7 8 5 1
3 4 5 7 8 1
1 3 4 5 7 8
Definition 4.1 Eine Liste A = (A1 , . . . , An ) heisst sortiert, wenn für alle
i = 1, . . . , n − 1 gilt Ai ≤ Ai+1 .
4.1.1
Algorithmus (grob)
Von links nach rechts: eine Zahl x wählen und verschieben nach links bis Ai−1 ≤ Ai = x ≤ Ai+1
erfüllt ist.
For i:= 2 To n Do
x:= a[i];
"füge x am richtigen Platz ein"
4.1.2
Algorithmus als PASCAL-Programm
Program sortieren(input,output);
CONST n = 8000;
TYPE
index = 0..n;
item = RECORD
key : Integer;
data : String[20]
END;
itemarray = ARRAY [0..n] OF item;
VAR a : itemarray;
i,j : Index;
41
Procedure ins sort(var a : itemarray);
VAR
i,j : index;
x : item;
BEGIN
FOR i := 2 TO n DO
BEGIN
x := a[i]; a[0] := x; j := i-1;
WHILE x.key < a[j].key DO
BEGIN
a[j+1] := a[j];
j := j-1;
END;
a[j+1] := x
END
END;
Index i:
Liste A:
0
x
1
Rechenzeit
worst case (Tmin (n))
(n − 1) · (I + C)
best case (Tmax (n))
(n − 1) · (I + C)
(n
Pn− 1) · (3M + I)
i=2 i · C
(n − 1) · (3M + I)
(n − 1) · C
Pn
i · (M + I)
Pi=2
n
i=2 i · (M + 2I)
0
0
(n − 1) · (I + M )
(n − 1) · (I + M )
i
a(i)
n
Durch kopieren von a(i) auf die Variable x und auf a(0) wird die Terminierung der Schleife
sichergestellt. Sollte die Zahl a(i) also kleiner als alle Elemente davor in der Liste sein und
ganz nach links verschoben werden müssen würde der Schleifenindex i ohne diese Terminierung einen negativen Wert annehmen. Da die Liste aber bei a(0) aufhört, würde dies zu einem
undefinierten Zustand führen. Diese Terminierung führt zu einem weiteren Schleifendurchlauf.
Dieser Durchlauf fällt aber nicht weiter ins Gewicht, da es sich um einen konstanten Aufwand
handelt. Dagegen wird im Vergleich zu einer zusätzlichen Bedingung im Kopf der While-Schleife
ein Aufwand proportional zu n eingespart.
4.1.3
Worst - Case Rechenzeit
Im Programmcode eingetragen ist für jede Programmzeile die Laufzeit. Als Parameter treten
rechnerabhängigen Größen I (Increment), M (Move) und C (Compare) auf:
I = Rechenzeit für eine Zähloperation
M = Rechenzeit für eine Zuweisungsoperation
C = Rechenzeit für eine Vergleichsoperation
Diese Zeiten sind konstant, d.h. nicht von n abhängig und deshalb für die Berechnung der
Komplexität unbedeutend. Für die Berechnung von exakten Laufzeiten sind sie jedoch sehr
wichtig.
Tmax (n) = (n − 1) · (I + C + 3M + I + M + I) +
n
X
(i · C + i · (M + 2I))
i=2
= (3I + 4M + C) · n − (3I + 4M + C) + (2I + M + C) ·
n
X
i=2
mit
n
X
i=2
i=
n2 + n − 2
n2 n
n(n + 1)
−1=
=
+ −1
2
2
2
2
42
i
erhalten wir
a
b
}|
{
z
}|
{
c
z
}|
{
C
3
M
9
Tmax (n) = (I +
+ ) ·n2 + (4I + M + C) ·n −(5I + 5M + 2C)
2
2
2
2
2
= a·n +b·n+c
z
Wenn die Konstanten nicht interessieren, kann die Berechnung der Worst-Case Rechenzeit
vereinfacht werden:
(n − 1) · (I + C)
(n − 1) · (3M + I)
n
X
i·C
→
→
→
(n − 1) · c1
(n − 1) · c2
2
X
(
i) · c3
i=2
i=2
..
.
..
.
..
.
Ergebnis: a · n2 + b · n + c
Bestimmung von a, b und c
1.) Messe drei Zeiten für verschiedene n = n1 , n2 , n3
−→ (n1 , T1 ), (n2 , T2 ), (n3 , T3 )
T(n)
T3
T2
T1
n1
n2
n3
n
2.) Einsetzen in Parabelgleichung:
T1 = a · n21 + b · n1 + c
T2 = a · n22 + b · n2 + c
T3 = a · n23 + b · n3 + c
3.) Auflösen des linearen Gleichungssystems nach a, b und c (siehe Übung 5).
Beispiel 4.2 Vergleich von 3 verschiedenen Komplexitäten
n
10
100
1000
Algorithmus 1
T (n) = log n · c
1s
2s
3s
Algorithmus 2 Algorithmus 3
T (n) = c · n
T (n) = c · n2
10 s
100 s
100 s
10 000 s
1000 s
1 000 000 s
Algorithmus 4
T (n) = c · n3
1 000 s
1 000 000 s
1 000 000 000 s
Algorithmus 5
T (n) = c · 2n
1024 s
≈ 1030 s
≈ 10300 s
Die Werte wurden mit einem c von einer Sekunde errechnet. Eine bessere Hardware würde nur
dieses c verbessern und dadurch die Rechenzeit nicht wesentlich beeinflussen. Bei großen n ist
die Komplexität viel ausschlaggebender als die Konstante c.
43
4.1.4
Best-Case Rechenzeit
Ist die Liste A vorsortiert, so wird die While-Schleife nicht durchlaufen und das Programm ist
viel schneller.
Analog zu den Berechnungen im Worst-Case kann man auch im Best-Case die Zeiten aus der
Tabelle aufaddieren und man erhält
Tmin (n) = d · n + e.
4.1.5
Einschub: Asymptotik
Beschreibung des asymptotischen Verhaltens von Rechenzeiten T (n) (oder Speicherplatz oder
anderer Funktionen) für n → ∞.
Idee: Vernachlässigung von konstanten Faktoren. Nur die Abhängigkeit von n für große n ist
wichtig.
Definition 4.2 Seien die Funktionen f : N → R+ , g : N → R+ gegeben. Dann schreibt man:
Asymptotische obere Schranke:
f (n)
f (n) = O(g(n))
⇔ ∃ c ∈ R+ : lim
≤c
n→∞ g(n)
f (n)
f (n) = o(g(n))
⇔
lim
=0
n→∞
g(n)
Asymptotische untere Schranke:
f (n)
≥c
f (n) = Ω(g(n))
⇔ ∃ c ∈ R+ : lim
n→∞ g(n)
f (n)
f (n) = ω(g(n))
⇔
lim
=∞
n→∞
g(n)
Asymptotische enge (harte) Schranke:
f (n)
+
≤ c2
f
(n)
=
Θ(g(n))
⇔
∃
c
,
c
∈
R
:
c
≤
lim
1
2
1
n→∞ g(n)
O, Ω, Θ, o, ω sind Relationen auf Funktionen, wie z.B. <, ≤ auf reellen Zahlen.
Analogien:
Funktionen f : N → R+
f (n) = O(g(n))
f (n) = o(g(n))
f (n) = Ω(g(n))
f (n) = ω(g(n))
f (n) = Θ(g(n))
reelle Zahlen
a≤b
a<b
a≥b
a>b
a=b
Satz 4.1
T (n) = Θ(g(n))
⇔
T (n) = Ω(g(n)) und T (n) = O(g(n))
44
Die bisher berechneten Ergebnisse lassen sich nun also formulieren wie folgt:
Satz 4.2 Beim Sortieren durch Einfügen gilt
Tmin (n)
Tmax (n)
T (n)
T (n)
4.1.6
=
=
=
=
Θ(n)
Θ(n2 )
Ω(n)
O(n2 )
Schwachstellen und mögliche Verbesserungen
x
Die Suche nach der Einfügestelle für das Element x soll verbessert werden.
Suche in Listen
Aufgabe 1: Suche ein Element x in einer beliebigen Liste.
optimale Lösung: lineare Suche mit Tmax (n) = Θ(n)
Aufgabe 2: Suche ein Element x in einer sortierten Liste A[1 . . . n]
optimale Lösung: Bisektion
Der Bereich links von x ist bereits sortiert. Man findet die richtige Stelle für x indem man die
Liste links von x mehrfach halbiert.
Definition 4.3 bxc := max{y ∈ Z|y ≤ x}. bxc ist also die größte ganze Zahl kleiner oder
gleich x. Analog sei dxe = min{y ∈ Z|y ≥ x}.
Der Bisektionsalgorithmus
a = 1
b = n
m = b a+b
c
2
while A[m] 6= x & b > a
If x < A[m]
Then b = m
Else a = m
m = b a+b
c
2
If A[m] == x
Then print (’’Hurra ’’,x,’’gefunden an position ’’,m)
Else print (’’Schade, ’’,x,’’nicht in A’’)
45
Komplexität
Sei die Arraylänge n = 2k . Dann sind höchstens k Wiederholungen der While-Schleife erforderlich. Also ist die Rechenzeit proportional zu k, d.h. T (n) = c · k.
n = 2k
lnn = k · ln 2
ln n
k =
ln 2
Also gilt für die Bisektion
T (n) = c ·
ln n
= c · log2 n = O(log n)
ln 2
x
Erläuterung: An log2 x = ln
= c · ln x ← log n, erkennt man, daß sich alle Logarithmen nur
ln 2
um einen kostanten Faktor unterscheiden.
Das Suchen der Einfügestelle ist mit logarithmischem Aufwand möglich.
Aber: verschieben der O(n) Arrayelemente im Array kostet linearen Aufwand.
Idee: verwende dynamische Datenstruktur als verkettete Liste.
x
Verschieben der Arrayelemente ist damit unnötig. x wird direkt an der richtigen Stelle eingefügt.
Aber: die Bisektion ist auf einer verketteten Liste nicht anwendbar.
Daher: für Sortieren durch Einfügen bleibt Tmax (n) = Θ(n2 )
4.2
Quicksort
Beispiel 4.3 Es soll die Liste 5, 3, 2, 6, 4, 1, 3, 7 sortiert werden. Dies erfolgt nach dem Prinzip
divide and conquer durch rekursiv wiederholtes Aufteilen und bearbeiten, wie in folgender
Tabelle zu sehen:
46
5
3
2
6
4
1
3
7
↑i
x = 5 (Pivotelement)
↑j
5
↑i
3
3
2
3
2
3
3
2
3
↑i
1
3 2
←→
3 2
↑i ↔↑j
2 3
3
↑j ↑i
2 3
3
↑i ↔↑j
2 3
3
↑j
↑i
2 3
3
↑i ↑j
2 3
3
1
1
↑i ↑j
1
1
1
6
4
←→
6
4
↑i ↔
1
4
↑j
1
4
↑j
3
4
1
3
↑j
5
7
7
4
1
↑j
6
5
↑i
6
5
↑i ↔↑j
5
6
↑j
↑i
5
6
↑i ↑j
5
6
4
5
6
7
4
5
6
7
4
5
6
7
4
7
7
x = 3, x = 6
7
7
7
Erläuterung: Der erste Wert der Liste ist das Pivotelement (ausgezeichnetes, besonderes Element). Zwei Indizes i und j durchlaufen die Liste nach folgendem Kriterium:
i sucht von links nach einem Wert ≥ x und j von rechts nach einem Wert ≤ x. Dann werden i
und j vertauscht. Das setzt sich solange fort bis sich beide Indizes überkreuzen oder gleich sind.
Dann wird die Liste rechts von j geteilt und auf beiden Hälften rekursiv von vorne begonnen.
4.2.1
Der Algorithmus
Seien A=Liste, p=Anfangsindex, r=Endeindex. Dann ist die rekursive Struktur gegeben durch:
Quicksort(A,p,r)
if p<r
then q=Partition (A,p,r)
Quicksort (A,p,q)
Quicksort (A,q+1,r)
Das Aufteilen erfolgt mittels
47
Partition (A,p,r)
x=A[p]
i=p-1
j=r+1
while TRUE do
repeat j=j-1
until A[j] ≤ x
repeat i=i+1
until A[i]≥ x
if i<j
then vertausche A[i] mit A[j]
else Return(j)
Der erste Aufruf von Quicksort auf einer Liste der Länge n erfolgt durch
Quicksort(A,1,length(A)).
4.2.2
Analyse
Laufzeit von Partition
auf Array A[p...r] mit n = r − p + 1
T (n) = Θ(n)
Laufzeit von Quicksort (Best Case)
n
n/2
n/2
n/4
111...
n/4
n/4
n/4
...111
Komplexität auf jeder Ebene ist Θ(n) =⇒ Komplexität gesamt: Θ(n · log2 n)
Zahl der Ebenen im Rekursionsbaum? Der Baum wächst in der Breite exponentiell:
n = 2k → k = Tiefe des Baumes
log2 n = log2 2k = k
Tmin (n) = c · n · log2 n = Θ(n log n)
48
Laufzeit von Quicksort (Worst Case, sortierte Liste)
1
2
3
4
5 6
7 8
↑i
↑j
1
↑i ↑j
1
1
2
3
4
5 6
2
↑i ↑j
2
3
4
5
3
↑i ↑j
4
5 6
7 8
6 7
8
7 8
Rekursionsbaum
n
n
n
n-1
1
1
n-2
n-1
n
2
1
1
2
1
n
X
Tmax (n) = c2 · (
i + n)
i=2
n(n + 1)
− 1 + n)
2
n2 3
= c2 · ( + n − 1)
2
2
2
= Θ(n )
= c2 · (
Für die Rechenzeit T(n) gilt:
c1 · n log n ≤ T (n) ≤ c2 · n2
Idee zur Verhinderung des Worst Case: Liste vorher zufällig permutieren.
Begründung: Die Wahrscheinlichkeit für das Erzeugen einer sortierten Liste ist sehr klein.
falls nur 10 Zahlen erlaubt sind.
Allgemeine Wahrscheinlichkeit: M1n für M unterschiedliche zu sortierende Werte.
Beispiel 4.4 32 Bit Integer Zahlen: M = 232 , n = 106 ,
1
Mn
=
1
(232 )106
=
1
10n
1
232·106
Folgerung: Die Wahrscheinlichkeit, dass ein randomisiertes Quicksort den Worst-Case trifft
ist sehr klein. Aber die zufällige Permutation der Liste vor dem Sortieren kostet Rechenzeit.
Daher:
49
Zufällige Wahl des Pivotelements
ersetze x = A[p] durch x = A[random (p,r)]
Average-Case-Analyse: Berechnung der mittleren Laufzeit des Algorithmus z.B. Quicksort
auf einer repräsentativen Menge von Eingaben.
Beispiel 4.5 Die Average-Case-Analyse für Quicksort ist sehr schwierig. Daher wird hier der
ungünstige Fall eines konstanten Aufteilungsverhältnisses 1 : n am Beispiel 1 : 9 behandelt.
n
9n/10
1n/10
81n/100
9n/100
9n/100
1n/100
729n 81n
1000 1000
81n
9n
1000 1000
81n
9n
1000 1000
9n
1n
1000 1000
9 dl
( 10
) ·n=1
1 dr
( 10
) ·n=1
9
+ log n = 0
10
log n
dl =
log 10
9
dl · log
T (n) <
Tiefe k =
log n
log 10
9
c
· n log n
log 10
9
≈ 21, 8 · log10 n
Aufwand auf jeder Ebene ≤ n ⇒
im Best-Case auch n · log n ist, gilt:
T (n) = O(n · log n). Da die komplexität von Quicksort
Satz 4.3 Quicksort besitzt im Average-Case die Komplexität T (n) = Θ(n · log n)
Bemerkung: Der Worst-Case tritt bei Quicksort sehr selten auf. Er kommt bei vorsortierten
Listen vor, diese sind in der Praxis allerdings häufig.
Verbesserung: zufällige Wahl des Pivot-Elements, d.h. Ersetzung von Partition (A,p,r) durch:
Random-Partition (A,p,r)
i=Random (p,r)
vertausche A[p] mit A[i]
return Partition (A,p,r)
Random (p,r) liefert zufällig mit konstanter Wahrscheinlichkeit eine Zahl aus {p, p+1, . . . ,r}.
Bemerkung: Durch Randomisierung gibt es keine Eingabe mehr, für die der Algorithmus
immer Worst-Case Verhalten zeigt.
50
4.3
Sortieren mit Bäumen (Heapsort)
Beispiel 4.6
1
16
i:
A[i] :
2
14
3
10
4
8
5
7
6
9
7
3
8
2
9
4
10
1
Darstellung von A als Baum:
1
16
14
2
10
4
8
2 8
7
4 9
5
9
3
6
3
7
1 10
Keine neue Datenstruktur nötig, sondern nur Funktionen parent, left, right mit den Eigenschaften
parent(i) = b 2i c
left(i) = 2i
right(i) = 2i + 1
(Vorgänger)
(linker Nachfolger)
(rechter Nachfolger)
Definition 4.4 Ein Array mit den Funktionen left, right, parent heisst heap, wenn gilt
A[parent(i)] ≥ A[i]
Definition 4.5 Die Höhe eines Knotens i in einem Baum ist gleich der Zahl der Knoten
im längsten Pfad von i zu einem Blattknoten. Die Höhe des Baumes ist gleich der Höhe
des Wurzelknotens.
Der folgende Algorithmus verwandelt einen Binärbaum in einen Heap unter der Voraussetzung,
dass beide Unterbäume schon Heaps sind.
Heapify(A,i)
vertausche A[i] mit seinem größten Nachfolger
A[largest] falls A[largest] > A[i]
heapify (A,largest)
Beispiel 4.7
1
16 3
10 2
4 4
14 5
7 8 9 10
2 8 1 1
16 1
16 6 7
9 3 3
10 2
14 4
4 5
7 6 7
9 3 3
10 2
14 4
8 5
7 8 9 10
2 4 1 8 9 10
2 8 1 51
6 7
9 3 Der Algorithmus
Heapify(A,i)
l = Left(i)
r = Right(i)
if l ≤ heapsize(A) AND A[l] > A[i]
then largest = l
else largest = i
if r ≤ heapsize(A) AND A[r] > A[largest]
then largest = r
if largest 6= i
then vertausche A[i] mit A[largest]
Heapify(A, largest)
Laufzeit von heapify
Vergleich von A[i] mit A[lef t(i)] und A[right(i)]: konstante Zeit= Θ(1)
Rekursion
maximale Zahl von Knoten in einem der Unterbäume left(i), right(i) = 23 n, wenn n = Zahl der
Unterknoten in i.
Rekurrenzrelation
2
T (n) ≤ T ( n) + Θ(1)
3
Das Auflösen der Rekurrenzrelation erfolgt mit Hilfe des Mastertheorems:
Satz 4.4 (Mastertheorem) Seien a ≥ 1, b > 1 Konstanten und f : R+ → R+ , T : R+ → R+
Funtionen mit
T (n) = aT (n/b) + f (n)
wobei n/b für die ganzzahlige Division (bn/bc
beschränkt werden durch

Θ(nlogb a )
falls



logb a
Θ(n
log n) falls
T (n) =
Θ(f
(n))
falls



oder dn/be) steht. Dann kann T (n) asymptotisch
∃ε>0 : f (n) = O(nlogb a−ε )
f (n) = Θ(nlogb a )
∃ε>0 : f (n) = Ω(nlogb a+ε ) und
∃c<1 ∃n0 ∀n≥n0 : af (n/b) ≤ cf (n)
Für Heapsort gilt T (n) ≤ T ( 32 n) + Θ(1). Für den Worst Case gilt
n
Tmax (n) = 1 · T
+c
3/2
Für die Anwendung des Mastertheorems gilt dann also a = 1, b = 32 , f (n) = 1 sowie
nlogb a = n
log 3 1
2
=1
Es ist der zweite Fall anwendbar, denn f (n) = Θ(nlogb a ). Also gilt für heapify
Tmax (n) = Θ(1 · log n) = Θ(log n).
52
Beispiel 4.8 Anwendung des Master-Theorems auf Quicksort (Best Case):
T (n) = 2 T ( n2 ) + c · n
a = 2, b = 2, f (n) = c · n
nlogb a = nlog2 2 = n
f (n) = Θ(n)
⇒ 2. Fall: T (n) = Θ(n · log n)
Beispiel 4.9 wie oben, jedoch mit anderem f (n):
T (n) = 2T ( n2 ) + c · log n
a = 2, b = 2, f (n) = c · log n
nlogb a = n
f (n) = c · log n = O(n(1−ε) )
⇒ 1. Fall: T (n) = Θ(n)
4.3.1
Erzeugen eines Heap
Build-Heap(A)
length(A)
c downto 1
for i = b
2
do heapify(A,i)
Beispiel
4.10
1
4 1
4 2
1 4
2 3
3 5 6 7
16
9 10 2
1 4
14 1
4 4
14 8 9 10
2 8 1 2
1 5 6 7
16
9 10 4
14 6 7
9 3 2
14 4
8 3
10 5
7 6 7
9 3 8 9 10
2 4 1 Analyse
obere Schranke
Jeder der Θ(n) Aufrufe von heapify kostet O(log n) Zeit. Also gilt
=⇒ T (n) = O(n log n).
53
3
10 5 6 7
16
9 3 8 9 10
2 8 7 1
16 3
10 5
7 3
3 8 9 10
2 8 7 8 9 10
14
8 7 2
16 1
4 bessere Schranke
Die Laufzeit von heapify hängt von der Höhe des Knotens im Baum ab. Die meisten Knoten
haben sehr niedrige Höhe!
(Zahl der Knoten auf Höhe h) ≤ d
n
2h+1
e
Die Laufzeit von heapify für Knoten der Höhe h wächst linear mit h. Also Theapif y (h) = O(h) =
O(log(Anzahl Knoten im Unterbaum))


blog nc
blog nc l
m
X
X
h
n
· O(h) = On
= O(2n) = O(n)
T (n) ≤
h+1
2
2h
h=0
h=0
Die vorletzte Gleichung gilt weil
∞
1
X
h
2
=
1 2 = 2,
h
2
)
(1
−
2
h=0
was man in der Formelsammlung findet.
4.3.2
Der Heapsort - Algorithmus
Voraussetzung: Build-Heap setzt maximales Element an die Wurzel, d.h. in A[1]
Idee
Wiederhole folgende Schritte bis der Heap nur noch aus einem Element besteht: 1.) vertausche
A[1] mit A[n]
2.) lösche A[n] aus dem Heap
3.) Heapify (A,1)
Beispiel 4.11
14
8
4
2 8
10
2
10
4
7
1 9
1
5
9
3
6
8
3
7
16 10
4
2 8
i
4
10 8
5
1
2
4
10 8
4
14 9
3
1
3
6
8
3
7
16 10
6
9
7
10 8
10 8
16 10
5
4
2
14 9
8
6
3
1
9
7
4
10 8
4
3
7
14 9
5
1
3
6
2
7
16 10
4
14 9
4
3
i
5
8
3
6
2
9
7
16 10
8
16 10
5
6
3
2
9
7
4
4
14 9
8
3
6
9
7
16 10
1
i
10 8
54
7
i
3
5
3
i
4
14 9
1
2
1
2
7
1
10 8
2
1
2
1
2
1
2
7
1
4
1
i
4
i
16 10
3
i
5
7
3
2
14 9
7
1
2
4
9
i
8
7
9
2
4
14 9
1
1
2
3
7
16 10
5
8
6
3
9
7
Algorithmus
Heapsort(A)
Build-Heap(A)
for i= length(A) downto 2
do vertausche A[1] mit A[n]
heapsize(A)= heapsize(A)-1
Heapify(A,1)
Analyse
Build-Heap: T (n) = O(n)
for-Schleife: (n − 1) mal Heapify mit T (n) = O(log n) und Vertauschen mit O(1)
T (n) ≤ c1 · n + (n − 1) · [c2 · log n + c3 ]
= c2 · n log n + (c1 + c3 ) · n − c2 log n − c3
{z
}
|
vernachlässigbar für n → ∞
= O(n log n)
4.3.3
Priority-Queues als Anwendung der Heap-Struktur
Bei der Verwaltung von Warteschlangen mit Aufträgen unterschiedlicher Priorität muß als
jeweils nächster Auftrag immer ein Auftrag mit höchster Priorität ausgewählt werden. Dies
kann zum Beispiel erreicht werden, indem man die Aufträge in einer sortierten Liste speichert.
Allerdings ist dann die Komplexität zum Speichern der Aufträge in der Liste linear in der Länge
n.
Verwendet man dagegen einen Heap zur Verwaltung der Warteschlangen von Aufträgen, so ist
die Komplexität zum speichern und holen von Aufträgen im Heap logarithmisch in n.
Beispiel 4.12 Einfügen eines Elements x im Heap
Idee
1.) neues Blatt erzeugen
2.) Pfad vom Blatt zur Wurzel durchsuchen und x an der richtigen Stelle einfügen.
Algorithmus
Heap-Insert(A, key)
heapsize(A) = heapsize(A)+1
i=heapsize(A)
while i>1 AND A[parent(i)] < key
do A[i] = A[parent(i)]
i=parent(i)
A[i]=key
Beispiel 4.13 Anwendung von Heap-Insert zum Einfügen des Elements X = 15
55
1
16 1
16 2
14 4
8 2
14 3
10 5
7 6 7
9 3 5
7 4
8 1
16 1
16 4
8 3
10 2
15 3
10 5
14 6 7
9 3 8 9 10 11
2 4 1 X 8 9 10
2 4 1 2
X 3
10 5
14 4
8 6 7
9 3 6 7
9 3 8 9 10 11
2 4 1 7 8 9 10 11
2 4 1 7 Analyse
T (n) = O(log n).
4.4
Sortieren in linearer Zeit
Unter ganz bestimmten Bedingungen ist Sortieren sogar in linearer Zeit möglich, wie man an
folgendem Beispiel erkannt.
Idee
Wenn alle in der Liste A vorkommenden Sortierschlüssel aus einer bekannten endlichen Menge
sind, kann man durch einfaches Abzählen der Häufigkeiten aller in A vorkommenden Elemente
eine Tabelle S der Häufigkeiten erstellen. Danach wird die Liste A überschrieben mit den
Elementen in der richtigen Reihenfolge (siehe Beispiel).
Beispiel 4.14 Zu sortieren sei A = (2, 1, 4, 5, 4, 7, 3, 1, 4, 4, 1). Als Häufigkeitstabelle S erhält
man
Sortierschlüssel 1
Häufigkeit 3
2 3
1 1
4 5
4 1
6
0
7
1
Daraus erhält man einfach die sortierte Liste A = (1, 1, 1, 2, 3, 4, 4, 4, 4, 5, 7).
Komplexität
Mit m = |S| entsteht beim Abzählen ein linearer Aufwand und beim Zurückschreiben auch und
man erhält
T (n) = c1 · n + c2 · m + c3 · n
= Θ(n + m)
56
Dieser Algorithmus ist besonders interessant, wenn die Zahl m der verwendeten Sortierschlüssel
klein ist, zum Beispiel beim Sortieren einer großen Adressdatei nach Postleitzahlen.
Das hier verwendete Verfahren setzt voraus, dass die Menge der verwendeten Schlüssel bekannt
ist. Daher ist der aufwändige Vergleichen der Sortierschlüssel nicht nötig. Ist diese Voraussetzung jedoch nicht erfüllt und auch sonst kein Zusatzwissen über die zu sortierenden Daten
vorhanden, so ist Sortieren in linearer Zeit nicht möglich und man kann für die Komplexität
folgende untere Schranke angeben:
Satz 4.5 Wenn ein Sortieralgorithmus für beliebige Listen nur mit Vergleichen und Kopieren
arbeitet und keine Zusatzinformation über die Liste erhält, dann gilt:
T (n) = Ω(n log n)
57
Kapitel 5
Algorithmen auf Graphen
5.1
Einführung
Graphen werden immer dann verwendet, wenn man eine Menge von Objekten und Relationen
zwischen diesen Objekten darstellen und/oder untersuchen will. Verkehrsnetze werden z.B. oft
als Graph modelliert:
Bay
F
N
Ma
Ka
Reg
Ul
S
Pa
Li
M
Rv
Ba
Ros
Sal
Z
Be
Inn
Definition 5.1 Ein gerichteter Graph ist ein Paar G = (V, E), bestehend aus einer endlichen Knotenmenge V (engl. vertex) und einer zweistelligen Relation E ⊆ V ×V . Die Elemente
von E werden Kanten (engl. edge) genannt.
G0 = (V 0 , E 0 ) ist ein Teilgraph von G = (V, E), wenn V 0 ⊆ V und E 0 ⊆ E.
Beispiel 5.1 folgendes sind Graphen:
•
V1 = Menge aller Städte in Süddeutschland
E1 = {(x, y) ∈ V1 × V1 |es gibt eine direkte Straßenverbindung von x nach y}
•
V2 = Menge der Einwohner von Ravensburg
E2 = {(x, y) ∈ V2 × V2 |x kennt y}
•
V3 = Menge der Einwohner von Ravensburg
E3 = {(x, y) ∈ V3 × V3 |x ist verheiratet mit y}
G3 = (V3 , E3 ) ist Teilgraph von G2 = (V2 , E2 )
Zur graphischen Darstellung von Graphen werden Knoten durch Punkte und jede Kante (x, y)
durch einen Pfeil von x nach y dargestellt.
58
Beispiel 5.2
c
V = { a, b, c, d, e, f, g, h }
E = { (a, d), (d, a), (a, b),
(b, c), (c, a), (b, e),
(a, e), (f, g), (f, f ) }
h
b
d
f
a
g
e
Definition 5.2 Falls für jede Kante e = (x, y) ∈ E eines Graphen G = (V, E) auch die Kante
e = (y, x) ∈ E ist, so heißt G ungerichteter Graph. Alle anderen Graphen sind gerichtet.
Beim Zeichnen von ungerichteten Graphen wird für jedes verbundene Knotenpaar nur eine
Linie ohne Pfeile gezeichnet.
Beispiel 5.3 G = (V, E) mit V = Menge von Städten in Süddeutschland,
E = {(x, y) ∈ V1 × V1 | es gibt eine direkte Straße von x nach y (keine Einbahnstraße!)}
Definition 5.3
• Sei G = (V, E) ein Graph. Ein Pfad (oder Weg) von Knoten x ∈ V nach y ∈ V ist eine
Folge (x = a0 , . . . , a` ) von Knoten mit (ai , ai+1 ) ∈ E. ` ist die Länge des Weges von x
nach y.
• In einem einfachen Pfad kommt jeder Knoten höchstens einmal vor.
• Ein Pfad der Länge ` ≥ 1 von x nach x heißt Kreis.
• Ein Kreis, in dem kein Knoten mehr als einmal vorkommt, heißt Zyklus.
• Ein gerichteter Graph G = (V, E) heißt zyklenfrei oder gerichteter azyklischer Graph
(engl. directed acyclic graph (DAG)), wenn er keine Zyklen enthält.
• (x, x) und (x, y, x) heißen triviale Zyklen. Ein ungerichteter Graph ist zyklenfrei, wenn
es zwischen jedem Paar von Knoten (x, y) höchstens einen Pfad (ohne triviale Zyklen) gibt.
• Die Zahl der Kanten, die von einem Knoten v ausgehen oder in ihm enden heißt Grad des
Knotens. Er wird mit deg(v) bezeichnet.
Beispiel 5.4 Für den Graphen aus Beispiel 5.2 gilt:
• (b, c, a, d, a) ist ein Pfad von b nach a.
• (c, a, b, e) ist ein einfacher Pfad von c nach e.
c
• (f, f, f, g) ist ein Pfad.
f
a
• Er enthält u.a. den Kreis (a, b, c, a, d, a).
• ({a, b, c, e}, {(a, b), (b, c), (b, e), (a, e)}) ist ein azyklischer Teilgraph von G.
• deg(a) = 5, deg(b) = deg(f ) = 3, deg(h) = 0.
59
h
b
• (a, b, c, a) und (a, d, a) und (f, f ) sind die einzigen Zyklen.
d
e
g
Definition 5.4
• Ein ungerichteter Graph G heißt zusammenhängend, wenn es zwischen je zwei beliebigen
Knoten einen Weg gibt.
• Ein zusammenhängender zyklenfreier Graph ist ein Baum.
• Eine Gruppe paarweise nicht zusammenhängender Bäume heißt Wald.
• Ein Kreis heißt Eulerkreis, wenn er jede Kante des Graphen genau einmal durchläuft.
5.2
Eulerkreise
Beispiel 5.5 Die Stadt Königsberg (heute Kaliningrad, Rußland) hatte folgenden Verlauf des
Flusses Pregel mit sieben Brücken. Leonhard Euler fragte sich 1736, ob es einen Rundweg durch
die Stadt gibt, auf dem jede Brücke genau einmal überquert wird. Der zugehörige Graph ist
rechts angegeben.
C
A
D
B
Satz 5.1 Ein ungerichteter zusammenhängender Graph enthält genau dann einen Eulerkreis
wenn der Grad jedes Knotens gerade ist.
Beweis: (Beweisskizze) “⇒”: Wird ein Knoten besucht, so über eine ankommende und eine
abgehende Kante. Bei jedem Besuch eines Knoten auf dem Eulerkreis werden also zwei Kanten
“verbraucht”.
“⇐”: Sei G ein Graph in dem alle n Knoten geraden Grad haben. Weil der Graph zusammenhängend ist, muss der Grad aller Knoten mindestens 2 sein. Dann besitzt der Graph also
mindestens n Kanten und damit einen Zyklus.
Nun konstruieren wir einen Eulerkreis mit folgendem Algorithmus: Wir starten bei einem Knoten und traversieren den Graphen so lange bis ein Knoten vorkommt, der schon besucht wurde.
Nun ist ein Kreis C gefunden. Alle Kanten von C werden nun gelöscht. Im verbleibenden Graphen wird dieses Verfahren fortgesetzt, bis alle Kanten besucht sind. Nun ist der Graph in
disjunkte Zyklen zerlegt. Diese lassen sich leicht zu einem Eulerkreis verbinden. Haben zwei
Kreise einen Knoten gemeinsam, so starten wir auf einem Kreis bis wir einen gemeinsamen
Knoten V finden, verfolgen dann den zweiten Kreis von V bis wieder zu V und traversieren
dann den Rest des ersten Kreises. Wir haben nun einen Kreis der beide Kreise zu einem neuen
verbindet. Dieses Verfahren wird rekursiv fortgesetzt, bis alle alle Zyklen zu einem Eulerkreis
verbunden sind (siehe Abbildung).
2
60
Der im Beweis skizzierte Algorithmus arbeitet in linearer Zeit. Das heißt, bei einem Graphen
mit geradem Grad und m Knoten gilt für die Rechenzeit T (m) = Θ(m).
5.3
Datenstrukturen für Graphen
5.3.1
Rv
Ul
M
S
Ka
Z
Ba
Be
F
Ma
N
Adjazenzmatrix
Rv Ul M S Ka Z Ba Be F Ma N
x x x
x x
x
x x
x
x x
x
x x
x
x x x
x
x
x
x
x x
x
x x
x
x x
x
x x
x x
x
x
x x x
x x
F
N
Ma
Ka
Ul
S
M
Rv
Ba
Z
Be
Die Matrix ist symmetrisch. Warum?
5.3.2
Adjazenzlisten
a
b
c
d
e 0
f
g 0
h 0
b
c
a 0
a 0
e
e 0
f
g 0
d 0
c
f
a
h
b
d
61
e
g
5.3.3
Liste von Adjazenzlisten
a
b
e
b
c
e 0
c
a 0
d 0
c
d
a 0
f
a
f
h
b
e 0
f
d
g 0
e
g
g 0
h 0
0
5.3.4
Vergleich der drei Datenstrukturen
Adjazenzmatrix
Adjazenzlisten
Liste von Adjazenzlisten
Vorteile
Berechnung der Inzidenz mit
O(1)
Speicherplatz = O(n + m)
Nachteile
Speicherplatz und Initialisierung teuer, beide O(n2 )
Berechnung der Inzidenz mit
O(m)
Speicherplatz = O(n + Berechnung der Inzidenz
m), Knoten können einfach mit O(m), Knotensuche mit
gelöscht oder hinzugefügt O(n)
werden
n = Knotenzahl, m = Kantenzahl
5.4
Kürzeste Wege
Definition 5.5 Ein gewichteter Graph (auch bewerteter Graph) ist ein Tripel G =
(V, E, w), bestehend aus einem Graphen (V,E) zusammen mit einer Gewichtungsfunktion w : E → R+ , die jeder Kante eine relle Zahl zuordnet. Die Länge eines Weges
(x = a0 , . . . , a` ) ist
`−1
X
w(ai , ai+1 ).
i=0
62
Beispiel 5.6 Entfernungstabelle einiger süddeutscher Städte
RV Ul M S Ka
Rv 0 86 178 195 –
Ul
0 123 107 –
M
0
– –
S
0 64
Ka
0
Z
Ba
Be
F
Ma
N
Z
91
–
–
–
–
0
Ba Be F Ma
180 –
–
–
–
–
–
–
–
–
–
–
–
– 210 135
191 –
– 67
85 120 –
–
0 91 –
–
0
–
–
0 85
0
N
–
171
170
210
–
–
–
–
230
230
0
F
230
85
230
Ma
67 135
Ka
107
S
64
210
171
123
170
86
180
Be
Ul
195
191
Ba
N
210
85
91
120
Z
91
RV
178
M
Wegen der Symmetrie kann die untere Dreiecksmatrix weggelassen werden.
Definition 5.6 Ein Baum T = (V, E 0 ), der alle Knoten V eines Graphen G = (V, E) enthält,
heißt minimal aufspannender Baum, wenn die Summe aller Kantengewichte minimal ist,
d.h. wenn
X
E 0 = argminX⊂E
w(e).
e∈X
5.4.1
Der Kruskal-Algorithmus
Satz 5.2 (Kruskal-Algorithmus) Für einen ungerichteten, zusammenhängenden, bewerteten Graphen findet der folgende Algorithmus einen minimal aufspannenden Baum T :
1. Setze T = {}, i = 0
2. Sortiere die Kanten nach ihrem Gewicht.
3. Wähle aus den noch nicht gewählten Kanten die mit dem kleinsten Gewicht. Falls diese
Kante in T keinen Zyklus erzeugt, erweitere T um diese Kante. Wiederhole Schritt 3 bis
alle Kanten verbraucht sind.
Beispiel 5.7 Wir wenden nun den Kruskal-Algorithmus auf obiges Beispiel an und erhalten
folgenden minimal aufspannenden Baum:
63
F
230
85
230
Ma
210
67 135
Ka
210
171
123
195
191
170
86
180
Be
Ul
107
S
64
Ba
N
85
91
120
Z
91
RV
178
M
Satz 5.3 Die Laufzeit des Kruskal-Algorithmus ohne Sortieren für einen Graphen mit n Knoten
und m Kanten ist O(m + n log n). Mit optimierten Datenstrukturen ist (ohne Sortieren) sogar
eine fast lineare Komplexität erreichbar [9].
Definition 5.7 Gegeben sei ein bewerteter Graph G = (V, E, w).
• Beim Single Pair Shortest Path Problem (SPP) ist ein kürzester Weg von einem
Knoten a zu einem Knoten b gesucht.
• Beim Single Source Shortest Path Problem (SSP) sind kürzeste Wege von einem
Knoten a zu allen anderen Knoten b ∈ V gesucht.
• Beim All Pairs Shortest Path Problem (APSP) ist für jedes Paar von Knoten (a, b)
ein kürzester Weg gesucht.
5.4.2
Der Dijkstra-Algorithmus
Wir geben nun einen bekannten Algorithmus für das SSP an:
Satz 5.4 (Dijkstra-Algorithmus) Für einen bewerteten Graphen G = (V, E, w) und einen
gegebenen Knoten a findet der folgende Algorithmus einen aufspannenden Baum, der das SSPProblem für den Knoten a löst. Hierbei ist
δ(S) = {k ∈ V \S|k ist mit einem Knoten aus S direkt verbunden.}
Dijkstra(G,a)
Setze S = {}, F = {}
while S 6= V do
suche in δ(S) den Knoten v mit dem
kürzesten Pfad (a, . . . , u, v) von a zu v.
S = S ∪ {v}
F = F ∪ {(u, v)}
64
Beispiel 5.8 Dijkstra-Algorithmus mit a = Rv:
F
230
85
230
Ma
Ka
64
S
107
Be
91
Knoten in δ (S):
171
170
123
Kanten in F:
120
M
178
85
86
180
Ul
195
191
Ba
210
Knoten in S:
N
67 135 210
Z
91
RV = a
S
F
230
85
230
Ma
210
67 135
Ka
107
S
64
210
171
123
170
86
180
Be
Ul
195
191
Ba
N
85
91
120
Z
91
RV
178
M
Satz 5.5 Die Laufzeit des Dijkstra-Algorithmus O(m + Cn), wobei C eine Konstante ist, die
vom maximalen Kantengewicht abhängt [9].
5.4.3
Anwendungen
•
“Städteverbindungen” der Bahn
•
Routing im Internet: Router berechnet die beste Route zum nächsten Backbone-Knoten
über einen aufspannenden Baum, den er mit dem Dijkstra-Algorithmus erstellt.
Definition 5.8 Ein Hamilton-Kreis (hamiltonian circle) in einem Graphen G ist ein ge
schlossener Weg, in dem jeder Konten aus G genau einmal vorkommt. Eine Clique in einem
(ungerichteten) Graphen ist ein vollvernetzter Teilgraph.
5.5
Das Problem des Handlungsreisenden
(traveling salesman problem, TSP)
65
gegeben: Menge von Städten s1 , . . . , sn und eine Entfernungstabelle d mit dij = |si − sj | =
Entfernung zwischen Stadt i und Stadt j.
gesucht: Eine Permutation (Vertauschung) Π von (s1 , . . . , sn ), so dass
n−1
X
wΠ(i),Π(i+1) + wΠ(n),Π(1)
i=1
minimal ist. Es ist also eine Route gesucht, die jede Stadt genau einmal besucht und am Ende
wieder im Ausgangspunkt endet.
k Definition 5.9 Eine bijektive Abbildung einer Menge M auf sich selbst heißt Permutation.
Beispiel 5.9 Eine Permutation der Menge {1, . . . , 6}
i 1 2 3 4 5 6
Π(i) 4 2 1 3 5 6
5.5.1
Ein praktisches Ergebnis
TSP-Tour durch mehr als 15112 deutsche Städte:
66
David Applegate, Robert Bixby und William Cook von der Rice-Universität in Houston (Texas) sowie Vasek Chvatal von der
Rutgers-Universität in New Brunswick (New Jersey), 1998, siehe: www.tsp.gatech.edu
5.5.2
Der Nearest-Neighbour-Algorithmus
Idee
Starte in einem Knoten und wähle als nächsten immer den mit dem geringsten Abstand.
Algorithmus
NN TSP(D)
For i=1 To n Do
tour[i]=i
tour[n+1]=1
For i=2 To n-1 Do
next=argmin{D[i − 1, j]|j ∈ tour[i...n]}
vetimesrtausche tour[i] mit tour[next]
Return(tour)
67
Komplexität
T (n) = Θ(n2 )
5.5.3
Der Greedy - Algorithmus
Idee
“Greedy” heißt auf deutsch “gierig”. Dieses Attribut trifft auf den Algorithmus sehr gut zu,
denn er greift gierig immer nach der “besten” Kante ohne auf das Gesamtresultat zu schauen.
Algorithmus
• sortiere alle Kanten in der Liste K
• Sei (v, v 0 ) die Kante aus K mit kleinstem Gewicht. Falls deg(v) < 2 und deg(v 0 ) < 2 und
(v, v 0 ) schließt keinen Zyklus mit ≤ n Knoten, erweitere die Tour um (v, v 0 ) und lösche (v, v 0 )
aus K.
• Wiederhole 2. bis für alle v ∈ V deg(v) = 2.
Komplexität
T (n) = Θ(n2 log n)
Beispiel 5.10 Vergleich von 2 Heuristiken mit der optimalen Lösung an einem ganz einfachen
Beispiel:
a
6
1
b
3
f
5
4
e
a
c
2
d
3
Greedy Algorithmus
b
f
4
2
e
1
6
a
5
c
b
f
e
c
d
d
Nearest Neighbour (Start in d)
Beispiel 5.11 Vergleich von 3 Heuristiken mit der optimalen Lösung:
68
optimale Tour
5.5.4
Optimaler Algorithmus Optimal TSP
Idee
berechne für jede Tour
Pn
i=1
wtour[i],tour[i+1] und wähle eine Tour mit minimalem Wert.
Komplexität
ohne Beschränkung der Allgemeinheit ist die erste Stadt frei wählbar.
zweite Stadt: n − 1 Möglichkeiten
dritte n − 2 Möglichkeiten
...
n-te Stadt: eine Möglichkeit
T (n) = c · (n − 1)! = Θ((n − 1)!)
(n − 1)! = (n − 1)(n − 2) . . . 1 ≤ (n − 1)n−1
n! ≤ nn = n · n . . . n =⇒ T (n) = O(nn−1 )
69
5.5.5
Stirling’sche Formel
⇒
√
n
n! ≈ ( )n · 2Πn für n → ∞
e
√
n
T (n) = Θ(( )n−1 · n)
e
=⇒ überexponentielles Wachstum
Resultate
1.) Fachleute sind überzeugt, daß es keinen polynomiellen Alg. für TSP gibt!
2.) und dass es sogar für fast optimale Lösungen keinen polynomiellen Alg. gibt.
3.) für TSP mit Dreiecksungleichung gibt es einen fast optimalen Alg. mit T (n) = O(n2 )
Dreiecksungleichung:
∀i, j, k wij ≤ wik + wkj
i
Diese Gleichung besagt, dass die direkte Verbindung zwischen zwei Städten immer minimale
Länge hat. Sie gilt zum Beispiel für Luftlinienverbindungen zwischen Städten. Für die Entfernungen auf Straßen gilt sie jedoch nicht immer.
j
dij
djk
d
ik
k
Wachstum der Rechenzeit von Optimal TSP
Folgende Tabelle veranschaulicht das extrem schnelle Wachstum der Rechenzeit von Optimal TSP. Heute ist das TSP-Problem mit optimierten Algorithmen für etwa 30 Städte lösbar.
Wie man an der Tabelle erkennt, ist der Aufwand für 40 Städte etwa um den Faktor 1016 höher
und damit also unerreichbar.
n
10
20
30
40
50
5.5.6
(n-1)!
362880
121645100408832000
8841761993739701954543616000000
20397882081197443358640281739902897356800000000
608281864034267560872252163321295376887552831379210240000000000
(n-1)!
3.6 · 105
1.2 · 1017
8.8 · 1030
2.0 · 1046
6.1 · 1062
Die Minimum-Spanning-Tree-Heuristik
Definition 5.10 Ein Preorder-Tree-Walk traversiert einen Baum folgendermassen: Be
ginnend mit dem Wurzelknoten werden von links nach rechts rekursiv alle Nachfolgerknoten
besucht.
70
Beispiel 5.12 Angewendet auf den minimal aufspannenden Baum mit Wurzelknoten Bern
ergibt sich:
F
230
85
230
Ma
210
67 135
Ka
210
171
123
195
191
170
86
180
85
Z
91
Be
Ul
107
S
64
Ba
N
120
91
M
178
RV
Listet man nun alle besuchten Städte in der besuchten Reihenfolge und löscht alle Wiederholungen so ergibt sich ein einfacher Pfad, der alle Knoten besucht.
F
230
85
230
Ma
67 135
Ka
107
S
64
210
171
123
170
86
180
Be
Ul
195
191
Ba
N
210
85
91
120
Z
91
RV
178
M
Im Fall eines voll vernetzten Graphen läßt sich dieser Pfad durch eine Verbindung von Frankfurt
nach Bern zu einem Hamilton-Kreis schließen und man erhält eine Näherungslösung für das
TSP-Problem. Dieses heuristische Vorgehen nennt man die Minumum-Spanning-TreeHeuristik.
Ist der Graph nicht vollständig vernetzt, wie im Beispiel, so ist es durchaus möglich, dass es
keinen Hamilton-Kreis gibt.
Der minimal aufspannende Baum liefert jedoch auch hier einen guten Ausgangspunkt für eine
Näherung zur Lösung des TSP-Problems.
71
F
230
85
230
Ma
210
67 135
Ka
107
S
64
5.6
210
171
123
170
86
180
Be
Ul
195
191
Ba
N
85
91
120
Z
91
RV
178
M
Planare Graphen
Definition 5.11 Läßt sich ein Graph in der Ebene darstellen, ohne dass sich Kanten kreuzen,
so nennt man ihn planar. Die Menge der durch die Kanten begrenzten Flächenstücke wird
mit A bezeichnet.
Beispiel 5.13 Zwei planare Darstellungen des vollständigen Graphen mit vier Knoten:
Für diesen Graphen gilt |A| = 4.
Satz 5.6 (Eulerformel) Für jeden planaren zusammenhängenden Graphen G = (V, E) gilt
|V | − |E| + |A| = 2.
Beweis: Falls G ein Baum ist gilt |V | = |E| + 1 und |A| = 1 und es ergibt sich
|V | − |E| + |A| = |E| + 1 − |E| + 1 = 2.
Für den Fall, dass G kein Baum ist zeigen wir die Behauptung per Induktion über die Zahl der
Kanten n = |E|. Für n = 0 besteht der Baum aus einem Knoten, d.h. es gilt |V | = 1, |E| = 0,
|A| = 1 und die Formel stimmt.
Wir nehmen an, die Formel gilt für n > 0. Nun fügen wir eine Kante hinzu und erzeugen den
neuen Graphen G0 = (V 0 , E 0 ) mit |V 0 | = |V | und |E 0 | = |E| + 1. Die neue Kante schließt einen
Kreis und es gilt |A0 | = |A| + 1, woraus
|V 0 | − |E 0 | + |A0 | = |V | − (|E| + 1) + |A| + 1 = |V | − |E| + |A| = 2
2
folgt.
72
Kapitel 6
Übungen
6.1
Geschichte der Informatik
Aufgabe 1
Recherchieren Sie in Ihrer Lerngruppe über eine(n) berühmten Informatiker(in) und bereiten
Sie ein kurzes Referat vor. In der Übungsstunde tragen Sie darüber vor. Beachten Sie dabei
bitte folgendes:
• Versuchen Sie zu verstehen (und im Vortrag darzustellen), was die von Ihnen gewählte
Person erfunden/geleistet hat.
• Berichten Sie auch über die Persönlichkeit und das Privatleben.
• Versuchen Sie sich kurz zu halten, aber trotzdem das Wesentliche zu vermitteln.
• Arbeiten Sie mit Farbe, Anschauung, Bildern.
6.2
Endliche Automaten
Aufgabe 2
Konstruieren sie (deterministische oder nichtdeterministische) endliche Automaten für folgende
Sprachen:
a) Die Menge der Dezimalzahlen mit beliebig vielen Dezimalziffern vor dem Dezimalpunkt
und beliebig vielen (mindestens einer) Dezimalziffern nach dem Dezimalpunkt.
Aufgabe 3
Es soll eine Fußgängerampel mit Hilfe eines endlichen Automaten programmiert werden. Die
Ampel hat die zwei Zustände rot und grün (aus der Sicht des Fahrzeugs). Im Zustand rot
akzeptiert die Ampel Signale von der Kontaktschleife auf der Straße und schaltet dann auf
Grün. Im Zustand Grün akzeptiert die Ampel Signale vom Fußgängertaster und schaltet auf
Rot. Alle anderen Eingaben ignoriert der Automat.
a) Geben Sie einen endlichen Automaten für diese Aufgabe an.
b) Zeichnen Sie ein Zustandsdiagramm zu diesem Automaten.
c) Geben Sie einen regulären Ausdruck für diese Sprache an.
d) Geben Sie eine reguläre Grammatik für diesen Automaten an.
73
e) Zeigen Sie, dass diese Ampelschaltung bei geringem Verkehrsaufkommen das Mehrheitsprinzip exakt erfüllt, das heisst, das Verhältnis aus rot- zu grün-Zuständen ist gleich dem
Verhältnis aus Fußgängerzahl zu Autofahrerzahl.
Aufgabe 4
Es soll ein Getränkeautomat mit Hilfe eines endlichen Automaten programmiert werden. Der
Automat kann mit bis zu 4 Dosen Mineralwasser, 4 Dosen Limo und 4 Dosen Bier gefüllt
werden. Wenn eine 1-Euro-Münze eingegeben wird, soll er eine Dose des gewählten Getränks
ausgeben. Bei Eingabe einer anderen Münze soll er die eingegebene Münze wieder ausgeben,
aber kein Getränk. Wenn von einer Getränkesorte alle Dosen ausgegeben sind, soll er anhalten
und per Funk den Service benachrichtigen.
a) Geben Sie einen endlichen Automaten (mit Ausgabe) für diese Aufgabe an.
b) Zeichnen Sie ein Zustandsdiagramm zu diesem Automaten.
c) Geben Sie einen regulären Ausdruck für diese Sprache an.
d) Geben Sie eine reguläre Grammatik an, welche die für diesen Automaten erlaubte Eingabesprache akzeptiert.
6.3
Sortieren
Sortieren durch Einfügen
Aufgabe 5
a) Programmieren Sie “Sortieren durch Einfügen” in C für Integerzahlen - Arrays.
b) Testen Sie das Programm mit sortierten, zufälligen und umgekehrt sortierten Arrays auf
Korrektheit.
c) Bestimmen Sie für sortierte, zufällige und umgekehrt sortierte Arrays die Parameter a, b
und c von T (n) = a · n2 + b · n + c. Da in der Sprache C die Länge statischer Arrays auf
250000 beschränkt ist, sollten Sie mit dynamischen Arrays arbeiten. Das geht (mit C++)
z.B. so:
/* Deklaration Array */
int* a;
n = 300000000
/* Speicherplatz reservieren */
a = new int[n];
d) Bestimmen Sie die theoretische Rechenzeit für ein Array der Länge 5 · 109 .
e) Warum wird in der Praxis T (5 · 109 ) viel größer sein als oben errechneter Wert?
f ) Durch welche Massnahme kann man die berechnete Rechenzeit tatsächlich erreichen?
Quicksort
Aufgabe 6
Skizzieren Sie den Rekursionsbaum von Quicksort für ein konstantes Aufteilungsverhältnis von
1:k und leiten Sie aus diesem Baum T (n) = O(n lg n) ab.
74
Aufgabe 7
Programmieren Sie Quicksort für einfache Arrays von Integer-Zahlen, indem Sie die Funktion
Partition wie in der Vorlesung beschrieben implementieren. Zeigen Sie empirisch, daß für
zufällig sortierte Arrays Trand (n) = Θ(n lg n) und für vorsortierte Arrays Tmax (n) = Θ(n2 )
gilt.
Aufgabe 8
Beweisen Sie, daß für Sortieralgorithmen gilt Tmin (n) = Ω(n).
Aufgabe 9
Gegeben sei folgender Programmteil eines C-Programms:
for(i = 1; i <= n; i++)
for(j = 1; j <= n; j++)
for(k = 1; k <= j; k++)
z = z+1;
a) Berechnen Sie die Laufzeit T (n) und geben Sie die (asymptotische) Zeitkomplexität an.
b) Welchen Wert hat z nach Verlassen der äußersten Schleife für n = 100?
Aufgabe 10
Gegeben sei die rekursive Funktion fib:
fib(0) = 1
fib(1) = 1
fib(n) = fib(n − 1) + fib(n − 2) für n ≥ 2.
a) Berechnen Sie fib(5).
b) Zeichnen Sie den Rekursionsbaum für fib.
c) Bestimmen Sie anhand des Rekursionsbaumes die Komplexität von fib.
Heapsort
Aufgabe 11
Zeigen Sie, daß gilt
∞
X
k=0
kq k =
q
.
(1 − q)2
Tip: Entweder Sie schreiben die Reihe gliedweise in geeigneter Form und wenden dann die
Formel für die geometrische Reihe an, oder Sie starten indem Sie die Formel für die geometrische
Reihe differenzieren.
Aufgabe 12
Warum wird der Schleifenindex i in Zeile 2 von Build-Heap von blength[A]/2c bis 1 erniedrigt
und nicht von 1 bis blength[A]/2c erhöht?
75
Aufgabe 13
Stellen Sie den Ablauf von Build-Heap für A = (5, 3, 17, 10, 84, 19, 6, 22, 9) grafisch dar, ähnlich wie in Beispiel 4.10.
Aufgabe 14
Stellen Sie den Ablauf von Heapsort für A = (5, 13, 2, 25, 7, 17, 20, 8, 4) grafisch dar, ähnlich
wie in Beispiel 4.11.
Aufgabe 15
Benutzen Sie die Master-Methode zur Berechnung der Laufzeit der Suche durch Bisektion mit
der Rekurrenzgleichung T (n) = T (n/2) + Θ(1).
Aufgabe 16
Geben Sie mit Hilfe des Master-Theorems asymptotische Schranken für folgende Rekurrenzen
an:
a)
T (n) = 4T (n/2) + n
b)
T (n) = 4T (n/2) + n2
c)
T (n) = 4T (n/2) + n3 .
6.4
Graphen
Aufgabe 17
Zeigen Sie, dass jeder zyklenfreie ungerichtete Graph ein Wald ist.
Aufgabe 18
Zeigen Sie, dass in jedem Graphen G = (V, E) mit m Kanten
X
deg(v) = 2m
v∈V
gilt.
Aufgabe 19
Konstruieren Sie für den Graphen aus dem Beweis von Satz 5.6 einen Eulerkreis, indem Sie mit
anderen Zyklen beginnen.
Aufgabe 20
Geben Sie für den bewerteten Süddeutschlandgraphen die Adjazenzlisten und die Liste von
Adjazenzlisten an.
Aufgabe 21
Geben Sie für den Graphen aus Beispiel 5.2 Adjazenzmatrix an.
76
Aufgabe 22
Erzeugen Sie einen minimal aufspannenden Baum mit dem Algorithmus von Kruskal für den
SFBay-Graphen.
Aufgabe 23
Verwenden Sie den Algorithmus von Dijkstra für das Single-Source-Shortest-Path-Problem beim
SFBay-Graphen mit Start in Palo Alto.
Aufgabe 24
Gegeben ist folgende Entfernungstabelle deutscher Städte:
Br
Aachen
Basel
Berlin
Bremen
Dortmund
Dresden
Düsseldorf
545
650
370
155
645
90
Aachen
Do
875
775
555
745
550
Basel
Be
400
495
200
560
Berlin
Aa
235
490
285
Bremen
515
70
Dortmund
Dü
Dre
580
Dresden
Ba
a) Bestimmen Sie mit dem Greedy-Algorithmus eine Lösung für das TSP-Problem. Starten
Sie in Düsseldorf. Geben Sie die Tour sowie deren Länge an.
b) Bestimmen Sie einen Minimum Spanning Tree mit dem Kruskal-Algorithmus. Zeichnen
Sie diesen in die Landkarte (unten) ein.
c) Verwenden Sie die Minimum-Spanning-Tree-Heuristik mit Wurzelknoten Bremen zur Bestimmung einer Lösung des TSP-Problems. Zeichnen Sie die Lösung in die Karte ein und
geben Sie Tour sowie Länge an.
Aufgabe 25
Versuchen Sie, die Minimum-Spanning-Tree-Heuristik zur Lösung des TSP-Problems beim
SFBay-Graphen anzuwenden. Vergleichen Sie das Ergebnis mit dem des Greedy-Algorithmus
bei Start in San Franzisko oder anderen Städten. Warum treten hier Probleme auf?
Aufgabe 26
Bestimmen Sie eine optimale Tour für das TSP-Problem beim SFBay-Graphen.
Aufgabe 27
Für einen planaren (ebenen) ungerichteten Graphen sei A die Menge der durch die Kanten
des Graphen begrenzten Flächenstücke. Überprüfen Sie an allen bisher verwendeten Graphen
(V, E) die Gültigkeit der Euler-Formel
|V | − |E| + |A| = 2.
77
Problem des Handlungsreisenden
Aufgabe 28
Es soll ein Programm entworfen werden, das bei gegebener Abstandsmatrix für vollständig
vollständige Graphen eine optimale Tour findet.
a) Schreiben Sie ein Programm für Optimal TSP mit 4 Städten
b) Schreiben Sie ein Programm für Optimal TSP mit n Städten
78
Kapitel 7
Lösungen zu den Übungsaufgaben
7.1
Geschichte der Informatik
7.2
Endliche Automaten
Aufgabe 2
a) ({z0 , z1 , ze }, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, .}, δ, z0 , {ze }) wobei δ gegeben ist durch:
z0 , 0 → z0 z0 , 1 → z0 z0 , 2 → z0 ... z0 , 9 → z0
z0 , . → z1
z1 , 0 → ze z1 , 1 → ze z1 , 2 → ze ... z1 , 9 → ze
ze , 0 → ze ze , 1 → ze ze , 2 → ze ... ze , 9 → ze
Aufgabe 3
a) ({r, g}, {e, f, a}, δ, z0 , {z0 }) wobei δ gegeben ist durch:
r, f → r
r, a → g
g, f → r
r, f → r
b)
c) [ab]*
d) S → Sa, S → Sb, S → a, S → b
Aufgabe 4 Der Automat ist ähnlich dem Automat mit den Mineralwasserdosen auf Seite S.
64 im Script. Beim Automat in der Aufgabe sind es drei Getränksorten (Mineralwasser, Bier
und Limo). Dies würde dann ein Automat mit 53 (5 Zustände z0 bis z4 mit drei Sorten) werden.
Da der Automat aufwendig zu zeichnen ist und die Zustandstabelle recht gross wird, führt man
Indizes ein. Z.B. Si,j,k z.B. wobei i Mineralwasser, j Bier und k Limo ist.
79
7.3
Sortieren
Sortieren durch Einfügen
Aufgabe 5
a) Lösung des Programms
b) siehe Programm
c) Tabelle zur Ermittlung der Koeffizienten a,b,c über LGS aus Messungen
20
10
5
2
n absteigend aufsteigend
zufällig
000 80 960 ms
28 940 ms 54 870 ms
000 27 460 ms
14 440 ms 20 980 ms
7 200 ms 8 790 ms
000 10 490 ms
500
4 400 ms
3 570 ms 4 010 ms
absteigend (Worst Case):
c = 40
b=
7220−30
5000
a=
80960−40−28760
400000000
= 1, 438
= 1, 304 · 10−4
aufsteigend (Best Case):
c = −33, 3
b=
7205+25
5000
a=
28940−28920+12,5
400000000
= 1, 446
= 8, 125 · 10−8
zufällig (Average Case):
c = −230
b=
7262,5+172,5
5000
a=
54870−29740+230
400000000
= 1, 487
= 6, 34 · 10−5
d) Worst Case: 1, 30 · 10−4 · (5 · 109 )2 + 1, 438 · 5 · 109 + 40 = 3, 26 · 1015 ms ≈ 103374 Jahre
Best Case: 8, 125 · 10−8 · (5 · 109 )2 + 1, 446 · 5 · 109 − 33, 3̄ = 2, 04 · 2012 ms ≈ 65 Jahre
Zufällig: 6, 34 · 10−5 · (5 · 109 )2 + 1, 487 · 5 · 109 − 230 = 1, 59 · 1015 ms ≈ 50260 Jahre
e) In der Praxis wird der Wert viel größer wie der oben errechnete Wert, da es Hardwaregrenzen wie z.B. den Hauptspeicher gibt. Wenn dieser sein Maximum an Kapizität erreicht
hat, muß er Daten auf die Festplatte auslagern, dies kostet Zeit.
f ) Durch die Anpassung der Hardware. D.h. den Speicher ausreichend erweitern, und den
Adressbus vergrössern.
80
Quicksort
Aufgabe 6
n
kn
k+1
2
kn
2
(k + 1)
n
k+1
kn
2
(k + 1)
kn
n
2
2
(k + 1) (k + 1)
Tiefe der untersten Ebene:
dl
k
·n=1
k+1
Rechenaufwand pro Ebene ≤ n
k
dl · log k+1
+ log n = 0
dl =
log n
log k+1
k
wegen T (n) ≤ n · dl folgt T (n) = O(n · log n)
Aufgabe 7
Messungen:
n
2000000
4000000
6000000
8000000
10000000
15000000
20000000
40000000
80000000
T(n) [sec]
1.1
2.47
3.5
4.76
5.84
9.41
12.72
26.98
55.46
Für n → ∞ gilt T (n) = Cn ln n,
also C = T (n)/n ln n
Man erhält also die folgende Tabelle und schließt daraus C ≈ 3.810−8
sec, d.h. T (n) ≈ 3.810−8 n ln nsec.
n
2000000
4000000
6000000
8000000
10000000
15000000
20000000
40000000
80000000
T (n)/(n ln n) [sec]
3.79084 10−8
4.06202 10−8
3.73757 10−8
3.74333 10−8
3.62326 10−8
3.7966 10−8
3.78318 10−8
3.85332 10−8
3.80958 10−8
Aufgabe 8 Weil der Algorithmus auf jedes Element mindestens
einmal zugreifen muß, um zu überprüfen, ob es an der richtigen Stelle steht. Ansonsten ist nicht
garantiert, daß die gesamte Liste sortiert ist.
Aufgabe 9
a)
T (n) = n ·
n
X
j=1
j =n·
n(n + 1)
n
1
= (n2 + n) = (n3 + n2 ) = Θ(n3 )
2
2
2
b)
1 6
1
(10 + 104 ) = 1.01 · 106 = 0.505 · 106 = 505000
2
2
81
Aufgabe 10
a) fib(5) = 8
b)
c) Tiefe des Baumes: n, Zahl der Blätter: 2n
Zahl der Knoten auf Ebene k: 2k
Zahl der Knoten gesamt:
n−1
X
2k = 2n − 1
k=0
Heapsort
Aufgabe 11 Formel für geometrische Reihe:
∞
X
qk =
k=0
differenziert:
∞
X
k=0
1
1−q
∞
k·q
k−1
X
1
q
=
⇒
k · qk =
2
(1 − q)
(1 − q)2
k=0
Aufgabe 12 Heapify setzt voraus, dass die Unterbäume schon Heaps sind. Darum muß der
Baum von unten nach oben in einen Heap umgewandelt werden.
Aufgabe 13
tausche 22 mit 10
tausche 19 mit 17
tausche 3 mit 84
tausche 5 mit 84
tausche 5 mit 22
tausche 5 mit 10
82
Aufgabe 14
tausche 25 mit 13
tausche 20 mit 2
tausche 5 mit 25
tausche 5 mit 13
tausche 5 mit 8
tausche 25 mit 4
löse 25 aus Heap
tausche 4 mit 20
tausche 4 mit 17
tausche 20 mit 5
löse 20 aus Heap
tausche 17 mit 5
tausche 17 mit 2
löse 17 aus Heap
tausche 13 mit 2
tausche 8 mit 2
tausche 13 mit 4
löse 13 aus Heap
tausche 8 mit 4
tausche 7 mit 4
tausche 8 mit 4
löse 8 aus Heap
tausche 7 mit 4
tausche 7 mit 2
löse 7 aus Heap
tausche 5 mit 2
tausche 5 mit 2
löse 5, 4, 2 aus Heap
Aufgabe 15 f (n) = 1nlog2 1 = n0 = 1 ⇒ F all2 ⇒ T (n) = Θ(n0 · log n) = Θ(log n)
Aufgabe 16
a) f (n) = n
nlog2 4 = n2
⇒ Fall 1
T (n) = Θ(n2 )
b) f (n) = n2
nlog2 4 = n2
⇒ Fall 2
T (n) = Θ(n2 · log n)
c) f (n) = n3
nlog2 4 = n2
⇒ Fall 3
T (n) = Θ(n3 )
7.4
Graphen
P
Aufgabe 18 Die Summe v∈V deg(v) zählt die Endknoten aller Kanten des Graphen. Damit
wird jede Kante zweimal gezählt.
83
Aufgabe 20
Aufgabe 22
Aufgabe 23
Nr
6
9
7
4
8
5
0
13
10
3
14
12
1
2
11
Name
Palo Alto
Santa Clara
Fremont
San Manteo
San Jose
Hayward
San Francisco
Half Moon Bay
Scotts Valley
Oakland
Pacifica
Santa Cruz
San Rafael
Richmond
Watsonville
Entfernung
0
10
15
18
25
29
38
43
45
49
53
55
56
64
85
Die angegebenen Nummern in der linken
Spalte sind die Knoten, die zur Menge S
schrittweise hinzugefügt werden.
Aufgabe 24 Süddeutschlandgraph:
a) Dü,Do,Aa,Br,Ber,Dre,Bas,Dü, Gesamtentfernung: 2490
b) siehe unten
84
c) Dü,Do,Br,Dre,Ber,Bas,Aa,Dü, Gesamtentfernung: 2505, siehe unten
Br
Do
Aa
Be
Dü
Dre
spanning
tree
TSP−Tour
mit Min.Sp.Tree−Heuristik
Preorder−Tree−Walk
Ba
Aufgabe 25 Da es nur recht wenige Verbindungen in diesem Graph gibt, wundert es nicht,
dass der Greedy-Algorithmus versagt.
Aufgabe 26 Die Lösung auf das TSP-Problem beim SFBay-Graphen ist eindeutig und intuitiv:
Die optimal Tour:
1 → 2 → 3 → 5 → 7 → 8 → 11 → 12 → 10 → 9 → 6 → 4 → 13 → 14 → 0 → 1
Aufgabe 27
V = Knoten; E = Kanten; A = Flächen;
Problem des Handlungsreisenden
85
Literaturverzeichnis
[1] Wikipedia – Die freie Enzyklopädie. www.wikipedia.org. 2.8.17
[2] F. Naumann. Vom Abakus zum Internet. Wissenschaftliche Buchgesellschaft, 2001. Geschichte der Informatik. 2.1
[3] H. Matis. Die Wundermaschine. mitp-Verlag, 2002. Geschichte des Computers. 2.1
[4] W. de Beauclair. Rechnen mit Maschinen – eine Bildgeschichte der Rechentechnik. Vieweg
Verlag, 1968. Die Lektüre dieses Bilderbuches lohnt sich! 2.1
[5] D. Shasha and C. Lazere. Out of Their Minds: The Lives and Discoveries of 15 Great
Computer Scientists. Copernicus/ An Imprint of Springer-Verlag, 1995. Sehr unterhaltsam
und informativ.
[6] V. Claus and A. Schwill. Duden Informatik. Bibliographisches Institut & F.A. Brockhaus
AG, 1988. Ein gutes Nachschlagewerk zur Informatik allgemein.
[7] P. Rechenberg and G. Pomberger. Informatik-Handbuch. Hanser Verlag, 2001.
[8] C. Horn and O. Kerner. Lehr- und Übungsbuch Informatik, Band 1: Grundlagen und
Überblick. Fachbuchverlag Leipzig, 2001.
[9] T.H. Cormen, Ch.E. Leiserson, and R. L. Rivest. Introduction to Algorithms. MIT Press,
Cambridge, Mass, 1994. Sehr gute Einführung in die Analyse von Algorithmen. 5.3, 5.5
[10] N. Wirth. Algorithmen und Datenstrukturen. Teubner-Verlag, Stuttgart, 1983 (3. Auflage).
Ein Klassiker, vom Erfinder der Sprache PASCAL.
[11] R. Sedgewick. Algorithmen. Addison-Wesley, Bonn, 1995. Übersetzung d. engl. Originals,
empfehlenswert.
[12] P. Tittmann. Graphentheorie. Fachbuchverlag Leipzig, 2003. Sehr gutes Buch mit vielen
Beispielen. Leider fehlen die Wegesuchalgorithmen.
[13] S. Krumke and H. Noltemeier. Graphentheoretische Konzepte und Algorithmen. Teubner
Verlag, 2005. Exakt und gleichzeitig anschaulich.
86