Algorithmik 1. Kapitel 8 - Rekursion. Friedrich-Alexander-Universität Erlangen-Nürnberg. Informatik 2/8 Programmiersysteme / Künstliche Intelligenz

Transkript

1 Kapitel 8 - Rekursion Algorithmik 1 8. Palindromtest 8.5 Skyline-Problem Teile-und-Herrsche Prof. Dr. Michael Philippsen / Prof. Dr. Herbert Stoyan Friedrich-Alexander-Universität Erlangen-Nürnberg Informatik 2/8 Programmiersysteme / Künstliche Intelligenz Algorithmik 1, WS 2004/05, Folie 8-2 Eine Geschichte Es war einmal ein Mann mit 2 Kindern, die eine Geschichte hören wollten. Der Vater fing an: Es war einmal ein Mann mit Kindern, die eine Geschichte hören wollten. Der Vater fing an: Es war einmal ein Mann mit 4 Kindern, die eine Geschichte hören wollten. Eine Geschichte anfang(x) { return "Es war einmal ein Mann mit "+ x + "Kindern, die eine Geschichte hören wollten."; ueberleit = "Der Vater fing an:"; ende() { return "Und wenn sie nicht gestorben sind,..."; Und wenn Sie nicht gestorben sind, dann leben sie noch heute. Und wenn Sie nicht gestorben sind, dann leben sie noch heute. Und wenn Sie nicht gestorben sind, dann leben sie noch heute. Algorithmik 1, WS 2004/05, Folie 8- Stopp Aufhören! geschichte(x) { Fragezeichen-Operator return anfang(x) + nochlust() Rekursionsschritt? ueberleit + geschichte(x+1) : "" + ende() Algorithmik 1, WS 2004/05, Folie 8-4 Terminierungsbedingung Leere Else -Fall, ohne geschichte-aufruf Nachklappern Rekursive Funktionsdefinition Zentrale Fragen der Rekursion Eine Methode f heißt rekursiv (lat. recurrere), gdw. zur Berechnung von f diese Methode f wieder benutzt wird. f(x) { heißt rekursive Methodendefinition, gdw. f in { auftritt. Unterschied: Im Rumpf von f steht g, im Rumpf von g steht wieder f. Keine rekursive Funktionsdefinition, wohl aber rekursiv. Stichwort: verschränkte Rekursion. Semantik: Zyklische Definitionen sind in der Regel unbefriedigend. Rekursive Funktionen erlangen erst durch ihre spezifische Behandlung der Argumente eine Bedeutung trotz ihrer zyklischen Struktur. Terminierung: Kommt die Berechnung zum Ende? Wiederum ist die spezifische Behandlung der Argumente wichtig. Nicht rekursiver Basis-/Abbruchfall ist erforderlich. Euklids ggt-algorithmus (1. und 4. Vorlesung) war rekursiv. Algorithmik 1, WS 2004/05, Folie 8-5 Algorithmik 1, WS 2004/05, Folie 8-6

2 Fakultätsfunktion (für n>0) 1 falls n=1 n! := n (n-1)! sonst Java-Code: Rekursive Definition long fakultaet(int n) { return (n == 1)? 1 : n*fakultaet(n-1); Terminierungsbedingung Basisfall Rekursionsschritt Nachklappern Java-Code der Fakultätsfunktion long fakultaet(int n) { return (n == 1)? 1 : n*fakultaet(n-1); Ausführung fakultaet(4) 4. fakultaet() 4. 6=24. fakultaet(2). 2= =2 fakultaet(1) 1 Algorithmik 1, WS 2004/05, Folie 8-7 Algorithmik 1, WS 2004/05, Folie 8-8 Nachklappern mit Hilfe der offenen Methodenschachteln Korrekt gemäß Spezifikation? (1) Gegeben: Spezifikation einer Funktion f (im mathematischen Sinne). Gefragt: Berechnet eine in einer Programmiersprache ausgedrückte Funktion f immer f? Für jede Eingabe kann das Ergebnis durch schrittweises Ausführen von f ermittelt werden. Dabei werden Methodenaufrufe im Methodenschachtelmodell ausgewertet. Durch Verallgemeinerung Aussage für alle Eingaben ableiten! Korrektheitsbeweis Rekursion als konstruktive Form der Induktion Rekursionsprinzip Auswertung f(e) für ein e Für einige f(e 0 ) ist der Wert von f ohne weitere Rekursion feststellbar. Versuche einen/mehrere Werte e <e zu finden, so dass sich f(e) leicht berechnen lässt, wenn f(e ) bekannt ist/sind. Induktion (vollständig) Beweis P für alle e Induktionsanfang: Zeige P(e 0 ) für kleinstes Element e 0 Induktionsschluss: Zeige P(e n ) P(e n+1 ) Bedeutung (und oft Terminierung) rekursiver Funktionsdefinitionen läßt sich mit Induktion beweisen. Algorithmik 1, WS 2004/05, Folie 8-9 Algorithmik 1, WS 2004/05, Folie 8-10 Korrekt gemäß Spezifikation? (2) n Fakultätsfunktion mathematisch: n! = Π i=1 i Java-Code long fakultaet(int n) { return (n == 1)? 1 : n*fakultaet(n-1); Nachweis von fakultaet(n) = n! für alle n 1 Induktionsanfang: fakultaet(1) = 1 = Π i=1 i = 1! Induktionsschluss "nn+1": fakultaet(n+1) = (n+1)*fakultaet(n) //Ausführung //Methodenschachtel = (n+1). n! //Induktionsvoraussetzg. n = (n+1). Π i=1 i //Definition von n! n+1 = Π i=1 i //Definition von Π Algorithmik 1, WS 2004/05, Folie 8-11 Terminierungsüberlegungen Terminierung kann für eine einzelne Eingabe nur im Erfolgsfall nachgewiesen werden. Rekursive Berechnung terminiert, wenn es eine Fallunterscheidung im Rumpf der Funktion gibt, bei der mindestens ein Fall keinen rekursiven Aufruf enthält und wenn jeder rekursive Aufruf nach endlich vielen Schritten einen nichtrekursiven Fall erreicht. Algorithmik 1, WS 2004/05, Folie 8-12

3 Skizze für Terminierungsbeweise e 0, e 1, e 2,... sei Argumentfolge der Rekursionsschritte bei Auswertung von f. Finde (ganzzahlige) Terminierungsfunktion t(e i ) und beweise (per Induktion?): t fällt bei jedem Rekursionsschritt streng monoton t ist nach unten beschränkt. Terminierungsbeweis für fakultaet long fakultaet(int n) { return (n == 1)? 1 : n*fakultaet(n-1); Argumentfolge betrachten: x, x-1, x-2,... Terminierungsfunktion finden: t(x) = x Nachweis (für ganzzahlige x>0): t(x) ist auf der Folge der Argumente streng monoton fallend bei jedem Rekursionsschritt (Induktionsbeweis) Bei der impliziten Annahme x ganzzahlig und x>0 ist t(x) nach unten durch 1 beschränkt. Algorithmik 1, WS 2004/05, Folie 8-1 Algorithmik 1, WS 2004/05, Folie 8-14 Der Induktionsgedanke ist ein wesentliches, wenn nicht das essentielle Mittel zum Entwurf von Algorithmen: Bestimme die Lösung für einen Basisfall Zerlege das Problem in ein, zwei oder mehrere einfache Teilprobleme, die entweder direkt oder rekursiv lösbar sind und verknüpfe die Lösung zur Gesamtlösung Beipiel: n! = n. (n-1)! Teilproblem 1: trival Verknüpfung Algorithmik 1, WS 2004/05, Folie 8-15 Teilproblem 2: Rekursiv lösbar Der Fall n wird auf den Fall n-1 zurückgeführt. Die Induktionsannahme wird einmal angewendet. Rekursion am Ende des Rumpfs. Problemspezifikation Gegeben: k Scheiben unterschiedlichen Durchmessers, der Größe nach geordnet auf Position A. Positionen B und C ohne Scheiben. A B C Problem: Verlege Scheiben-Turm von A nach B, wobei jede Scheibe nur einzeln bewegt werden kann, immer nur die oberste Scheibe eines Turmes bewegt werden kann, niemals eine größere Scheibe auf einer kleineren liegen darf und C zur Zwischenablage benutzt werden kann. Algorithmik 1, WS 2004/05, Folie 8-16 Lösungsansatz: Induktionsprinzip (1) Basisfall k=0: keine Scheiben. Trivial, weil sofort fertig. Rückführung auf kleinere Probleme (k>0) Teilproblem 1: Verlege die oberen k-1 Scheiben von Turm von A nach C kleines Problem: rekursiv lösbar Teilproblem 2: Verlege die verbleibende k-te Scheibe von A auf Turm B Triviale Elementaroperation Teilproblem : Verlege die k-1 Scheiben von Turm von C nach B kleines Problem: rekursiv lösbar Verknüpfung: Hintereinanderausführung der Teillösungen Induktionsannahme: Das Problem ist für die Verlegung von k-1 Scheiben lösbar. Gleiche Induktionsannahme nochmals Lösungsansatz: Induktionsprinzip (2) A B C k-1 Scheiben von A nach C 1 Scheibe von A nach B k-1 Scheiben von C nach B Algorithmik 1, WS 2004/05, Folie 8-17 Algorithmik 1, WS 2004/05, Folie 8-18

4 Java-Code public static void hanoi(int scheiben, char start, char ziel, char hilfe) { if (scheiben > 0) { hanoi(scheiben-1, start, hilfe, ziel); System.out.println("Verlege Scheibe " + scheiben + " von " + start + " nach " + ziel); hanoi(scheiben-1, hilfe, ziel, start); //else Fall=Basisfall der Induktion ist leer hanoi(, A, B, C ); > java Hanoi Verlege Scheibe 1 von A nach B Verlege Scheibe 2 von A nach C Verlege Scheibe 1 von B nach C //zwei Scheiben A C Verlege Scheibe von A nach B //größte Scheibe am Ziel Verlege Scheibe 1 von C nach A Verlege Scheibe 2 von C nach B //zweitgrößte Scheibe am Ziel Verlege Scheibe 1 von A nach B //fertig Der Fall k wird auf den Fall k-1 zurückgeführt. Die Induktionsannahme wird doppelt angewendet. Rekursion nicht nur am Ende des Rumpfs. Algorithmik 1, WS 2004/05, Folie 8-19 Algorithmik 1, WS 2004/05, Folie Palindromtest Korrektheit: Beweis per Induktion (kann direkt aus Rekursion abgelesen werden.) Terminierung: Terminierungsfunktion T(x) = x //Anzahl zu verlegender Scheiben Streng monoton fallend (per Induktionsbeweis) Nach unten durch 0 beschränkt Palindrom = Zeichenreihe die vorwärts und rückwärts gelesen gleich ist. Auch die leere Zeichenreihe ist ein Palindrom. Beispiele: ABBA // Palindrom ABB // kein Palindrom LEGINEINESOHELLEHOSENIENIGEL // Palindrom Gesucht: Entscheidungsfunktion, die angibt, ob eine Zeichenreihe ein Palindrom ist, oder nicht. Algorithmik 1, WS 2004/05, Folie 8-21 Algorithmik 1, WS 2004/05, Folie Palindromtest 8. Palindromtest Lösungsansatz: Induktionsprinzip Basisfall: n=0: die leere Zeichenfolge ist Palindrom n=1: die Zeichenfolge mit einem Zeichen ist Palindrom Rückführung auf kleinere Probleme (n>1): Wenn das erste und das letzte Zeichen übereinstimmen, dann Reduktion der Problemgröße um 2: Teste Palindromeigenschaft der Zeichenfolge ohne erstes und letztes Zeichen rekursiv Andernfalls: kein Palindrom Verknüpfung: Fallunterscheidung Der Fall n wird auf den Fall n-2 zurückgeführt. Man benötigt 2 Basisfälle, je einen für gerade und ungerade n. Rekursion nur am Ende des Rumpfs. Java-Code static boolean istpalindrom(string s) { // prueft s auf Palindromeigenschaft return istpalindrom(s, 0, s.length-1); static boolean istpalindrom(string s, int erstes, int letztes){ // prueft Zeichenreihe s[erstes],..., s[letztes] // (einschliesslich) auf Palindromeigenschaft if (erstes >= letztes) return true; // Basisfaelle if (s.charat(erstes)!= s.charat(letztes)) return false; return istpalindrom(s, erstes+1, letztes-1); Korrektheit und Terminierung wieder per Induktion leicht zu beweisen Algorithmik 1, WS 2004/05, Folie 8-2 Algorithmik 1, WS 2004/05, Folie 8-24

5 Ursprüngliche Fragestellung aus dem Jahr 1202 Gegeben sei ein neugeborenes Kaninchenpaar. Jedes Kaninchenweibchen bringt jeden Monat ein neues Paar zur Welt. Junge Kaninchen haben nach 2 Monaten ihre ersten Jungen. Kaninchen sterben nicht. Gesucht: Wie viele Kaninchenpaare gibt es nach 12 Monaten? Ergebnis: 1, 1, 2,, 5, 8, 1, 21, 4, 55, 8.4 Fibonaci-Zahlen Lösungsansatz: Induktionsprinzip Basisfall: n=0: Fib(0) = 1 n=1: Fib(1) = 1 Rückführung auf kleinere Probleme Teilproblem 1: Fib(n-2) Teilproblem 2: Fib(n-1) Verknüpfung: Addition Rekursive Definition: Fib(0) = 1, Fib(1) = 1, Fib(n)=Fib(n-2)+Fib(n-1) Die so genannten Fibonacci-Zahlen spielen in der Informatik an ganz unterschiedlichen Stellen eine Rolle. Algorithmik 1, WS 2004/05, Folie 8-25 / H. Stoyan Der Fall n wird auf zwei kleinere Fälle zurückgeführt. Man benötigt 2 Basisfälle. Rekursion nicht nur am Ende des Rumpfs. Algorithmik 1, WS 2004/05, Folie Fibonaci-Zahlen Java-Code public static int fibonacci(int n) { return ((n==0) (n==1))? 1 : fibonacci(n-1) + fibonacci(n-2); Nachteile der rekursiven Lösung fibonacci(4) fibonacci(2) fibonacci() Korrektheit und Terminierung wieder per Induktion leicht zu beweisen fibonacci(0) fibonacci(1) Algorithmik 1, WS 2004/05, Folie 8-27 Algorithmik 1, WS 2004/05, Folie 8-28 Nachteile der rekursiven Lösung fibonacci(2) fibonacci(0) fibonacci(4) fibonacci(1) fibonacci(1) Wenn man hier das Zwischenergebnis von fibonacci(2) noch hätte, könnte man die neue Berechnung einsparen. fibonacci() fibonacci(2) fibonacci(0) fibonacci(1) werden jeweils erneut ausgewertet! Durchreichen von Zwischenergebnissen public static int fibonacci(int fim1, int fi, int i, int n) { //Zwischenergebnis Fib(i-1) in fim1 // und Fib(i) in fi return (i >= n)? fi : fibonacci(fi, fim1 + fi, i+1, n); public static int fibonacci(int n) { return fibonacci(1,1,1,n); Statt Neuberechung wird (früheres) Teilergebnis verwendet. Diese Darstellung wird Aufrufbaum genannt. Algorithmik 1, WS 2004/05, Folie 8-29 Algorithmik 1, WS 2004/05, Folie 8-0

6 Rekursion bei durchgereichten Zwischenergebnissen fibonacci(1,1,1,4) fibonacci(1,2,2,4) fibonacci(2,,,4) fibonacci(,5,4,4) Zwischenergebnisse rücken auf u. werden zur Berechnung neuer Zwischenergebnisse verwendet. Korrektheit und Terminierung wieder per Induktion leicht zu beweisen Durchreichen von Zwischenergebnissen ist eine grundlegende Programmiermethode Analyse der Rekursion public static int fibonacci(int fim1, int fi, int i, int n) { //Zwischenergebnis Fib(i-1) in fim1 // und Fib(i) in fi return (i >= n)? fi : fibonacci(fi, fim1 + fi, i+1, n); Dann wird das Ergebnis von Methodenschachtel zu Methodenschachtel kopiert. Erst Abstieg bis auf tiefste Rekursionsebene (Basisfall). fibonacci(1,1,1,4) fibonacci(1,2,2,4) fibonacci(2,,,4) fibonacci(,5,4,4) Algorithmik 1, WS 2004/05, Folie 8-1 Algorithmik 1, WS 2004/05, Folie 8-2 / H. Stoyan 8.5 Skyline-Problem Teile-und-Herrsche Iterative Alternative zur Rekursion int fibonacci(int n) { if (n <= 1) return 1; int fim1 = 1; //Zwischenergebnis Fib(i-1) int fi = 1; //Zwischenergebnis Fib(i) for (int i = 2; i <= n; i++) { int temp = fi; fi = fim1 + fi; //Berechnung nächstes Zwischenergebis fim1 = temp; // Aufrücken über temp return fi; Korrektheit und Terminierung wieder per Induktion leicht zu beweisen Wo möglich sollte Iteration statt Rekursion verwendet werden, um Aufwand zu sparen (eine Methodenschachtel reicht aus.) Später mehr dazu. Algorithmik 1, WS 2004/05, Folie 8- Problem: Gegeben: Exakte Lage und Form von diversen rechteckigen Gebäuden einer Stadt Gesucht: Zeichne die zweidimensionale Skyline, wobei verborgene Linien eliminiert werden Gebäude B i wird durch Tripel (L i, H i, R i ) repräsentiert. Dabei stellen L i und R i die Koordinaten der linken bzw. rechten Ecke des Gebäudes dar. H i ist dessen Höhe. Beispiel: (1,11,5) 11 Algorithmik 1, WS 2004/05, Folie Skyline-Problem Teile-und-Herrsche 8.5 Skyline-Problem Teile-und-Herrsche Skyline-Problem am Beispiel Gegeben: Lösung: (1,11,5) (2,6,7) (,1,9) (12,7,16) (14,,25) (19,18,22) (2,1,29) (24,4,28) Lösungsansatz: Induktionsprinzip Basisfall: ein Gebäude ist seine eigene Skyline, also trivial Rückführung auf kleinere Probleme: Teilproblem 1: Skyline für n-1 Gebäude berechnen Teilproblem 2: ein Gebäude: trivial Verknüpfung: übereinanderlegen und neue Skyline koordinatenweise ablesen. Bsp: n-tes Haus: (5,9,26) Im Unterschied zu früheren Beispielen ist Verknüpfung hier recht aufwändig Skyline-Beschreibung: (1,11,,1,9,0,12,7,16,,19,18,22,,2,1,29,0) Skyline (n-1): (1,11,,1,9,0,12,7,16,,19,18,22,,2,1,29,0) Skyline (n): (1,11,,1,9,9, 19,18,22,9,2,1,29,0) Algorithmik 1, WS 2004/05, Folie 8-5 Algorithmik 1, WS 2004/05, Folie 8-6

7 8.5 Skyline-Problem Teile-und-Herrsche Diese Lösung kann als korrekt und terminierend bewiesen werden. Allerdings: Um das Gebäude n hinzuzufügen, muss der Durchlauf durch die Skyline der n-1 Gebäude im schlimmsten Fall n Stellen überprüfen bzw. ändern: Hinzufügen Gebäude n: n Hinzufügen Gebäude n-1: n-1 Hinzufügen Gebäude n-2: n-2 Hinzufügen Gebäude 1: 1 Gesamt: ½ n(n+1) Überprüfungen/Änderungen Bei 16 Gebäuden: 16 17/2 = 16 Schritte Es gibt i.a. mehrere Algorithmen für ein Problem Algorithmik 1, WS 2004/05, Folie Skyline-Problem Teile-und-Herrsche 2. Lösungsansatz, ebenfalls Induktionsprinzip Basisfall: ein Gebäude ist seine eigene Skyline, also trivial Rückführung auf kleinere Probleme: Teilproblem 1: Skyline für n/2 Gebäude berechnen Teilproblem 2: Skyline für restliche n/2 Gebäude berechnen Verknüpfung: Führe die beiden Skylines zusammen. Man spricht von Verschmelzung Beispiel: Algorithmik 1, WS 2004/05, Folie 8-8 Verknüpfung nicht langsamer als im 1-Gebäude-Fall! Schrittweises Durchlaufen beider Skyline-Folgen halber Länge, maximal n Änderungen 8.5 Skyline-Problem Teile-und-Herrsche 2. Lösung kann als korrekt und terminierend bewiesen werden. Schneller: Beispiel: Aufwand T(n) zur Lösung des Problems für n Gebäude vereinfachend: 2er-Potenz T(n) = 2 * T(n/2) + n //Aufteilung 2 halb so große Teilprobleme //n Schritte zur Verknüpfung n = 16 Gebäude: T(16) = 2 * T(8) + 16 = 2 * ( 2 * T(4) + 8) + 16 = 4 * T(4) + 2 * 16 = 4 * (2 * T(2) + 4) + 2 * 16 = 8 * T(2) + * 16 = 16 * T(1) + 4 * 16 = 80 Schritte (statt 16) Algorithmik 1, WS 2004/05, Folie Skyline-Problem Teile-und-Herrsche Allgemein: Die Rekurrenz T(n) = 2. T(n/2) + n, T(1) = 1 hat für 2er Potenzen n die Lösung T(n) = n + n. log 2 (n) //Beispiel: T(16) = *4 = 80 Beweis durch Induktion: Induktionsanfang: T(1) = 1 //trivial Induktionshypothese: Es gilt: T(n/2) = n/2 + n/2. log 2 (n/2) Induktionsschritt: T(n) = 2. T(n/2) + n //nach Definition von T(n) = 2. (n/2 + n/2. log 2 (n/2)) + n //Induktionshypothese = n + n. log 2 (n/2) + n = n + n. (log 2 (n/2) + 1) = n + n. log 2 (n) //nach Definition log 2 Algorithmik 1, WS 2004/05, Folie Skyline-Problem Teile-und-Herrsche 8.5 Skyline-Problem Teile-und-Herrsche Von Problemgröße abhängiger Aufwand Schrittzahl Problemgröße Algorithmik 1, WS 2004/05, Folie 8-41 n(n+1)/2 n+n*log(n,2) Bis n=6 ist der 1. Lösungsansatz besser, dann Umstiegspunkt. Teile-und-Herrsche: = Anwendung des Induktionsprinzips zur Algorithmenkonstruktion Prinzip: Zerlegung des Problems in mehrere (deutlich) kleinere Probleme Lösung dieser durch Rekursion (falls groß genug) Direkte Lösung oder Basisfall, wenn Problem klein genug ist. Hier/meistens: 2 Probleme halber Größe Füge Teillösungen zur Gesamtlösung zusammen, wobei die Verschmelzung relativ wenig Aufwand verursacht Aufwand: Rekurrenz; kann per Induktion nachgewiesen werden. Da es für ein Problem i.a. mehrere Algorithmen gibt, wird uns die Frage nach dem Aufwand und dem besten Algorithmus für ein Problem später noch beschäftigen! Algorithmik 1, WS 2004/05, Folie 8-42

8 Lineare Rekursion = eine rekursive Methodendeklaration f heißt linear rekursiv, wenn in jedem Zweig einer Fallunterscheidung höchstens einmal f aufgerufen wird. Repetitive Rekursion (Rumpf-Rekursion, tail recursion ) = Spezialfall der linearen Rekursion, bei dem der rekursive Aufruf stets als letzte Aktion des Zweigs auftaucht. Sobald die tiefste Rekursionsebene erreicht ist, wird das Ergebnis von Methodenschachtel zu Methodenschachten einfach nur nach oben kopiert, um dann als Gesamtergebnis zurück gegeben zu werden. Repetitive Rekursionen können daher unmittelbar entrekursiviert und durch Schleifen ersetzt werden. Oben am Beispiel der Fibonacci-Zahlen Die lokalen Variablen der Methode werden dann bei jedem Schleifendurchlauf erneut verwendet. Bei Referenz-Aufruf ist Entrekursivierung wegen möglicher Seiteneffekte unter Umständen schwieriger. Schema zur Entrekursivierung rumpfrekursiver Funktionen: Rumpfrekursive Funktion: g(x) falls Präd(x) //nicht-rekursiver Basisfall f(x) = f(r(x)) sonst //rekursiver Aufruf, //modifizierter ( kleinerer ) Parameter Entrekursivierte Fassung: arg = x; //Hilfsvariable while (!Präd(arg)) { arg = r(arg); //modifiziere Parameter return = g(arg); //nicht-rekursiver Basisfall Algorithmik 1, WS 2004/05, Folie 8-4 Algorithmik 1, WS 2004/05, Folie 8-44 Kaskadenartige Rekursion = In einem Zweig einer Fallunterscheidung im Rumpf einer rekursiven Methodendeklaration f treten zwei oder mehr Aufrufe von f auf. Baumartige Aufrufstruktur Lawinenartiges Anwachsen der anfallenden rekursiven Aufrufe Kaskadenartige Rekursion lässt sich nicht (leicht) in Iterationen umwandeln. Siehe oben: Teile-und-Herrsche Verschachtelte Rekursion = die rekursiven Aufrufe treten nicht nur im Rumpf der Methodendeklaration sondern zusätzlich bei den aktuellen Parameterausdrücken auf. int ackermann(int m, int n) { if (m==0) return n+1; else if (n==0) return ackermann(m-1,1); else return ackermann(m-1, ackermann(m, n-1)); Diese Funktion werden Sie in der theoretischen Informatik noch intensiv studieren (Stichwort: Berechenbarkeit). Sie ist nicht mit primitver Rekursion (f(n+1)=h(n,f(n)) ausdrückbar. Sie terminiert immer. Ihre Werte wachsen jedoch bei Vergrößerung der Argumente außerordentlich schnell: ackermann(,) = 61, ackermann(2,4) , ackermann(4,4) Algorithmik 1, WS 2004/05, Folie 8-45 Algorithmik 1, WS 2004/05, Folie 8-46 Anderes Beispiel: iterierte Quersumme Modulo 9 k Sei ù 0 hn = a i 10 i mit 0 a i 9 die Darstellung von n im i=0 Dezimalsystem. Dann ist die iterierte Quersumme Modulo 9: k qsum(n) = ( a i ) % 9 i=0 int qsum(int n) { if (n<9) return n; else if (n==9) return 0; else return qsum(qsum(n/10) + (n%10)); Verschachtelte Rekursionen: Schwer zu beweisende Terminierung Sind in der Praxis unbedeutend. Verschränkte Rekursion: Eine Methodendeklaration f enthält einen Aufruf der Methode g, die wiederum einen Aufruf von f enthält. Im allgemeinen Fall: k Methodendeklarationen. Beispiel: iterierte binäre Quersumme boolean qsumis1(int n) { if (n==0) return false; //Quersumme ist nicht 1 else if ((n%2)==0) return qsumis1(n/2); //wenn gerade, dann muss binäre //Quersumme der Hälfte 1 sein. else return qsumis0(n/2); //wenn ungerade, dann muss bin. //Quersumme der Hälfte 0 sein. //Achtung / ist Div ohne Rest. boolean qsumis0(int n) { //analog Algorithmik 1, WS 2004/05, Folie 8-47 Algorithmik 1, WS 2004/05, Folie 8-48

9 Beispiel: iterierte binäre Quersumme qsumis1(42) boolean qsumis1(int n) { if (n==0) return false; else if ((n%2)==0) return qsumis1(n/2); else return qsumis0(n/2); boolean qsumis0(int n) { if (n==0) return true; else if ((n%2)==0) return qsumis0(n/2); else return qsumis1(n/2); qsumis1(21) qsumis0(10) qsumis0(5) qsumis1(2) qsumis1(1) qsumis0(0) true ggt: repetitive Rekursion Fakultätsfunktion: lineare Rekursion Türme von Hanoi: kaskadenartige Rekursion Palindromtest: repetitive Rekursion Fibonacci-Zahlen: kaskandenartige Rekursion Durchreichen von Zwischenergebnissen liefert repetitive Rekursion umgebaut in Iteration. Skyline-Problem: kaskadenartige Rekursion Hat die Binärdarstellung von 42 eine ungerade Zahl von Einsen? 42 = 2+8+2= binär qsumis1(42) Algorithmik 1, WS 2004/05, Folie 8-49 Algorithmik 1, WS 2004/05, Folie 8-50