Vorlesung Programmieren

Transkript

1 Vorlesung Programmieren 11 Rekursion Jun.-Prof. Dr.-Ing. Anne Koziolek Version 1.1 ARBEITSGRUPPE ARCHITECTURE-DRIVEN REQUIREMENTS ENGINEERING (ARE) INSTITUT FÜR PROGRAMMSTRUKTUREN UND DATENORGANISATION (IPD), KIT-FAKULTÄT FÜR INFORMATIK are.ipd.kit.edu KIT Universität des Landes Baden-Württemberg und nationales Forschungszentrum in der Helmholtz-Gemeinschaft

2 Wichtige Termine Programmieren Übungsschein: Anmeldungszeitraum zwischen und Programmieren Präsenzübung am , ca. 13:00 Uhr Programmieren Abschlussaufgaben: Anmeldungszeitraum zwischen und Anmeldung jeweils über das Campus Management Portal : 2

3 Organisatorisches: Programmieren SS 2017 Programmieren-Vorlesung findet nächstes Semester nicht statt Tutorien finden nächstes Semester auch nicht statt Der Übungsschein kann trotzdem erworben werden 5 Übungsblätter Präsenzübung 2 Abschlussaufgaben Gleiche Bedingungen zum Erwerben des Übungsscheins wie in diesem Semester 3

4 Literaturhinweis - Weiterlesen Dietmar Ratz, Jens Scheffler, Detlef Seese und Jan Wiesenberger Grundkurs Programmieren in Java, 7. Auflage, 2014 (mit Java 8), Hansa-Verlag Kapitel 6 Methoden, Unterprogramme Abschnitt 6.2 Rekursiv definierte Methoden 4

5 Motivation: Divide and Conquer divide et impera / teile und herrsche Wichtiges Grundprinzip der Algorithmik: Um ein Problem zu lösen, teile es in mehrere (einfachere) Teilprobleme auf Löse die einzelnen Teilprobleme Vereine die Teillösungen zu einer Gesamtlösung Beispiel: Merge-Sort Problem aufteilen bis einzelne, sortierte Listen Merge zweier Listen, jeweils kleinste Elemente vergleichen, in neue Liste kopieren

6 Rekursion Prinzip der Rekursion: Man führe das gleiche Berechnungsmuster immer wieder mit einfacheren bzw. kleineren Eingabedaten aus, bis man zu einer trivialen Eingabe gelangt Realisierung: Methoden, die sich direkt oder indirekt selbst aufrufen Rekursion ist die Standard-Implementierung von Divide-and-Conquer 6

7 Rekursive Methoden Definition: Eine Methode f heißt (direkt) rekursiv, wenn im Rumpf von f Aufrufe von f vorkommen. Eine Methode f heißt indirekt rekursiv, wenn im Rumpf von f eine Methode g aufgerufen wird, die ihrerseits direkt oder indirekt auf Aufrufe von f führt. Eine Methode f heißt endständig rekursiv, wenn im Rumpf von nach dem rekursiven Aufruf von f kein weiterer Code steht. Bei jedem rekursiven Aufruf wir eine neue Instanz der jeweiligen Methode gestartet. Jede Instanz hat ihre eigenen lokalen Variablen und Parameter, welche von außen nicht sichtbar sind 7

8 Beispiel: Fakultätsfunktion Die Fakultätsfunktion n! berechnet das Produkt der Zahlen 1, 2,..., n. Rekursiv lässt sich n! daher so berechnen: 0! = 1 n! = n (n - 1)! für n 1 Das lässt sich einfach als Funktion in Java schreiben: public static int fac(int n) { if (n > 0) { return n * fac(n - 1); else { return 1; 8

9 Beispiel: Fakultätsfunktion Was passiert nun beim Aufruf von fac? fac(4) = if (4 > 0) { 4*fac(4-1) else { 1 ) // Einsetzen = 4*fac(3) // Auswerten = 4*( if (3 > 0) { 3*fac(3-1) else { 1 ) // Einsetzen = 4*(3*fac(2)) // Auswerten = 4*(3*( if (2 > 0) { 2*fac(2-1) else { 1 )) // Einsetzen = 4*(3*(2*fac(1))) // Auswerten = 4*(3*(2*( if (1 > 0) { 1*fac(1-1) else { 1 ))) // Einsetzen = 4*(3*(2*(1*fac(0))) // Auswerten = 4*(3*(2*(1*( if (0 > 0) { 1*fac(0-1) else { 1 )))) // Einsetzen = 4*(3*(2*(1*1))) // Auswerten = 4*(3*(2*1)) = 4*(3*2) = 4*6 = 24 public static int fac(int n) { if (n > 0) { return n * fac(n - 1); else { return 1; 9

10 Binomialfunktion Die Binomialfunktion für n k 0 ist mit Hilfe der Fakultätsfunktion definiert als: Eine direkte Implementierung ist overflow-gefährdet, da die Fakultätsfunktion nur für kleine n im Computer darstellbar ist. Für die Binomialfunktion gilt aber: 10

11 Binomialfunktion (II) Damit lässt sich die Binomialfunktion rekursiv berechnen: public static int binom(int n, int k) { if (k < 0 k > n) { return 0; else { if (k == 0 k == n) { return 1; else { return binom(n-1, k-1) + binom(n-1, k); 11

12 Instanzen der Methode binom(n, k) Was passiert beim Aufruf von binom(3, 2)? binom(n, binom(3, 2) k) int n 3 (Parameter) int k 2 (Parameter) binom(2, 1) if (2 (k == 0 2 k == 3) n) { int n 2 return (Parameter) 1; binom(2, 2) int k 1 else { (Parameter) int n 2 (Parameter) return binom(2, 2 binom(n-1, binom(3-1, + binom(2, 1; 1) k-1) 2-1) int + 2); binom(2, k + binom(n-1, binom(3-1, 22); 2); k); (Parameter) binom(1, if == 0) binom(1, 0 1 == 1) 2) { int return n 1; 1 (Parameter) int n 1 (Parameter) if (2 == 0 2 == 2) { int else k { 0 (Parameter) int k 1 (Parameter) return 1; return binom(1, 1 binom(2-1, + binom(1, 1; 0) 1-1) + 1); binom(1, + binom(2-1, 1); else 1); { if (0 == 0 0 == 1) { if (1 == 0 1 == 1) { return binom(2-1, 2-1) + binom(2-1, 2); return 1; return 1; binom(3, 2) = 3 else { else { return binom(1-1, 0-1) + binom(1-1, 0); return binom(1-1, 1-1) + binom(1-1, 1); 12

13 Binomialfunktion mit Caching Effizientere Implementierung mit Caching: public static int binom(int n, int k) { int[][] cache = new int[n+1][k+1]; return binom(n, k, cache); private static int binom(int n, int k, int[][] cache) { if (cache[n][k] == 0) { if (k == 0 k == n) { cache[n][k] = 1; else { cache[n][k] = binom(n-1, k-1, cache) + binom(n-1, k, cache); return cache[n][k]; 13

14 Rekursion - Zusammenfassung Löse Problem durch Berechnung einer kleineren Instanz des Problems, bis Instanz des Problem so klein ist, dass die Lösung offensichtlich ist. Instanzen hängen von Parameter ab. Nachweis der Termination notwendig. Speicherverbrauch linear zur Zahl der Aufrufe (für lokale Variablen, Rücksprung-Adresse und aktuelle Parameter, für die in jeder Instanz neuer Speicher belegt wird). 14

15 Rekursion vs. Iteration Vorteilhaft, wenn die Anzahl der Iterationen noch unklar Viele Methodenaufrufe Zeitaufwendiger Belegen des Stacks für die Werte der aktuellen und lokalen Variablen Speicheraufwendiger Nicht auf dem ersten Blick abschätzbar, ob sie terminiert. Vorteilhaft, wenn die Anzahl der Iterationen bekannt ist. Komplexität leichter abschätzbar Leichter abschätzbar, ob die Iteration terminiert. 15

16 Die Kochsche Schneeflockenkurve Die Koch-Kurve ist ein Fraktal. Sie wird beginnend mit einer geraden Linie iterativ gebildet, indem aus jedem Geradenstück das mittlere Drittel entfernt wird und dafür der obere Teil eines gleichseitigen Dreieck aufgesetzt wird. 0: 1: 2: 3: 16