12. Iteration und Rekursion Funktionen sind Unterprogramme, die zur Berechnung eines Wertes dienen, die Aufrufstelle der Funktion muß Ausdruck sein. Wert der Funktion wird unmittelbar an Aufrufstelle weiterverwendet Deklaration enthält Namen, Parameterliste und Ergebnistyp Anweisungsblock enthält Zuweisung an den Namen der Funktion Seiteneffekte können über globale Variablen und Referenzparameter bewirkt werden FUNCTION Min(X, Y:REAL): REAL BEGIN IF X < Y THEN Min := X ELSE Min := Y END;

Geschachtelte Unterprogramme PROGRAM Syrakus; USES WinCrt; FUNCTION SyrakusTest (n: INTEGER) : BOOLEAN; FUNCTION Ulam(m: INTEGER): INTEGER BEGIN IF Odd(m) THEN Ulam := 3*m+1 ELSE Ulam := m DIV 2 END {Ulam} WHILE n > 1 DO n := Ulam(n); SyrakusTest := (n = 1) END {SyrakusTest}; VAR TestZahl : Integer; Read(TestZahl); IF SyrakusTest(TestZahl) THEN WriteLn(TestZahl, ' hat Test bestanden') END.

Rekursion Rückführung eines Problems auf einfachere Instanz desselben Problems Beispiel: Türme von Hanoi Omega Alpha Delta n Scheiben von Alpha nach Omega zu bewegen. Nur eine Scheibe kann jeweils bewegt werden. Eine größere Scheibe darf nie auf einer kleineren liegen. Lösungsstrategie: n = 0: n > 0: gar nichts machen 1) Turm der Höhe n-1 von ALPHA nach DELTA bewegen (via OMEGA) 2) Scheibe von ALPHA nach OMEGA legen 3) Turm der Höhe n-1 von DELTA nach OMEGA bewegen (via ALPHA)

PROGRAM Hanoi; CONST Gesamthoehe = 4; TYPE Hoehenbereich = [0..Gesamthoehe];Platz = (ALPHA, OMEGA, DELTA); PROCEDURE bewegeTurm (Hoehe: Hoehenbereich; vonPlatz, nachPlatz, ueberPlatz: Platz); PROCEDURE DruckeZug (Start, Ziel: Platz); PROCEDURE DruckePlatz (spezPlatz: Platz); BEGIN (* DruckePlatz *) CASE spezPlatz OF ALPHA: Write ('ALPHA'); OMEGA: Write ('OMEGA'); DELTA: Write ('DELTA'); END; (* CASE *) END (* DruckePlatz *); BEGIN (* DruckeZug *) Write('Scheibe ', Hoehe,' von '); DruckePlatz (Start); Write(' nach '); DruckePlatz (Ziel); WriteLn; END DruckeZug; BEGIN (* bewegeTurm *) IF Hoehe > 0 THEN BEGIN bewegeTurm (Hoehe - 1, vonPlatz, ueberPlatz, nachPlatz); DruckeZug (vonPlatz, nachPlatz); bewegeTurm (Hoehe - 1, ueberPlatz, nachPlatz, vonPlatz); END (* IF *); END (* bewegeTurm *); BEGIN (* Hanoi *) bewegeTurm (Gesamthoehe, ALPHA, OMEGA, DELTA); END (* Hanoi *).

PROGRAM Hanoi; CONST Gesamthoehe = 4; TYPE Hoehenbereich = [0..Gesamthoehe];Platz = (ALPHA, OMEGA, DELTA); PROCEDURE bewegeTurm (Hoehe: Hoehenbereich; vonPlatz, nachPlatz, ueberPlatz: Platz); PROCEDURE DruckeZug (Start, Ziel: Platz); PROCEDURE DruckePlatz (spezPlatz: Platz); BEGIN (* DruckePlatz *) CASE spezPlatz OF ALPHA: Write ('ALPHA'); OMEGA: Write ('OMEGA'); DELTA: Write ('DELTA'); END; (* CASE *) END (* DruckePlatz *); BEGIN (* DruckeZug *) Write('Scheibe ', Hoehe,' von '); DruckePlatz (Start); Write(' nach '); DruckePlatz (Ziel); WriteLn; END DruckeZug; BEGIN (* bewegeTurm *) IF Hoehe > 0 THEN BEGIN bewegeTurm (Hoehe - 1, vonPlatz, ueberPlatz, nachPlatz); DruckeZug (vonPlatz, nachPlatz); bewegeTurm (Hoehe - 1, ueberPlatz, nachPlatz, vonPlatz); END (* IF *); END (* bewegeTurm *); BEGIN (* Hanoi *) bewegeTurm (Gesamthoehe, ALPHA, OMEGA, DELTA); END (* Hanoi *).

Produzierte Ausgabe Scheibe 1 von ALPHA nach DELTA Scheibe 2 von ALPHA nach OMEGA Scheibe 1 von DELTA nach OMEGA Scheibe 3 von ALPHA nach DELTA Scheibe 1 von OMEGA nach ALPHA Scheibe 2 von OMEGA nach DELTA Scheibe 4 von ALPHA nach OMEGA Scheibe 2 von DELTA nach ALPHA Scheibe 3 von DELTA nach OMEGA

Prinzip der Rekursion Definition komplexer Funktionen durch rekursive Rückführung auf - elementare Ausdrücke für einfache Funktionen - Operationen, die auf Funktionen definiert sind Primitiv rekursive Funktion 1. Null-Funktion (Konstante Funktion) 2. Nachfolger 3. Identität (Projektion)

Substitution (Komposition) Primitive Rekursion f: 1-stellig h: 2-stellig g: 3-stellig

Fibonacci Funktion Wieviele Kaninchen-Pärchen gibt es nach n Jahren, wenn man im Jahr 1 mit einem Pärchen beginnt, jedes Pärchen vom zweiten Jahr an ein weiteres Pärchen Nachwuchs hat und die Kaninchen nie sterben. Jahr: 1 2 3 4 5 6 7 8 . . . Zahl der Pärchen: 1 1 2 3 5 8 13 21 . . . Wir definieren: Fibonacci(n) = 1 für n = 1, 2 Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2) für n > 2. FUNCTION Fib1 (Argument: INTEGER) : INTEGER; BEGIN (* Fib1 *) IF Argument <= 2 THEN Fib1 := 1 ELSE Fib1 := Fib1(Argument-1) + Fib1(Argument-2) END (* Fib1 *); Exponentielle Anzahl rekursiver Aufrufe: bei Fib1(30) bereits 1.664.079 Aufrufe !

Lösung mit linearer Anzahl von Aufrufen (rekursiv nicht-funktional) FUNCTION Fib2 (Arg: INTEGER) : INTEGER; PROCEDURE FibProc (Arg: INTEGER; VAR Fib, FibMin1: INTEGER ); (* Liefert fuer Arg >= 0 in Fib die Fibonacci-Zahl *) (* von Arg in FibMin1 die von Arg-1. *) (* Fuer Arg = 0 ist FibMin1 undef. *) VAR FibMin2 : INTEGER; BEGIN (* FibProc *) IF Arg <= 1 THEN BEGIN Fib := Arg; FibMin1 := 0 END ELSE BEGIN FibProc (Arg - 1, FibMin1, FibMin2); Fib := FibMin1 + FibMin2; END (* IF *); END (* FibProc *); VAR FibRes1, FibRes2 : INTEGER; BEGIN (* Fib2; dient nur zur Anpassung der Schnittstelle *) FibProc (Arg, FibRes1, FibRes2); Fib2 := FibRes1 END (* Fib2 *);

Iterative Lösung mit Umspeichern FUNCTION Fib3 (Arg: INTEGER) : INTEGER; (* Iterative Variante ohne Feld *) VAR Index, Fib, FibMin1, FibNew: INTEGER; BEGIN (* Fib3 *) IF Arg = 0 THEN Fib3 := 0 ELSE BEGIN FibMin1:= 0; Fib:= 1; FOR Index:= 2 TO Arg DO BEGIN FibNew:= Fib + FibMin1; FibMin1:= Fib; Fib:= FibNew; END (* FOR *); Fib3 := Fib END (* IF *); END (* Fib3 *);

Iterative Lösung ohne Umspeichern PROCEDURE Fib4 (Arg: INTEGER) : INTEGER; (* Iterative Variante mit Ringpuffer *) VAR Ring0, Ring1, Pos : INTEGER; BEGIN (* Fib4 *) Ring0:= 0; Ring1 := 1; (* Initialisierung des Rings *) FOR Pos := 2 TO Arg DO (* Berechnung *) IF Pos MOD 2 = 0 THEN Ring0 := Ring0 + Ring1 ELSE Ring1 := Ring0 + Ring1; IF Arg MOD 2 = 0 THEN Fib4 := Ring0 Fib4 := Ring1; END (* Fib4 *);

Indirekte Rekursion Rekursion kann auch dadurch entstehen, daß ein in Unterprogramm U1 aufgerufenes Unterprogramm U2 den Aufruf von U1 bewirkt FUNCTION Gerade(N : Integer) : Boolean; BEGIN IF N = 0 THEN Gerade := True ELSE Gerade := UnGerade(n - 1) END; FUNCTION UnGerade(N : Integer) : Boolean; IF N = 0 THEN UnGerade := False ELSE UnGerade := Gerade(n - 1) Jeder Bezeichner muß vor der ersten Benutzung deklariert sein! FUNCTION UnGerade(N : Integer) : Boolean; FORWARD; muß vor der Deklaration von Gerade stehen

Endrekursion Eine Funktion f heißt endrekursiv, falls sie von folgender Form ist: { g(x) f(r(x)) falls P(x) sonst f(x) = r(x) ist dabei "einfacher" als x. Für Terminierung muß gelten: Für jedes x gibt es ein n, so daß r (x) P erfüllt. n endrekursiv: nicht endrekursiv: { (x = 0) Even1(x - 2) x ≤ 1 sonst { (x = 0) not Even2(x - 1) x ≤ 1 sonst Even1(x) = Even2(x) = endrekursive Funktionen einfach iterativ zu berechnen: WHILE not P(x) DO x := r(x); f := g(x)