Scala Rekursion Erklärung von Scala Buch

Question

Ich ging durch Scala Buch von Martin Odersky. In Kapitel 10 (Zusammensetzung und Vererbung), in diesem Code:

def spiral(nEdges: Int, direction: Int): Element = { 
    if (nEdges == 1) { 
     elem("+") 
    } 
    else { 
     println(s"nEdgesInside1=$nEdges") 

     val sp = spiral(nEdges - 1, (direction + 3) % 4) 

     def verticalBar = elem('|', 1, sp.height) 

     def horizontalBar = elem('-', sp.width, 1) 

     println(s"nEdgesInside2=$nEdges") 

     if (direction == 0) 
     (corner beside horizontalBar) above (sp beside space) 
     else if (direction == 1) 
     (sp above space) beside (corner above verticalBar) 
     else if (direction == 2) 
     (space beside sp) above (horizontalBar beside corner) 
     else 
     (verticalBar above corner) beside (space above sp) 
    } 
    } 

Ich bin nicht in der Lage zu verstehen, wie Code über die Linie fließt:

val sp = spiral(nEdges - 1, (direction + 3) % 4) 

mein Verständnis Accoording wird nEdges in jeder Iteration verringert zu werden spiral Funktion wird aufgerufen und sobald sie 1 (dh Abbruchbedingung) erreicht, erstellt sie Objekt über elem Funktion.

Wenn ich diesen Code teste und die Werte von nEdges drucke, wird er dekrementiert, bis die Zeile über dem Aufruf von spiral funktioniert und nach dieser Zeile beginnt er zu inkrementieren. Kann mir jemand erklären, wie das passiert?

Vielen Dank im Voraus

Answer 1

Dies ist im Grunde, wie Rekursion funktioniert. edges wird dekrementiert, bis es 1 erreicht, und dabei ruft es weiterhin spiral auf, was mehr Stapelrahmen erzeugt, jeder mit seinem eigenen Wert von nEdges und direction. Sobald wir 1 erreichen, beginnt der Aufruf-Stack sich zu entspannen, ältere Stack-Frames werden zerstört, was bedeutet, dass kleinere Werte dieser beiden Felder anstelle von Werten höher im Stack-Frame verworfen werden, wo sie einen höheren Wert haben.

Nehmen wir zum Beispiel das Bild eines rekursiven faktorielles Berechnung:

(. © Chen Yu Jade - http://jade-cheng.com/hpu/2012-spring/csci-2912/recursion/)

Stellen Sie sich vor, dass n steht für nEdges, sehen Sie, dass es erniedrigt ist mit jedem Methodenaufruf, und wenn n = 0, fangen wir an, sich abzuwickeln und gehen höher und höher auf den Stapel, wo n einen höheren Wert hatte.