Rekursion Klaus Becker 2002 Rekursion 2 KB Teil

Rekursion Klaus Becker (2002)

Rekursion 2 KB Teil 1 Rekursive Algorithmen

Rekursion 3 KB 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 Rekursion 4 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“. KB 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 5 AZ: Rekursion A B C Bringe n-Stapel von A über B nach C ZZ: A KB

Lösungsidee 6 Rekursion AZ: A B C . . . ZZ: KB

Struktur der Lösungsidee Rekursion 7 KB A B C 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

Rekursive Problemreduktion 8 Problem: 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 Rekursion Bringe (n-1)-Stapel von B über A nach C KB Beachte: Die Lösung reduziert das Problem auf ein strukturgleiches Problem in verkleinerter Form (rekursive Problemreduktion).

Rekursiver Algorithmus 9 Algorithmus Bringe n-Stapel von X über Y nach Z wenn n> 1 dann Bringe (n-1)-Stapel von X über Z nach Y Rekursion 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. KB

Rekursiver Algorithmus 10 Algorithmus Hanoi(n: integer; X, , Y, Z: char) wenn n> 1 dann Hanoi(n-1, X, Z, Y) Rekursion 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. KB

Abarbeitung rekursiver Algorithmen 11 Hanoi(3, A, B, C) Hanoi(2, A, C, B) Hanoi(1, A, B, C) ALG. Hanoi(n: integer; X, , Y, Z: char) Rekursion 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 Bringe Scheibe von A nach C Bringe Scheibe von A nach B Hanoi(1, C, A, B) Bringe Scheibe von C nach B Bringe Scheibe von A nach C Hanoi(2, B, A, C) Hanoi(1, B, C, A) Bringe Scheibe von B nach A Bringe Scheibe von B nach C Hanoi(1, A, B, C) Bringe Scheibe von A nach C KB Wiederholte Ausführung des Algorithmus, bis die Abbruchbedingung erfüllt ist.

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

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

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

Quicksort 16 Entwurfsstrategie: Reduziere das Problem auf ein strukturgleiches Problem in „verkleinerter Form“, sofern das Problem nicht direkt lösbar ist. Rekursion ALGORITHMUS Quicksort(anfang, ende: t. Index) links : = anfang; rechts : = ende; Vorbereitung zerlege(links, rechts); WENN anfang < rechts Quicksort(anfang, rechts); WENN links < ende Quicksort(links, ende); Abbruchbedingung Bemerkung: Kurzer Algorithmus, der einen komplexen Ablauf festlegt. KB Rekursive Reduktionsschritte

Rekursion 17 KB Teil 2 Turtle-Grafik

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

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

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

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

Die Turtle als Objekt 22 TTurtle Attribute . . . Ereignisse Rekursion . . . 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. Draw. To(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. ). Turn. To(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. Move. To(x, y: double) // Die Turtle bewegt sich – ohne zu zeichnen – zum Punkt (x|y). Clear // Die Zeichenfläche der Turtle wird gelöscht. . KB

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

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

Übungen 25 Entwickeln Sie ein Turtle-Programm, mit dem man einen (primitiven) Tannenbaum zeichnen kann. Rekursion Gehen Sie wie folgt vor: KB Ü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 26 Entwickeln Sie ein Turtle-Programm, mit dem man einen Quadratturm (beliebiger) Höhe zeichnen kann. Rekursion Formulieren Sie zunächst die benutzten Algorithmen. KB Implementieren und testen Sie die Algorithmen abschließend mit Hilfe der Turtle-Komponente.

Rekursion 27 KB Teil 3 Selbstähnliche Figuren

Rekursion 28 KB Selbstähnlichkeit

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

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

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

Übungen 32 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: Rekursion Machen Sie sich (exemplarisch) einen rekursiven Problemreduktionsschritt klar. KB Überlegen Sie sich, was im trivialen Fall erfolgen soll (nichts /. . . ). Formulieren Sie einen rekursiven Algorithmus und implementieren ihn mit Hilfe der Turtle-Komponente.