Rekursion mit JavaKara

Transkript

1 Hans Peter Schneider Rekursion mit JavaKara eine Unterrichtsreihe des Faches Informatik im Rahmen des Wahlpflichtunterrichts der Klasse 9 an Gymnasien 1. Semesterarbeit zur Virtuellen Lehrerweiterbildung Informatik in Niedersachsen

2 Hans Peter Schneider Rekursion mit JavaKara Seite 2 Inhalt Seite JavaKara... 3 Beschreibung... 3 Einsatz... 3 Rekursion... 5 Rekursion vs. Iteration... 5 Modell der Impliziten Speicherung... 5 Unterrichtsreihe Hin und Zurück Einführung Labyrinth rekursiv Anwendung Füllen Vertiefung... 9 Weitere Aufgaben zur Rekursion Türme von Hanoi ggt mit Euler Quellen... 11

3 Hans Peter Schneider Rekursion mit JavaKara Seite 3 JavaKara Beschreibung Die ETH Zürich [1] bietet ein Java-Programm zum kostenlosen Download an, das für den Unterricht eine einfache Umgebung bietet, um Programmieren zu lernen. Ein Roboter-Objekt namens Kara in Form eines Marienkäfers kann mittels eines kleinen Befehlssatzes in einer diskreten Welt gesteuert werden. Unter anderem kann dieser Roboter in der Sprache Java programmiert werden, wobei die sequentielle Programmierung im Vordergrund steht, Objektorientierung und Ereignissteuerung werden nicht unterstützt. Die Welt, in der sich Kara bewegt, ist zweidimensional, in beiden Hauptrichtungen zyklisch und besteht aus einem rechteckigen Bereich aus endlich vielen quadratischen Feldern. Jedes Feld kann mit einem Kleeblatt, einem Pilz oder einem Baumstumpf belegt sein. Kara kann auf den freien Feldern und über Kleeblätter laufen. Ein Pilz wird von Kara verschoben, wenn das Feld dahinter frei ist. Ein Baumstumpf ist für Kara ein unbewegliches Hindernis. Der Benutzer kann die Welt frei gestalten und speichern. In der Java-Umgebung wird Kara durch das Objekt kara Die Befehle void void ein Feld vorwärts bewegen auf dem Feld eine Vierteldrehung links repräsentiert, die zulässigen void kara.turnright(); auf dem Feld eine Vierteldrehung rechts Befehle und Sensoren des Roboters sind als Methoden dieses void kara.putleaf(); Kleeblatt ablegen void kara.removeleaf(); Kleeblatt aufnehmen Die Sensoren Objekts implementiert (siehe boolean kara.treefront(); ist in Laufrichtung ein Baum? Kasten). Die Hauptklasse des boolean kara.treeleft(); ist links ein Baum? boolean kara.treeright(); ist rechts ein Baum? Java-Programms wird von der boolean kara.onleaf(); steht Kara auf einem Blatt? vordefinierten Klasse Java- boolean kara.mushroomfront(); ist in Laufrichtung ein Pilz? KaraProgram abgeleitet. In dieser wird das Programm selbst innerhalb der Methode public void myprogram() implementiert, die die gleichnamige Methode der Elternklasse überlagert. Innerhalb der Klasse können wie in jeder Klasse weitere Methoden und Variablen definiert werden. Weitere eigene Klassen können zwar definiert und verwendet werden, dies geht aber über die eigentliche Zielsetzung von JavaKara hinaus. Das fertige Programm wird aus der Umgebung heraus kompiliert und ausgeführt, dabei wird die zugehörige.class-datei erzeugt und als Teil von allkara.jar ausgeführt. Einsatz Die JavaKara-Umgebung wurde programmiert für die von Objektorientierung ungestörte Einführung in die sequentielle Programmierung mit C-Strukturen, die der Sprache Java zu Grunde liegen. Die Welt und der Befehlssatz von JavaKara erlauben am Anfang sogar eine variablen- und parameterfreie Programmierung, die es ermöglicht ohne großen Aufwand die Schüler zu komplexen kognitiven Strukturen wie

4 Hans Peter Schneider Rekursion mit JavaKara Seite 4 den Begriff der Rekursion zu führen. Das niedliche Design spricht Schüler in der Klasse 9 nicht mehr sehr an, es ist eher was für die Klassen 5 bis 7, dennoch ist JavaKara als Werkzeug für die Unterrichtsreihe Einführung in die Java-Programmierung im zweiten Quartal des Kurses sehr wertvoll. Die Verwendung von Java-Kara fügt sich wie folgt in den Kanon des Informatikunterrichts der Klasse 9 mit 4 Wochenstunden ein: 1. Halbjahr: Webseitengestaltung mit HTML und CSS: Gewöhnung an geschachtelte Strukturen, Gestaltung einer Website. 2. Halbjahr: Einführung in die Programmierung mit JavaKara: Programmstrukturen, Variablen, Felder, Sortieralgorithmen, Rekursion. 3. Halbjahr: Einführung in JavaScript: Verwendung des HTML-DOMs und ereignisgesteuerter Programmierung, Programmierprojekt: Gesellschaftsspiel (Memory, TicTacToe, Mühle, Minesweeper oder ähnliches). 4. Halbjahr: Javaprogrammierung: Anwendungen mit eigenem Fenster, OOP, Ereignissteuerung, GUI mit AWT, Computergrafik 1. Strategie Man taste nach der linken Wand und folge dieser bis zum Kleenlatt. 2. Algorithmus Ist links ein Durchgang, so benutze diesen; sonst, wenn geradaus frei, folge dem Gang; sonst, wenn rechts ein Durchlass, benutze diesen; sonst kehre um. Dies alles immer wieder bis zum Kleeblatt. 3. Struktogramm public class FindeBlatt extends JavaKaraProgram { public void myprogram() { while (!kara.onleaf()) { Naheliegend ist ein Start mit der Einführung der while-struktur, um Kara zu einer Markierung (etwa einem Blatt) laufen zu lassen. Besonders eignen sich im weiteren Verlauf Probleme aus dem Irrgarten -Sortiment, an denen die Schüler üben, Lösungsstrategien zu entwickeln, die sie verfeinern und über Struktogramme schließlich bis zum Code führen. Exemplarisch dafür ist Lösung Immer an der Wand lang für nicht zyklische Labyrinthe: Man versetze die Schüler in die Lage des Käfers, in dem man ihnen das Problem stellt, in einem finsteren, unbekannten Raum den Ausgang zu finden, wobei sie sich nur auf ihren Tastsinn verlassen können. In der Regel kommen die Schüler selbst auf die Strategie Immer an der Wand lang, sie müssen diese dann verbalisieren und schrittweise genauer formulieren, bis die Strategie sich in einen Algorithmus fassen lässt. 4. Code public class ImmerAnDerWandLang extends JavaKaraProgram { public void myprogram() { while (!kara.onleaf()) { while (kara.treefront()) { kara.turnright();

5 Hans Peter Schneider Rekursion mit JavaKara Seite 5 Rekursion Rekursion vs. Iteration Schon einige der ersten höheren Programmiersprachen, also solche, die die Implementierung von Methoden erlauben, kannten den Selbstaufruf der Methode innerhalb ihrer eigenen Deklaration. Doch selbst in Java, eine Sprache, in der sich weitgehend das System um Sicherheit, Kontrolle und Speicherverwaltung kümmern muss, kann der endlose Selbstaufruf nicht abgefangen werden und führt bei unsachgemäßer Anwendung zum Stack-Overflow und damit schlimmstenfalls zum Absturz des Rechners. Die Iteration kommt in der Regel mit einer definiert endlichen Speichermenge aus, ein Stack-Overflow ist nur vorsätzlich aber nicht fahrlässig zu erzeugen. Schülern fällt es schwer, den Rekursionsbegriff zu begreifen und rekursiv Probleme zu lösen, zu Anfang greifen sie immer lieber auf iterative Verfahren zurück. Daher muss bei der Einführung der Rekursion möglichst gleich zu Anfang Probleme auftauchen, die sich rekursiv sehr kurz und elegant lösen lassen, iterativ aber nur sehr umständlich und arbeitsintensiv. Beispiele für sehr effiziente, kurze Rekursionen sind die Türme von Hanoi, das Euler-Verfahren zur Bestimmung des ggt zweier Zahlen und das Füllen einer beliebigen, einfarbig zusammenhängenden Pixelfläche: Die rekursiven Kerne der Lösungen dieser Beispiele lassen sich jeweils mit weniger als zehn Zeilen implementieren und entfalten bei der Ausführung enorme Kraft und Effektivität. Modell der impliziten Speicherung Der Programm-Stack in der Laufzeitumgebung dient der Steuerung von Umterprogrammaufrufen: Wird ein Unterprogramm aufgerufen, wird die Adresse des ersten Befehls des Unterprogramms im Hauptspeicher in den Programmzeiger geladen. Damit der Programmzeiger nach Beendigung des Unterprogramms zum Ausgangspunkt, von dem aus das Unterprogramm aufgerufen wurde, zurückfindet, wird zuvor die aktuelle Adresse im Programmzeiger auf den Stack gelegt. Bei Beendigung des Unterprogramms wird stets ein ret (return)-befehl ausgeführt, der die oberste Adresse vom Stack nimmt und zurück in den Programmzeiger lädt. Der Programmschritt- Inkrement sorgt dafür, dass das Programm an der Stelle nach dem Aufruf des Unterprogramms fortgesetzt wird. Ist das Unterprogramm nun rekursiv, enthält es also einen Sprungbefehl zu seiner eigenen Startadresse, so wird mit jedem neuen Aufruf eine Adresse auf dem Stack abgelegt. Die Anzahl der Adressen auf dem Stack, bzw. der Wert des Stackzeigers ist eine Größe, die Information enthält, die vom laufenden Programm benutzt wird. In der Regel ist diese in der rekursiven Lösung nur implizit verwendete Information (implizit, da diese Größe nicht vorsätzlich oder zugreifbar im Programm verwaltet wird) gerade die, die zur Steuerung einer Schleife der korrespondierenden iterativen Lösung explizit angegeben oder errechnet werden muss. Die

6 Hans Peter Schneider Rekursion mit JavaKara Seite 6 Struktur der Rekursion dient selbst also als Informationsspeicher für die Ausführung des Programms. Dies ist im einführenden Problem Hin und wieder zurück besonders deutlich zu erkennen und kann daran mit den Schülern erarbeitet werden. Unterrichtsreihe Die Reihe zur Einführung der Rekursion umfasst drei zentrale Probleme, zu denen Lösungen entwickelt und implementiert werden. Das erste Problem Hin und wieder zurück ist so einfach, dass die Schüler die iterative Lösung selbst entwickeln und nach gemeinschaftlicher Erarbeitung der rekursiven Lösung beide Lösungen gegenüberstellen können. Das zweite Problem Labyrinth rekursiv vermittelt dann die Vorteile des rekursiven Algorithmus bei speziell strukturierten Problemen. Das dritte Problem des Füllens einer beliebigen, einfarbigen Pixelfläche zeigt die Macht der Rekursion und gleichzeitig ihre Schwäche: Einerseits ist das Füllen -Problem iterativ mit vertretbarem Aufwand nicht zu lösen, andererseits benötigt die rekursive Lösung bei großen Flächen ( = Pixel) hudertausende von rekursiven Aufrufen, die bei den üblichen Rechnern in der Regel einen stack overflow verursachen und so, wenn nicht den Rechner, doch zumindest das Programm zum Absturz bringen. Hin und wieder zurück Einführung Ein Aufgabenbeispiel, wo eine iterative Lösung praktischer erscheint, das sich aber gut dazu eignet den Unterschied zwischen Rekursion und Iteration zu diskutieren, ist das Problem des Hin und wieder zurück : Kara soll gerade auf einen Baum zulaufen, dort umkehren und genau zu dem Feld zurückkehren, von dem Kara gestartet ist. Dabei darf es keine Rolle spielen, wie viele Felder der Baum von der Ausgangsposition entfernt ist. Dazu können die Schüler verschiedene Lösungsansätze selbst entwickeln, wobei sie in der Regel iterative Lösungen vorschlagen, zum Beispiel: 1. Markierung des Ausgangsfeldes: Kara legt ein Kleeblatt auf sein Ausgangsfeld, dann läuft er bis zum Baum, dreht sich um und läuft, bis er auf einem Kleeblatt steht. 2. Messen der Entfernung: Kara zählt die Felder bis zum Baum und merkt sich den Wert. Vor dem Baum dreht sich Kara um und läuft so viele Schritte zurück, wie gezählt wurden. Schade, dass wir noch nicht gelernt haben, wie Kara zählen und sich eine Zahl merken kann. Beide Lösungen verlangen in irgendeiner Form einen Speicher, in dem Kara sich die Ausgangsposition merken kann. Verbietet der Lehrer solche Hilfen, wird das Problem komplizierter. Damit wird dann die rekursive Lösung motiviert. Die Lösung lässt sich auf der Kara-Welt gut grafisch entwickeln, dazu eignet sich als Einführung folgende Parodie: Einem Mathematiker und einem Ingenieur werden an einem Lagerfeuer jeweils die selben Aufgaben gestellt: 1. Ein Topf mit Wasser steht an Position A. Bringe das Wasser zum kochen! - Der Ingenieur nimmt den

7 Hans Peter Schneider Rekursion mit JavaKara Seite 7 Topf von Position A und stellt ihn auf das Feuer. - Der Mathematiker nimmt den Topf von Position A und stellt ihn auf das Feuer. 2. Ein Topf mit Wasser steht an Position B, die von A verschieden ist. Bringe das Wasser zum kochen! - Der Ingenieur nimmt den Topf von Position B und stellt ihn auf das Feuer. - Der Mathematiker nimmt den Topf von Position B, stellt ihn auf Position A und hat somit das Problem auf das vorherige zurückgeführt. Dieses Grundprinzip des Mathematikers wenden wir jetzt auf unser Problem an. Auf den ersten Blick scheint das Problem, Kara aus einiger Entfernung zum Baum und zurück gehen zu lassen, als zu schwierig, also reduzieren wir für den Anfang das Problem auf ein einfacheres: Wie sieht es aus, wenn Kara direkt vor dem Baum steht? Überhaupt kein Problem: Kara dreht sich um und fertig. Jetzt entwickeln wir das Problem rekursiv für zunehmende Entfernungen. Was ist, wenn Kara ein Feld von dem Baum entfernt steht (was Kara ja nicht weiß)? Ist augenscheinlich zu lösen: Kara geht ein Feld und hat somit das Problem auf das vorherige zurückgeführt. Nach dessen Lösung (umdrehen) muss Kara nur noch einmal ein Feld gehen (diesmal in die andere Richtung). Jetzt sehen wir schnell, dass dieses Konzept unser ganzes Problem vollständig löst: Kara geht ein Feld, hat das Problem auf das Problem mit einem Feld weniger zurückgeführt und nach dessen Lösung geht Kara noch einmal ein Feld. Analog zur vollständigen Induktion wird das Problem also vom Fall Entfernung gleich Null an entfaltet. Gehe zum Baum und zurück bedeutet jetzt im Einzelnen: - Steht Kara schon vor dem Baum, dann drehe er sich um. - Steht Kara nicht vor dem Baum, dann gehe einen Schritt, gehe zum Baum und zurück und gehe einen Schritt ( in die andere Richtung). Der Selbstaufruf der Definition stellt die Rekursion dar, die sich terminiert durch den Fall, dass Kara vor dem Baum steht. public class HinUndWiederZurueck extends JavaKaraProgram { void gehezumbaumundz() { if (kara.treefront()) { gehezumbaumundz(); // Rekursion public void myprogram() { gehezumbaumundz(); Bei dieser rekursiven Lösung braucht Kara weder eine Markierung noch eine Variable. Wie aber wird die Information über das Ausgangsfeld gespeichert? Irgendwo muss sie sein, da sie ja offensichtlich nicht verloren geht, sonst würde Kara ja nicht zum Ausgangsfeld zurückfinden. Die Information wird (im Gegensatz zur expliziten Speicherung über den Befehl merke Dir! ) implizit, also quasi unauffällig und nebenbei, in der Zahl der verschachtelten Selbstaufrufe gespeichert. Bei einer Entfernung von ca. fünf Feldern lässt sich diese Verschachtelung auch vollständig grafisch illustrieren. Versierte Schüler kommen schnell dahinter, dass diese Methode sehr viel mehr Speicher verbraucht als eine Variable zu definieren oder ein Kleeblatt zu hinterlegen, wird doch mit jedem Selbstaufruf der Programmzustand auf den Stack geschoben und ein neuer Programmzeiger gesetzt. Da der Programmieraufwand sich mit den iterativen Lösungen die Waage hält ist also nicht einzusehen, warum Rekursion sinnvoll sei. An diesem Punkt leite der Lehrer dann zu komplexeren Problemen wie

8 Hans Peter Schneider Rekursion mit JavaKara Seite 8 Labyrinth rekursiv über, deren rekursive Lösung aus wenigen Zeilen besteht, deren iterative Lösungen aber überhaupt nur schwer zu entwickeln sind. Labyrinth rekursiv Anwendung Wir haben im Laufe des Anfangsunterrichts zur Methodik des Programmierens bereits ein Labyrinth mit der Strategie Immer an der Wand lang gelöst (s.o.). Diese Strategie ist in sofern unbefriedigend, da die Schüler sehr schnell feststellen, dass man ohne Schwierigkeiten ein Labyrinth bauen kann, in dem Kara bis in alle Ewigkeit nach dem Kleeblatt sucht und es nicht finden kann, da das Labyrinth nicht aus nur einer sondern aus mehreren (unzusammenhängenden) Wänden besteht und das Kleeblatt gerade an einer anderen Wand als der abgetasteten liegt. Die Frage nach einer besseren Strategie führt schnell zur Hänsel und Gretel - Strategie: Kara hinterlege eine Spur, die kennzeichnet, ob Kara ein Teillabyrinth bereits untersucht hat. (Einige Schüler meinten, diese Strategie solle besser Ariadne - Strategie heißen, da es sonst eine Verschwendung von Lebensmitteln bedeuten würde. Wir haben uns dann darauf verständigt, die Strategie Hänsel und Gretel zu nennen für den Fall, das die Spur nur gelegt aber nicht wieder eingesammelt wird, aber Ariadne, wenn die Spur gemäß des roten Fadens im Labyrinth des Minotaurus beim zurückgehen wieder aufgerollt, äh, eingesammelt wird. Wir werden sehen, dass Einsammeln zur Lösung nicht beiträgt, aber auch keinen besonderen Aufwand bedeutet. Einsammeln hat jedoch zwei Vorteile: Zum Einen ist das Labyrinth im Anschluss der Lösung einigermaßen sauber, zum Anderen wird ein direkter Weg vom Ausgangspunkt zum Ziel markiert, dem andere folgen könnten.) Um eine Spur hinterlegen zu Können, die sich vom Ziel unterscheidet (wir erinnern uns: Wir suchten oben nach einem Kleeblatt unter lauter Bäumen), Soll Kara im Baumlabyrinth jetzt nach einem Pilz suchen, so kann er aus Kleeblättern die Spur legen. Die Strategie: Steht Kara auf einem Feld und hat den Pilz noch nicht gefunden, so markiert er dieses als schon durchsucht und wendet sich dann nacheinander dem Labyrinth hinter dem vorderen, dem linken und dem rechten Durchgang zu, bevor Kara sich umwendet, die Markierung wieder entfernt und sich auf den Rückweg macht. Der Ablauf soll gestoppt werden, sobald der Pilz gefunden wurde, dazu implementieren wir die Methode so, dass sie als Rückgabewert den Erfolg/Misserfolg an die aufrufende Methode weitergibt. public class LabyrinthRekursiv extends JavaKaraProgram { void turnu() { boolean fandnpilz() { if (kara.onleaf()) { //schon durchsucht, schnell zurück! turnu(); kara.putleaf(); Kara.turnLeft(); for (int i = 0; i < 3; i=i+1) { // drei Richtungen untersuchen: if (kara.mushroomfront()) { return true; } else if (kara.treefront()) { turnu(); if (fandnpilz()) { return true; // bereit zur Rückkehr: kara.removeleaf(); // Ariadne return false; // nichts gefunden public void myprogram() { fandnpilz();

9 Hans Peter Schneider Rekursion mit JavaKara Seite 9 Füllen Vertiefung Diese Aufgabe ist geeignet, um Schülern,die das Prinzip der Rekursion durchschaut haben, die Gelegenheit zu geben, selbst eine Rekursive Lösung zu entwickeln. Es geht darum, das Kara eine beliebige von Bäumen eingegrenzte Fläche mit Kleeblättern public class Fuellen extends JavaKaraProgram { void fuelle() { if (kara.onleaf()) { kara.putleaf(); // vier Nachbarfelder: for (int i = 0; i < 4; i=i+1) { if (kara.treefront()) { fuelle(); public void myprogram() { fuelle(); restlos füllen soll. Sicher wird es Wider-stand von einigen Schülern geben, das Problem ließe sich mindestens genauso gut iterativ lösen, diese kann man dann getrost machen lassen, eine iterative Lösung, die alle Eventualitäten berücksichtigt, werden die Schüler in angemessener Zeit auch nicht annähernd hinbekommen. Der rekursive Ansatz hat hier große Vorteile und ist relativ einfach zu erkären: Strategie: Wenn Kara auf einem Kleeblatt steht, drehe Kara um und gehe zurück. Im anderen Fall lege Kara auf seine Position ein Kleeblatt und fülle (rekursiv) die vier Nachbarfelder, wenn auf diesen kein Baum steht. Der schwierigste Teil ist nicht die Rekursion, sondern in der Implementierung Karas Stellung zu verfolgen und Kara richtig zu drehen und zu bewegen. Weitere Aufgaben zur Rekursion Die Türme von Hanoi Der Klassiker der rekursiven Problemstellungen: Auf einem von drei Plätzen steht ein Turm aus aufeinander geschichteten, nach oben kleiner werdenden Scheiben. Aufgabe ist es, den Turm auf einen der anderen Plätze zu bewegen unter folgenden Bedingungen: 1. Es darf nur jeweils die oberste Scheibe eines Stapels bewegt werden. 2. Eine Scheibe darf nur auf einen leeren Platz oder auf eine größere Scheibe gelegt werden. Die rekursive Lösung der Aufgabe reduziert ein Problem von n Scheiben darauf, die unterste der

10 Hans Peter Schneider Rekursion mit JavaKara Seite 10 Scheiben zu versetzen, in dem man den darüberliegenden Turm von (n 1) Scheiben auf dem dritten Platz zwischenlagert. Man gelangt zu folgendem Algorithmus: versetze Turm aus n Scheiben von Platz p nach Platz q{ wenn (n > 1) { r sei der dritte Platz neben p und q; versetze Turm aus n 1 Scheiben von Platz p nach Platz r; bewege oberste Scheibe von Platz p nach Platz q; versetze Turm aus n 1 Scheiben von Platz r nach Platz q; } sonst { bewege oberste Scheibe von Platz p nach Platz q; Hierzu lässt sich auch eine iterative Lösung implementieren, die aber nicht ganz einfach zu entdecken ist (siehe Kasten rechts, wer will, kann sie ja analysieren). int lowestbit(int i) { //Hilfsmethode // ermittelt niedrigstes Bit = 1 der // binären Darstellung von i int n = 0; while (i%2 == 0) { i = i >> 1; n++; return n; // iterativ public int hanoi(int n) { // Bewegt n Scheiben. // Die Plätze haben die Nummern // 0, 1 und 2. int[] platz = new int[n]; // Merkt sich den aktuellen Plätze // der n Scheiben. Initialisierung // mit p für alle Scheiben: for (int i = 0; i < n; i++) { platz[i] = 0; // Iteration über 2^n - 1 Bewegungen: for (int i = 1; i < (1 << n); i++) { // Scheinbennummer berechnen: n = lowestbit(i); // Scheibe bewegen: platz[n] = (platz[n]+1+n%2)%3; zeichnetuerme(platz); // Anzeige ggt mit Euler Den mathematische Satz Der größte gemeinsame Teiler von zwei natürlichen Zahlen ist auch der größte gemeinsame Teiler jeder der beiden Zahlen mit ihrer Differenz. ggt(a, b) = ggt(a, a b ) = ggt(b, a b ) V a, b C IN hat Euler zu dem rekursiven Algorithmus zur Bestimmung des größten gemeinsamen Teilers zweier Zahlen entwickelt. Durch die sukzessive Anwendung der des Satzes als ggt(a, b) = ggt(min(a, b), a b ) kann er die Zahlen a und b so weit verkleinern, bis sie sich bei ihrem ggt treffen, und sei dieser 1. An den Implementierungen rechts sehen wir, dass rekursive und iterative Form sich sowohl vom Aufwand als auch vom Algorithmus her sehr ähneln. Die gegenüberstellende Analyse der Implementierungen rückt Themen wie Speicherbedarf und Schnelligkeit der Methoden in den Fokus der Diskussion, lassen sich doch in beiden Fällen sowohl Ablauf als auch Speicherabbilder an konkreten Beispielen leicht Schritt für Schritt verfolgen. // rekursiv public int ggt(int a, int b) { if (a == b) { return a; } else if (a > b) { return ggt(b, a-b); return ggt(a, b-a); // iterativ public int ggt(int a, int b) { while (a!= b) { if (a > b) { a = a - b; b = b - a; return a;

11 Hans Peter Schneider Rekursion mit JavaKara Seite 11 Quellen [1] Eindgenössische Technische Hochschule Zürich, Bereich Edukation, Fach Informatik Informatik auf educeth - JavaKara: Einführung in Java