Algorithmen und Datenstrukturen (für ET/IT - CAMP-TUM

Probeklausur
• Wann? während Zentralübung am Mittwoch, 7. Juni 2017
Algorithmen und Datenstrukturen (für ET/IT)
• Wo? Hörsaal 1200
Sommersemester 2017
• Wie?
• 9:45 - 10:30: Bearbeitungszeit Probeklausur
• 10:30 - 11:15: Besprechung der Probeklausur
Dr. Stefanie Demirci
Computer Aided Medical Procedures
Technische Universität München
• Erlaubtes Material:
• nur 1 DIN A4 Blatt, handbeschrieben
• keine Bücher, Skripten, Ausdrucke, Smartphones, etc.
• Wozu?
• Simulation der tatsächlichen Prüfungssituation am 10. August
2017
• Vertrautmachen mit der Art von Prüfungsaufgaben
3
Programm heute
Kapitel 1: Einführung
• Algorithmus Definition:
1 Einführung
M. Broy: Informatik: Eine grundlegende Einführung
2 Grundlagen von Algorithmen
Ein Algorithmus ist ein Verfahren
”
• mit einer präzisen (d.h. in einer genau festgelegten Sprache
abgefassten),
• endlichen Beschreibung,
• unter Verwendung
• effektiver (d.h. tatsächlich ausführbarer),
• elementarer (Verarbeitungs-) Schritte.“
3 Grundlagen von Datenstrukturen
4 Grundlagen der Korrektheit von Algorithmen
• Datenstruktur Definition:
Definition Datenstruktur (nach Prof. Eckert)
5 Grundlagen der Effizienz von Algorithmen
Eine Datenstruktur ist eine
• logische Anordnung von Datenobjekten,
6 Grundlagen des Algorithmen-Entwurfs
• die Informationen repräsentieren,
• den Zugriff auf die repräsentierte Information über
Operationen auf Daten ermöglichen und
→ Wiederholung und Anwendungsbeispiele
• die Information verwalten.
4
5
Kapitel 1: Einführung
Kapitel 2: Grundlagen von Algorithmen
Algorithmus
Datenstrukturen
Hochsprache (z.B. C, C++)
Betriebssystem
Assembler
Computertechnik
Maschinensprache
Mikroarchitektur
Digitale Logik
Digitaltechnik
Transistoren, Verdrahtung
Schaltungstechnik
Masken-Layout, Halbleiter
2.1 Darstellung von Algorithmen
2.2 Elementare Bausteine
2.3 Logische Ausdrücke
Hardware
Algorithmen und
Software
• Einordnung in Computer-Schema:
Schema nach Prof. Diepold: Grundlagen der Informatik.
6
Kapitel 2.1: Darstellung von Algorithmen
Algorithmus : max (a , b )
Input : a , b
x=a
Falls b > a dann
x=b
Ende Falls
Output : x
Input: a,b
x=a
b>a?
ja
x=b
7
Kapitel 2.2: Elementare Bausteine
max(a,b)
x=a
b>a?
ja
nein
• Bausteine von Algorithmen:
x=b
x
Elementare Bausteine
Alle berechenbaren Algorithmen lassen sich mit
int max ( int a , int b )
{
int x = a ;
if ( b > a )
x = b;
return x ;
}
vier elementaren Bausteinen
darstellen:
nein
Output: x
1
Elementarer Verarbeitungsschritt (z.B. Zuweisung an Variable)
2
Sequenz (elementare Schritte nacheinander)
3
Bedingter Verarbeitungsschritt (z.B. if/else)
4
Wiederholung (z.B. while-Schleife)
• Churchsche These: alle “vernünftigen” Beschreibungen sind
äquivalent
8
9
Kapitel 2.3: Logische Ausdrücke
Kapitel 3: Grundlagen von Datenstrukturen
Grundrechenarten“ mit logischen Werten:
”
Wahrheitstabelle:
• Konjunktion: ^ : B × B ! B
• ähnlich zu Multiplikation bei Zahlen
• auch bezeichnet als UND bzw. AND
a
0
0
1
1
b
0
1
0
1
a^b
0
0
0
1
• Disjunktion: _ : B × B ! B
• ähnlich zu Addition bei Zahlen
• auch bezeichnet als ODER bzw. OR
a
0
0
1
1
b
0
1
0
1
a_b
0
1
1
1
a
0
1
¬a
1
0
• Negation: ¬ : B ! B
• auch bezeichnet als NICHT bzw. NOT
3.1 Primitive Datentypen und Zahldarstellung
3.2 Felder als sequentielle Liste
3.3 Zeichen und Zeichenfolgen
3.4 Felder als verkettete Liste
3.5 Abstrakte Datentypen
3.6 Stacks
3.7 Queues
• Verknüpfungen NAND, NOR, XOR
• Verknüpfungen Implikation, Äquivalenz
• Rechenregeln: NOT vor AND vor OR, De Morgan Gesetze
10
Kapitel 3.1: Primitive Datentypen und Zahldarstellung
Kapitel 3.2: Felder als sequentielle Liste
• Bits und Bytes
Bit 7
11
• Feld als sequentielle Liste / Array:
Bit 0
A[n-1]
1 Byte = 8 Bit
A[n-2]
..
..
A[1]
A[0]
• Operationen: elementAt: O(1), insert: O(n), erase: O(n)
• Primitive Datentypen: char, short, long, signed oder unsigned
• insert und erase erfordern Umkopieren der Elemente:
• Zahldarstellung mit Polynom p(x), wobei x Basis
• x = 10: Dezimaldarstellung
• x = 2: Binärdarstellung
25
16
9
4
1
25
16
9
8
4
1
25
16
9
4
1
0
25
16
9
4
1
• Wie viele Ziffern m pro Zahl z? m = ⌊logx (z)⌋ + 1
• Größte Zahl pro m Ziffern? zmax = x m − 1
• 2-Komplement Darstellung
• Floating Point Zahlen: f = (−1)V · (1 + M) · 2E −bias
• float, double
12
13
Kapitel 3.3: Zeichen und Zeichenfolgen
Kapitel 3.4: Felder als verkettete Liste
• Feld als verkettete Liste:
start
• Zeichen codiert als ASCII, Unicode, etc.
• Folge von Zeichen: String
Daten
Daten
Daten
Daten
next
next
next
next
null
• Operationen: elementAt: O(n), insert: O(n), erase: O(n)
• als String-Literal: “AuD”
• Feld als doppelte verkettete Liste:
• als Feld von Zeichen:
null
'\0'
'D'
3
'u'
2
prev
prev
prev
prev
Daten
Daten
Daten
Daten
next
next
next
next
'A'
1
0
Index
start
stop
null
• Operationen: elementAt: O(n), insert: O(n), erase: O(n)
14
Kapitel 3.5: Abstrakte Datentypen
15
Kapitel 3.6: Stacks
• Stack als abstrakter Datentyp mit
• Operationen (push, pop, top, isEmpty, initialize)
• Bedingungen (z.B. push(S, x); store(V, pop(S)) äquivalent zu
store(V, x))
• Definition abstrakter Datentyp:
Abstrakter Datentyp (englisch: abstract data type, ADT)
Ein abstrakter Datentyp ist ein mathematisches Modell für
bestimmte Datenstrukturen mit vergleichbarem Verhalten.
Ein abstrakter Datentyp wird indirekt definiert über
"pop"
• mögliche Operationen auf ihm sowie
• mathematische Bedingungen (oder: constraints) über die
Piz
za
Auswirkungen der Operationen (u.U. auch die Kosten der
Operationen).
#3
Piz
za
#2
Piz
za
#1
neu
e
Piz
za
• Stack implementiert als
• sequentielle Liste
• verkettete Liste
• beide mit Komplexität von push, pop, top: O(1)
• Abstrakte Variable V mit
• Operationen (load, store)
• Bedingungen (load(V) liefert Wert x von letztem store(V, x))
16
17
Kapitel 3.7: Queues
Kapitel 4: Grundlagen der Korrektheit von Algorithmen
• Queue als abstrakter Datentyp mit
• Operationen (dequeue, enqueue, isEmpty, initialize)
• Bedingungen (z.B. enqueue(Q, x); store(V, dequeue(Q))
äquivalent zu store(V, x))
4.1 Motivation und Spezifikation
4.2 Verifikation
Person verlässt Schlange
4.3 Beispiel: Insertion Sort
Person stellt sich an
4.4 Validation
• Queue implementiert als
• verkettete Liste
• sequentielle Liste (z.B. zirkulär)
• beide mit Komplexität von dequeue, enqueue: O(1)
• als Kuriosität: als zwei Stacks (dequeue hat hier worst-case
Komplexität O(n))
18
Kapitel 4.1: Motivation und Spezifikation
19
Kapitel 4.2: Verifikation
• Verifikation: formaler Beweis der Korrektheit bzgl.
Spezifikation
• mit Vor- und Nachbedingungen
• Software-Fehler sind leider alltäglich
{VOR} ANW {NACH}
für die vier elementaren Bausteine:
• Korrektheit ist relativ bezüglich der Spezifikation
•
•
•
•
für
für
für
für
elementaren Verarbeitungsschritt
Sequenz
bedingten Verarbeitungsschritt
Wiederholung mit Schleifeninvariante
• Verifikation ist aufwendig und teilweise automatisierbar
20
21
Kapitel 4.3: Beispiel Insertion Sort
Kapitel 4.4: Validation
• Insertion Sort: Sortieren durch direktes Einfügen
• Validation: informeller Nachweis der Korrektheit durch
systematisches Testen
• leider oft: Validation statt Verifikation
• Validation auch hilfreich falls Verifikation erfolgt
• Validation durch systematisches Testen:
• Blackbox-Test
• Whitebox-Test
• Regressions-Test
• Integrations-Test
• Komplexität:
• best case: O(n)
• worst case: O(n2 )
• Testen in der Praxis z.B. mit assert und Unit Test Frameworks
• formale Verifikation von Insertion Sort Pseudocode mit
• fehlertolerantes und fehlerpräventives Programmieren
Schleifeninvariante
23
22
Kapitel 5: Grundlagen der Effizienz von Algorithmen
Kapitel 5.1: Motivation
• Komplexitätsanalyse von Algorithmen: Bedarf an
Speicherplatz und Rechenzeit
• Komplexität abhängig von Eingabegröße n →
Wachstumsverhalten
5.1 Motivation
48
2n
n²
5.2 RAM-Modell
n*ln(n)
40
n
5.3 Landau-Symbole
32
24
16
8
ln(n)
0
8
16
24
32
40
48
56
64
72
• ausführliche Komplexitätsanalyse von Insertion Sort mit
Konstanten (aufwendig)
24
25
Kapitel 5.2: RAM-Modell
Kapitel 5.3: Landau-Symbole
• RAM-Modell: einfaches Rechnermodell zur Laufzeitanalyse
• nur sequentielle Ausführung
• keine Speicherlatenz
• alle elementaren Verarbeitungsschritte benötigen eine
Zeiteinheit
• Landau-Symbol Θ:
Landau-Symbol Θ
Sei g : R → R eine Funktion. Das Landau-Symbol Θ(g ) ist
definiert als die Menge
!
Θ(g ) := f : R → R : es existieren c1 , c2 > 0, n0 2 N so dass
"
für alle n ≥ n0 gilt: 0 ≤ c1 g (n) ≤ f (n) ≤ c2 g (n)
• der höchste Term dominiert Laufzeit:
n
T (n) = ln(n) T (n) = n T (n) = n ln(n) T (n) = n2 T (n) = 2n
10
20
30
40
50
100
1000
10000
100000
1 · 106
1 · 107
1 · 108
1 · 109
0.003µs
0.004µs
0.005µs
0.005µs
0.006µs
0.007µs
0.010µs
0.013µs
0.017µs
0.020µs
0.023µs
0.027µs
0.030µs
0.01µs
0.02µs
0.03µs
0.04µs
0.05µs
0.1µs
1.0µs
10µs
0.1ms
1ms
0.01s
0.1s
1s
0.033µs
0.086µs
0.147µs
0.213µs
0.282µs
0.644µs
9.966µs
130µs
1.67ms
19.93ms
0.23s
2.66s
29.9s
0.1µs
0.4µs
0.9µs
1.6µs
2.5µs
10µs
1ms
100ms
10s
16.7min
1.16 days
115.7 days
31.7 years
Für f : R → R mit f 2 Θ(g ) schreiben wir kurz: f = Θ(g ).
T (n) = n!
1µs
3.63ms
1ms
77.1 years
1s
8.4 · 1015 years
18.3min
13 days
4 · 1013 years
• Landau-Symbol O:
Landau-Symbol O
Sei g : R → R eine Funktion. Das Landau-Symbol O(g ) ist
definiert als die Menge
O(g ) := {f : R → R : es existieren c > 0 und n0 2 N so dass
für alle n ≥ n0 gilt: 0 ≤ f (n) ≤ cg (n)}
Für f : R → R mit f 2 O(g ) schreiben wir kurz: f = O(g ).
Tabelle adaptiert von “The Algorithm Design Manual”, S. Skiena, Springer
26
Kapitel 5.3: Landau-Symbole
27
Kapitel 6: Grundlagen des Algorithmen-Entwurfs
• Kategorisierung der Laufzeit von Algorithmen
• O(1): konstant
• O(log n): logarithmisch
• O(n): linear
• O(n log n): loglinear
• O(n2 ): quadratisch
• O(2n ): exponentiell
• Rechenregeln für die vier elementaren Bausteine
• elementarer Verarbeitungsschritt: O(1)
• Sequenz: Addition in O-Notation
• bedingter Verarbeitungsschritt: Maximum von if/else sowie
O(1) für Bedingung
• Wiederholung: Anzahl Schleifendurchläufe multipliziert mit
Komplexität Schleifenkörper sowie jeweils O(1) für Bedingung
6.1 Entwurfsprinzipien
6.2 Divide and Conquer
6.3 Greedy-Algorithmen
6.4 Backtracking
6.5 Dynamisches Programmieren
28
29
Kapitel 6.1: Entwurfsprinzipien
Kapitel 6.2: Divide and Conquer
• Algorithmen-Muster: Divide and Conquer
Input: Aufgabe A
DivideAndConquer(A):
if (A klein) {
löse A explizit;
}
else {
teile A in Teilaufgaben A1 , . . . , An auf;
DivideAndConquer(A1 );
...
DivideAndConquer(An );
setze Lösung für A zusammen aus Lösungen für A1 , . . . , An
}
• kein Patentrezept zum Entwurf von Algorithmen
• Prinzip: Verfeinerung bzw. Top-Down Entwurf
• Vorgehen mit schrittweiser Verfeinerung des Lösungsansatzes
• Prinzip: Algorithmen-Muster bzw. Design Patterns
• Lösungsverfahren für bestimmte Problemklasse
• Anpassung an konkrete Problemstellung
• Beispiel: MergeSort
• Komplexität O(n log n) mit Rekursionsbaum
• benötigt extra Speicher
• Beispiel: QuickSort
• Komplexität im Mittel O(n log n)
• worst case: O(n2 )
31
30
Kapitel 6.3: Greedy-Algorithmen
Kapitel 6.4: Backtracking
• Algorithmen-Muster: Backtracking
• Algorithmen-Muster: Greedy
Input: Konfiguration K
Backtrack(K ):
if (K ist Lösung) {
gib K aus;
} else {
for each (direkte Erweiterung K 0 von K ) {
Backtrack(K 0 );
}
}
Input: Aufgabe A
Greedy(A):
while (A nicht gelöst) {
wähle bestmöglichen Schritt; // Greedy Strategie
baue Schritt in Lösung ein;
}
• Beispiel: Wechselgeld, minimale Anzahl Münzen
• Beispiel: Labyrinth, Maus mit Käse
(1,1)
• Beispiel: Glasfasernetz, minimale Spannbaum
6
K2
1
(1,2)
K1
K4
2
(2,2)
(1,3)
1
7
9
10
K3
4
K5
8
2
1
3
K3
3
(3,2)
(2,3)
3
5
K1
(2,1)
(3,1)
2
K2
1
K5
2
(3,3)
3
• Beispiel: Traveling Salesman Problem
6
K4
• Beispiel: Acht-Damen-Problem
32
33
Kapitel 6.5: Dynamisches Programmieren
Warnung!
• Prinzip dynamisches Programmieren
• statt Rekursion aufwärts von kleinstem Teilproblem rechnen
• Zwischenergebnisse in Tabellen speichern
ACHTUNG!
• Beispiel: Fibonacci Folge
Fibonacci Folge
• Vorlesung heute dient nur der Wiederholung und Einordnung
Die Fibonacci Folge ist eine Folge natürlicher Zahlen f1 , f2 , f3 , . . .,
für die gilt
fn = fn−1 + fn−2
für n ≥ 3
des bereits behandelten Stoffes
• Anwendungs-Szenarien (und Hintergründe, Details dazu) sind
mit Anfangswerten f1 = 1, f2 = 1.
NICHT klausur-relevant!
34
Anwendungs-Szenarien
✑
35
Warnung!
ACHTUNG!
separate Präsentation
• Vorlesung heute dient nur der Wiederholung und Einordnung
des bereits behandelten Stoffes
• Anwendungs-Szenarien (und Hintergründe, Details dazu) sind
NICHT klausur-relevant!
36
37
Zusammenfassung
1 Einführung
2 Grundlagen von Algorithmen
3 Grundlagen von Datenstrukturen
4 Grundlagen der Korrektheit von Algorithmen
5 Grundlagen der Effizienz von Algorithmen
6 Grundlagen des Algorithmen-Entwurfs
→ Wiederholung und Anwendungsbeispiele
38