Transcript Rekursion - Informatik

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
B
C
Bringe n-Stapel von A über B nach C
ZZ:
A
KB
Lösungsidee
6
Rekursion
AZ:
A
B
C
A
B
C
A
B
C
A
B
C
...
...
ZZ:
KB
Struktur der Lösungsidee
Rekursion
7
KB
A
B
C
A
B
C
A
B
C
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
Wiederholte Ausführung des Algorithmus, bis die Abbruchbedingung erfüllt ist.
KB
Ü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)
Bringe Scheibe von A nach C
KB
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: tIndex)
links := anfang; rechts := ende;
Zahlen:
27
13
80
82
6
44
26
15
16
39
90
Rekursion
anfang
links
ende
rechts
p
zerlege(links, rechts)
Zahlen:
53
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: tIndex)
links := anfang; rechts := ende;
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
Vorbereitung
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);
Draw(100); Turn(90);
Draw(100); Turn(90);
Draw(100); Turn(90);
end;
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).
(688|0)
Rekursion
(0|0)
TTurtle
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.
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.
...
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;
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;
end;
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
Rekursive Problemreduktion:
Baum(200)
Baum(200)
Turtle.Draw(200);
Turtle.Turn(45);
Rekursion
Baum(100);
Turtle.Turn(-90);
Baum(100);
Turtle.Turn(45);
Baum(100)
Baum(100)
Draw(200)
Turtle.Move(-200);
Trivialer Fall:
Baum(x) // falls x < 2
// keine Operationen
KB
31
Rekursiver Algorithmus
Algorithmus Baum(Stamm: real)
Rekursion
WENN Stamm >= 2 DANN
Turtle.Draw(Stamm);
Turtle.Turn(45);
Baum(Stamm/2);
Turtle.Turn(-90);
Baum(Stamm/2);
TurtleTurn(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.
Rekursion
33
KB
Schachtelhalm
Rekursion
34
KB
Busch
Rekursion
35
KB
Teufelsgabel
Rekursion
36
KB
Treppe ins Nirgendwo
Rekursion
37
KB
Quadratpflanze
Rekursion
38
KB
Sierpinski-Dreieck
Rekursion
39
KB
Pythagoras-Baum
Rekursion
40
KB
Farn
Rekursion
41
KB
Koch-Kurve
Rekursion
42
KB
Variationen der Koch-Kurve