Rekursion IFB Weiterbildungslehrgang X Informatik Kurs 2: Thema „Rekursion“ 2. 12. 2005 Tobias Selinger

Was macht man mit einem großen Problem? Flugzeugsimulator-Programm Einleitung Was macht man mit einem großen Problem? Flugzeugsimulator-Programm ?

Modularisierung - „Teile und herrsche“ Was macht man mit einem großen Problem? Flugzeugsimulator-Programm in Teilprobleme zerlegen Benutzer-Oberfläche Spiel-Steuerung 3D-System Karten- datenbank Landschafts-generator Level-Editor

Zerlegung in Teilprobleme? 4 ! = 4 • 3 • 2 • 1 = 24 5 ! = 5 • 4 • 3 • 2 • 1 = 120

Definition: rekursiv lösbar Ein Problem ist rekursiv lösbar, falls man es in Teilprobleme zerlegen kann, die alle „ähnlich“ zum Gesamtproblem sind „kleiner“ als das Gesamtproblem sind irgendwann „direkt lösbar“ sind Beispiel: Zeichne diesen Busch! Ähnliche Teilprobleme ?

Busch: Teilprobleme Ein Problem ist rekursiv lösbar, falls man es in Teilprobleme zerlegen kann, die alle „ähnlich“ zum Gesamtproblem sind „kleiner“ als das Gesamtproblem sind irgendwann „direkt lösbar“ sind Beispiel 1: Zeichne diesen Busch! Ähnliche Teilprobleme: Zeichne Teilbüsche ! Wie ??? linker Teilbusch rechter Teilbusch Level 1

Busch: Teilprobleme Ein Problem ist rekursiv lösbar, falls man es in Teilprobleme zerlegen kann, die alle „ähnlich“ zum Gesamtproblem sind „kleiner“ als das Gesamtproblem sind irgendwann „direkt lösbar“ sind Beispiel 1: Zeichne diesen Busch! Ähnliche Teilprobleme: Zeichne Teilbüsche ! Wie ??? Ebenso... ! Teil-busch Teil-busch Teilbusch Teilbusch Level 2 Level 1

Busch: Bildungsgesetz Ein Problem ist rekursiv lösbar, falls man es in Teilprobleme zerlegen kann, die alle „ähnlich“ zum Gesamtproblem sind „kleiner“ als das Gesamtproblem sind irgendwann „direkt lösbar“ sind Das rekursive Bildungsgesetz für einen Busch lautet also: rechter (Teil-)Busch linker (Teil-)Busch Zweig nach rechts Zweig nach links Busch = ???

Busch: Bildungsgesetz Ein Problem ist rekursiv lösbar, falls man es in Teilprobleme zerlegen kann, die alle „ähnlich“ zum Gesamtproblem sind „kleiner“ als das Gesamtproblem sind irgendwann „direkt lösbar“ sind Das rekursive Bildungsgesetz für einen Busch lautet also: rechter (Teil-)Busch linker (Teil-)Busch Zweig nach rechts Zweig nach links Busch = rechter Zweig + rechter (Teil)-Busch + linker Zweig + linker (Teil)-Busch Beachte: Endlos-Rekursion???

Busch: Bildungsgesetz Ein Problem ist rekursiv lösbar, falls man es in Teilprobleme zerlegen kann, die alle „ähnlich“ zum Gesamtproblem sind „kleiner“ als das Gesamtproblem sind irgendwann „direkt lösbar“ sind Das rekursive Bildungsgesetz für einen Busch lautet also: rechter (Teil-)Busch linker (Teil-)Busch Zweig nach rechts Zweig nach links Busch = rechter Zweig + rechter (Teil)-Busch + linker Zweig + linker (Teil)-Busch Beachte: Wenn ein Teilbusch „klein genug“ ist, gilt er als „abgeschlossen“ (ohne weitere Folgearbeit) ! Ansonsten müsste man endlos weiterzeichnen...

Busch: Programmierung rechter (Teil-)Busch linker (Teil-)Busch Zweig nach rechts Zweig nach links Programmierung der Grundstruktur: procedure busch(laenge: real); begin if laenge > 10 then with Form1.Turtle1 do begin turnright(20); forwd(laenge); back(laenge); turnleft(40); forwd(laenge); back(laenge); turnright(20); end; end; Eintrittsbedingung ???

Busch: Programmierung rechter (Teil-)Busch linker (Teil-)Busch Zweig nach rechts Zweig nach links Programmierung der Grundstruktur: procedure busch(laenge: real); begin if laenge > 10 then with Form1.Turtle1 do begin turnright(20); forwd(laenge); back(laenge); turnleft(40); forwd(laenge); back(laenge); turnright(20); end; end; Eintrittsbedingung rechten Zweig zeichnen zurück und linken Zweig zeichnen zurück und geradeaus drehen (in Ausgangsposition!)

Busch: Programmierung rechter (Teil-)Busch linker (Teil-)Busch Zweig nach rechts Zweig nach links Programmierung der Grundstruktur: Ergänzung der rekursiven Aufrufe: procedure busch(laenge: real); begin if laenge > 10 then with Form1.Turtle1 do begin turnright(20); forwd(laenge); ??? back(laenge); turnleft(40); forwd(laenge); ??? back(laenge); turnright(20); end; end; rechten Zweig zeichnen rechten Teilbusch zeichnen? zurück und linken Zweig zeichnen linken Teilbusch zeichnen? zurück und geradeaus drehen

Busch: Programmierung rechter (Teil-)Busch linker (Teil-)Busch Zweig nach rechts Zweig nach links Programmierung der Grundstruktur: Ergänzung der rekursiven Aufrufe: procedure busch(laenge: real); begin if laenge > 10 then with Form1.Turtle1 do begin turnright(20); forwd(laenge); busch(...................); back(laenge); turnleft(40); forwd(laenge); busch(...................); back(laenge); turnright(20); end; end; rechten Zweig zeichnen rechten Teilbusch zeichnen zurück und linken Zweig zeichnen linken Teilbusch zeichnen zurück und geradeaus drehen

Busch: Programmierung rechter (Teil-)Busch linker (Teil-)Busch Zweig nach rechts Zweig nach links Programmierung der Grundstruktur: Ergänzung der rekursiven Aufrufe: procedure busch(laenge: real); begin if laenge > 10 then with Form1.Turtle1 do begin turnright(20); forwd(laenge); busch(laenge * 0.7); back(laenge); turnleft(40); forwd(laenge); busch(laenge * 0.7); back(laenge); turnright(20); end; end; rechten Zweig zeichnen rechten Teilbusch zeichnen zurück und linken Zweig zeichnen linken Teilbusch zeichnen zurück und geradeaus drehen Programm-Demo!

Busch: Aufbau der „Levels“

Busch: Aufbau der „Levels“

Busch: Aufbau der „Levels“

Busch: Aufbau der „Levels“ Programm-Demo! Level ? Übungen!

Übungen: Spirale und Baum Übungen: Entwickeln Sie zunächst das Grundmuster, danach die Einstiegspunkte für rekursive Aufrufe. Vergessen Sie nie die Eintritts-/Abbruchbedingung! Kopieren Sie das Delphi-Projekt „Rekursion graphisch“ und bauen Sie Ihre Prozeduren dort ein! Testen Sie! spirale(laenge) erzeugt eine „Spirale“ als geknickte Linie (Winkel jeweils 30°), deren Linienstücke immer kürzer werden. baum(laenge) ähnelt dem Busch, hat aber als Grundmuster einen Stamm mit zwei „Knospen“.

Übungen: Kochkurve und Hutschnur koch(laenge) erzeugt die berühmte Kochkurve: Das mittlere Drittel einer Strecke wird durch zwei ebenso lange Dreieckseiten ersetzt, dies wird dann auf allen vier Teilstrecken durchgeführt, und wiederum auf deren Teilstrecken... hutschnur(laenge) ähnelt der Kochkurve, ersetzt das mittlere Drittel aber durch drei Quadratseiten, und setzt dieses Verfahren auf allen Teilstrecken fort.

Übungen für Spezialisten: Sierpinski und Drachenkurve sierpinski(laenge) erzeugt ein gleichseitiges Dreieck, in dessen Ecken halb so große Dreiecke sitzen, in deren Ecken wiederum... drache(laenge) erzeugt die berühmte Drachenkurve, die sich aus einem geknickten Papierstreifen ergibt: Einen langen Streifen durch Knicken sorgfältig halbieren, die beiden übereinanderliegenden Teilstreifen wieder Knicken ... ... und am Schluss den gesamten Streifen jeweils mit 90°-Knicks auseinanderfalten. Am besten macht man es einmal vor! (Tipp: Verwenden Sie zwei Parameter: drache(laenge, winkel) , wobei der winkel die gewünschte Knickrichtung +/- 90° angibt!)

Numerischer Einstieg: Fakultätsfunktion Beispiel 2: Die Fakultät einer Zahl: 4 ! = 4 • 3 • 2 • 1 = 24 Rekursion?? 5 ! = 5 • 4 • 3 • 2 • 1 = 120 Test: 3 ! = ? 1 ! = ?

Fakultät: Bildungsgesetz Beispiel 2: Die Fakultät einer Zahl: 4 ! = 4 • 3 • 2 • 1 = 24 5 ! = 5 • 4 • 3 • 2 • 1 = 120 Rekursion: 5 ! = 5 • 4 ! Rekursive Formel: Test: 3 ! = 6 1 ! = 1 n ! = ???

Fakultät: Bildungsgesetz Beispiel 2: Die Fakultät einer Zahl: 4 ! = 4 • 3 • 2 • 1 = 24 5 ! = 5 • 4 • 3 • 2 • 1 = 120 Rekursion: 5 ! = 5 • 4 ! Rekursive Formel: Problem: Was ist Test: 3 ! = 6 1 ! = 1 n ! = n • (n-1) ! Rekursionsschritt 1 ! = ?

Fakultät: Bildungsgesetz Beispiel 2: Die Fakultät einer Zahl: 4 ! = 4 • 3 • 2 • 1 = 24 5 ! = 5 • 4 • 3 • 2 • 1 = 120 Rekursion: 5 ! = 5 • 4 ! Rekursive Formel: Problem: Lösung: Für den Sonderfall n = 1 ist das Teilproblem direkt lösbar, d.h. bei n = 1 erfolgt kein rekursiver Aufruf mehr! Beachte: Jeder rekursive Prozess benötigt eine Rekursionbedingung und einen solchen Start- bzw. Endwert, sonst gingen die rekursiven Aufrufe ins Endlose! Test: 3 ! = 6 1 ! = 1 n ! = n • (n-1) ! , falls n > 1 ist Rekursionsschritt Rekursionbedingung 1 ! = 1 Start-/Endwert Rollenspiel!

Fakultät: Berechnung mit rekursivem Abstieg... Beispiel 2: Die Fakultät einer Zahl: 5 ! = 5 • 4 • 3 • 2 • 1 = 120 5 ! = 5 • 4 ! 4 ! = ??? Phase des rekursiven „Abstiegs“ (rekursive Aufrufe)

Fakultät: Berechnung mit rekursivem Abstieg... Beispiel 2: Die Fakultät einer Zahl: 5 ! = 5 • 4 • 3 • 2 • 1 = 120 5 ! = 5 • 4 ! 4 ! = 4 • 3 ! 3 ! = 3 • 2 ! 2 ! = 2 • 1 ! 1 ! = ..... Phase des rekursiven „Abstiegs“ (rekursive Aufrufe)

Fakultät: Berechnung mit rekursivem Abstieg... Beispiel 2: Die Fakultät einer Zahl: 5 ! = 5 • 4 • 3 • 2 • 1 = 120 5 ! = 5 • 4 ! 4 ! = 4 • 3 ! 3 ! = 3 • 2 ! 2 ! = 2 • 1 ! 1 ! = 1 Phase des rekursiven „Abstiegs“ (rekursive Aufrufe)

Fakultät: ... und Aufstieg Beispiel 2: Die Fakultät einer Zahl: 5 ! = 5 • 4 • 3 • 2 • 1 = 120 5 ! = 5 • 4 ! 4 ! = 4 • 3 ! 3 ! = 3 • 2 ! 2 ! = 2 • 1 ! 1 ! = 1 Phase des rekursiven „Abstiegs“ (rekursive Aufrufe) Phase des rekursiven „Aufstiegs“ (Zusammenbau) 1 2

Fakultät: ... und Aufstieg Beispiel 2: Die Fakultät einer Zahl: 5 ! = 5 • 4 • 3 • 2 • 1 = 120 5 ! = 5 • 4 ! 4 ! = 4 • 3 ! 3 ! = 3 • 2 ! 2 ! = 2 • 1 ! 1 ! = 1 Phase des rekursiven „Abstiegs“ (rekursive Aufrufe) Phase des rekursiven „Aufstiegs“ (Zusammenbau) 1 2 6

Fakultät: ... und Aufstieg Beispiel 2: Die Fakultät einer Zahl: 5 ! = 5 • 4 • 3 • 2 • 1 = 120 5 ! = 5 • 4 ! 4 ! = 4 • 3 ! 3 ! = 3 • 2 ! 2 ! = 2 • 1 ! 1 ! = 1 Phase des rekursiven „Abstiegs“ (rekursive Aufrufe) Phase des rekursiven „Aufstiegs“ (Zusammenbau) 1 2 6 24 120

Fakultät: Ab- und Aufstieg Beispiel 2: Die Fakultät einer Zahl: 5 ! = 5 • 4 • 3 • 2 • 1 = 120 5 ! = 5 • 4! = 5 • (4 • 3!) = 5 • (4 • (3 • 2!)) = 5 • (4 • (3 • (2 • 1!))) = 5 • (4 • (3 • (2 • (1)))) = 5 • (4 • (3 • (2))) = 5 • (4 • (6)) = 5 • (24) = 120 Phase des rekursiven „Abstiegs“ (rekursive Aufrufe) Phase des rekursiven „Aufstiegs“ (Rückgabe und Zusammenbau der Ergebnisse)

Fibonacci (Bildungsgesetz?) Beispiel 3: Die Fibonacci-Folge beginnt mit den Zahlen 1. 2. 3. 4. 5. 6. 7. 8. 1 2 3 5 ...

Fibonacci (Bildungsgesetz?) Beispiel 3: Die Fibonacci-Folge beginnt mit den Zahlen 1. 2. 3. 4. 5. 6. 7. 8. 1 2 3 5 ... fib(1) = 1 fib(2) = 1 fib(...) = ................... fib(3) = 2

Fibonacci (Bildungsgesetz?) Beispiel 3: Die Fibonacci-Folge beginnt mit den Zahlen 1. 2. 3. 4. 5. 6. 7. 8. 1 2 3 5 ... fib(1) = 1 fib(2) = 1 fib(6) = 5 + 3 = 8 fib(3) = 2 = fib(5) + fib(4)

Fibonacci (Startproblem!) Beispiel 3: Die Fibonacci-Folge beginnt mit den Zahlen 1. 2. 3. 4. 5. 6. 7. 8. 1 2 3 5 ... fib(1) = 1 fib(2) = 1 fib(6) = 5 + 3 = 8 fib(3) = 2 = fib(5) + fib(4) Bildungsgesetz: aktuelle Zahl = ???

Fibonacci (Startproblem!) Beispiel 3: Die Fibonacci-Folge beginnt mit den Zahlen 1. 2. 3. 4. 5. 6. 7. 8. 1 2 3 5 ... fib(1) = 1 fib(2) = 1 fib(6) = 5 + 3 = 8 fib(3) = 2 = fib(5) + fib(4) Bildungsgesetz: aktuelle Zahl = letzte Zahl + vorletzte Zahl

Fibonacci (Startproblem!) Beispiel 3: Die Fibonacci-Folge beginnt mit den Zahlen 1. 2. 3. 4. 5. 6. 7. 8. 1 2 3 5 ... fib(1) = 1 fib(2) = 1 fib(6) = 5 + 3 = 8 fib(3) = 2 = fib(5) + fib(4) Bildungsgesetz: aktuelle Zahl = letzte Zahl + vorletzte Zahl Rekursive Formel: fib(n) = fib( ... ) + fib( ... )

Fibonacci (Startproblem!) Beispiel 3: Die Fibonacci-Folge beginnt mit den Zahlen 1. 2. 3. 4. 5. 6. 7. 8. 1 2 3 5 ... fib(1) = 1 fib(2) = 1 fib(6) = 5 + 3 = 8 fib(3) = 2 = fib(5) + fib(4) Rekursions-Schritt Bildungsgesetz: aktuelle Zahl = letzte Zahl + vorletzte Zahl Rekursive Formel: fib(n) = fib(n-1) + fib(n-2)

Fibonacci (Startproblem!) Beispiel 3: Die Fibonacci-Folge beginnt mit den Zahlen 1. 2. 3. 4. 5. 6. 7. 8. 1 2 3 5 ... fib(1) = 1 fib(2) = 1 fib(6) = 5 + 3 = 8 fib(3) = 2 = fib(5) + fib(4) Rekursions-Schritt Bildungsgesetz: aktuelle Zahl = letzte Zahl + vorletzte Zahl Rekursive Formel: fib(n) = fib(n-1) + fib(n-2) Beachte Problemfall: fib(1) = fib(...) + fib(...) ???

Fibonacci (Startproblem!) Beispiel 3: Die Fibonacci-Folge beginnt mit den Zahlen 1. 2. 3. 4. 5. 6. 7. 8. 1 2 3 5 ... fib(1) = 1 fib(2) = 1 fib(6) = 5 + 3 = 8 fib(3) = 2 = fib(5) + fib(4) Rekursions-Schritt Bildungsgesetz: aktuelle Zahl = letzte Zahl + vorletzte Zahl Rekursive Formel: fib(n) = fib(n-1) + fib(n-2) Beachte Problemfall: fib(1) = fib(0) + fib(-1) ???  Endlos-Rekursion? Undefiniert? Abhilfe?

Fibonacci (rekursive Formel) Beispiel 3: Die Fibonacci-Folge beginnt mit den Zahlen 1. 2. 3. 4. 5. 6. 7. 8. 1 2 3 5 ... fib(1) = 1 fib(2) = 1 fib(6) = 5 + 3 = 8 fib(3) = 2 = fib(5) + fib(4) Rekursions-Schritt Bildungsgesetz: aktuelle Zahl = letzte Zahl + vorletzte Zahl Rekursive Formel: fib(n) = fib(n-1) + fib(n-2) Ausnahme: für n < 3 ist: fib(n) = 1 Rekursions-Start bzw. -Ende

Fibonacci (Funktions-Aufbau) Beispiel 3: Die Fibonacci-Folge beginnt mit den Zahlen 1. 2. 3. 4. 5. 6. 7. 8. 1 2 3 5 ... Rekursive Formel: fib(n) = fib(n-1) + fib(n-2) Ausnahme: für n < 3 ist: fib(n) = 1 Aufgabe: Programmiere eine Funktion namens fib, die zur Eingabe n die zugehörige Fibonacci-Zahl liefert! Aufbau der Funktion: Funktions- Name Eingabe- parameter Typ des Rückgabewerts function fib(n: integer): integer; begin ... fib := ... ... end; Zuweisung des Rückgabewerts an den Funktionsnamen

Fibonacci (Programmierung) Beispiel 3: Die Fibonacci-Folge beginnt mit den Zahlen 1. 2. 3. 4. 5. 6. 7. 8. 1 2 3 5 ... Rekursive Formel: fib(n) = fib(n-1) + fib(n-2) Ausnahme: für n < 3 ist: fib(n) = 1 Aufgabe: Programmiere eine Funktion namens fib, die zur Eingabe n die zugehörige Fibonacci-Zahl liefert! Rekursions-Bedingung function fib(n: integer): integer; begin if ..... then ......... else ......... end; Rekursions-Schritt Rekursions-Anfang bzw. -Ende

Fibonacci (Programmierung) Beispiel 3: Die Fibonacci-Folge beginnt mit den Zahlen 1. 2. 3. 4. 5. 6. 7. 8. 1 2 3 5 ... Rekursive Formel: fib(n) = fib(n-1) + fib(n-2) Ausnahme: für n < 3 ist: fib(n) = 1 Aufgabe: Programmiere eine Funktion namens fib, die zur Eingabe n die zugehörige Fibonacci-Zahl liefert! Rekursions-Bedingung function fib(n: integer): integer; begin if ..... then fib := fib(n-1) + fib(n-2) else ......... end; Rekursions-Schritt Rekursions-Anfang bzw. -Ende rekursive Aufrufe Rekursions-Schritt

Fibonacci (Programmierung) Beispiel 3: Die Fibonacci-Folge beginnt mit den Zahlen 1. 2. 3. 4. 5. 6. 7. 8. 1 2 3 5 ... Rekursive Formel: fib(n) = fib(n-1) + fib(n-2) Ausnahme: für n < 3 ist: fib(n) = 1 Aufgabe: Programmiere eine Funktion namens fib, die zur Eingabe n die zugehörige Fibonacci-Zahl liefert! Rekursions-Bedingung function fib(n: integer): integer; begin if n > 2 then fib := fib(n-1) + fib(n-2) else fib := 1 end; Rekursions-Schritt Rekursions-Anfang bzw. -Ende rekursive Aufrufe Rekursions-Schritt

Fibonacci (Aufrufstruktur) Aufruf der Fibonacci-Funktion: function fib(n: integer): integer; begin if n > 2 then fib := fib(n-1) + fib(n-2) else fib := 1 end; a := fib(6) fib(5) + fib(4) ........???........

Fibonacci (Aufrufstruktur) Aufruf der Fibonacci-Funktion: function fib(n: integer): integer; begin if n > 2 then fib := fib(n-1) + fib(n-2) else fib := 1 end; a := fib(6) fib(5) + fib(4) fib(4) + fib(3) .................

Fibonacci (Aufrufstruktur) Aufruf der Fibonacci-Funktion: function fib(n: integer): integer; begin if n > 2 then fib := fib(n-1) + fib(n-2) else fib := 1 end; a := fib(6) fib(5) + fib(4) fib(4) + fib(3) fib(3)+fib(2) .................

Fibonacci (Aufrufstruktur) Aufruf der Fibonacci-Funktion: function fib(n: integer): integer; begin if n > 2 then fib := fib(n-1) + fib(n-2) else fib := 1 end; a := fib(6) fib(5) + fib(4) fib(4) + fib(3) fib(3)+fib(2) fib(2)+fib(1) ...... ......

Fibonacci (Aufrufstruktur) Aufruf der Fibonacci-Funktion: function fib(n: integer): integer; begin if n > 2 then fib := fib(n-1) + fib(n-2) else fib := 1 end; a := fib(6) fib(5) + fib(4) fib(4) + fib(3) fib(3)+fib(2) fib(2)+fib(1) 1 ......

Fibonacci (Aufrufstruktur) Aufruf der Fibonacci-Funktion: function fib(n: integer): integer; begin if n > 2 then fib := fib(n-1) + fib(n-2) else fib := 1 end; a := fib(6) fib(5) + fib(4) fib(4) + fib(3) fib(3)+fib(2) 2 fib(2)+fib(1) 1 1

Fibonacci (Aufrufstruktur) Aufruf der Fibonacci-Funktion: function fib(n: integer): integer; begin if n > 2 then fib := fib(n-1) + fib(n-2) else fib := 1 end; a := fib(6) fib(5) + fib(4) fib(4) + fib(3) 3 fib(3)+fib(2) 2 fib(2)+fib(1) 1 1 1

Fibonacci (Aufrufstruktur) Aufruf der Fibonacci-Funktion: function fib(n: integer): integer; begin if n > 2 then fib := fib(n-1) + fib(n-2) else fib := 1 end; a := fib(6) fib(5) + fib(4) fib(4) + fib(3) 3 2 fib(3)+fib(2) fib(2)+fib(1) 2 fib(2)+fib(1) 1 1 1 1 1

Fibonacci (Aufrufstruktur) Aufruf der Fibonacci-Funktion: function fib(n: integer): integer; begin if n > 2 then fib := fib(n-1) + fib(n-2) else fib := 1 end; a := fib(6) fib(5) + fib(4) 5 fib(4) + fib(3) 3 2 fib(3)+fib(2) fib(2)+fib(1) 2 fib(2)+fib(1) 1 1 1 1 1

Fibonacci (Aufrufstruktur) Aufruf der Fibonacci-Funktion: function fib(n: integer): integer; begin if n > 2 then fib := fib(n-1) + fib(n-2) else fib := 1 end; a := fib(6) fib(5) + fib(4) 5 fib(4) + fib(3) ................ 3 2 fib(3)+fib(2) fib(2)+fib(1) 2 fib(2)+fib(1) 1 1 1 1 1

Fibonacci (Aufrufstruktur) Aufruf der Fibonacci-Funktion: function fib(n: integer): integer; begin if n > 2 then fib := fib(n-1) + fib(n-2) else fib := 1 end; a := fib(6) fib(5) + fib(4) 5 3 Beachte: Aufrufstruktur? Verzweigungsfaktor? Komplexität? fib(4) + fib(3) fib(3) + fib(2) 3 2 2 fib(3)+fib(2) fib(2)+fib(1) fib(2)+fib(1) 1 2 fib(2)+fib(1) 1 1 1 1 1 1 1

Fibonacci (Aufrufstruktur) Aufruf der Fibonacci-Funktion: function fib(n: integer): integer; begin if n > 2 then fib := fib(n-1)+ fib(n-2) else fib := 1 end; a := fib(6) fib(5) + fib(4) 5 3 Beachte: Durch den zweifachen rekursiven Aufruf von fib entsteht eine (unvollständige) Baumstruktur mit 2-facher Verzweigung! Eine Vergrößerung von n bedeutet daher fast doppelten Aufwand, d.h. die Komplexität liegt bei etwa 2n. (asymptotisch: 1,618n) fib(4) + fib(3) fib(3) + fib(2) 3 2 2 fib(3)+fib(2) fib(2)+fib(1) fib(2)+fib(1) 1 2 fib(2)+fib(1) 1 1 1 1 1 1 1

Aufgaben (numerisch) Aufgaben: Entwickeln und testen Sie Funktionen: fak zur rekursiven Berechnung der Fakultät einer Zahl summe_1_bis_n zur Berechnung von 1+2+3+...+n (Tipp: Kopieren und ändern Sie fak entsprechend!) fib zur rekursiven Berechnung der Fibonaccizahl Bauen Sie bei fib einen Aufrufzähler (globale Variable! warum?) ein, der bei jedem Aufruf von fib inkrementiert wird! Zum Vergleich: Programmieren Sie fakiter und fibiter zur iterativen Berechnung von fak und fib, d.h. mit Schleifen anstatt Rekursion!

Aufgabe: Binomialkoeffizienten Eine Funktion mit zwei Eingabewerten: bin(n,k) dient zur Berechnung von Binomialkoeffizienten ( ) anhand des Pascalschen Dreiecks: n k ??? ???

Aufgabe: Binomialkoeffizienten Eine Funktion mit zwei Eingabewerten: bin(n,k) dient zur Berechnung von Binomialkoeffizienten ( ) anhand des Pascalschen Dreiecks: n k

Aufgabe: Permutationen Buchstabenrätsel: ZUES = ??? Eine Prozedur soll systematisch alle Permutationen erzeugen! Strategie: perm(ZUES) Z + perm(UES) U + perm(ZES) E + perm(ZUS) S + perm(ZUE) . . . . . . . . . ZU + perm(ES) ZE + perm(US) ZS + perm(UE) ZUE + perm(S) ZUS + perm(E) ZEU + perm(S) ZES + perm(U) ZSU + perm(E) ZSE + perm(U) ZUES ZUSE ZEUS ZESU ZSUE ZSEU Tipp: Verwenden Sie zwei Parameter : perm(kopf,rest : string) und den Startaufruf perm(‘‘ , ‘ZUES‘). restlicher Teil bereits permutierter Teil

Aufgabe: Ackermann-Funktion Ein Beispiel für verschachtelte Rekursion: Die Ackermann-Funktion hat 2 Eingabewerte x und y, und wächst extrem schnell! y+1 , falls x = 0 a(x,y) = a(x-1,1) , falls x  0 und y = 0 a(x-1, a(x, y-1)) , sonst Berechne „per Hand“ a(1,1) und a(2, 2) . Programmiere und teste a ! (Für theoretische Informatiker: Die Ackermann-Funktion ist zwar berechenbar, aber nicht primitiv-rekursiv... )

Aufgabe: universelle Funktion Die universelle Funktion f (x, y, a) kann verschiedene Funktionen berechnen. x und y sind die beiden Eingabewerte, und mit a bestimmt man: a = 1: Addieren a = 2: Multiplizieren a = 3: Potenzieren a > 3: ??? x + y , falls a = 1 f (x,y,a) = x , falls a  1 und y = 1 f (x, f (x, y-1, a), a-1) , sonst Berechne „per Hand“ f(4, 3, 2) und f( 2, 3, 3) . Programmiere und teste f !

Aufgabe: Türme von Hanoi Bei den „Türmen von Hanoi“ muss ein Stapel von goldenen Scheiben von einem Startplatz auf einen Zielplatz bewegt werden. Zum Manövrieren gibt es noch einen Ablageplatz, denn es darf niemals eine größere auf eine kleinere Scheibe gelegt werden. Suchen Sie zunächst das rekursive Prinzip, um das Problem „Bewege einen Turm der Höhe n“ auf ein kleineres Problem zu reduzieren! Entwickeln Sie dann eine rekursive Prozedur hanoi(hoehe, von, nach: integer) , die eine Ausgabe wie z.B. nebenstehend erzeugt! (Ein praktischer Trick: 1+2+3 = 6, d.h. die Formel für eine Platznummer lautet immer: „6 – die beiden anderen Platznummern“ . Hilft das ?!) Start (1) Ablage (2) Ziel (3)

Sammlung rekursiver Probleme Eine kleine Sammlung rekursiv lösbarer Probleme: Numerisch: Fakultät, Summe-1-bis-n, Potenz, Fibonacci, Binomialkoeffizienten (Pascalsches Dreieck), universelle Funktion, Ackermann Graphisch: Spirale, Busch, Baum, Kochkurve (Schneeflocke), Hutschnur, Drachenkurve (Papierfaltung), Sierpinski-Dreieck/-Quadrat, Peano-Kurve, Cantor-Staub (zerstückelte Strecke) Textuell: Spiegelung, Permutationen (Buchstabenrätsel), Formale Sprache (Erzeugung anhand Grammatik) Spiel: Zahlenraten, Türme von Hanoi Backtracking: Labyrinth, Acht-Damen- / Springer-Problem, Solitaire (Nimm-Spiel), Spielstrategien Suchen und Sortieren: binäre Suche, Quicksort, Mergesort

Methodische Zugänge Problemanalyse: Zerlegung in ähnliche Teilaufgaben Code-orientiert: a) „Was tut dieses Programm?“ b) Code mit „Auskunftsfunktion“: bei jedem Aufruf wird dieser inkl. aktueller Parameter ausgegeben c) Einbau eines Aufruf-Zählers (globale Variable) Gegenständlich: verschachtelte Kartons oder Matrioschkas (im Innern liegt ein Schatz: nacheinander alle öffnen und danach alle wieder schließen), Papierstreifen falten (Faltrichtung beachten!) Rollenspiel: Für jeden Aufruf kommt ein weiterer Spieler auf die Bühne, der „seine“ Arbeit demonstriert und ggf. weitere Spieler aufruft. Evtl. Tafelprotokoll. Hilfe: Vorbereitete Aufruf-/Aufgabenzettel. Visualisierungen: a) Aufrufstruktur mit rekursivem Ab- und Aufstieg b) Entwicklung des Aufruf-Stapels („stacks“): Aufbau und Abbau (dynamisches Tafelbild)

Rekursion versus Iteration: Bsp. Fakultät rekursiv iterativ function fak(n: integer): integer; begin if n > 1 then fak := n  fak(n-1) else fak := 1; end; function fak(n: integer): integer; var f, i: integer; begin f := 1; for i := 2 to n do f := f  i; fak := f; end; Benötigt wird intern ein Stack, um die „unfertigen“ Aufrufe zu speichern. Benötigt werden hier zwei Variablen: i als Laufvariable für die Schleife, und f als Variable für das Zwischenergebnis, da die „Funktionsvariable“ fak nur auf der linken Seite einer Zuweisung benutzt werden darf! (rechts: rekursiver Aufruf!!)

Vor- und Nachteile von Rekursion Rekursion – pro und contra: mächtige Methode der Problemzerlegung elegante „deklarative“ Formulierung der Lösung flexibel bezüglich der Problemgröße (keine festgelegten Schleifenanzahlen, z.B. bei Permutationen, n-Damen) nicht sofort zu durchschauen evtl. unnötig hoher Zeitbedarf (exponentielle Komplexität bei Mehrfachrekursion) (wiederholtes Berechnen von Zwischenergebnissen, z.B. bei fib ) (interner Verwaltungsaufwand: Stack mit begrenzter Größe)

Literaturverzeichnis und Links Quicksort: Baumann: Informatik für die Sekundarstufe II, Band 2 MUI-Sprache (MU-Problem): Hofstadter: Gödel, Escher, Bach (dtv 1991) Rekursion ETH: http://www.ite.ethz.ch/education/id1/vortraege/rekursion.pdf Downloads (Word, PDF) zu "Rekursives Programmieren": http://educeth.ethz.ch/informatik/leitprog/rekursion Backtracking anschaulich: http://educeth.ethz.ch/informatik/vortraege/backtracking Über Fragen, Hinweise, Korrekturen würde ich mich freuen: tobias.selinger@gmx.de