3.6.4 Rekursive Funktionen

3.6.4 Rekursive Funktionen 

Beispiel: Keine Einführung in die Informatik ohne die Türme von Hanoi. 

Das Spiel wurde 1883 von dem französischen Mathematiker Edouard 

Lucas erfunden. 

Die Scheiben auf Stab A (links) sollen nach Stab C (rechts) gebracht 

werden, ohne dass jemals eine größere Scheibe auf einer kleineren 

liegt. Es darf immer nur die oberste Scheibe eines Stapels bewegt 

werden; ablegen neben den Stäben ist verboten. 

© Xiaoyi Jiang Informatik I – Grundlagen der Programmierung 

148


Wenn das Universum sein Ende finden wird … 

Legende über ein buddhistisches Kloster bei Hanoi, in dem sich ein 

riesiger Raum mit drei abgenutzten Pfosten befindet, die von 64 

goldenen Scheiben umgeben waren 

� Seit der Gründung des Klosters vor über tausend Jahren führen 

Mönche die Anordnung einer alten Prophezeiung aus: 

• Sie bewegen die Scheiben, in Übereinstimmung mit den Regeln 

des Puzzles 

• Jeden Tag eine Scheibe 

� Sie glauben, wenn die letzte Bewegung ausgeführt würde, wird die 

Welt mit einem Donnerschlag untergehen 


149


Algorithmus in rekursiver Formulierung: 

n Scheiben von A unter Zuhilfenahme des Stabes 

B nach C bringen 

� n − 1 Scheiben von A unter Zuhilfenahme des 

Stabes C nach B bringen 

� Bewege eine Scheibe von A nach C 

� n − 1 Scheiben von B unter Zuhilfenahme des 

Stabes A nach C bringen 

(define(move T1 T2 T3 n) 

(cond [(= n 0) empty] 

[else (append 

(move T1 T3 T2 (- n 1)) 

(list (list T1 T2)) 

(move T3 T2 T1 (- n 1)))])) 


> (move 'A 'B 'C 4) 

(list 

(list 'A 'C) 

(list 'A 'B) 

(list 'C 'B) 

(list 'A 'C) 

(list 'B 'A) 

(list 'B 'C) 

(list 'A 'C) 

(list 'A 'B) 

(list 'C 'B) 

(list 'C 'A) 

(list 'B 'A) 

(list 'C 'B) 

(list 'A 'C) 

(list 'A 'B) 

(list 'C 'B)) 

150


Spielzüge mit drei Scheiben: 

Spielzüge mit vier Scheiben: 


Quelle: Wikipedia 

151


Wenn t n die Rechenzeit für (move X Y Z n) bezeichnet, dann gilt: 

Die Anzahl der Bewegungen zur Lösung des Problems mit n Scheiben ist 

bei diesem Verfahren 2 n − 1. Man kann beweisen, dass das optimal ist. 


152

Exkurs: Wachstum von Zweierpotenzen 

Eine praktische Umsetzung einer Lösung 

mit exponentieller Komplexität ist nur für 

kleine n möglich. Die nebenstehende 

Tabelle zeigt die Dauer unter der Annahme, 

dass eine Scheibe pro Sekunde 

verschoben wird. 

Zum Glück sind die Mönche nicht mal annäherungsweise fertig! 

� Sie bräuchten 264−1 Sekunden oder ungefähr 585 Milliarden Jahre 

� Unser Universum ist zur Zeit ungefähr 13,7 Milliarden Jahre alt 


153


Weizenkornlegende: Sissa (auch: Sessa) lebte 

angeblich im dritten oder vierten Jahrhundert 

n.Chr. in Indien und gilt Legenden zufolge als 

der Erfinder des Schachspiels bzw. seiner 

indischen Urform Tschaturanga. 

Der indische Herrscher Shihram tyrannisierte seine 

Untertanen und stürzte sein Land in Not und Elend. 

Um die Aufmerksamkeit des Königs, ohne seinen Zorn zu entfachen, auf seine 

Fehler zu lenken, schuf der weise Sissa ein Spiel, in dem die wichtigste Figur, 

der König, ohne Hilfe anderer Figuren und Bauern nichts ausrichten kann. 

Der Unterricht im Schachspiel hat auf Shihram einen starken Eindruck gemacht. 

Er wurde milder und ließ das Schachspiel verbreiten, damit alle davon Kenntnis 

nähmen. Um sich für die anschauliche Lehre von Lebensweisheit und zugleich 

Unterhaltung zu bedanken, gewährte er Sissa einen freien Wunsch. Dieser 

wünschte sich Weizenkörner: Auf das erste Feld eines Schachbretts wollte er ein 

Korn, auf das zweite Feld die doppelte Menge, also zwei, auf das dritte wiederum 

doppelt so viele, also vier und so weiter. Quelle: Wikipedia 


154


Der König lachte und war gleichzeitig erbost ob der vermeintlichen 

Bescheidenheit des Brahmanen. Als sich Shihram einige Tage später 

erkundigte, ob Sissa seine Belohnung in Empfang genommen habe, 

musste er hören, dass die Rechenmeister die Menge der Weizenkörner 

noch nicht berechnet hatten. Nach mehreren Tagen ununterbrochener 

Arbeit meldete der Vorsteher der Kornkammer, dass er die Menge 

Getreidekörner im ganzen Reich nicht aufbringen könne. Auf allen 

Feldern zusammen wären es 2 64 −1 oder 18.446.744.073.709.551.615 

Weizenkörner (eine Wagenkolonne mit dieser Menge würde 

231666mal um die Erde reichen). 

Nun stellte sich die Frage, wie das Versprechen eingelöst werden 

könne. Der Rechenmeister half dem Herrscher aus der Verlegenheit, 

indem er ihm empfahl, er solle Sissa ganz einfach das Getreide Korn 

für Korn zählen lassen. 


155


Linear rekursiver Prozess: 

(define (fak n) (if (= n 0) 1 (∗ n (fak (- n 1))))) 

Auswertung im Substitutionsmodell: 

(fak 4) → 

(∗ 4 (fak 3)) → Expansion 

(∗ 4 (∗ 3 (fak 2))) → 

(∗ 4 (∗ 3 (∗ 2 (fak 1)))) → 

(∗ 4 (∗ 3 (∗ 2 (∗ 1 (fak 0))))) → 

(∗ 4 (∗ 3 (∗ 2 (∗ 1 1)))) → 

(∗ 4 (∗ 3 (∗ 2 1))) → 

(∗ 4 (∗ 3 2)) → Kontraktion 

(∗ 4 6) → 

24 


Interpreter muss über die 

später durchzuführenden 

Operationen Buch führen. 

Anzahl aufgeschobener 

Operationen wächst linear 

mit n � Zeit- und Speicherplatzbedarf 

wächst linear 

mit n 

� Rekursiver Prozess: Operationen werden aufgeschoben und erst nach 

Beenden der rekursiven Aufrufe durchgeführt 

� fak erzeugt einen linear rekursiven Prozess 

156


Linear iterativer Prozess: 

Berechne n! durch 1 → 1 ∗ 1 → 2 ∗ 1 → 3 ∗ 2 → 4 ∗ 6 → 5 ∗ 24 → … 

d.h. verwalte ein Zwischenprodukt p, das mit 1 initialisiert wird, und 

einen Zähler c, der von 1 bis n zählt. p und c ändern sich in jedem Schritt 

simultan gemäß 

p ← c ∗ p c ← c + 1 

(define (fak n) (ifak 1 1 n)) 

(define (ifak p c max) 

(if (> c max) p (ifak (∗ c p) (+ c 1) max))) 

Auswertung im Substitutionsmodell: 

(fak 5) → 

(ifak 1 1 5) → (ifak 1 2 5) → (ifak 2 3 5) → 

(ifak 6 4 5) → (ifak 24 5 5) → (ifak 120 6 5) → 120 

Variablen p, c und max beschreiben zu jedem Zeitpunkt den 

Berechnungsprozess vollständig 


157


Linear iterativer Prozess: 

� Zustand des Prozesses wird durch eine feste, von der Eingabe 

unabhängige Anzahl von Zustandsvariablen beschrieben 

• Fixe Regel beschreibt, wie die Zustandsvariablen aktualisiert 

werden, wenn der Prozess von einem Zustand in den nächsten 

Zustand übergeht 

• (Optionaler) Test, der die Bedingungen spezifiziert, unter denen 

der Prozess terminiert 

� Interpreter muss sich einzig die Zwischenwerte der Zustandsvariablen 

merken � Speicherplatzbedarf ist konstant 

� Zeitbedarf ist bestimmt durch Anzahl der rekursiven Aufrufe, die linear 

mit n wächst 


158


Beispiel: Fibonacci-Zahlen 

� Folgen lassen sich in vielen Fällen durch eine iterative Funktion 

beschreiben 

� Die Fibonacci-Folge kann man fortsetzen, wenn man jeweils die 

beiden letzten Elemente kennt: 

0 1 � 1 1 � 1 2 � 2 3 � 3 5 � 5 8 � 8 13 � …… 

(define (fib n) (fib-iter 0 1 n)) 

(define (fib-iter a b n) 

(cond [(= n 0) a] 

[else (fib-iter b (+ a b) (- n 1))])) 

> (fib 10) 

55 

> (map fib (list 0 1 2 3 4 5 6 7 8 9 10)) 

(list 0 1 1 2 3 5 8 13 21 34 55) 


159


Endrekursion: 

Erzeugt eine linear rekursive Funktion bei ihrer Auswertung einen 

iterativen Prozess, d.h. das Ergebnis eines rekursiven Aufrufs wird nicht 

im Rumpf der rekursiven Funktion weiterverarbeitet und mit dem 

Beenden des letzten rekursiven Aufrufs liegt auch das Ergebnis der 

Berechnung vor, so nennt man die Funktion endrekursiv bzw. 

endrekursion (tail recursion). 

� Weniger Platzbedarf bei der Abarbeitung, da die Größe des auszuwertenden 

Ausdrucks nicht mit jedem rekursiven Aufruf wächst 


160


Beispiel: Berechnung von 

(define (sum n) 

(if (= n 0) 0 (+ n (sum (- n 1))))) 

sum ist nicht endrekursiv 

(define (sum n) (isum n 0)) 

(define (isum n result) 

(if (= n 0) result (isum (- n 1) (+ n result)))) 

isum ist endrekursiv 


n 

∑ 

i =0 

i 

(isum 5 0) � (isum 4 5) � (isum 3 9) � (isum 2 12) � (isum 1 14) � 

(isum 0 15) � 15 

161


Beispiel: Länge einer Liste (vgl. Folie 112, Kap.3) 

Endrekursion: 

(define (len list-of-anything) 

(cond [(empty? list-of-anything) 0] 

[else (+ 1 (len (rest list-of-anything)))])) 

(define (len list-of-anything) (len-iter list-of-anything 0)) 

(define (len-iter l n) 

(cond [(empty? l) n] 

[else (len-iter (rest l) (+ n 1))])) 

(len-iter (list 1 2 3) 0) � (len-iter (list 2 3) 1) � (len-iter (list 3) 2) � 

(len-iter empty, 3) � 3 


162


Eine Funktion kann rekursiv in der syntaktischen Definition, aber iterativ 

in der effektiven Ausführung sein 

� Funktion ist rekursiv � syntaktische Eigenschaft 

� Prozess ist linear rekursiv oder linear iterativ � Aussage über die 

Entwicklung des Berechnungsprozesses, nicht aber über die Syntax 

der Funktion 

Für den Speicher- und Zeitbedarf ist das Prozessverhalten, nicht die 

syntaktische Definition, entscheidend 


163


Terminierung bei rekursiven Funktionen: 

� Terminierung bei nicht-rekursiven Funktionen 

Komplexe Funktionen stützen sich auf einfachere Funktionen ab, 

dieser Abstützprozess endet nach endlich vielen Schritten bei den 

vordefinierten Funktionen von Scheme 

� Versuche, die Vorgehensweise auf die Kombination aus 

Funktionsaufrufen und Parametern zu übertragen. Gelingt es also, 

für eine Funktion nachzuweisen, dass die aufgerufenen Funktionen 

und ihre Parameter als Ganzes in dem Sinne einfacher werden, dass 

sie nach endlich vielen Schritten die Abbruchbedingung erfüllen, so 

kann daraus die Terminierung der (rekursiven) Funktion gefolgert 

bzw. nachgewiesen werden. 


164


Beispiel: 

(define (fak n) (if (= n 0) 1 (∗ n (fak (- n 1))))) 

� fak ist linear rekursive Funktion mit einem Parameter; Definition 

stützt sich auf { ∗ , - , = } und auf fak selbst ab 

� Rekursion terminiert genau dann, wenn das Abbruchkriterium (= n 0) 

erfüllt ist 

� In jedem Aufruf von fak wird das Argument um 1 dekrementiert 

• Für Startwerte n∈ N ist (fak n) bzgl. des Abbruchkriteriums 

komplexer als (fak (- n 1)) � Funktion terminiert nach n 

rekursiven Aufrufen 

• Für Startwerte n


� Wichtig: kombinierte Betrachtung der Parameter der rekursiven 

Aufrufe, der Abbruchbedingung und der erlaubten Eingabewerte 

� Dabei sind nicht unbedingt alle Parameter relevant, sondern nur die, 

die in den Abbruchbedingungen berücksichtigt werden. Man sagt 

dann, dass bestimmte Parameter die Rekursion steuern. 

Beispiel: 

(define (fak n) (ifak 1 1 n)) 

(define (ifak p c max) 

(if (> c max) p (ifak (∗ c p) (+ c 1) max))) 

Nur c und max steuern die Rekursion; p dient lediglich zur 

Speicherung des Zwischenprodukts 


166


Beispiel: Linear rekursive Funktion t mit zwei Parametern 

(define (t x y) (cond [(< y 0) x] 

[(


Bei nicht-linearer Rekursion muss man das Terminieren aller rekursiven 

Aufrufe zeigen, d.h. dass jede der auftretenden Rekursionen eine 

Abbruchbedingung erreicht 

Beispiel: 

(define (fib n) 

(cond [(= n 0) 0] 

[(= n 1) 1] 

[else (+ (fib (- n 1)) (fib (- n 2)))])) 

Die baumrekursive Fibonacci-Funktion terminiert für alle n ∈ N 0, da 

beide auftretenden rekursiven Aufrufe in jedem Schritt zu um 1 oder 2 

kleineren Parameterwerten führen und die Abbruchbedingungen 

(= n 0) bzw. (= n 1) immer erreicht werden 


168


Vorgehen zum Sicherstellen von Terminierung: 

� Welche Abbruchbedingungen sind für welche Parameter relevant? 

� Wie werden die relevanten Parameter in jedem Rekursionsschritt 

verändert? 

� Auf Grundlage dieses Wissens muss man versuchen, 

sicherzustellen (nachzuweisen), dass 

• alle vorkommenden rekursiven Aufrufe 

• für mindestens einen relevanten Parameter 

• nach endlich vielen Schritten 

• eine der Abbruchbedingungen erreichen durch Zuordnen einer 

Reihenfolge von komplexen zu einfacheren Aufrufen 

Berücksichtige diese Überlegungen nicht erst am (scheinbar) fertigen 

Programm, sondern bei der Entwicklung des Programms. 


169


Korrektheitsbeweis: 

Man kann für eine Funktion eine Zusicherung ihrer Eigenschaften 

geben. Zusicherungen für Funktionen, die mit Listen arbeiten, werden 

oft mit vollständiger Induktion über die Länge der beteiligten Listen 

bewiesen. 

Beispiel: Konkatenieren zweier Listen (vgl. Folie 114, Kap.3) 

(define (concat l1 l2) 

(cond [(empty? l1) l2] 

[else (cons (first l1) (concat (rest l1) l2))])) 

Zusicherung: Ist l1 = (x1 . . . xn) eine Liste der Länge n und l2 = (y1 . . . 

ym) eine Liste der Länge m, so ist der Wert von (concat l1 l2) die Liste 

(x1 . . . xn y1 . . . ym) der Länge n + m. 


170


(define (concat l1 l2) 

(cond [(empty? l1) l2] ; Zeile 1 

[else (cons (first l1) (concat (rest l1) l2))])) ; Zeile 2 

Beweis mit Induktion über n (Länge der Liste l1): 

Induktionsanfang: Für n = 0 folgt die Behauptung aus Zeile 1 

Induktionsschritt: Ist n > 0 und die Zusicherung für Listen der Länge n − 1 

richtig, dann gilt sie für Listen der Länge n: Nach Induktionsvoraussetzung 

ist der Wert von (concat (rest l1) l2) die Liste (x2 . . . xn y1 . . . ym) der 

Länge n − 1 + m, daraus und aus Zeile 2 folgt, dass (cons (first l1) ...) und 

damit das Resultat die Liste (x1 . . . xn y1 . . . ym) der Länge n + m ist. 


171

Exkurs: Beweis durch Induktion 

Wir wollen zeigen, dass eine Aussage P(n) für alle natürlichen Zahlen 

n ≥ k gilt 

Beweismethode der vollständigen Induktion: 

� Induktionsanfang (IA, auch Anker genannt): Zeige P(k) 

� Induktionsschritt (IS): Zeige, dass für alle natürlichen Zahlen n > k gilt: 

P(n) � P(n + 1) 

P(n) heisst auch Induktionsannahme oder Induktionsvoraussetzung (IV) 


172


Der folgende Satz ist benannt nach Carl Friedrich Gauss (1777–1855), 

der ihn bereits während seiner Grundschulzeit bewiesen hat 

Theorem: Für alle natürlichen Zahlen n gilt: Die Summe der ersten n 

natürlichen Zahlen ist gleich n(n + 1)/2 

Beweis: 

Der Induktionsanfang mit P(1) = 1 ist klar. 

IV: P(n) stimmt, d.h. 

Nun zeigen wir, dass auch P(n + 1) stimmt: 


173


Manchmal gelingt es nicht, aus der Gültigkeit der Eigenschaft P(n) auf 

die Gültigkeit von P(n + 1) zu schliessen. Hier hilft zuweilen das 

allgemeine Induktionsprinzip, bei dem man im Induktionsschritt zeigt: 

Wenn P(n′), k ≤ n′ ≤n, gilt, dann gilt auch P(n + 1) 

Beweismethode der allgemeinen Induktion: 

� Induktionsanfang (IA, auch Anker genannt): Zeige P(k) 

� Induktionsschritt (IS): Zeige, dass für alle natürlichen Zahlen n > k gilt: 

P(k) ∧ P(k + 1) ∧ ···∧ P(n) � P(n + 1) 


174

3.6.4 Rekursive Funktionen

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?