Iteration versus Rekursion

Rekursion in der Informatik:

Rekursive Definition: Einen Funktion f ist rekursiv wenn sie sich selbst aufruft.

Die Funktion heißt indirekt-rekursiv wenn sie sich selbst aufruft über den Umweg einer anderen Funktion (oder mehrerer anderer Funktionen).

Beispiel einer indirekten Rekursion:

   foo  --->  bar  --->  foo
      ruft auf    ruft auf

Entscheidende Eigenschaften der Rekursion

Jeder Aufruf einer rekursiven Funktion f hat sein eigenes Set von lokalen Variablen, d.h. der rekursive Aufruf hat die gleichen Anweisungen auszuführen, aber er hat seine eigenen Daten. Betrachten wir z.B. die rekursive Funktion

     def f(n):
         r = f(n-1)
         ... # weiterer Code
         return r

Für ein gegebenes n erhalten wir die Aufrufkette:

     f(n)             1.Ebene
        f(n-1)        2.Ebene
             f(n-2)   3.Ebene
                      ...

Die Funktionsaufrufe der verschiedenen Ebenen werden so ausgeführt, als ob wir für jede Ebene eine eigene Funktion f₁(n₁), f₂(n₂), f₃(n₃) usw. definiert hätten:

     f₁(n₁)            1.Ebene ---> n₁ = n
         f₂(n₂)        2.Ebene ---> n₂ = n₁-1
             f₃(n₃)    3.Ebene ---> n₃ = n₂-1 = n₁-2 = n-2
                       ...

Die Funktionen f₁(n₁), f₂(n₂), f₃(n₃) enthalten alle den gleichen Code, aber mit unterschiedlich benannten Variablen n₁, n₂, n₃. Durch diese Umbenennungen sollte die obige Aussage deutlich werden.

Jede rekursive Funktion muß mindestens einen nicht-rekursiven Zweig haben. Dieser Zweig wird als Basisfall oder Rekursionsabschluss bezeichnet.

Jeder rekursive Aufruf muß über endlich viele Stufen auf einen Basisfall zurückgeführt werden, denn sonst erhält man eine Endlosrekursion (und das ist fast so übel wie eine Endlosschleife -- "fast" deshalb, weil die Endlosrekursion spätestens dann abbricht wenn der Speicher voll ist --> siehe Übung 7 Aufgabe 1).

Die Anzahl der rekursiven Aufrufe bis zum Rekursionsabschluss bezeichnet man als Rekursionstiefe d.

Arten der Rekursion

Die Arten der Rekursion sind hier nicht vollständig angegeben, es gibt noch weitere. Aber die hier folgenden sind für die Programmierung am wichtigsten.

Lineare Rekursion

Jeder Ausführungspfad durch die Funktion f enthält höchstens einen rekursiven Aufruf.
Höchstens einen, weil mindestens ein Pfad existieren muss, der keinen rekursiven Aufruf enthält (der Basisfall).

⇒ Das Ergebnis der Aufrufe ist eine 1-dimensionale "Rekursionskette".

Baumrekursion

(auch Kaskadenrekursion)

Mindestens ein Ausführungspfad durch die Funktion enthält mindestens 2 rekursive Aufrufe.
Baumrekursion ist damit das Gegenteil der linearen Rekursion.

⇒ Das Ergebnis der Aufrufe ist ein verzweigter "Rekursionsbaum". Ein baum-rekursiver Algorithmus ist deshalb häufig ineffizient: Wird der Pfad mit mehreren rekursiven Aufrufen mindestens Ω(d)-mal ausgeführt (wobei d die Rekursionstiefe) ist, entsteht ein Rekursionsbaum mit O(2^d) Knoten, also ein Algorithmus mit exponentieller Komplexität.

Course-of-values recursion

Das Ergebnis des rekursiven Aufrufes für Argument n hängt nur von den Ergebnissen der letzten p-Aufrufe, also für Argument n-1,n-2,...,n-p ab (wobei p eine Konstante ist).

Primitive Rekursion

Dies ist eine course-of-values recursion mit p=1.

⇒ Das ist ein Spezialfall der linearen Rekursion, denn wenn das Ergebnis nur von einem rekursiven Aufruf abhängt, kann kein Rekursionsbaum entstehen.

Endrekursion

In jedem Ausführungspfad mit einem rekursiven Aufruf ist dieser Aufruf der letzte Befehl vor dem return-Befehl.

⇒ Das ist ein Spezialfall der linearen Rekursion

Implementationen

Als Beispiel nehmen wir die Fibonacci-Zahl:
Definition: f₀=0, f₁=1,...., f_n=f_n-1+f_n-2
Es ergibt sich folgende Reihe: f_k=0, 1, 1, 2, 3, 5, 8, 13,....., (=>die Reihe wächst exponentiell an).

1. Version: Implementation Rekursiv - naive Implementation:

def fib1(n):                      # Funtion berechnet die n-te Fibonacci-Zahl
    if n <= 1: return n           # Rekursionsabschluss
    return fib1(n-1) + fib1(n-2)

Die Funktion fib1(n) ist ein Beispiel für eine Baumrekursion mit exponentieller Komplexität. Der Aufrufbaum sieht dann wie folgt aus:

                                              fib1(n)
                                             /       \
                                            /         \
                                           /           \
                                          /             \
                                   fib1(n-1)           fib1(n-2)
                                   /       \           /       \
                                  /         \         /         \
                                 /           \       /           \
                             fib1(n-2)  fib1(n-3)  fib1(n-3)   fib1(n-4)

Das ist natürlich ein ungünstiger Algorithmus, weil wiederholte Berechnungen gemacht werden.
Aber einige Probleme sind echt Baumrekursiv, z.B. das Ausrechnen der möglichen Züge beim Schachspiel.

Es gilt folgender Satz:
Jeder rekursiver Algorithmus kann mit einem Stack in iterativen Algorithmus umgewandelt werden (d.h. mit einer Schleife statt einer Rekursion). Das bedeutet, dass die Rekursion gleichmächtig ist wie die Schleife, d.h. gleichmächtig wie die Turing-Maschine. Die Komplexität ändert sich nicht.

2. Version: iterativ mit einem Stack

def fib2(n):
    stack = [n]   # unser Array
    f = 0         # f wird später die Lösung enthalten
    
    while len(stack) > 0:          # solange noch was auf dem Stack liegt, ist noch Arbeit zu tun
          k = stack.pop(-1)        # wenn etwas auf dem Stack liegt, dann nehme vom Stack herunter
          if k <= 1:               # Abschluss der Schleife
               f += k
          else:                    # Umwandlung der Rekursion in Iteration
               stack.append(k-1)   
               stack.append(k-2)
    return f

3. Version: Course-of-values

Fibonacci ist Course-of-values rekursiv (folgt unmittelbar aus der Definition) mit p=2.

def fib3(n):
    if n == 0: return 0     # Rekursionsabschluss
    f₁,f₂ = fib3Impl(n)     # Hilfsfuntion, f₁ ist die Fibonacci-Zahl von n und f₂ ist dei Fibonacci-Zahl von (n-1)
    return f₁

Die Hilfsfunktion:

def fib3Impl(n):
    if n == 1: return 1, 0         # gebe die Fibonacci-Zahl von 1 und die davor zurück
    else:                          # rekursiver Aufruf
       f₁,f₂ = fib3Impl(n-1)       # f₁ ist Fibonacci-Zahl von (n-1), f₂ die von (n-2)
       return f₁ + f₂, f₁          # gebe neue Fibonacci-Zahl f₁+f₂ und die vorherige (f₁) zurück

==> Diese Implementation ist jetzt linear-rekursiv und hat damit auch lineare Komplexität und nicht exponentielle wie die vorherigen Versionen.

Es gilt folgender Satz:
Jede Course-of-values Rekursion kann in Endrekursion umgewandelt werden.

4. Version: Endrekursiv

def fib4(n)
    if n == 0: return 0    
    else:                    
       return fib4Impl(0,1,n)

Die Hilfsfunktion:

def fib4Impl(f₁,f₂,n)
    if n == 1: return f₂
    else:
       return fib4Impl(f₂,f₁+f₂,n-1)   # f₂ ist die vorletzte Fibonacci-Zahl,

                                       # f₁+f₂ wird die neue Fibonacci-Zahl und wir müssen n um 1 herunterzählen

Beispiel mit n=2:

	f₁	f₂	n	return
fib4Impl 1.Aufruf	0	1	2	1
fib4Impl 2.Aufruf	1	1	1	1

==> Ergebnis von 2.Fibonacci-Zahl ist: 1

Es gilt folgender Satz:
Jede endrekursive Funktion kann ohne Stack in eine iterative Funtion umgewandelt werden.

5. Version: iterativ ohne Stack

def fib5(n):
    if n == 0: return 0
    f₁,f₂ = 0,1
    k = 1
    while k < n:
        f₁,f₂ = f₂,f₁+f₂
        k += 1
    return f₂

Das ist genau das gleiche wie fib4 nur das bei fib4 das n rückwärts gezählt wird und hier das k vorwärts. Das könnte man auch so schreiben:

while n > 0:
  f₁,f₂ = f₂,f₁+f₂
  n -= 1

Beispiel: treeSort

Input:
-ein balancierter Binärbaum root
-ein leeres dynamisches Array a

Aufgerufen wird: treeSort(root,a) # kopiert Elemente des Baums sortiert in Array a

Wiederholung (vergleiche Abschnitt "Sortieren mit Hilfe eines selbst-balancierenden Suchbaums"):

def treeSort(node,a):
   if node is None: return
   treeSort(node.left,a)
   a.append(node.key)
   treeSort(node.right,a)

Implementation als iterative Funktion:

def treeSortIterative(node,a):
   stack = []
   traverseLeft(node,stack)   # Hilfsfuntion, füllt Stack
   while len(stack) > 0:
       node = stack.pop(-1)
       a.append(node.key)
       traverseLeft(node.right,stack)

Hilfsfunktion:

def traverseLeft(node,stack):
   while node is not None:
       stack.append(node)
       node = node.left

Auflösung rekursiver Gleichungen

Komplexitätsberechnung rekursiver Algorithmen

<math>\underbrace{T(n)}_{Anzahl der Befehle} = \underbrace{ a_1T\left(\frac{n}{b_1}\right)+a_2T\left(\frac{n}{b_2}\right)+\cdots+a_kT\left(\frac{n}{b_k}\right) }_{rekursives Teilproblem} +\underbrace{f(n)}_{nicht-rekursiver Teil}</math>

Bemerkung: Aufrunden von <math>\lceil\frac{n}{b_i}\rceil</math> oder abrunden von <math>\lfloor\frac{n}{b_i}\rfloor</math> spielen für die Auflösung der Formeln i.a. keine Rolle.

Spezialfall: k = 1, d.h. alle Unterprobleme haben die gleiche Größe.

<math>T(n) = aT\left(\frac{n}{b}\right)+f(n)</math>

In diesem Fall muss folgender Rekursionsexponent eingeführt werden:

<math>\boldsymbol{\rho}=log_ba</math>

==> Master-Theorem

Master-Theorem

Fall 1:

<math>f(n) \in O(n^{\rho-\epsilon}) , \epsilon>0</math>


==> das bedeutet: die Kosten der Rekursion überwiegen


==><math>\boldsymbol{T(n) =\Theta(n^{\rho})}</math>

Fall 2:

<math>f(n) \in \Theta(n^{\rho}) </math>


==> das bedeutet: die Kosten von f und Rekursion addieren sich


==><math>\boldsymbol{T(n) =\Theta(n^{\rho}*logn})</math>

Fall 3:

<math>f(n) \in \Omega(n^{\rho+\epsilon})</math>


==> das bedeutet: die Kosten von f überwiegen


==><math>\boldsymbol{T(n) =\Theta(f(n))}</math>

es muß ausserdem noch gelten:
<math>a*f\left(\frac{n}{b}\right)\le c*f(n)</math> für c<1

Beispiel: Merge Sort

<math>T(n)  =  \underbrace{ 2T\left(\frac{1}{2}\right)}_{rekursiver Aufruf von MergeSort}+\underbrace {\Theta(n)}_{Merge}</math>


a=2, b=2 ==> <math>\rho=log_22 =1</math>
==> das ist Fall 2: <math>f(n) = \Theta(n) = O(n^{\rho}) </math>

==> Komplexität von MergeSort: <math>T(n) \in \Theta(n^\rho*logn) </math>

Fälle die nicht durch das Master-Theorem abgedeckt sind:

- wenn <math>k \ > 1</math>: rekursive Teilprobleme verschiedener Grösse

- wenn <math>f(n) \in O\left(\frac{n^\rho}{logn}\right)</math>

- wenn <math>f(n) \in \Omega\left(n^\rho*logn\right)</math>

Wo das Master-Theorem nicht anwendbar ist:

Beispiel ist die folgende Rekursion:
 <math>T(n)  =  \underbrace{ T\left(\frac{n}{3}\right)}_{\frac{1}{3} der Daten}+\underbrace {T\left(\frac{2n}{3}\right)}_{\frac{2}{3} der Daten}+O(n)</math>


Rekursionsbaum:

                                                n    --> wächst mit c*n
                                              /    \
                                             /      \
                                            /        \
                                           /          \
                                          /            \
                                      (n/3)            (2n/3)
                                    /       \          /     \
                                   /         \        /       \
                                  /           \      /         \
                               (n/9)       (2n/9)  (2n/9)      (4n/9)


                       ==> <math>c*\left(\frac{n}{9}+\frac{2n}{9}+\frac{2n}{9}+\frac{4n}{9}\right)=c*n</math>

Rekursion endet wenn: <math>\left(\frac{2}{3}\right)^d*n=1</math> wird, wobei d die Tiefe des Baums ist.


<math>n=\left(\frac{3}{2}\right) ---> d=log_\frac{3}{2}n</math>

Vermutung: 
<math>T(n) \in O\left(log_\frac{3}{2}n*c*n\right)</math>
 
nach den Regeln der O-Notation ist das: 0(n*logn), d.h unsere Vermutung stimmt.

Ungleiche Aufteilung in Teilprobleme ändert nicht dei Komplexität, falls das Teilungsverhältnis konstant ist.

 
Beweis durch Substitution:

<math>T(n)\le T\left(\frac{n}{3}\right)+ T\left(\frac{2n}{3}\right)+ c\,n</math>

<math>\le d\left(\frac{n}{3}\,\log\frac{n}{3}\right)+ d\left(\frac{2n}{3}\,\log\frac{2n}{3}\right)+ c\,n</math>

<math> = d\frac{n}{3}\,\log n-d\,\frac{n}{3}\,\log 3+d\,\frac{2}{3}\,n\,\log n-d\,\frac{2}{3}\,n\,\log\frac{3}{2}+c\,n</math>

<math> = d\,n\,\log n-d\underbrace{\left( \frac{n}{3}\,\log 3+\frac{2n}{3}\,\log\frac{3}{2}\right) }_{\frac{n}{3}\,\log 3+\frac{2n}{3}\,\log 3-\frac{2n}{3}\,\log 2}+c\,n</math>

<math> = d\,n\,\log n-d\,n\left(\log 3-\frac{2}{3}\right)+c\,n</math>

<math> \le d\,n\,\log n</math> falls <math>c\,n-d\,n\left(\log 3-\frac{2}{3}\right)< 0</math>

<math> \Longleftrightarrow  d \ge \frac{c}{\log 3-\frac{2}{3}}</math>