Rekursion. Beispiel Fakultät (iterativ) Rekursive Java-Implementierung. Beispiel Fakultät (rekursiv) n! = n

Transkript

1 Rekursion Beispiel Fakultät (iterativ) Methoden können Methoden aufrufen Methoden können nicht nur andere Methoden aufrufen, sondern auch sich selbst Eine Methode, die sich selbst (direkt oder indirekt) aufruft, nennt man rekursiv Viele Probleme (in der Informatik) lassen sich durch Rekursion besonders einfach und elegant lösen Schon die Beschreibung eines Problems kann interativ oder rekursiv geschehen Das Rad des Theodorus (465 v. Chr.) D 1 : Rechtwinkeliges Dreieck mit Seitenlänge 1 D 2 : Rechtwinkeliges Dreieck Schenkel 1: Hypotenuse von D1 Schenkel 2: Seitenlänge 1... D n : Rechtwinkeliges Dreieck Schenkel 1: Hypotenuse von Dn-1 Schenkel 2: Seitenlänge 1 Mathematisch: Iterative Definition der Fakultät (Faktorielle) n! einer natürlichen Zahl n: n! = n Die Lösung wird durch n-1 hintereinander ausgeführte Multiplikationen gewonnen Schreiben Sie eine Funktion zur Berechnung der Fakultät von n: static long fac(int n) static long fac(int n) { long result = 1; for(int i=2; i<=n; ++i) result *= i; return result; 1 2 Beispiel Fakultät (rekursiv) Rekursive Java-Implementierung Rekursive Definition der Fakultät Zurückführung auf sich selbst Die ersten (n-1) Faktoren des Produkts n! ergeben (n-1)!: 1. n! = (n-1)! n falls n > 1 2. n! = 1 falls n = 1 Das Problem n! zu berechnen wurde auf das gleichartige, aber kleinere Problem (n-1)! zu berechnen zurückgeführt (reduziert) Zweite Zeile ist notwendig, damit man bei der wiederholten Anwendung der ersten Zeile irgendwann zu einem Ende kommt Rekursive Implementierung der Fakultät if(n==1) // Nicht rekursiver Zweig return fact(n-1)*n; // Rekursiver Zweig Beispiel: Aufruf von fact(4) Rekursiver Zweig: 1. fact(4) ruft fact(3) auf, bewahrt den Wert 4 in lokaler Variable n 2. fact(3) ruft fact(2) auf, bewahrt den Wert 3 in lokaler Variable n (verschieden von n aus 1.) 3. fact(2) ruft fact(1) auf, bewahrt den Wert 2 in lokaler Variable n (wiederum neue Variable) Nicht rekursiver Zweig fact(1) gibt den Wert 1 zurück Auf dem Weg nach oben wird der vor dem rekursiven Aufruf ermittelte Wert mit der jeweiligen lokalen Variablen n des Rufers multipliziert und das Ergebnis weiter nach oben gegeben 3 4

2 Auswertung der Rekursion (logisch) Auswertung der Rekursion (Rechner) Jeder Aufruf von fact besitzt eigene lokale Variable Werte sind in der Regel verschieden Lokale Variablen aller gerade laufenden Methoden werden in Methodenkeller verwaltet Die Datenstruktur Keller erlaubt das Speichern und Lesen von Daten Zugriff nur auf zuletzt gespeichertes Datum Keller funktioniert also nach dem Last In First Out (LIFO)- Prinzip Beim Aufruf einer Methode werden ihre lokalen Variablen im Keller abgelegt Beim Beenden einer Methode werden ihre lokalen Variablen aus dem Keller entfernt if(n==1) return fact(n-1)*n; Beispiel: Aufruf von fact(4) if(n==1) return fact(n-1)*n fact(3) if(n==1) return fact(n-1)*n fact(2) if(n==1) return fact(n-1)*n fact(1) n=4 n=3 n=2 if(n==1) return fact(n-1)*n 6 = n=1 Auswertung Pro rekursivem Aufruf eine neue Kopie der lokalen Variablen Beispiel Fakultät Parameter n Lokale Variable result Rückgabewert Nicht sichtbar n result! // Funktion static int fak(int n) { if (n == 1) { { int result =! fak(n-1); return result*n; Im Debugger nachvollziehen 3?? 4?? 1? 1 2?? Manuelle Auswertung Ihre Eingabe Ihr Auftraggeber füllt das aus stack frame // Funktion static int fact(int n ) { if (n == 1) { { int result =! fact(n-1); return result*n; n result! Lokale Variablen Können für Ihre Berechnungen benutzt werden Was geben Sie zurück? Ausfüllen und an Auftraggeber zurückgeben 7 Rekursion: Teile und Herrsche Rekursion: Das Prinzip Teile und Herrsche : Wenn das Problem trivial ist, dann löse es Wenn das Problem nicht trivial ist, dann Zerlege es in kleinere, unabhängige Teilprobleme Löse die (kleineren) Teilprobleme separat Verbinde die Teillösungen zu einer Gesamtlösung Auf Englisch: divide and conquer Abstraktes Schema if(problem ist klein genug ( trivial )) führe nichtrekursiven Zweig aus (löse Problem) führe rekursiven Zweig aus (zerlege Problem) Rekursion liegt auch dann vor, wenn eine Methode p eine andere Methode q aufruft und diese wiederum p aufruft. Unterscheidung: indirekter Rekursion: Methode wird indirekt wieder aufgerufen direkte Rekursion: Methode ruft sich (direkt) selbst wieder auf 8

3 Vergleich: Iteration und Rekursion Beispiel: Eleganz von Rekursion (ggt) Iteration Rekursion static int fact(int n) { int result = 1; for (int i=2; i<=n; ++i) { result *= i; return result; Kein Funktionsaufruf der Funktion, die definiert wird Explizite Zustandsverwaltung in lokaler Variablen Schleifen Kein inhärenter Effizienzunterschied static int fact(int n) { if (n==1) return fact(n-1)*n; Funktionsaufruf der Funktion, die definiert wird Implizite Zustandsverwaltung durch verschiedene Instanzen der Parametervariablen Keine Schleifen Iterative Lösung // Kurz?! static int ggt(int x, int y) { int rest; do { rest = x%y; x = y; y = rest; while (y!=0) return x; Rekursive Lösung // Kuerzer static int ggt(int x, int y) { int rest = x%y; if(rest==0) return y; return ggt(y,rest); // Noch kuerzer static int ggt(int x, int y) { if(x%y==0) return y; return ggt(y,x%y); 9 10 Endrekursion Von Endrekursion nach Iterativ Algorithmus ist endrekursiv falls Rekursiver Aufruf die letzte Anweisung ist und keine weiteren Berechnungen statt finden Ergebnis des rekursiven Aufrufs ist das Ergebnis der gesamten Funktion Umwandeln in endrekursive Funktion meist einfach möglich Mitführen von zusätzlichen Argumenten / Kumulator Sammeln der bisherigen Ergebnisse in Kumulator Kontinuierliche Konstruktion des jeweiligen Zwischenergebnisses Beispiel Fakultät // rekursiv int fact(int n) { if (n == 1) return fact(n-1)*n; // endrekursiv int fact(int n, int akk) { if (n == 1) return akk; return fact(n-1, akk*n); int fact(int n) { return fact(n, 1); Automatische Überführung von Endrekursiv nach Iterativ möglich Solange nicht der tiviale Fall Berechne den Wert der neuen Aufrufparameter Beispiel: Fakultät Solange nicht n==1 Berechne den neuen Parameter akk aus altem akk*n Berechne den neuen Parameter n aus altem n-1 Umwandlung nicht endrekursiver Algorithmen ist schwieriger Lokale Variablen selbst verwalten (Stapel) Jeder rekursive Algorithmus ist in einen iterativen überführbar Stapel Variablen entspricht Abarbeitung auf Maschine // endrekursiv int fact(int n, int akk) { if (n == 1) return akk; return fact(n-1, akk*n); // iterativ int fact(int n, int akk) { while (n!= 1) { akk = akk * n; n = n - 1; return akk; 11 12

4 Verzweigte Rekursion (Beispiel: Fibonacci) Der italienische Mathematiker Leonardo von Pisa besser bekannt unter dem Namen Fibonacci (Kurzform von Filius Bonaccii ) fragte sich eines Tages, wieviele Kaninchen in einem eingezäunten Gehege pro Jahres geboren werden, wenn man davon ausgeht, dass Berechnung der Fibonacci-Zahlen Variante 1 (ineffizienter Algo.) Variante 2 (effizienter Algorithmus) static int fibo(int n) { int fibo(int n, int a, int b) { if(n==0!n==1) if(n==0) return n; return a; jeden Monat jedes Paar ein weiteres Paar erzeugt return fibo(n-1)+fibo(n-2); Kaninchen zwei Monate nach Geburt geschlechtsreif sind alle Kaninchen unsterblich sind Mit Fn = Anzahl der Kaninchen Paare nach n Monaten gilt F0=0, F1=1 und Fn=Fn-1+Fn-2 Aufruf von fibo(n) erzeugt knapp n*n Funktionsaufrufe Die durch die Folge F0=0, F1=1 und Fn=Fn-1+Fn-2 definierten Zahlen heißen Fibonacci-Zahlen Die ersten Fibonacci-Zahlen lauten Zwei Basisfälle (triviale Fälle) Zweifach rekursiver Aufruf Wiederholte Berechnung bereits berechneter Werte return fibo(n-1, b, a+b); Aufruf von fibo(n, 0, 1) erzeugt n+1 Funktionsaufrufe Bei 0.01sec pro Funktionsaufruf benötigt fibo(40, 0, 1) ca. 0.4sec Iterative Lösung: Bei 0.01sec pro Funktionsaufruf benötigt fibo(40) ca. 16sec int fibo(int n) { int[] f = new int[n+1]; f[0] = 0; f[1] = 1; for(int i=2; i<=n; ++i) f[i] = f[i-1] + f[i-2]; 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377,... return f[n]; 13 Beispiel: Türme von Hanoi (dramatisch) Edouard Anatole Lucas, ein französischer Mathematiker, erzählte 1883 folgende Legende: In einem Tempel im indischen Benares ruht eine Messingplatte in der drei Diamantnadeln befestigt sind. Auf einer der Nadeln hat Gott 64 Scheiben aus Gold zu einem Turm aufgeschichtet, wobei jede Scheibe etwas kleiner ist, als die Scheibe auf der sie ruht. Die Priester des Tempels sind Tag und Nacht damit beschäftigt, den Turm unter Beachtung der folgenden heiligen Regeln auf eine der anderen Nadeln zu bewegen. Die Scheiben sind so kostbar, dass sie nur auf den drei Diamantnadeln im Tempel aufgeschichtet werden dürfen. Die Scheiben sind schwer und zerbrechlich, daher darf immer nur eine der Scheiben bewegt werden, niemals mehrere zur gleichen Zeit. Niemals darf eine Scheibe auf einer kleineren Scheibe liegen. 14 Türme von Hanoi (realistisch) Türme aus Scheiben unterschiedlicher Größe Quelle Arbeitsbereich Ziel Drei Stangen Quelle Ziel Arbeitsbereich Bewege den Turm von der Quelle zum Ziel, wobei Nur die oberste Scheibe bewegt werden darf Sobald alle 64 Scheiben von der Nadel, auf die sie Gott bei der Erschaffung der Welt gesetzt hat, auf eine der anderen Nadeln gesetzt sind, wird der Tempel zusammen mit der Welt in einem Donnerschlag untergehen. 15 Nie eine größere auf einer kleineren Scheibe liegen darf 16

5 Türme von Hanoi (praktisch) Türme von Hanoi (algorithmisch) Rekursive Lösung Falls nur eine Scheibe (n=1) Bewege Scheibe von Quelle nach Ziel Falls mehrere Scheiben (n>1) 1. Bewege Turm aus den n-1 obersten Scheiben zum Arbeitsbereich 2. Bewege n-te Scheibe zum Ziel 3. Bewege Turm aus n-1 obersten Scheiben vom Arbeitsbereich zum Ziel 3 7 Wieviele Züge erfordert die Lösung? x n = Anzahl Züge, um n Scheiben von einer Stange auf eine andere zu bewegen Nach obiger Strategie x 1 =1 und x n =x n-1 +1+x n-1 =2x n-1 +1 für n=2,3,... Also x n = 2 n-1 +2 n = 2 n Flinke Mönche (1 Sekunde pro Scheibenwechsel) brauchen für die 64 Scheiben also = sec oder rund 580Milliarden Jahre Türme von Hanoi (in Java) Türme von Hanoi (iterativ I) static void hanoi(int n, int src, int work, int dest ) { if(n==1) { System.out.print("Bewege Scheibe von "); System.out.println(src + " nach " + dest); { hanoi(n-1, src, dest, work); System.out.print("Bewege Scheibe von "); System.out.println(src + " nach " + dest); hanoi(n-1, work, src, dest); static void hanoi(int n, int src, int work, int dest ) { if(n>1) hanoi(n-1, src, dest, work); System.out.print("Bewege Scheibe von "); System.out.println(src + " nach " + dest); if(n>1) hanoi(n-1, work, src, dest); 19 static void hanoiiterative(int n)"{" // n has to be greater than 1 int [][] bars = new int[3][n+1]; // src, work, dest bar, containing discs int [] lastpos = {n, 0, 0; // start configuration" int possdisc = 0; // smallest disc is on source for (int i=0; i<n+1; ++i) bars[0][i] = n+1-i; // put discs on source bar (n+1 avoid tests) bars[1][0] = n+1; bars[2][0] = n+1; // init work & dest (n+1 avoid empty bar test) while(bars[2][n]!=1) {" // while not al of the discs at destination // put smallest disc to the right System.out.printf("Smallest disc from %d to %d\n", possdisc, (possdisc+1)%3); bars[possdisc][lastpos[possdisc]--] = 0;" possdisc = (possdisc+1)%3;" bars[possdisc][++lastpos[possdisc]] = 1; // put second smallest disc to only possible destination"(cycle through list) int pos1 = (possdisc+1)%3, pos2 = (possdisc+2)%3; if (bars[pos1][lastpos[pos1]] > bars[pos2][lastpos[pos2]]) { System.out.printf(" > Disc from %d to %d\n", pos2, pos1); bars[pos1][++lastpos[pos1]] = bars[pos2][lastpos[pos2]]; bars[pos2][lastpos[pos2]--] = 0; if (bars[pos1][lastpos[pos1]] < bars[pos2][lastpos[pos2]]) { System.out.printf(" > Disc from %d to %d\n", pos1, pos2); bars[pos2][++lastpos[pos2]] = bars[pos1][lastpos[pos1]]; bars[pos1][lastpos[pos1]--] = 0; 20

6 Türme von Hanoi (iterativ II) Türme von Hanoi (künstlerisch) static void hanoiiterative2(int n) { int [][] bars = new int[3][n+1]; // src, work, dest bar int [] last = {n, 0, 0; // start configuration int ps=0, pos1, pos2; // smallest disc on source" for (int i=0; i<n+1; ++i) bars[0][i] = n+1-i; // (n+1 avoid tests) bars[1][0] = n+1; bars[2][0] = n+1; // init work & dest while(bars[2][n]!=1) { System.out.printf("Smallest disc from %d to %d\n", ps, (ps+1)%3); bars[ps][last[ps]--] = 0; // smallest disc to the right ps = (ps+1)%3; bars[ps][++last[ps]] = 1; pos2 = (bars[(ps+1)%3][last[(ps+1)%3]]>bars[(ps+2)%3][last[(ps+2)%3]])? (ps+2)%3 : (ps+1)%3; // disc to only possible place pos1 = 2*(pS+pos2) % 3; if (bars[pos1][last[pos1]]!= bars[pos2][last[pos2]]) { System.out.printf(" > Disc from %d to %d\n", pos2, pos1); bars[pos1][++last[pos1]] = bars[pos2][last[pos2]]; bars[pos2][last[pos2]--] = 0; Verschachtelte Rekursion Zusammenfassung Rekursion Prinzip Argument des rekursiven Aufrufs wird selbst durch rekursiven Aufruf bestimmt In jeder Programmiersprache mit Rekursion nutzbar Ausführung wieder mit lokalen Variablen und Stapel Beispiel Ackermannfunktion Sehr schnell wachsende Funktion Sehr aufwendige Berechnung int ackermann(int m, int n) { if (m == 0) return n+1; if (n == 0) return ackermann(m-1, 1); return ackermann(m-1, ackermann(m,n-1)); Rekursion Eine Funktion ruft sich selbst (direkt oder indirekt) auf Die Rekursion endet immer bei trivialen Fällen Vorteile der Rekursion Einfache, mächtige, intuitive Darstellung und Formulierung vieler Algorithmen Prinzip der Problemreduktion (Teile und Herrsche) direkt implementierbar Legenden um die Rekursion Rekursion ist immer langsamer Rekursion geht nicht in allen Umgebungen Rekursion braucht man nicht Fakten zur Rekursion Iteration und Rekursion sind gleich ausdrucksstark Alle sinnvollen Programmierumgebungen unterstützen Rekursion Rekursion kann (fast) immer so effizient wie ein iterativer Algorithmus implementiert und ausgeführt werden Ohne Rekursion werden Programm meist länger, unübersichtlicher, unwartbar, teuer, unelegant,