Rekursive Funktionen

Transkript

1 Um Rekursion zu verstehen, muss man vor allem Rekursion verstehen. Rekursive Funktionen OOPM, Ralf Lämmel

2 Was ist Rekursion? (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 190

3 Eine Illustration von Rekursion

4 192 Eine (rekursive) mathematische Definition von! (Fakultät) n! = 1, falls n = 0 n * (n-1)!, falls n > 1

5 193 Rekursive Berechnung von! 5! = 5 * 4! = 4 * 3! = 3 * 2! = 2 * - 1! = 1 * - 0! = 1

6 Rekursive Definition von! in Java Umsetzung in Java: // Assume n >= 0 public static int factorial(int n) { if (n == 0) return 1; else return n * factorial(n-1); (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau Siehe package algorithm.factorial 194

7 195 Aufruf (nicht-) rekursiver Funktionen public class Program { public static int divby2(int x) { return x / 2; public static void main(string[] args) { int x = 5; int y = divby2(x); System.out.println(y);

8 196 Die Realisierung eines Funktionsaufrufs entspricht dem Entfalten der Funktionsdefinition. Dabei werden formale Parameter durch aktuelle Parameter ersetzt. int x = 5; int y = divby2(x); System.out.println(y); int x = 5; int y = x / 2; System.out.println(y); Die Entfaltung ist statisch möglich für nichtrekursive Funktionen. Die Entfaltung ist notwendigerweise dynamisch (zur Laufzeit) nötig für rekursive Funktionen.

9 197 Rekursive Funktionsdefinitionen Teile der Definition Basisfall Nichtrekursive Berechnung Rekursiver Fall Rekursive(r) Aufruf(e) Verwertung der (des) Aufrufe(s) Nichtrekursive Berechnung Die Auswahl der Teile erfolgt über Bedingung(en). Es kann auch mehre Fälle jeder Art geben.

10 198 Rekursive Definition von! // Assume n >= 0 public static int factorial(int n) { if (n == 0) return 1; else Abbruchbedingung Basisfall return n * factorial(n-1); Rekursiver Fall

11 199! mittels ternärem Operator // Assume n >= 0 Angenommene Vorbedingung (oft ausgelassen) public static int factorial(int n) { return (n == 0)? Abbruchbedingung 1 Basisfall : n * factorial(n-1); Rekursiver Fall

12 200 Die Fibonacci-Folge Anzahl neugeborener Kaninchen nach n Jahren: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,... Rekursive Funktionsdefinition: fib(n) = 0, falls n = 0 1, falls n = 1 fib(n-2) + fib(n-1), n >= 2

13 Die Fibonacci-Folge public static int fib(int n) { if (n == 0) return 0; else if (n == 1) return 1; 1. Basisfall 2. Basisfall else return fib(n - 2) + fib(n - 1); 2 rekursive Aufrufe (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau Siehe package algorithm.fibonacci 201

14 202 Die Fibonacci-Folge (mit Verwendung des ternären Operators) public static int fib(int n) { return n == 0? 0 : n == 1? 1 : fib(n - 2) + fib(n - 1);

15 203 Anmerkung zur Wahl rekursiver Definitionen Folgende Attribute sind relativ: Eleganz In-/effizienz Beispiel - Die Fibonacci-Folge: Exponentielle Explosion von Aufrufen fib(n) benötigt nur 2 direkte Vorgänger. Effizientere Formulierung darum naheliegend Overhead Stichwort Compiler-Optimierungen

16 204 Umwandlung der ineffizienten, (binär-)rekursiven Fibonacci-Funktion in eine effiziente, entweder (linear-)rekursive oder iterative Darstellung Naive, rekursive Formulierung Exponentielle Explosion von Aufrufen Schlüsseleigenschaft fib(n) benötigt nur 2 direkte Vorgänger. Effiziente, rekursive Formulierung Vorgänger werden als Parameter gereicht. Effiziente, iterative Formulierung Vorgänger werden in Variablen gehalten.

17 205 Effiziente, rekursive Formulierung public static int fib(int n) { return fib(n,0,1); public static int fib(int n, int n1, int n2) { return n == 0? n1 : fib(n-1, n2, n1 + n2); Wir überladen den Funktionsnamen. (Wir verwenden verschiedene Argumenttypen.)

18 206 Effiziente, iterative Formulierung public static int fib(int n) { int n1 = 0; int n2 = 1; for (; n!= 0; n--) { int m1 = n1; int m2 = n2; n1 = m2; n2 = m1 + m2; return n1;

19 207 Türme von Hanoi Annahmen: N Scheiben verschiedener Durchmesser Stapelung mit abnehmendem Durchmesser 3 Plätze: A, B, C Ziel: Bewegen aller Scheiben von A nach C

20 208 Türme von Hanoi - Illustration Startkonfiguration Move 1 Move 2 Move 3 Move 4 Move 5 Move 6 Endkonfiguration

21 209 Türme von Hanoi - Ansatz Ziel: Verschiebung von N Scheiben von A nach C Annahme: Verschieben von N-1 Scheiben möglich Schritte: Verschiebe N-1 Scheiben von A nach B Verschiebe letzte (große) Scheibe von A nach C Verschiebe N-1 Scheiben von B nach C

22 Türme von Hanoi public class Program { public static void move( int n, String from, String temp, String to) { if (n == 0) return; move(n-1, from, to, temp); System.out.println( "Move disc " + n + " from " + from + " to " + to); move(n-1, temp, from, to); public static void main(string[] args) { move(3,"a","b","c"); (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau Siehe package algorithm.hanoi 210 Move disc 1 from A to C Move disc 2 from A to B Move disc 1 from C to B Move disc 3 from A to C Move disc 1 from B to A Move disc 2 from B to C Move disc 1 from A to C

23 211 Formen von Rekursion Primitive Rekursion Allgemeine Rekursion Endrekursion Lineare Rekursion Binäre Rekursion Indirekte Rekursion

24 212 Primitive Rekursion Funktion über induktive Struktur von nat. Zahlen Schemavariablen: g, h Schema: f(n) = g, falls n=0 h(n,f(n-1)), sonst Termination ist garantiert. Bestimme g und h! public static int factorial(int n) { if (n == 0) return 1; else return n * factorial(n-1);

25 213 Beispiel: even/odd (Primitiv-rekursive Variante) // Assume n >= 0 public static boolean even(int n) { return (n<=1)? (n==0) :!even(n-1); // Assume n >= 0 public static boolean odd(int n) { return (n<=1)? (n==1) :!odd(n-1); Eine einfache Verallgemeinerung der primitiven Rekursion mit einem Basisfall > 0

26 214 Allgemeine Rekursion Keine Einschränkungen an Rekursion Beispiel: McCarty 91-er Funktion: f(n) = n-10, falls x > 100 f(f(n+11)), sonst Eigenschaften: f(n) = 91 für alle n <= 101 f(n) = n - 10 für alle n > 101

27 215 Beispiel: McCarty 91-er Funktion public static int f(int n) { if (n > 100) return n - 10; else return f(f(n+11)); f(n) = 91 für alle n <= 101 f(n) = n - 10 für alle n > 101

28 216 Endrekursion Schemavariablen: g, p, r Schema: f(x) = g(x), falls p(x) f(r(x)), sonst Der rekursive Aufruf ist die letzte Operation auf jeder Ebene. Bedeutung: iterative Implementation trivial Endrekursive Formulierung oft relativ einfach Beispiele:!, even/odd nach Anpassung

29 217 Beispiel: even/odd (Primitiv-rekursive Variante) // Assume n >= 0 public static boolean even(int n) { return (n<=1)? (n==0) :!even(n-1); // Assume n >= 0 public static boolean odd(int n) { return (n<=1)? (n==1) :!odd(n-1);

30 218 Beispiel: even/odd (End-rekursive Variante) // Assume n >= 0 public static boolean even(int n) { return (n<=1)? (n==0) : even(n-2); // Assume n >= 0 public static boolean odd(int n) { return (n<=1)? (n==1) : odd(n-2);

31 219 Umwandlung von Endrekursion in eine iterative Formulierung Rekursiv: f(x) = g(x), falls p(x) f(r(x)), sonst Iterativ: f(x) = Solange p(x) nicht gilt x = r(x) Gib g(x) zurück.

32 220 Beispiel: even/odd (End-rekursive Variante) public static boolean even(int n) { return (n<=1)? (n==0) : even(n-2); public static boolean even(int n) { while (!(n<=1)) n -= 2; return n==0;

33 221 Umwandlung von primitiver nach End- Rekursion am Beispiel der Fakultät (Verwendung eines Akkumulatorargumentes) Primitive Rekursion: n! = 1, falls n = 0 n * (n-1)!, sonst Endrekursion: n! = factorial(1,n) factorial(x,n) = x, falls n = 0 factorial(x*n, n-1), sonst

34 222 Beispiel: Fakultät (End-rekursive Variante) public static int factorial(int n) { return (n == 0)? 1 : n * factorial(n-1); public static int factorial(int n) { return factorial(1,n); public static int factorial(int x, int n) { return (n==0)? x : factorial(n*x,n-1); Wir überladen den Funktionsnamen. (Wir verwenden verschiedene Argumenttypen.)

35 223 Lineare Rekursion Verallgemeinerung von: Primitive Rekursion Endrekursion Schemavariablen: g, p, h, r Schema: f(x) = g(x), falls p(x) h(x,f(r(x))), sonst Einfache Verallgemeinerung: f kann mehrmals referenziert werden aber nur einmal ausgewertet werden.

36 224 Binäre Rekursion Verallgemeinerung von linearer Rekursion Zwei, verschiedenartige rekursive Aufrufe. Beide Aufrufe fallen auch dynamisch an. Beispiel: Die Fibonacci-Funktion

37 225 Indirekte Rekursion Eine Funktion ruft sich nicht (nur) direkt selbst auf. Stattdessen sind mehrere Funktionen beteiligt. Indirekte Rekursion erleichtert Modularisierung. Beispiel: even(n) = true, falls n = 0 odd(n-1), sonst odd(n) = false, falls n = 0 even(n-1), sonst

38 Beispiel: even/odd (Indirekt-rekursive Variante) // Assume n >= 0 public static boolean even(int n) { if (n==0) return true; else return odd(n-1); // Assume n >= 0 public static boolean odd(int n) { if (n==0) return false; else return even(n-1); (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 226

39 227 Beispiel: even/odd (Kompaktere indirekt-rekursive Variante) // Assume n >= 0 public static boolean even(int n) { return (n==0) odd(n-1); // Assume n >= 0 public static boolean odd(int n) { return!(n==0) && even(n-1);

40 Zusammenfassung Rekursive Definitionen sind oft elegant. Rekursion kann Kosten verursachen. Konvertierung rekursiv nach iterativ Prinzipiell immer möglich Praktisch oft elegant möglich Ausblick Nächstes Mal: Einfache Sortieralgorithmen Anwendung von Feldern Anwendung von rekursiven Funktionen