Erlang 递归

Rekursion ist ein wichtiger Bestandteil von Erlang. Lassen Sie uns zunächst sehen, wie man einfache Rekursion durch die Implementierung des Programmierens von Fakultät umsetzt.

实例

-module(helloworld).　
-export([fac/1,start/0]).　
fac(N) when N == 0　->　1;　
fac(N) when N > 0　-> N*fac(N-1.　
start()　->　
　　　X = fac(4,　
　　　io:fwrite("~w",[X]).

Bezüglich des obigen Programms gibt es einige Punkte zu beachten:

• Zunächst definieren wir eine Funktion namens fac(N).

• Wir können die rekursive Funktion fac(N) durch einen rekursiven Aufruf definieren.

Die Ausgabe des obigen Programms ist:

Ausgabe

24

Praktische Methode der Rekursion

In diesem Abschnitt werden wir die verschiedenen Arten von Rekursion und ihre Verwendung in Erlang im Detail besprechen.

Rekursion mit Länge

Eine praktischere Methode für Rekursion lässt sich an einem einfachen Beispiel zur Bestimmung der Länge einer Liste erkennen. Eine Liste kann mehrere Werte enthalten, wie z.B. [1,2,3,4]. Lassen Sie uns rekursiv sehen, wie man die Länge einer Liste erhält.

-module(helloworld).　
-export([len/1,start/0]).　
len([])　-> 0;　
len([_|T])　->　1　+　len(T).　
start()　->　
　　　X = [1,2,3,4,　
　　　Y = len(X),　
　　　io:fwrite("~w",[Y]).

Bezüglich des obigen Programms gibt es einige Punkte zu beachten:

• wenn die Liste leer ist, wird die Funktion len([]) für den speziellen Fall verwendet.

• [H|T] -Muster, um eine Liste mit einem oder mehreren Elementen zu matchen, wie die Länge von1definiert [X|[]], und die Länge ist　2　definiert [X|[Y|[]]] .　　

• Beachten Sie, dass das zweite Element die Liste selbst ist. Dies bedeutet, dass wir nur den ersten zählen müssen, und die Funktion kann sich selbst auf dem zweiten Element aufrufen. Der Wert der Länge der Liste wird als　1　.
  

Die Ausgabe des obigen Programms wird sein

4

Tailrekursion

Um zu verstehen, wie Tailrekursion funktioniert, lassen Sie uns das folgende Code in der vorherigen Lektion betrachten.

Syntax

len([])　-> 0;　
len([_|T])　->　1　+　len(T).

1 + Die Antwort auf len (Rest) muss die Antwort auf len (Rest) finden. Dann muss die Funktion len (Rest) selbst das Ergebnis eines anderen Funktionsaufrufs finden. Der hinzugefügte Teil stapelt sich auf, bis der Letzte gefunden wird, dann kann das endgültige Ergebnis berechnet werden.

Tailrekursion zielt darauf ab, diese Stapeloperationen durch Reduzieren ihrer Anzahl beim Vorkommen der Operationen zu eliminieren.

Um dies zu erreichen, müssen wir in der Funktion eine zusätzliche temporäre Variable als Parameter beibehalten. Die oben erwähnte temporäre Variable wird manchmal als Akkumulator bezeichnet und dient als Ort zur Speicherung der berechneten Ergebnisse, um das Anwachsen der Aufrufe zu begrenzen.

Lassen Sie uns ein Beispiel für eine nachfolgende Rekursion betrachten

-module(helloworld).
-export([tail_len/1,tail_len/2,start/0]).　
tail_len(L)　-> tail_len(L,0).　
tail_len([], Acc)　-> Acc;　
tail_len([_|T], Acc)　-> tail_len(T,Acc+1.　
start()　->　
　　　X = [1,2,3,4,　
　　　Y = tail_len(X),　
　　　io:fwrite("~w",[Y]).

Die Ausgabe des obigen Programms ist

4

Wiederholen (Kopieren)

Lassen Sie uns ein rekursives Beispiel betrachten. Diesmal schreiben wir eine Funktion, die ein Integer als ersten Parameter und dann jedes andere Element als zweiten Parameter annimmt. Dann erstellt sie eine Liste von Term-Replikationen, die durch das Integer bestimmt werden.

Lassen Sie uns einen solchen Beispiel betrachten-

-module(helloworld).　
-export([duplicate/2,start/0]).　
duplicate(0,_)　->　
　　　[];　
duplicate(N,Term) when N > 0　->
　　　io:fwrite("~w,~n",[Term]),
　　　[Term|duplicate(N-1,Term)].　
start()　->　
　　　duplicate(5,1.

Die Ausgabe des obigen Programms wird sein-

Ausgabe

1,
1,
1,
1,
1,

Listenumkehr

In Erlang kann rekursiv ohne Einschränkungen gearbeitet werden. Lassen Sie uns schnell einen Blick darauf werfen, wie man mit Rekursion die Elemente einer Liste umkehrt. Folgender Programmcode kann dies erreichen.

实例

-module(helloworld).　
-export([tail_reverse/2,start/0]).　
tail_reverse(L)　-> tail_reverse(L,[]).
tail_reverse([],Acc)　-> Acc;　
tail_reverse([H|T],Acc)　-> tail_reverse(T, [H|Acc]).
start()　->　
　　　X = [1,2,3,4,　
　　　Y = tail_reverse(X),　
　　　io:fwrite("~w",[Y]).

Die Ausgabe des obigen Programms wird sein-

Ausgabe

[4,3,2,1]

Bezüglich des obigen Programms gibt es einige Punkte zu beachten:

• Wir verwenden erneut das Konzept der temporären Variable, um jedes Element der Liste in einer Variable namens Acc zu speichern.

  Dann wird tail_reverse rekursiv aufgerufen, aber diesmal stellen wir sicher, dass das letzte Element zuerst in die neue Liste eingefügt wird.

  Dann wird tail_reverse auf jeden Element der Liste rekursiv aufgerufen.