Iterative und Rekursive Algorithmen Iteration und Rekursion sind im ...

© J. Rau Januar 2013
Iterative und Rekursive Algorithmen
Iteration und Rekursion sind im Prinzip gleichwertig - sie sorgen für das mehrmaliges Ausführen einer Aktion.
Rekursive Algorithmen sind aber häufig kürzer und eleganter, dafür benötigen sie während ihrer Laufzeit mehr
Arbeitsspeicher.
Ein iterativer Algorithmus wiederholt die Aktion, indem sie einen Zähler benutzt, der angibt wie oft die
Aktion ausgeführt werden soll.
Iterationen werden durch die bekannten Schleifenstrukturen for ( ) { } und while ( ) { } programmiert.
Iterative Methode PizzaEssen ( )
for (ersten bis letzten Bissen ; nimm den nächsten Bissen) {Schneide diesen Bissen ab und iss ihn auf };
Unter Rekursion versteht man ebenfalls eine wiederholte Ausführung, doch ohne Zählschleife, stattdessen ruft
sich die Aktion (bis zu einer Abbruchbedingung) immer wieder selbst auf und nutzt dafür die
Entscheidungsstruktur if( ) { } else { }.
Rekursive Methode Pizzaessen ( ):
if (Teller nicht leer) {Schneide einen Bissen ab und iss ihn auf; PizzaEssen ( );} else {fertig;};
Ein Algorithmus heißt rekursiv, wenn mindestens einer seiner Schritte darin besteht, den gleichen Algorithmus
für einfachere Anfangswerte auszuführen. Man erkennt die Rekursion daran, dass sich die Methode selbst
aufruft. Jeder rekursive Algorithmus muss eine Abbruchbedingung enthalten.
Kennen Sie Matroschkas ? Sie sind ein typisches Anschauungsmodell für Rekursion:
Methode matroschkaAuspacken (Puppe P):
if ( P zu öffnen geht) { Packe P aus und entnimm den Inhalt von P‘; matroschkaAuspacken (P‘);}
else { nimm P freue dich du hast die ganz Kleine [Ende]}
Damit ein Problem eine rekursive Lösung hat, muss es folgende Eigenschaften besitzen:
Das Originalproblem muss sich in einfachere Varianten von sich selbst zerlegen lassen.
Die Zerlegung in Teilprobleme muss zuletzt auf so einfache Varianten des Originalproblems führen, dass
sie ohne weitere Zerlegung gelöst werden können.
Wenn alle Teilprobleme gelöst sind, müssen die Lösungen so zusammengesetzt werden können, dass sich
eine Lösung des Originalproblems ergibt.

© J. Rau Januar 2013
Vergleich von Rekursion und Iteration
Iteration ist die Wiederholung
strukturgleicher Blöcke durch Aneinanderreihung
Rekursion ist die Wiederholung strukturgleicher
Blöcke durch Schachtelung
Iteration (Endrekursion):
Man öffnet die größte Puppe, entnimmt die
kleinere Puppe und setzt die beiden Teile der
größeren Puppe wieder zusammen. Dies wiederholt
man, bis die kleinste Puppe ausgepackt ist.
Echte Rekursion:
Man öffnet nacheinander jede Puppe, stellt deren 2
Teile geöffnet ab und entnimmt die nächste Puppe.
Wenn die kleinste Puppe entnommen wurde, setzt man
die jeweiligen zwei Teile der größeren Puppen in
umgekehrter Reihenfolge zusammen.
Rekursive Algorithmen sind oft besonders gut zur Problemlösung geeignet, da
(1) sie sehr mächtig und kompakt darstellbar sind,
(2) sie sich relativ leicht finden lassen,
(3) sich ihre Korrektheit relativ leicht zeigen lässt.
Der Nachteil ist, dass rekursive Algorithmen evtl. viel Speicherplatz und Rechenzeit erfordern.
Beispiele
Berechnung des größten gemeinsamen Teilers zweier Zahlen (ggT)
iterativer Algorithmus itggT(int m,int n):
Speichere m und n unter den Namen x und y.
Schritt 1: while ( x! = y), else { gehe zu Schritt 2};
Schritt 2: if ( x > y) { x =(x-y) und gehe zu Schritt 1};
if ( x < y) { y= (y-x) und gehe zu Schritt 1};
{ liefere x als Ergebnis ab };
Flussdiagramme für ggT in Java Beispiel ggT 84 und 30
Minus
Minus
Minus
Gleich

© J. Rau Januar 2013
Die Wiederholung des Algorithmus ab Schritt 2 in der Iteration wird durch Rekursion ersetzt.
rekursiver Algorithmus rekggT (int m,int n):
Schritt 1: if ( m == n) {liefere m als Ergebnis, sonst gehe zu Schritt 2};
Schritt 2: if ( m > n) {liefere das Ergebnis von rggT ( (m-n), n) als Ergebnis ab} else {gehe zu Schritt 3};
Schritt 3:
if ( m < n) {liefere das Ergebnis von rggT ( m, (n-m) ) als Resultat ab};
ggT mit BlueJ (iterativ)
public void itggT (int m, int n) {
int x = m;
int y = n;
int z;
while (x!= y) {
z = x;
if (x > y) { x = x - y; }
else { y = y - x; }; };
System.out.println (“Der ggT ist: ”+z); }
ggT mit BlueJ (rekursiv)
public int rekggT (int m, int n) {
}
if (m == n) { return m; }
if (m > n) { return rekggT (m-n, n); }
else { return rekggT(m, n-m); }
public void ausgabeggT (int m, int n) {
int z = rekggT (m,n);
System.out.println (“Der ggT ist: ”+z); }
Fibonacci-Folge und weitere Beispiele Fakultät, Quersumme
1) Hinter den Ziffernfolgen 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377... verbirgt sich ein
interessantes rekursives Bildungsgesetz: die Folge von Fibonacci.
( n 1) Fib( n 2) für n > 2
Fib( n)
1 für 0

© J. Rau Januar 2013
2) Eine rekursive Methode fakultät(int n) berechnet die Fakultät einer positiven ganzen Zahl n.
public int fak (int n) {
if (n > 1) { return n * fak (n- 1); }
else { return 1; }
}
3) Was berechnen die Algorithmen, die durch die folgenden Quelltexte dargestellt werden ?
public int irgendwas ( int p, int q ){
if ( p == 0 ) { return 0; } else { return q*irgendwas ( p-1, q ); }; }
public int irgendwas ( int p ){
if ( p == 1 ) { return 1; } else { return p + irgendwas ( p-1 ); }; }
4) Die Methode int querSumme(int zahl) berechnet die Quersumme einer pos. Ganzzahl zahl.
Hinweise: Beispiel: zahl=345 von hinten mit der Zerlegung beginnen:
letzte Ziffer x= zahl modulo 10 5
vorletzte Ziffer a= zahl modulo 100 45
y= (a-x):10 40:10=4
erste Ziffer b= zahl modulo 1000 345
oder einfach die Zahl nehmen
z= (b-a-x):100 300:100=3
Quersumme:
qs=x+y+z
Lässt sich beliebig erweitern für 4 stellige... usw.
x= (zahl modulo10-zahl modulo1) :1
y= (zahl modulo100-zahl modulo10) :10
z= (zahl modulo1000-zahl modulo100-zahl modulo10) :100 ...
Beispiel:zahl= 3456
1.DL qs=6 (3456-(3456%10)):10=345
2.DL qs=5+6 (345-(345%10)):10=34
3.DL qs=4+5+6 (34-(34%10)):10=3
4.DL qs=3+4+5+6 (3-(3%10)):10=0
public int querIterativ (int zahl) {
int qs;
while (zahl>0) {
qs=qs+(zahl%10);
zahl=((zahl –(zahl % 10)) /10);
}
return qs; }
//iterativ
public int querRekursiv (int zahl) { //rekursiv
if (zahl>0) {
qs=querRekursiv((zahl-(zahl%10))/10)+zahl%10
;}
return qs; }