TigerJython4Kids
HomeTurtlegrafikRobotikDatenbanken
rekursionen

17. REKURSIONEN

 

 

DU LERNST HIER...

 

dass Rekursion ein Lösungsverfahren ist, bei dem ein Problem auf das gleichartige, aber etwas vereinfachte Problem zurückgeführt wird. Eine Funktion ist dann rekursiv, wenn sie sich selbst aufruft. Damit sich eine rekursive Funktion nicht endlos aufruft, braucht sie eine Abbruchbedingung. Betrachte dieses Kapitel als Zusatzstoff und freue dich an schönen Bildern, die mit Rekursionen entstehen.

 

 

MUSTERBEISPIELE

 

Das Prinzip einer Rekursion kann anschaulich am Beispiel des Zeichnens einer Treppe erklärt werden: Eine Treppe mit 6 Stufen wird aus einer Stufe und einer Treppe mit 5 Stufen zusammengesetzt, ein Treppe mit 5 Stufen wird auf eine Stufe und einer Treppe mit 4 Stufen zurückgeführt (usw.). In der Funktion staircase(n) wird also jeweils dieselbe Funktion staircase(n - 1) aufgerufen. Wenn die Abbruchbedingung n = 0 erfüllt ist, bricht das Programm mit return ab.

   

from gturtle import *

def step():
    forward(20)
    right(90)
    forward(20)
    left(90)

def staircase(n):
    if n == 0:
        return
    step()
    staircase(n-1)  

makeTurtle() 
staircase(6)
► In Zwischenablage kopieren


 
Das Zeichnen eines binären Baums lässt sich auf eine einfache Grundfigur zurückführen.

Anschaulich gesagt ist ein binärer Baum mit der Stammlänge s ein Stamm und ein Links- sowie ein Rechtsbaum mit der Stammlänge s /2. Für die Stammlänge < 8 bricht die Rekursion ab.

   

from gturtle import *

def tree(s):
    if s < 8:
        return
    forward(s)
    left(45)
    tree(s/2)
    right(90)
    tree(s/2)
    left(45)
    back(s)

makeTurtle()
setY(-100)
tree(128)
► In Zwischenablage kopieren

Bemerkung: das back(s) ist wichtig, da nach dem Zeichnen des (Teil-)Baums die Turtle wieder im Anfangszustand sein muss.

 

 

MERKE DIR...
 

Die Rekursion ist ein wichtiges Lösungsverfahren, bei dem man ein Problem auf dasselbe, etwas vereinfachte Problem zurückführt und dieses in einem besonders einfachen Fall löst (bei Rekursionsabbruch). Rekursive Lösungsverfahren sind elegant, aber meist schwierig zu durchblicken.

 

 

ZUM SELBST LÖSEN


  1.

Überlege, wie du das Programm, das den binären Baum zeichnet (Beispiel 2) ändern musst, damit der nebenstehende Baum entsteht.

  

  2.

Ergänze den Programmcode so, dass eine Flocke gezeichnet wird. Gehe von folgendem Gerüst aus.

def figure(s):
    
    for i in range(6):
        forward(s)
        figure(s/3)
        back(s)
        right(60)
 

   


 

WEITERE BEKANNTE REKURSIONEN

 

Sirpinsky Fractal: 

from gturtle import *

def triangle(s):
   repeat 3:
      forward(s)
      left(120)   

def sierpi(n, s):
   if n == 0: 
      triangle(s)  
      return
   sierpi(n - 1, s / 2)
   forward(s / 2)
   sierpi(n - 1, s / 2)
   left(120)
   forward(s / 2)
   right(120)
   sierpi(n - 1, s / 2)
   left(60)
   back(s / 2)
   right(60)
    
makeTurtle()
n = 6
s = 400
speed(-1)
setPos( -200, -190)
right(90)
sierpi(n, s)
► In Zwischenablage kopieren

Flower Fractal:

from gturtle import *

def figur(size, angle, turn):
    if size < 10:
        return
    while True:  
        flower(size, angle)
        turn = turn + angle
        if turn % 360 == 0:
            break       
def flower(size, angle):
    forward(size)
    dot(15)
    figur(size/2, -angle, 0)
    right(angle)    

makeTurtle()
setPos(-80, -80)
setPenColor("blue")
figur(64, 60, 0)
► In Zwischenablage kopieren

Peano Fractal:

# Peano.py

from gturtle import *

makeTurtle()
setPos(100, -100)
speed(-1)
#ht()

def peano(n, s, w):
    if  n == 0:
        return
    lt(w)
    peano(n - 1, s, -w)
    fd(s)
    rt(w)
    peano(n - 1, s, w)
    fd(s)
    peano(n - 1, s, w)
    rt(w)
    fd(s)
    peano(n - 1, s, -w)
    lt(w)
  
peano(5, 10, 90)
► In Zwischenablage kopieren