Präsentationsfolien (PDF)

Algorithmen und Datenstrukturen 

8. Rekursion 

Dr.-Ing. Norbert Oster 

Department Informatik Martensstraße 3 91058 Erlangen

Vorwarnung: Bitte nicht erschrecken… 

• Die Folien dieses Vortrags 

□ stammen aus der Vorlesung 

„Algorithmen und Datenstrukturen“ (i.W. „Kapitel 8“) 

□ hören Studenten verschiedener Studiengänge 

i.d.R. im ersten (bis dritten) Semester 

□ allerdings erst 

etwa in der Mitte des ersten Semesters… 

□ … bis dahin haben sie schon etliche Programmier- 

Grundlagen am Beispiel der Sprache „Java“ 

kennengelernt 

• Zweck heute: 

□ „schnuppern“, 

wie eine „echte“ Vorlesung meistens abläuft… 

□ … auch wenn nicht alles auf Anhieb zu Verstehen ist 

Algorithmen und Datenstrukturen Philippsen/Stamminger/Pflaum/Riehle WS 2010/2011 Folie 08-2

8. Rekursion 

8.1 Einführung der Rekursion 

8.2 Türme von Hanoi 

8.3 Fibonacci-Zahlen 

8.4 Skyline-Problem Teile-und-Herrsche 

8.5 Rekursionsformen 

8.6 Sortieren durch Mischen („merge sort“) 



Eine Geschichte 

Es war einmal ein Mann mit 2 Kindern, die eine Geschichte 

hören wollten. Der Vater fing an: 





Und wenn sie nicht gestorben sind, 

dann leben sie noch heute. 





Stopp – Aufhören! 



Eine Geschichte (in Java) 

void geschichte(int x) { 

print ("Es war einmal ein Mann mit " + x + " Kindern," 

+ " die eine Geschichte hören wollten."); 

if (nochLust()) { 

Terminierungsbedingung 

print("Der Vater fing an:"); 

geschichte(x+1); 

Rekursionsschritt 

} 

leerer „else“-Fall, ohne geschichte-Aufruf 

print ("Und wenn sie nicht gestorben sind," 

+ " dann leben sie noch heute."); 

} 

„Nachklappern“ 



Rekursive Methodendefinition 

• Eine Methode (Prozedur, Funktion) 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 {...} aufgerufen wird. 

Rumpf 

• Variante: 

Im Rumpf von f steht g, im Rumpf von g steht wieder f. 

Keine rekursive Methodendefinition, wohl aber rekursiv. 

Stichwort: verschränkte Rekursion. 



Zentrale Fragen der 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. 



Fakultätsfunktion (für n>0) 

1 falls n=1 

n! := 

n · (n-1)! sonst 

Rekursive Definition 

1! = 1 = 1 

2! = 2*1 = 2 

3! = 3*2*1 = 6 

4! = 4*3*2*1 = 24 

5! = 5*4*3*2*1 = 120 

6! = 6*5*4*3*2*1 = 720 

… 

• Java-Code: 

long fakultaet(int n) { 

if (n == 1) { 

return 1; 

} else { 

Terminierungsbedingung 

Basisfall 

return n * fakultaet(n - 1); 

} 

} 

„Nachklappern“ Rekursionsschritt 



Java-Code der Fakultätsfunktion 


if (n == 1) { 

return 1; 

} else { 


} 

} 

Ausführung fakultaet(4): 

4 . 

fakultaet(3) 

4 . 6=24 

3 . 

fakultaet(2) 

3 . 2=6 

2 . 2 . 1=2 

fakultaet(1) 

1 

„Nachklappern“ mit Hilfe der 

offenen Methodenschachteln 



Korrekt gemäß Spezifikation? 

• Gegeben: 

Spezifikation einer Funktion f (im mathematischen Sinne). 

Gefragt: 

Berechnet eine in einer Programmiersprache 

ausgedrückte Funktion f immer f ? 

• Naiver Ansatz („ausprobieren“): 

Für jede Eingabe kann das Ergebnis durch schrittweises 

Ausführen von f ermittelt werden. Dabei werden Methodenaufrufe 

im Methodenschachtelmodell ausgewertet. 

• Formaler Ansatz („beweisen“): 

Durch Verallgemeinerung Aussage für alle Eingaben ableiten! 

Korrektheitsbeweis 



Rekursion als konstruktive Form der Induktion 

Rekursionsprinzip 

Auswertung f(e) für ein e 

Induktion (vollständig) 

Beweis P für alle e 

• Für einige f(e 0 ) ist der Wert von f 

ohne weitere Rekursion feststellbar. 

• Versuche einen/mehrere Werte e‘


Korrekt gemäß Spezifikation? 

n 

• Fakultätsfunktion mathematisch: n! = i=1 i 

• Java-Code: 


if (n == 1) { 

return 1; 

} else { 


} 

} 

• 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 

= (n+1) . n! //Induktionsannahme 

n 

= (n+1) . i=1 i //Definition von n! 

n+1 

= i=1 i //Definition von 



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 nicht-rekursiven Fall erreicht. 



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 (z.B. wird nie kleiner als 0). 



Terminierungsbeweis für fakultaet 


if (n == 1) { 

return 1; 

} else { 


} 

} 

• 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. 



• Der Induktionsgedanke ist ein oft verwendetes Mittel 

zum Entwurf von Algorithmen: 

□ Bestimme die Lösung für einen Basisfall. 

□ Zerlege das Problem in ein, zwei oder mehrere einfache(re) 

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: 

trivial 

Teilproblem 2: 

Rekursiv lösbar 

 

 

Verknüpfung 

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: Versetze 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. 



Beispiel 

• Gegeben: 3 Scheiben unterschiedlichen Durchmessers, der Größe 

nach geordnet auf Position A. Positionen B und C ohne Scheiben. 

A B C 

• Problem: Versetze 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. 



Lösungsansatz: Induktionsprinzip 

• Basisfall k=0: keine Scheiben. 

Trivial, weil sofort fertig. 

• Rückführung auf kleinere Probleme (k>0) 

□ Teilproblem 1: Versetze die oberen k-1 Scheiben von A nach C 

kleines Problem: rekursiv lösbar 

□ Teilproblem 2: Versetze die verbleibende 

k-te Scheibe von A auf Turm B 

Triviale Elementaroperation 

□ Teilproblem 3: Versetze die k-1 Scheiben von C nach B 

kleines Problem: rekursiv lösbar 

□ Verknüpfung: 

Hintereinanderausführung der 3 Teillösungen 

Induktionsannahme: 

Das Problem ist für die 

Versetzung von k-1 

Scheiben lösbar. 

Gleiche Induktionsannahme 

nochmals 



• Lösungsansatz: Induktionsprinzip 

A B C 

k-1 Scheiben 

von A nach C 

1 Scheibe 

von A nach B 

k-1 Scheiben 

von C nach B 



Java-Code 

void hanoi(int k, char start, char ziel, char hilfe) { 

if (k > 0) { 

hanoi(k - 1, start, hilfe, ziel); 

System.out.print("Versetze Scheibe " + k); 

System.out.print(" von " + start); 

System.out.println(" nach " + ziel); 

hanoi(k - 1, hilfe, ziel, start); 

} 

// else-Fall = Basisfall der Induktion ist leer 

} 

 

 

Der Fall k wird auf den Fall k-1 zurückgeführt. 

Die Induktionsannahme wird doppelt angewendet. 

Rekursion nicht nur am Ende des Rumpfs. 



hanoi(3, ‘A‘, ‘B‘, ‘C‘); 

> java Hanoi 

Versetze Scheibe 1 von A nach B 

Versetze Scheibe 2 von A nach C 

Versetze Scheibe 1 von B nach C // zwei Scheiben A C 

Versetze Scheibe 3 von A nach B // größte Scheibe am Ziel 

Versetze Scheibe 1 von C nach A 

Versetze Scheibe 2 von C nach B // zweitgrößte Scheibe am Ziel 

Versetze Scheibe 1 von A nach B // fertig 



• Korrektheit: 

Beweis per Induktion 

(kann direkt aus Rekursion abgelesen werden.) 

• Terminierung: 

Terminierungsfunktion T(x) = x 

(Anzahl zu versetzender Scheiben) 

□ Streng monoton fallend (per Induktionsbeweis) 

□ Nach unten durch 0 beschränkt 



• 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, 3, 5, 8, 13, 21, 34, 55, … 

• Rekursive Definition: 

□ fibo(0) = 1 

□ fibo(1) = 1 

□ fibo(n) = fibo(n-2) + fibo(n-1) 

• Die so genannten Fibonacci-Zahlen 

spielen in der Informatik an ganz 

unterschiedlichen Stellen eine Rolle. 




• Basisfall: 

□ n=0: fibo(0) = 1 

□ n=1: fibo(1) = 1 

• Rückführung auf kleinere Probleme 

□ Teilproblem 1: fibo(n - 2) 

□ Teilproblem 2: fibo(n - 1) 

□ Verknüpfung: Addition 

 

 

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. 



• Fibonacci-Zahlen in Java 

 

 

long fibo(int n) { 

if (n


Nachteile der rekursiven Lösung 

fibo(4) 

fibo(2) 

Wenn man hier das 

Zwischenergebnis von 

fibo(2) noch hätte, 

könnte man die neue 

Berechnung einsparen. 

fibo(3) 

fibo(0) fibo(1) fibo(1) fibo(2) 

fibo(0) 

fibo(1) 

Diese Darstellung wird Aufrufbaum genannt. 

werden jeweils erneut ausgewertet! 



Durchreichen von Zwischenergebnissen 

long fiboFast(int fim1, int fi, int i, int n) { 

//Zwischenergebnis Fibonacci(i - 1) in fim1 

// und Fibonacci(i) in fi 

if (i >= n) { 

return fi; 

} else { 

return fiboFast(fi, fim1 + fi, i + 1, n); 

} 

} 

long fiboSchnell(int n) { 

return fiboFast(1, 1, 1, n); 

} 

Statt Neuberechung 

wird (früheres) Teilergebnis 

verwendet. 



Rekursion bei durchgereichten Zwischenergebnissen 

fiboFast (1, 1, 1, 4) 

fiboFast (1, 2, 2, 4) 

fiboFast (2, 3, 3, 4) 

Zwischenergebnisse „rücken auf“ 

und werden zur Berechnung neuer 

Zwischenergebnisse verwendet. 

fiboFast (3, 5, 4, 4) 

 

 

Korrektheit und Terminierung wieder per Induktion 

leicht zu beweisen. 

Durchreichen von Zwischenergebnissen ist eine 

grundlegende Programmiermethode. 



Analyse der Rekursion 

long fiboFast(int fim1, int fi, int i, int n) { 

//Zwischenergebnis Fibonacci(i - 1) in fim1 

// und Fibonacci(i) in fi 

if (i >= n) { 

return fi; 

} else { 

return fiboFast(fi, fim1 + fi, i + 1, n); 

} 

} 

Dann wird das Ergebnis von 

Methodenschachtel zu 

Methodenschachtel kopiert. 

5 

5 

fiboFast (1, 1, 1, 4) 

fiboFast (1, 2, 2, 4) 

Erst Abstieg bis auf tiefste 

Rekursionsebene (Basisfall). 

5 

5 

fiboFast (2, 3, 3, 4) 

fiboFast (3, 5, 4, 4) 



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 

1 5 



Skyline-Problem am Beispiel 

• Gegeben: 

1 5 10 15 20 25 30 

(1,11,5) 

(2,6,7) 

(3,13,9) 

(12,7,16) 

(14,3,25) 

(19,18,22) 

(23,13,29) 

(24,4,28) 

• Lösung: 

1 5 10 15 20 25 30 

Skyline-Beschreibung: (1,11,3,13,9,0,12,7,16,3,19,18,22,3,23,13,29,0) 




• 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. 

1 5 10 15 20 25 30 

Skyline (n-1): (1,11,3,13,9,0,12,7,16,3,19,18,22,3,23,13,29,0) 

Skyline (n): (1,11,3,13,9,9, 19,18,22,9,23,13,29,0) 



• Man kann dafür Korrektheit und Terminierung beweisen. 

Allerdings: 

• Um das Gebäude n hinzuzufügen, muss der Durchlauf durch die 

Skyline der n-1 Gebäude etwa 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 

□ … 

„Komplexitätstheorie“: O(n²) 

□ Hinzufügen Gebäude 1: + 1 

□ Gesamt: 

½ n(n+1) Überprüfungen/Änderungen 

• Bei 16 Gebäuden: 16·17/2 = 136 Schritte 

aber es gibt im Allg. mehrere Algorithmen für ein Problem … 



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 (ggf. aufrunden) berechnen. 

□ Teilproblem 2: Skyline für restl. n/2 Gebäude (ggf. abrunden) berechnen. 

□ Verknüpfung: 

• Beispiel: 

• Führe die beiden Skylines zusammen. 

• Man spricht von Verschmelzung. 

Man kann dafür Korrektheit 

und Terminierung beweisen 

Verknüpfung nicht langsamer 

als im 1-Gebäude-Fall! 

Schrittweises Durchlaufen 

beider Skyline-Folgen halber 

Länge, maximal n Änderungen. 



• 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) = 16 + 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) 

Wie man leicht erkennt, gilt… 

= n + n . log 2 (n) // nach Definition log 2 

„Komplexitätstheorie“: O(n · log n) – statt O(n²) 



Von Problemgröße abhängiger Aufwand 

250 

200 

Je ein Gebäude einzeln hinzufügen 

(20 Gebäude: 210 Schritte) 

Schrittzahl 

150 

100 

50 

n(n+1)/2 

n+n*log(n,2) 

Bis n=6 ist der 

1. Lösungsansatz 

besser, dann 

Umstiegspunkt. 

0 

Problem „halbieren“ und „Verschmelzen“ 

(20 Gebäude: ca. 106 Schritte) 

1 

3 

5 

7 

9 

11 

13 

15 

17 

19 

Problemgröße 



Teile-und-Herrsche: 

(divide-and-conquer) 

= 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 im Allgemeinen mehrere Algorithmen gibt, 

bleibt stets die Frage nach dem Aufwand und damit dem besten 

Algorithmus für das jeweilige Problem! 


8.5 Hinführung: Blasensortierung („bubble sort“) 

Gegeben 

• Reihe mit n (zunächst unsortierten) Elementen 

10 3 2 5 8 1 4 7 

Grundidee 

• Die Reihe wird immer wieder durchlaufen und dabei werden 

benachbarte Elemente in die richtige Reihenfolge gebracht. 

• Größere Elemente überholen so die kleineren und drängen an das 

Ende der Folge (= aufsteigende Blasen). 

Aufwandsabschätzung 

• Im ersten Durchlauf werden n Elementpaare verglichen. 

• Im zweiten Durchlauf werden n-1 Elementpaare verglichen. 

• … 

• Gesamtaufwand: O(n²) 


8.5 Hinführung: Blasensortierung („bubble sort“) 

Beispiel 

10 3 2 5 8 1 4 7 

3 10 2 5 8 1 4 7 

3 2 10 5 8 1 4 7 

… 

10 „blubbert hoch“ 

3 2 5 8 1 4 7 10 

2 3 5 8 1 4 7 10 

bis hier sortiert 

… 

8 „blubbert hoch“ 

2 3 5 1 4 7 8 10 



Sortieren durch Mischen („merge sort“) 

Grundidee: Teile-und-Herrsche 

• Wir können eine Liste der Länge n=2 m , m>0, mit geringem 

Aufwand (n/2) in zwei gleich große Teillisten der Länge n/2=2 m-1 

zerlegen und mit gleichem Aufwand die Ergebnisse 

zusammenfügen (Reißverschluss). 

• Leere oder einelementige Mengen sind sortiert. 

• Damit gibt es nur noch m = log 2 n Rekursionen. 

Aufwandsschätzung (n sei die Länge der Liste) 

• Also Gesamtaufwand im schlechtesten Fall: O(n·log 2 n) 

eines der schnellsten Sortierverfahren! 



Grundprinzip 

Rekursion: 

1 n 

n Basisfälle 

Lösung 1. Teil 

Lösung 2. Teil 

Rekursion 

Gesamtlösung 

Mischen: 

10 

7 

3 

5 

4 

2 

10 

7 

3 

5 

4 

10 

7 

5 

4 

≤ 

≤ 

≤ 

… 

2 

3 

2 



Beispiel 

10 3 2 5 8 1 4 7 

10 3 2 5 8 1 4 7 

10 3 2 5 8 1 4 7 

10 3 2 5 8 1 4 7 

3 10 2 5 1 8 4 7 

3 10 2 5 1 8 4 7 

2 3 5 10 1 4 7 8 

takeAndDrop 

1 2 3 4 5 7 8 10 

merge 



Wichtige Eigenschaften 

• mergesort() ist stabil 

(gleich Elemente werden nie vertauscht) 

• Schnellstes Verfahren auf verketteten Listen 

wegen der geringsten Zahl an Vergleichen 

• Sequentieller Zugriff auf Teillisten externes Sortierverfahren. 

Daher verbreitetes Sortierverfahren für große Listen, die nicht 

mehr in den Hauptspeicher passen: 

□ Unterteile Datei in Abschnitte. 

□ Sortiere jeden der Abschnitte für sich im Hauptspeicher. 

□ Speichere sortierten Abschnitt in Hilfsdatei. 

□ Verschmelze die Hilfsdateien mit Reißverschlussverfahren. Wichtig 

ist dabei, dass die Hilfsdateien sequentiell von links nach rechts 

verarbeitet werden. (Das geht schnell und ohne wahlfreien Zugriff.) 



• 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. 

□ Repetitive Rekursionen können daher unmittelbar entrekursiviert und 

durch Schleifen ersetzt werden 

• 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. 



• 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 primitiver 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(3,3) = 61, 

ackermann(2,4) ≈ 10 21000 , ackermann(4,4) ≈ 10 101021000 



• Verschränkte Rekursion: Methoden rufen sich zyklisch 

gegenseitig auf. (Einfacher Fall: Methodendeklaration f enthält einen 

Aufruf der Methode g, die wiederum einen Aufruf von f enthält.) 

• Beispiel: ist eine Zahl n gerade (oder ungerade)? 

boolean isEven(int n) { 

if (n == 0) { 

return true; 

} else if (n == 1) { 

return false; 

} else { 

return isOdd(n-1); 

} 

} 

boolean isOdd(int n) { 

if (n == 0) { 

return false; 

} else if (n == 1) { 

return true; 

} else { 

return isEven(n-1); 

} 

} 



• Verschränkte Rekursion: Methoden rufen sich zyklisch 

gegenseitig auf. (Einfacher Fall: Methodendeklaration f enthält einen 

Aufruf der Methode g, die wiederum einen Aufruf von f enthält.) 

• Beispiel: binäre Quersumme von n 

Hat die Binärdarstellung von n eine ungerade Zahl von Einsen? 

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. 

} 


// analog 

} 



• Beispiel: binäre Quersumme 


if (n == 0) return false; 

else if ((n % 2) == 0) 

return qsumIs1(n / 2); 

else return qsumIs0(n / 2); 

} 


if (n == 0) return true; 

else if ((n % 2) == 0) 

return qsumIs0(n / 2); 

else return qsumIs1(n / 2); 

} 

qsumIs1(42) 0101010 

qsumIs1(21) 010101 

qsumIs0(10) 01010 

qsumIs0(5) 0101 

qsumIs1(2) 010 

qsumIs1(1) 01 

qsumIs0(0) 0 

true 

Hat die Binärdarstellung von 42 eine ungerade Zahl von Einsen? 

42 = 32+8+2=101010 binär 

qsumIs1(42) 



• Fakultätsfunktion: lineare Rekursion 

(Durchreichen-Variante: repetitiv) 

• Türme von Hanoi: kaskadenartige Rekursion 

• Fibonacci-Zahlen: kaskadenartige Rekursion; 

Durchreichen von Zwischenergebnissen 

liefert repetitive Rekursion; 

umgebaut in Iteration. 

• Skyline-Problem: kaskadenartige Rekursion 

• Sortieren durch Mischen: kaskadenartige Rekursion 

• Gerade/Ungerade: verschränkte Rekursion 

• Binäre Quersumme: verschränkte Rekursion 


Vielen Dank für‘s Zuhören 

• Fragen?

Präsentationsfolien (PDF)

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?