Algorithmen und Datenstrukturen (f ur ET/IT) - Sommersemester 2018
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
Algorithmen und Datenstrukturen (für ET/IT)
Sommersemester 2018
Dr. Stefanie Demirci
Computer Aided Medical Procedures
Technische Universität MünchenProbeklausur
• Wann? während Zentralübung am Mittwoch, 9. Mai 2018
• Wo? Hörsaal 1200
• Wie?
• 9:45 - 11:15: Bearbeitungszeit Probeklausur
• In den Tutorübungen ab 14. Mai: Besprechung der
Probeklausur
• Erlaubtes Material:
• nur 1 DIN A4 Blatt, handbeschrieben
• keine Bücher, Skripten, Ausdrucke, Smartphones, etc.
• Wozu?
• Simulation der tatsächlichen Prüfungssituation am 18. Juli
2018
• Vertrautmachen mit der Art von Prüfungsaufgaben
4Programm heute
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
5Kapitel 1: Einführung
• Algorithmus Definition:
M. Broy: Informatik: Eine grundlegende Einführung
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.“
• Datenstruktur Definition:
Definition Datenstruktur (nach Prof. Eckert)
Eine Datenstruktur ist eine
• logische Anordnung von Datenobjekten,
• die Informationen repräsentieren,
• den Zugriff auf die repräsentierte Information über
Operationen auf Daten ermöglichen und
• die Information verwalten.
6Kapitel 1: Einführung
• Einordnung in Computer-Schema:
Algorithmen und Algorithmus
Datenstrukturen Hochsprache (z.B. C, C++)
Betriebssystem
Software
Assembler
Maschinensprache
Computertechnik
Mikroarchitektur
Hardware
Digitale Logik
Digitaltechnik Transistoren, Verdrahtung
Schaltungstechnik Masken-Layout, Halbleiter
Schema nach Prof. Diepold: Grundlagen der Informatik.
7Kapitel 2: Grundlagen von Algorithmen
2.1 Darstellung von Algorithmen
2.2 Elementare Bausteine
2.3 Logische Ausdrücke
8Kapitel 2.1: Darstellung von Algorithmen
max(a,b)
Algorithmus : max (a , b )
Input : a , b
x=a
x=a b>a?
Falls b > a dann ja nein
x=b x=b
Ende Falls
Output : x x
Input: a,b int max ( int a , int b )
{
int x = a ;
x=a
if ( b > a )
x = b;
ja return x ;
b>a? x=b
}
nein
Output: x
• Churchsche These: alle “vernünftigen” Beschreibungen sind
äquivalent
9Kapitel 2.2: Elementare Bausteine
• Bausteine von Algorithmen:
Elementare Bausteine
Alle berechenbaren Algorithmen lassen sich mit
vier elementaren Bausteinen
darstellen:
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)
10Kapitel 2.3: Logische Ausdrücke
Grundrechenarten“ mit logischen Werten: Wahrheitstabelle:
”
• Konjunktion: ^ : B × B ! B a b a^b
• ähnlich zu Multiplikation bei Zahlen 0 0 0
• auch bezeichnet als UND bzw. AND 0 1 0
1 0 0
1 1 1
• Disjunktion: _ : B × B ! B a b a_b
• ähnlich zu Addition bei Zahlen 0 0 0
• auch bezeichnet als ODER bzw. OR 0 1 1
1 0 1
1 1 1
• Negation: ¬ : B ! B a ¬a
• auch bezeichnet als NICHT bzw. NOT 0 1
1 0
• Verknüpfungen NAND, NOR, XOR
• Verknüpfungen Implikation, Äquivalenz
• Rechenregeln: NOT vor AND vor OR, De Morgan Gesetze
11Kapitel 3: Grundlagen von Datenstrukturen
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
12Kapitel 3.1: Primitive Datentypen und Zahldarstellung
• Bits und Bytes
Bit 7 Bit 0
1 Byte = 8 Bit
• Primitive Datentypen: char, short, long, signed oder unsigned
• Zahldarstellung mit Polynom p(x), wobei x Basis
• x = 10: Dezimaldarstellung
• x = 2: Binärdarstellung
• 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
13Kapitel 3.2: Felder als sequentielle Liste
• Feld als sequentielle Liste / Array:
A[n-1] A[n-2] .. .. A[1] A[0]
• Operationen: elementAt: O(1), insert: O(n), erase: O(n)
• insert und erase erfordern Umkopieren der Elemente:
25 16 9 4 1
25 16 9 8 4 1
25 16 9 4 1 0
25 16 9 4 1
14Kapitel 3.3: Zeichen und Zeichenfolgen
• Zeichen codiert als ASCII, Unicode, etc.
• Folge von Zeichen: String
• als String-Literal: “AuD”
• als Feld von Zeichen:
'\0' 'D' 'u' 'A'
3 2 1 0 Index
15Kapitel 3.4: Felder als verkettete Liste
• Feld als verkettete Liste:
start Daten Daten Daten Daten
next next next next null
• Operationen: elementAt: O(n), insert: O(n), erase: O(n)
• Feld als doppelte verkettete Liste:
null prev prev prev prev
start Daten Daten Daten Daten stop
next next next next null
• Operationen: elementAt: O(n), insert: O(n), erase: O(n)
16Kapitel 3.5: Abstrakte Datentypen
• 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
• mögliche Operationen auf ihm sowie
• mathematische Bedingungen (oder: constraints) über die
Auswirkungen der Operationen (u.U. auch die Kosten der
Operationen).
• Abstrakte Variable V mit
• Operationen (load, store)
• Bedingungen (load(V) liefert Wert x von letztem store(V, x))
17Kapitel 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))
"pop"
Piz
za
#3
Piz
za
#2
Piz neu
za e Piz
#1 za
• Stack implementiert als
• sequentielle Liste
• verkettete Liste
• beide mit Komplexität von push, pop, top: O(1)
18Kapitel 3.7: Queues
• 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))
Person verlässt Schlange Person stellt sich an
• 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))
19Kapitel 4: Grundlagen der Korrektheit von Algorithmen
4.1 Motivation und Spezifikation
4.2 Verifikation
4.3 Beispiel: Insertion Sort
4.4 Validation
20Kapitel 4.1: Motivation und Spezifikation
• Software-Fehler sind leider alltäglich
• Korrektheit ist relativ bezüglich der Spezifikation
21Kapitel 4.2: Verifikation
• Verifikation: formaler Beweis der Korrektheit bzgl.
Spezifikation
• mit Vor- und Nachbedingungen
{VOR} ANW {NACH}
für die vier elementaren Bausteine:
• für elementaren Verarbeitungsschritt
• für Sequenz
• für bedingten Verarbeitungsschritt
• für Wiederholung mit Schleifeninvariante
• Verifikation ist aufwendig und teilweise automatisierbar
22Kapitel 4.3: Beispiel Insertion Sort
• Insertion Sort: Sortieren durch direktes Einfügen
• Komplexität:
• best case: O(n)
• worst case: O(n2 )
• formale Verifikation von Insertion Sort Pseudocode mit
Schleifeninvariante
23Kapitel 4.4: Validation
• 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
• Testen in der Praxis z.B. mit assert und Unit Test Frameworks
• fehlertolerantes und fehlerpräventives Programmieren
24Kapitel 5: Grundlagen der Effizienz von Algorithmen
5.1 Motivation
5.2 RAM-Modell
5.3 Landau-Symbole
25Kapitel 5.1: Motivation
• Komplexitätsanalyse von Algorithmen: Bedarf an
Speicherplatz und Rechenzeit
• Komplexität abhängig von Eingabegröße n →
Wachstumsverhalten
48
2n
n² n*ln(n)
40
n
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)
26Kapitel 5.2: RAM-Modell
• RAM-Modell: einfaches Rechnermodell zur Laufzeitanalyse
• nur sequentielle Ausführung
• keine Speicherlatenz
• alle elementaren Verarbeitungsschritte benötigen eine
Zeiteinheit
• 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 T (n) = n!
10 0.003µs 0.01µs 0.033µs 0.1µs 1µs 3.63ms
20 0.004µs 0.02µs 0.086µs 0.4µs 1ms 77.1 years
30 0.005µs 0.03µs 0.147µs 0.9µs 1s 8.4 · 1015 years
40 0.005µs 0.04µs 0.213µs 1.6µs 18.3min
50 0.006µs 0.05µs 0.282µs 2.5µs 13 days
100 0.007µs 0.1µs 0.644µs 10µs 4 · 1013 years
1000 0.010µs 1.0µs 9.966µs 1ms
10000 0.013µs 10µs 130µs 100ms
100000 0.017µs 0.1ms 1.67ms 10s
1 · 106 0.020µs 1ms 19.93ms 16.7min
1 · 107 0.023µs 0.01s 0.23s 1.16 days
1 · 108 0.027µs 0.1s 2.66s 115.7 days
1 · 109 0.030µs 1s 29.9s 31.7 years
Tabelle adaptiert von “The Algorithm Design Manual”, S. Skiena, Springer
27Kapitel 5.3: Landau-Symbole
• 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)
Für f : R → R mit f 2 Θ(g ) schreiben wir kurz: f = Θ(g ).
• 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 ).
28Kapitel 5.3: Landau-Symbole
• 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
29Kapitel 6: Grundlagen des Algorithmen-Entwurfs
6.1 Entwurfsprinzipien
6.2 Divide and Conquer
6.3 Greedy-Algorithmen
6.4 Backtracking
6.5 Dynamisches Programmieren
30Kapitel 6.1: Entwurfsprinzipien
• 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
31Kapitel 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
}
• 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 )
32Kapitel 6.3: Greedy-Algorithmen
• Algorithmen-Muster: Greedy
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: Glasfasernetz, minimale Spannbaum
K1
K2 6 K4
1
7 9
10 K3
4
5 3
K1 K5 2
2 8 K2 K5
1 3
K3 6
K4
33Kapitel 6.4: Backtracking
• Algorithmen-Muster: Backtracking
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 );
}
}
• Beispiel: Labyrinth, Maus mit Käse
(1,1)
1
(1,2)
2 (2,2) (1,3)
(2,1) (3,2) (2,3)
3
(3,1) (3,3)
1 2 3
• Beispiel: Traveling Salesman Problem
• Beispiel: Acht-Damen-Problem
34Kapitel 6.5: Dynamisches Programmieren
• Prinzip dynamisches Programmieren
• statt Rekursion aufwärts von kleinstem Teilproblem rechnen
• Zwischenergebnisse in Tabellen speichern
• Beispiel: Fibonacci Folge
Fibonacci Folge
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
mit Anfangswerten f1 = 1, f2 = 1.
35Warnung!
ACHTUNG!
• Vorlesung heute dient nur der Wiederholung und Einordnung
des bereits behandelten Stoffes
• Anwendungs-Szenarien (und Hintergründe, Details dazu) sind
NICHT klausur-relevant!
36Anwendungs-Szenarien
✑ separate Präsentation
37Warnung!
ACHTUNG!
• Vorlesung heute dient nur der Wiederholung und Einordnung
des bereits behandelten Stoffes
• Anwendungs-Szenarien (und Hintergründe, Details dazu) sind
NICHT klausur-relevant!
38Zusammenfassung
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
39Sie können auch lesen
