Rekursion Klaus Becker (2002)

Rekursive Algorithmen Teil 1 Rekursive Algorithmen

Türme von Hanoi 1883 hatte der französische Mathematiker Edouard Lucas jene kleine Geschichte ersonnen, die fortan als die Geschichte der Türme von Hanoi selbst Geschichte machte: Im Großen Tempel von Benares, unter dem Dom, der die Mitte der Welt markiert, ruht eine Messingplatte, in der drei Diamantnadeln befestigt sind, jede eine Elle hoch und so stark wie der Körper einer Biene. Bei der Erschaffung der Welt hat Gott vierundsechzig Scheiben aus purem Gold auf eine der Nadeln gesteckt, wobei die größte Scheibe auf der Messingplatte ruht, und die übrigen, immer kleiner werdend, eine auf der anderen. Das ist der Turm von Brahma. Tag und Nacht sind die Priester unablässig damit beschäftigt, den festgeschriebenen und unveränderlichen Gesetzen von Brahma folgend, die Scheiben von einer Diamantnadel auf eine andere zu setzen, wobei der oberste Priester nur jeweils eine Scheibe auf einmal umsetzen darf, und zwar so, dass sich nie eine kleinere Scheibe unter einer größeren befindet. Sobald dereinst alle vierundsechzig Scheiben von der Nadel, auf die Gott sie bei der Erschaffung der Welt gesetzt hat, auf eine der anderen Nadeln gebracht sein werden, werden der Turm samt dem Tempel und allen Brahmanen zu Staub zerfallen, und die Welt wird mit einem Donnerschlag untergehen.

Türme von Hanoi A B C Aufgabe: Versuchen Sie, 4 (einfach) bzw. 5 oder 6 (schwieriger) Scheiben von Platz A nach Platz C nach den Regeln der Priester von Benares zu bringen. Benutzen Sie das Simulationsprogramm „Hanoi“. Wenn Sie es geschafft haben, überlegen Sie sich, wie lang es dauert, einen Turm aus 64 Scheiben umzubauen, wenn man 1 Sekunde benötigt, um eine Scheibe zu bewegen.

Problembeschreibung A B C A B C AZ: Bringe n-Stapel von A über B nach C ZZ: A B C

Lösungsidee AZ: A B C ... A B C ... A B C ZZ: A B C

Struktur der Lösungsidee A B C Bringe (n-1)-Stapel von A über C nach B A B C Bringe Scheibe von A nach C A B C Bringe (n-1)-Stapel von B über A nach C A B C

Rekursive Problemreduktion Bringe n-Stapel von A über B nach C Lösung: Bringe (n-1)-Stapel von A über C nach B Bringe Scheibe von A nach C Bringe (n-1)-Stapel von B über A nach C Beachte: Die Lösung reduziert das Problem auf ein strukturgleiches Problem in verkleinerter Form (rekursive Problemreduktion).

Rekursiver Algorithmus Bringe n-Stapel von X über Y nach Z wenn n> 1 dann Bringe (n-1)-Stapel von X über Z nach Y Bringe Scheibe von X nach Z Bringe (n-1)-Stapel von Y über X nach Z sonst Bringe Scheibe von X nach Z Beachte: Der Algorithmus ruft sich selbst auf, er ist infolgedessen rekursiv.

Rekursiver Algorithmus Hanoi(n: integer; X, ,Y, Z: char) wenn n> 1 dann Hanoi(n-1, X,Z,Y) Bringe Scheibe von X nach Z Hanoi(n-1, Y, X, Z) sonst Bringe Scheibe von X nach Z Beachte: Der Algorithmus ruft sich selbst auf, er ist infolgedessen rekursiv.

Abarbeitung rekursiver Algorithmen Hanoi(3, A, B, C) Hanoi(2, A, C, B) Hanoi(1, A, B, C) Bringe Scheibe von A nach C Bringe Scheibe von A nach B Hanoi(1, C, A, B) Bringe Scheibe von C nach B Hanoi(2, B, A, C) Hanoi(1, B, C, A) Bringe Scheibe von B nach A Bringe Scheibe von B nach C ALG. Hanoi(n: integer; X, ,Y, Z: char) WENN n> 1 DANN Hanoi(n-1, X,Z,Y) Bringe Scheibe von X nach Z Hanoi(n-1, Y, X, Z) SONST Wiederholte Ausführung des Algorithmus, bis die Abbruchbedingung erfüllt ist.

Übung ALG. Hanoi(n: integer; X, ,Y, Z: char) WENN n> 1 DANN Hanoi(n-1, X,Z,Y) Bringe Scheibe von X nach Z Hanoi(n-1, Y, X, Z) SONST Sie sollen einen Turm mit 4 Scheiben umschichten. Gehen Sie dabei nach dem entwickelten rekursiven Algorithmus vor. Notieren Sie sich zunächst sämtliche Scheibenbewegungen. Testen Sie sie anschließend mit dem Simulationsprogramm.

Zusammenfassung Entwurf: Ausführung: Muss vom Entwickler geleistet werden. Wird vom System übernommen. ALG. Hanoi(n: integer; X, ,Y, Z: char) WENN n> 1 DANN Hanoi(n-1, X,Z,Y) Bringe Scheibe von X nach Z Hanoi(n-1, Y, X, Z) SONST Hanoi(3, A, B, C) Hanoi(2, A, C, B) Hanoi(1, A, B, C) Bringe Scheibe von A nach C Bringe Scheibe von A nach B Hanoi(1, C, A, B) Bringe Scheibe von C nach B Hanoi(2, B, A, C) Hanoi(1, B, C, A) Bringe Scheibe von B nach A Bringe Scheibe von B nach C Entwurfsstrategie: Reduziere das Problem auf ein strukturgleiches Problem in „verkleinerter Form“, sofern das Problem nicht direkt lösbar ist.

Quicksort Eine Reihung von Zahlen / ... soll der Größe nach sortiert werden. AZ: Zahlen: 27 13 80 82 6 44 26 15 16 39 90 53 anfang ende Quicksort(anfang, ende) ZZ: Zahlen: 6 13 15 16 26 27 39 44 53 80 82 90 anfang ende

Quicksort ALGORITHMUS Quicksort(anfang, ende: tIndex) links := anfang; rechts := ende; Zahlen: 27 13 80 82 6 44 26 15 16 39 90 53 anfang ende links rechts zerlege(links, rechts) p Zahlen: 27 13 39 16 6 15 26 44 82 80 90 53 anfang rechts links ende WENN anfang < rechts Quicksort(anfang, rechts) Zahlen: 6 13 15 16 26 27 39 44 82 80 90 53 anfang rechts links ende WENN links < ende Quicksort(links, ende) Zahlen: 6 13 15 16 26 27 39 44 53 80 82 90 anfang rechts links ende

Rekursive Reduktions-schritte Quicksort Entwurfsstrategie: Reduziere das Problem auf ein strukturgleiches Problem in „verkleinerter Form“, sofern das Problem nicht direkt lösbar ist. ALGORITHMUS Quicksort(anfang, ende: tIndex) links := anfang; rechts := ende; Vorbereitung zerlege(links, rechts); WENN anfang < rechts Quicksort(anfang, rechts); Rekursive Reduktions-schritte WENN links < ende Quicksort(links, ende); Abbruch-bedingung Bemerkung: Kurzer Algorithmus, der einen komplexen Ablauf festlegt.

Teil 2 Turtle-Grafik

Turtle-Grafik Die Turtle lebt auf einer Zeichenfläche. Die Turtle kann sich bewegen, drehen und – zum Zeichnen – eine Spur hinterlassen. Zeichen-fläche Turtlespur Turtle

Turtle-Grafik Die Turtle agiert auf Befehle / führt Anweisungen aus. Draw(100)

Turtle-Grafik Die Turtle kann „neue Befehle“ lernen. Diese werden in Turtle-Programmen festgelegt. Quadrat procedure Quadrat; begin with Turtle do begin Draw(100); Turn(90); Draw(100); Turn(90); Draw(100); Turn(90); Draw(100); Turn(90); end; end;

Die Turtle als Objekt Die Turtle wird als ein Objekt der Klasse TTurtle erzeugt. Sie besitzt infolgedessen charakteristische Eigenschaften ( Attribute) und kann charakteristische Operationen ausführen ( Methoden). (0|0) (688|0) TTurtle Attribute XPos : double // x-Position YPos : double // y-Position Angle : double // Richtung Color : TColor // Zeichenfarbe ... Ereignisse Methoden Turtle (0|452) (688|452)

Die Turtle als Objekt TTurtle ... Attribute ... Ereignisse Methoden Init // Die Turtle wird in die Mitte der Zeichenfläche mit Blickrichtung nach rechts gesetzt. Draw(d: double) // Die Turtle zeichnet in der aktuell. Blickrichtung eine Strecke der Länge d. DrawTo(x,y: double) // Die Turtle zeichnet eine Strecke zum Punkt (x|y). Turn(a: double) // Die Turtle dreht sich um den Winkel a (a > 0: Linksdr.; a < 0: Rechtsdr.). TurnTo(a: double) // Die Turtle setzt ihre Blickricht. nach a (a = 0: rechts; a = 90: oben; ...). Move(d: double) // Die Turtle bewegt sich – ohne zu zeichnen – um d in Blickrichtung. MoveTo(x,y: double) // Die Turtle bewegt sich – ohne zu zeichnen – zum Punkt (x|y). Clear // Die Zeichenfläche der Turtle wird gelöscht.

Zeichnen mit der Turtle AZ: procedure Quadrat(x: real); var i: integer; begin for i := 1 to 4 do begin Turtle.Draw(x); Turtle.Turn(90); end; end; Al: Quadrat(200); ZZ:

Zeichnen mit der Turtle AZ: procedure Quadrat(x: real); var i: integer; begin with Turtle do begin for i := 1 to 4 do begin Draw(x); Turn(90); end; end; end; Al: Quadrat(200); ZZ: Quadrat

Übungen Entwickeln Sie ein Turtle-Programm, mit dem man einen (primitiven) Tannenbaum zeichnen kann. Gehen Sie wie folgt vor: Überlegen Sie sich zunächst, aus welchen Bestandteilen der Tannenbaum besteht. Formulieren Sie anschließend die Algorithmen für die Bestandteile. Implementieren und testen Sie die Algorithmen abschließend mit Hilfe der Turtle-Komponente.

Übungen Entwickeln Sie ein Turtle-Programm, mit dem man einen Quadratturm (beliebiger) Höhe zeichnen kann. Formulieren Sie zunächst die benutzten Algorithmen. Implementieren und testen Sie die Algorithmen abschließend mit Hilfe der Turtle-Komponente.

Selbstähnliche Figuren Teil 3 Selbstähnliche Figuren

Selbstähnlichkeit

Selbstähnlichkeit Eine Figur ist selbstähnlich, wenn sie sich in Teile zerlegen lässt, die zur ihr ähnlich sind.

Rekursive Problemreduktion Baum(200) Rekursive Problemreduktion: Baum(200) Turtle.Draw(200); Turtle.Turn(45); Baum(100); Turtle.Turn(-90); Turtle.Move(-200); Baum(100) Baum(100) Trivialer Fall: Draw(200) Baum(x) // falls x < 2 // keine Operationen

Rekursiver Algorithmus Algorithmus Baum(Stamm: real) WENN Stamm >= 2 DANN Turtle.Draw(Stamm); Turtle.Turn(45); Baum(Stamm/2); Turtle.Turn(-90); TurtleTurn(45); Turtle.Move(-Stamm);

Übungen Suchen Sie sich auf den folgenden Seiten eine selbstähnliche Figur aus und entwickeln Sie für diese ein Turtle-Zeichenprogramm. Gehen Sie wie folgt vor: Machen Sie sich (exemplarisch) einen rekursiven Problemreduktionsschritt klar. Überlegen Sie sich, was im trivialen Fall erfolgen soll (nichts / ...). Formulieren Sie einen rekursiven Algorithmus und implementieren ihn mit Hilfe der Turtle-Komponente.

Schachtelhalm

Busch

Teufelsgabel

Treppe ins Nirgendwo

Quadratpflanze

Sierpinski-Dreieck

Pythagoras-Baum

Farn

Koch-Kurve

Variationen der Koch-Kurve