Rekursion: Unterschied zwischen den Versionen

Aus EINI
Wechseln zu: Navigation, Suche
 
(12 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
−
Ein '''rekursiver''' Algorithmus oder Programm ist ein Alorithmus/Programm, welches sich selber immer wieder aufruft. Jede Rekursion kann theoretisch durch eine Schleife ersetzt werden und umgekehrt, jedoch ist dies nicht immer ratsam. Schleifen und Rekursionen sind also semmantisch äquivalent. Rekursion kommt vom lateinischen Wort ''recurrere'', was ''zurücklaufen'' bedeutet.  
+
Als '''rekursiv''' wird ein [[Programm]] oder [[Algorithmus]] bezeichnet, das/der sich selbst direkt oder indirekt aufruft.
 +
Eine '''Rekursive Funktion''' ist demnach eine Funktion, die sich selbst aufruft.
  
−
===Erstes Beispiel für eine Rekursion===
+
Rekursionen und [[Schleifen]] sind semantisch äquivalent und können daher durch durch das jeweils andere ersetzt werden. Dies ist jedoch nicht immer sinnvoll.
  
−
<source lang= "java"> public int Beispiel1(int n)
+
'''Rekursion''' kommt vom lateinischen Wort ''recurrere'', was '''zurücklaufen''' bedeutet.
−
  {
+
−
  if(n == 0)
+
−
  {
+
−
        return 1;
+
−
  }
+
−
  else
+
−
    {
+
−
        return n*Beispiel1(n-1);
+
−
    }
+
−
  }
+
−
</source>
+
  
−
Dieses Beispiel berechnet n Fakultät. Dieses Programm wird nun beispielhaft mit dem Wert n = 3  aufgerufen:
+
=Erstes Beispiel<ref> Alle Rekursionsbeispiele werden hier zum besseren Verständnis im sogenannten [[Pseudocode]] notiert.</ref>: Fakultät=
  
−
'''n = 3'''
+
==Definition==
−
Z. 3 ist ''false'', else-Zweig wird ausgeführt
+
−
Z. 9 wird ausgeführt: ''3''  *Beispiel(''3''-1)
+
  
−
Das Programm führt nun die Methode für n = 2 aus
+
'''Fakultät von ''n'' '''
−
'''n = 2'''
+
−
Z. 3 ist ''false'', else-Zweig wird ausgeführt
+
−
Z. 9 wird ausgeführt: ''2'' * Beispiel(''2''-1)
+
  
−
Das Programm führt nun die Methode für n = 1 aus
+
Die Fakultät einer Zahl ist das Produkt aller natürlichen Zahlen (außer 0), die kleiner oder gleich dieser Zahl sind. Fakultät wird mit einem Ausrufezeichen hinter der Zahl notiert. Die Fakultät von 0 ist 1 (0! = 1).
−
'''n = 1'''
+
−
Z. 3 ist nun ''true''
+
−
Z. 6 Die Methode Beispiel(1) gibt nun 1 an Beispiel(2) zurück
+
  
−
Beispiel1(2) erhält nun das Ergbnis der Methode Beispiel1(1) und gibt ''2*1'' an die Methode Beispiel1(3) zurück
+
Eingabe: Eine natürliche Zahl n
 +
Ausgabe: Die Fakultät von n
 +
Vorgehensweise:
 +
    Wenn ''n'' gleich ''0'',
 +
    dann gib ''1'' zurück,
 +
    ansonsten gib das Produkt von ''n'' und dem Algorithmus mit der Eingabe ''n''-1 zurück.
  
−
Beispiel1(3) erhält nun das Ergbnis der Methode Beispiel1(2) und gibt ''3*2*1'' zurück, was ''6'' ist.
+
 
 +
==Ausführung mit ''n'' = 3==
 +
 
 +
'''Aufbau der Rekursion ("Hinweg")'''
 +
 +
''Ebene:'' n = 3
 +
''Ausführung:'' n ist ungleich 0, berechne daher das Produkt von 3 und (3-1)!
 +
''Aufruf:'' Fakultät(2)
 +
 +
  ''Ebene:'' n = 2
 +
  ''Ausführung:'' n ist ungleich 0, berechne daher das Produkt von 2 und (2-1)!
 +
  ''Aufruf:'' Fakultät(1)
 +
 +
    ''Ebene:'' n = 1
 +
    ''Ausführung:'' n ist ungleich 0, berechne daher das Produkt von 1 und (1-1)!
 +
    ''Aufruf:'' Fakultät(0)
 +
 +
      ''Ebene:'' n = 0
 +
      ''Ausführung:'' n ist nun gleich 0, gib also 1 zurück
 +
   
 +
'''Abbau der Rekursion ("Rückweg")'''
 +
   
 +
      ''Rückgabe:'' Fakultät(0) = 1
 +
   
 +
    ''Ebene:'' n = 1
 +
    ''Rückgabe:'' 1 * 1 = 1
 +
 
 +
  ''Ebene:'' n = 2
 +
  ''Rückgabe:'' 2 * 1 = 2
 +
 +
''Ebene:'' n = 3
 +
''Rückgabe:'' 3 * 2 = 6
 +
 
 +
 
 +
 
 +
Mathematisch notiert sieht das ganze folgendermaßen aus:
 +
 
 +
3! = 3 * 2! = 3 * 2 * 1! = 3 * 2 * 1 * 0! = 3 * 2 * 1 * 1 = 3 * 2 * 1 = 3 * 2 = 6
 +
 
 +
 
 +
=Aufbau=
 +
 
 +
Jede Rekursion besteht aus einer Abbruch-/Terminierungsbedingung und einem Rekursionsrumpf.
 +
 
 +
Der Rekursionsabbruch erfolgt, wenn die '''Terminierungsbedingung''' erfüllt ist. Diese Bedingung überprüft, ob die unterste Ebene des [[Baum|Rekursionsbaums]] erreicht wurde. Im obigen Beispiel ist dies die Überprüfung, ob n gleich 0 ist, da 0! gleich 1 ist. Sollte diese Bedingung nicht erfüllt werden, wird der Rekursionsrumpf ausgeführt. Wichtig für eine funktionierende Rekursion ist, dass die Bedingung irgendwann erreicht wird, da ansonsten die Rekursion nicht terminiert ('''Endlosrekursion''').
 +
 
 +
Im '''Rekursionsrumpf''' geschieht der Aufruf der Funktion für eine niedrigere Ebene und die Berechnung des Ergebnisses der aktuellen Ebene mit diesem. In dem Beispiel ist dies der Ansonsten-Pfad.
 +
 
 +
 
 +
=Zweites Beispiel: Ungerade/Gerade=
 +
 
 +
==Vorgehensweise==
 +
 
 +
'''Ist die Zahl ''n'' gerade?'''
 +
 
 +
'''1. Funktion'''
 +
''Eingabe:'' Eine natürliche Zahl n
 +
''Ausgabe:'' ''Ja'', wenn ''n'' gerade ist, ''Nein'', wenn ''n'' ungerade ist.
 +
''Vorgehensweise:''
 +
      Wenn ''n'' gleich ''0'' ist, dann gebe ''Ja'' zurück,
 +
      ansonsten gebe das Ergebnis der ''2. Funktion'' für ''n-1'' zurück.
 +
 +
'''2. Funktion'''
 +
''Eingabe:'' Eine natürliche Zahl n
 +
''Ausgabe:'' ''Ja'', wenn ''n'' ungerade ist, ''Nein'', wenn ''n'' gerade ist.
 +
''Vorgehensweise:''
 +
      Wenn ''n'' gleich ''0'' ist, dann gebe ''Nein'' zurück,
 +
      ansonsten gebe das Ergebnis der ''1. Funktion'' mit ''n-1'' zurück.
 +
 
 +
==Ausführung mit ''n'' = 5==
 +
 
 +
'''Aufbau der Rekursion ("Hinweg")'''
 +
 +
'''1. Funktion''' wird mit ''n'' = 5 aufgerufen
 +
''n'' ist ungleich ''0'', daher führe ''2. Funktion'' mit ''n'' = 5-1 = 4 aus
 +
 
 +
  '''2. Funktion''' mit ''n'' = 4
 +
  ''n'' ist ungleich ''0'', daher führe ''1. Funktion'' mit ''n'' = 4-1 = 3 aus
 +
 +
    '''1. Funktion''' mit ''n'' = 3
 +
    ''n'' ist ungleich ''0'', daher führe ''2. Funktion'' mit ''n'' = 3-1 = 2 aus
 +
 +
      '''2. Funktion''' mit ''n'' = 2
 +
      ''n'' ist ungleich ''0'', daher führe ''1. Funktion'' mit ''n'' = 2-1 = 1 aus
 +
       
 +
        '''1. Funktion''' mit ''n'' = 1
 +
        ''n'' ist ungleich ''0'', daher führe ''2. Funktion'' mit ''n'' = 1-1 = 0 aus
 +
       
 +
          '''2. Funktion''' mit ''n'' = 0
 +
          ''n'' ist gleich ''0'', daher
 +
          ''Rückgabe:'' ''Nein''
 +
 +
'''Abbau der Rekursion ("Rückweg")'''
 +
 +
          '''1. Funktion''' mit ''n'' = 1
 +
          ''Rückgabe: ''Nein''
 +
 +
        '''2. Funktion''' mit ''n'' = 2
 +
        ''Rückgabe:'' ''Nein''
 +
 
 +
      '''1. Funktion''' mit ''n'' = 3
 +
      ''Rückgabe:'' ''Nein''
 +
 +
    '''2. Funktion''' mit ''n'' = 4
 +
    ''Rückgabe:'' ''Nein''
 +
 +
'''1. Funktion''' mit ''n'' = 5
 +
''Rückgabe:'' ''Nein''
 +
 
 +
=> ''5'' ist ungerade
 +
 
 +
=Direkte und indirekte Rekursion=
 +
 
 +
Bei der '''direkten Rekursion''' ruft sich die Funktion bei der Rückgabe selbst wieder auf. Dies trifft auf das erste Beispiel zu.
 +
 
 +
Bei der '''indirekten Rekursion''' ruft Funktion ''f'' eine andere Funktion ''g'' auf, die wiederum ''f'' aufruft. Dies geschieht im zweiten Beispiel.
 +
 
 +
=Verwendung=
 +
 
 +
=Fußnote=

Aktuelle Version vom 18. Januar 2017, 15:42 Uhr

Als rekursiv wird ein Programm oder Algorithmus bezeichnet, das/der sich selbst direkt oder indirekt aufruft. Eine Rekursive Funktion ist demnach eine Funktion, die sich selbst aufruft.

Rekursionen und Schleifen sind semantisch äquivalent und können daher durch durch das jeweils andere ersetzt werden. Dies ist jedoch nicht immer sinnvoll.

Rekursion kommt vom lateinischen Wort recurrere, was zurücklaufen bedeutet.

Erstes Beispiel[1]: Fakultät

Definition

Fakultät von n

Die Fakultät einer Zahl ist das Produkt aller natürlichen Zahlen (außer 0), die kleiner oder gleich dieser Zahl sind. Fakultät wird mit einem Ausrufezeichen hinter der Zahl notiert. Die Fakultät von 0 ist 1 (0! = 1). 

Eingabe: Eine natürliche Zahl n
Ausgabe: Die Fakultät von n
Vorgehensweise:
   Wenn n gleich 0,
   dann gib 1 zurück,
   ansonsten gib das Produkt von n und dem Algorithmus mit der Eingabe n-1 zurück.


Ausführung mit n = 3

Aufbau der Rekursion ("Hinweg")

Ebene: n = 3
Ausführung: n ist ungleich 0, berechne daher das Produkt von 3 und (3-1)!
Aufruf: Fakultät(2)

  Ebene: n = 2
  Ausführung: n ist ungleich 0, berechne daher das Produkt von 2 und (2-1)!
  Aufruf: Fakultät(1)

    Ebene: n = 1
    Ausführung: n ist ungleich 0, berechne daher das Produkt von 1 und (1-1)!
    Aufruf: Fakultät(0)

      Ebene: n = 0
      Ausführung: n ist nun gleich 0, gib also 1 zurück
    
Abbau der Rekursion ("Rückweg")
    
      Rückgabe: Fakultät(0) = 1
    
    Ebene: n = 1
    Rückgabe: 1 * 1 = 1
  
  Ebene: n = 2
  Rückgabe: 2 * 1 = 2

Ebene: n = 3
Rückgabe: 3 * 2 = 6


Mathematisch notiert sieht das ganze folgendermaßen aus:

3! = 3 * 2! = 3 * 2 * 1! = 3 * 2 * 1 * 0! = 3 * 2 * 1 * 1 = 3 * 2 * 1 = 3 * 2 = 6


Aufbau

Jede Rekursion besteht aus einer Abbruch-/Terminierungsbedingung und einem Rekursionsrumpf.

Der Rekursionsabbruch erfolgt, wenn die Terminierungsbedingung erfüllt ist. Diese Bedingung überprüft, ob die unterste Ebene des Rekursionsbaums erreicht wurde. Im obigen Beispiel ist dies die Überprüfung, ob n gleich 0 ist, da 0! gleich 1 ist. Sollte diese Bedingung nicht erfüllt werden, wird der Rekursionsrumpf ausgeführt. Wichtig für eine funktionierende Rekursion ist, dass die Bedingung irgendwann erreicht wird, da ansonsten die Rekursion nicht terminiert (Endlosrekursion).

Im Rekursionsrumpf geschieht der Aufruf der Funktion für eine niedrigere Ebene und die Berechnung des Ergebnisses der aktuellen Ebene mit diesem. In dem Beispiel ist dies der Ansonsten-Pfad.


Zweites Beispiel: Ungerade/Gerade

Vorgehensweise

Ist die Zahl n gerade? 

1. Funktion
Eingabe: Eine natürliche Zahl n
Ausgabe: Ja, wenn n gerade ist, Nein, wenn n ungerade ist.
Vorgehensweise:
     Wenn n gleich 0 ist, dann gebe Ja zurück,
     ansonsten gebe das Ergebnis der 2. Funktion für n-1 zurück.

2. Funktion
Eingabe: Eine natürliche Zahl n
Ausgabe: Ja, wenn n ungerade ist, Nein, wenn n gerade ist. 
Vorgehensweise:
     Wenn n gleich 0 ist, dann gebe Nein zurück,
     ansonsten gebe das Ergebnis der 1. Funktion mit n-1 zurück.

Ausführung mit n = 5

Aufbau der Rekursion ("Hinweg")

1. Funktion wird mit n = 5 aufgerufen
n ist ungleich 0, daher führe 2. Funktion mit n = 5-1 = 4 aus
  
  2. Funktion mit n = 4
  n ist ungleich 0, daher führe 1. Funktion mit n = 4-1 = 3 aus

    1. Funktion mit n = 3
    n ist ungleich 0, daher führe 2. Funktion mit n = 3-1 = 2 aus

      2. Funktion mit n = 2
      n ist ungleich 0, daher führe 1. Funktion mit n = 2-1 = 1 aus
        
        1. Funktion mit n = 1
        n ist ungleich 0, daher führe 2. Funktion mit n = 1-1 = 0 aus
       
          2. Funktion mit n = 0
          n ist gleich 0, daher
          Rückgabe: Nein

Abbau der Rekursion ("Rückweg")

          1. Funktion mit n = 1
          Rückgabe: Nein

        2. Funktion mit n = 2
        Rückgabe: Nein
  
      1. Funktion mit n = 3
      Rückgabe: Nein

   2. Funktion mit n = 4
   Rückgabe: Nein

1. Funktion mit n = 5
Rückgabe: Nein

=> 5 ist ungerade

Direkte und indirekte Rekursion

Bei der direkten Rekursion ruft sich die Funktion bei der Rückgabe selbst wieder auf. Dies trifft auf das erste Beispiel zu.

Bei der indirekten Rekursion ruft Funktion f eine andere Funktion g auf, die wiederum f aufruft. Dies geschieht im zweiten Beispiel.

Verwendung

Fußnote

  1. ↑ Alle Rekursionsbeispiele werden hier zum besseren Verständnis im sogenannten Pseudocode notiert.
Von „https://ls14-eini.cs.tu-dortmund.de/index.php?title=Rekursion&oldid=1942“