Sommersemester 2015 - CAMP-TUM

Übung zu
Algorithmen und Datenstrukturen (für ET/IT)
Sommersemester 2015
Matthias Wieczorek
Computer-Aided Medical Procedures
Technische Universität München
Administratives
I
Zentralübung (Mittwoch, 09:45 – 11:15)
I
I
I
I
Tutorfragestunden
I
I
I
I
I
I
Besprechung des Aufgabenblattes der Vorwoche
Fragen von allgemeinem Interesse
Probeklausur
Dienstag, 15:00 – 17:00, Raum 0999
Freitag, 09:00 - 11:00, Raum 0999
Detailliertere und individuelle Fragen
Kontakt-E-Mail: [email protected]
Sprechstunde (Termin per E-Mail)
Moodle
I
I
https://www.moodle.tum.de/course/view.php?id=17994
Diskussionsforum & Bekanntmachungen
http://campar.in.tum.de/Chair/TeachingSs15AuD
2/37
Website
3/37
onlineTED
I
https://www.onlineted.de
I
Webbasiertes Abstimmungssystem
I
Live-Umfragen in Lehrveranstaltungen
4/37
onlineTED
5/37
Euklidischer Algorithmus
Wenn CD aber AB nicht misst, und man nimmt bei AB, CD
”
abwechselnd immer das kleinere vom größeren weg, dann muss
(schließlich) eine Zahl übrig bleiben, die die vorangehende misst.“
aus Euklid: Die Elemente, Buch VII (Clemens Thaer)
I
Vorschrift zur Berechnung des größten gemeinsamen Teilers
I
Keine Definition des ggT im mathematischen Sinn
I
Verschiedene Algorithmen mit gleichem Ziel (
Sortierung!)
6/37
Ablauf nach Originalformulierung
AB = 11
CD = 4
0 Rechenschritte
7/37
Ablauf nach Originalformulierung
AB = 7 = 11 − CD
CD = 4
1 Rechenschritt
7/37
Ablauf nach Originalformulierung
AB = 3 = 7 − CD
CD = 4
2 Rechenschritte
7/37
Ablauf nach Originalformulierung
AB = 3
CD = 1 = 4 − AB
3 Rechenschritte
7/37
Ablauf nach Originalformulierung
AB = 2 = 3 − CD
CD = 1
4 Rechenschritte
7/37
Ablauf nach Originalformulierung
AB = 1 = 2 − CD
CD = 1
5 Rechenschritte
7/37
Ablauf nach Originalformulierung
AB = 1
CD = 1
⇒ ggT (11, 4) = 1
11 ist eine Primzahl!
5 Rechenschritte
7/37
Algorithmus
I
I
präzise/eindeutige, endliche Beschreibung
Bausteine:
I
I
I
I
Elementarer Verarbeitungsschritt
Sequenz (Abfolge elementarer Schritte)
Bedingter Verarbeitungsschritt
Wiederholung
8/37
Variablen
I
Speicherung von Werten mittels Typ-behafteter, eindeutig
benannter Variablen
I
I
I
I
I
I
int für ganze Zahlen (Integer)
double für Fließkommazahlen (Double Precision Floating
Point)
char für Zeichen (Character)
...
Zuweisung über =
Kurze Schreibweise für Updates
I
I
i *= 4; statt i = i * 4; (ebenso +=, -=, *=, /=, ...)
i++; statt i = i + 1; (ebenso --)
int i = 23;
int j = 2 * (i -2);
char s = ’a ’;
// Klammerung !
9/37
Elementarer Verarbeitungsschritt
I
Mathematische Operatoren +, -, *, /, . . .
I
Zuweisungen =, +=, -=, *=, /=, . . .
I
...
10/37
Sequenz
int i = 10;
i = i +2; // Wert von i ist 12
11/37
Bedingter Verarbeitungsschritt
I
if (b) {...}
I
if (b) {...} else {...}
I
if (b) {...} else if (...) {...} else {...}
I
Klammern {...} zur Sicherheit immer schreiben
I
b steht für einen logischen Ausdruck oder eine logische
(boolsche) Variable:
12/37
Logische Ausdrücke
I
Logischer Typ (bool) mit Werten true (wahr, 1) und false
(unwahr, 0)
I
Vergleichs-Operatoren: == (gleich), != (ungleich), <, <=, ...
I
Verknüpfungen: && (AND; beide wahr), || (OR; mindestens
eines von beiden wahr), ...
I
Negation: !a (NOT)
13/37
Wiederholung
Schleifen für Wiederholungen
I
while (b) {...} (Test vor jeder Iteration)
I
do {...} while (b); (Test nach jeder Iteration)
I
for i = 1...100 {...} (Gewisse Anzahl an Iterationen)
14/37
Pseudocode
I
Informelle Veranschaulichung eines Algorithmus
I
Identifizierung der elementaren Bausteine nicht offensichtlich
Input: Natürliche Zahlen a,b
Output: ggT(a,b)
euklid(a,b):
I
I
Falls a = 0, liefere b zurück
Solange b > 0 wiederhole
I
I
I
Falls a > b setze a = a − b
sonst setze b = b − a
Liefere a zurück
15/37
Beispiel Programmiersprache: C
I
Kompilierte Sprache, sehr effizient
int euklid ( int a , int b )
{
if ( a ==0)
return b ;
while (b >0)
{
if (a > b )
a = a - b;
else
b = b - a;
}
return a ;
}
16/37
Konvention der Vorlesung
I
Pseudocode + C Syntax
Input: Natürliche Zahlen a,b
Output: ggT(a,b)
euklid(a,b):
{
if ( a ==0)
return b ;
while (b >0)
{
if (a > b )
a = a - b;
else
b = b - a;
}
return a ;
}
17/37
Konvention der Vorlesung – Funktionsdefinition
Input: Natürliche Zahlen a,b // Einsprungspunkt
Output: ggT(a,b) // Aus -/ Rückgabe
euklid(a,b): // Funktionsname
{
if ( a ==0)
return b ;
while (b >0)
{
if (a > b )
a = a - b;
else
b = b - a;
}
return a ;
}
I
Aufruf mittels euklid(a,b) (z.B. euklid(6,3))
18/37
Konvention der Vorlesung – Identifikation der Bausteine
Input: Natürliche Zahlen a,b
Output: ggT(a,b)
euklid(a,b):
{ // Beginn einer Sequenz
if ( a ==0) // Bedingter V e r a r b e i t u n g s s c h r i t t
return b ; // Elementarer V e r a r b e i t u n g s s c h r i t t
while (b >0) // Wiederholung
{ // Beginn einer Sequenz
if (a > b ) // Bedingter V e r a r b e i t u n g s s c h r i t t
a =a - b ; // Elementarer V e r a r b e i t u n g s s c h r i t t
else // Bedingter V e r a r b e i t u n g s s c h r i t t
b =b - a ; // Elementarer V e r a r b e i t u n g s s c h r i t t
} // Ende einer Sequenz
return a ; // Elementarer V e r a r b e i t u n g s s c h r i t t
} // Ende einer Sequenz
19/37
Ablauf nach Originalformulierung
AB = 11
CD = 4
0 Rechenschritte
20/37
Ablauf nach Originalformulierung
AB = 7 = 11 − CD
CD = 4
1 Rechenschritt
20/37
Ablauf nach Originalformulierung
AB = 3 = 7 − CD
CD = 4
2 Rechenschritte
20/37
Ablauf nach Originalformulierung
AB = 3
CD = 1 = 4 − AB
3 Rechenschritte
20/37
Ablauf nach Originalformulierung
AB = 2 = 3 − CD
CD = 1
4 Rechenschritte
20/37
Ablauf nach Originalformulierung
AB = 1 = 2 − CD
CD = 1
5 Rechenschritte
20/37
Ablauf nach Originalformulierung
AB = 1
CD = 1
⇒ ggT (11, 4) = 1
11 ist eine Primzahl!
5 Rechenschritte
20/37
Beobachtung
AB = 11 = 2 · CD + 3
AB
:
CD
=
−
11
8
3
:
4
=
2
I
Die Modulo-Berechnung liefert den Rest nach Teilung.
I
Wir schreiben 11 mod 4 = 3 ...
I
... und programmieren int rest = 11 % 4;
21/37
Ablauf mit Modulo
AB = 11
CD = 4
0 Rechenschritte
22/37
Ablauf mit Modulo
AB = 3 = 11 mod CD
CD = 4
1 Rechenschritt
22/37
Ablauf mit Modulo
AB = 3
CD = 1 = 4 mod AB
2 Rechenschritte
22/37
Ablauf mit Modulo
AB = 0 = 3 mod CD
=⇒ AB = CD = 1
CD = 1
⇒ ggT (11, 4) = 1
Abbruch bei Rest 0!
3 Rechenschritte
22/37
Caveat
I
Die Zählung von Rechenschritten ist stark vereinfachend!
I
Tatsächlich dauert die Berechnung einer Teilung (bzw. einer
Modulo-Operation) erheblich länger als eine Differenz!
23/37
Implementierung via Modulo
Input: Natürliche Zahlen a,b
Output: ggT(a,b)
euklid modulo(a,b):
{
while ( b != 0)
{
int rest = a % b ;
a = b;
b = rest ;
}
return a ;
}
24/37
Rekursion
I
Funktionen rufen sich selbst wieder auf, nachdem die
Parameter geändert wurden.
I
Abbruchbedingungen beenden diese Kette von Aufrufen.
I
Beispiel: Addition der Zahlen m bis n
25/37
Iterative Variante
Input: Natürliche Zahlen m,n
Output: Summe der Zahlen m bis n
summe iterativ(m,n):
{
int wert = 0;
for ( int i = m ; i <= n ; ++ i )
wert += i ;
return wert ;
}
26/37
Rekursive Variante
Input: Natürliche Zahlen m,n
Output: Summe der Zahlen m bis n
summe rekursiv(m,n):
{
if ( m > n )
return 0;
else
return m + summe_rekursiv ( m +1 , n );
}
27/37
Aufrufkette
I
summe rekursiv(2, 4) +(0)
I
2 + summe rekursiv(3, 4)
I
2 + 3 + summe rekursiv(4, 4)
I
2 + 3 + 4 + summe rekursiv(5, 4)
I
2 + 3 + 4 + 0 +(0)
I
2 + 3 + 4 +(0)
I
2 + 7 +(0)
I
9 +(0)
28/37
ggT mit Rekursion
I
Mittels dreier Eigenschaften läßt sich der ggT rekursiv
berechnen:
ggT(ab, cd) = ggT(cd, ab)
(1)
ggT(ab, cd) = ggT(ab, cd mod ab)
(2)
ggT(ab, cd) = ggT(ab, cd + λ · ab)
(3)
29/37
Implementierung via Rekursion
Input: Natürliche Zahlen a,b
Output: ggT(a,b)
euklid rekursiv(a,b):
{
if ( b ==0)
return a ;
else if ( a ==0)
return b ;
else if (a > b )
return euklid_rekursiv (a -b , b );
else
return euklid_rekursiv (a , b - a );
}
30/37
Implementierung via Rekursion und Modulo
Input: Natürliche Zahlen a,b
Output: ggT(a,b)
euklid rekursiv modulo(a,b):
{
if ( b ==0)
return a ;
else
return e uk l i d _ r e k u r s i v _ m o d u l o (b , a % b );
}
31/37
Apropos...
I
ggT via Primfaktorzerlegung?
32/37
Zusammenfassung
I
I
Feststellung: Unterschiedliche Algorithmen für die selbe
Aufgabe
Angenommen eine Aufgabe sei gegeben (z.B.: Automatisierte
Sortierung von Paketen)
I
I
I
Welche Algorithmen eignen sich hierzu?
Welche Unterschiede gibt es
Welcher Algorithmus eigenen sich am besten?
33/37