Detaillierte Code-Erklärung der jeweiligen Vorteile von Rekursion und Schleifen in JavaScript

Rekursion und Schleife

Für verschiedene Arten von Problemen, die wiederholte Berechnungen erfordern, haben Schleifen- und Rekursionsmethoden ihre eigenen Vorteile und können intuitivere und einfachere Lösungen bieten. Andererseits können Schleifen- und rekursive Methoden ineinander umgewandelt werden. Jede Codeschleife kann mithilfe der Rekursion umgeschrieben werden, um dieselbe Funktion zu erreichen, und umgekehrt. Ohne ihre Allgemeingültigkeit zu verlieren, können Schleifen und Rekursionen mit dem folgenden Pseudocode zusammengefasst werden.

Beschreibung des Pseudocode-Formats: Die Schleife verwendet die while-Form; bedingte Ausdrücke werden in Form von Funktionen geschrieben, und relevante Werte werden in Klammern geschrieben. Versuchen Sie in Bezug auf die sonstige Syntax, den Javascript-Spezifikationen so nahe wie möglich zu kommen.

//pseudo code of a loop 
//while形式 
function loop(arguments){ 
//结果的初始值 
result:=initial_value; 

while(condition(variable, arguments)){//循环条件，可能只需arguments，也可能为了方便引入循环变量 
//计算结果。参数包括之前的结果、当前循环变量和外部变量 
result:=calculate(result, variable, extern_variables); 
//影响函数的外部环境，即修改外部变量 
changeStatus(result, variable, extern_variables); 
//执行完循环体中的语句后，修改参数或循环变量。 
modify_arguments_variable(arguments, variable); 
} 
//返回结果 
return result; 
}

Ähnlich geben wir den Pseudocode der rekursiven Funktion an.

//pseudo code of a recursion 
function recursion(arguments){ 
//以下代码为控制函数重复调用的结构部分。 
//获得再次调用此函数的新的参数，可能为多组arguments值。 
//对应于循环中的condition(variable, arguments)和modify_arguments_variable(arguments, variable)。 
new_arguments:=conditional_get_next(arguments); 
//对新参数的每一组，调用函数自身。 
results:=recursion(new_arguments); 
//以下的代码为每次调用都运行的功能部分 
//计算结果。涉及到之前的结果、当前循环变量和外部变量。 
//对应于循环中的result:=calculate(result, variable, extern_variables)。 
result:=calculate(arguments, extern_variables); 
result:=combine(result, results); 
//影响函数的外部环境，即修改外部变量 
changeStatus(result, arguments, extern_variables); 
return result; 
}

Wenn wir die beiden Codeteile vergleichen, können wir sehen, dass Schleifen und Rekursionen ähnliche Zusammensetzungen haben. Durch Ändern der Reihenfolge und Vornehmen entsprechender Transformationen kann jede Schleife rekursiv implementiert werden. Diese Transformation ist leicht zu erkennen, wenn das Programm einfach ist. Zum Beispiel die folgende einfache kumulative Summenfunktion:

//loop 
function sum(num){ 
var result=1; 
while (num>1){ 
result+=num; 
num--; 
} 
return result; 
}

Die entsprechende rekursive Form:

//recursion 
function sum2(num){ 
if (num>1){ 
return num+sum(num-1); 
}else{ 
return 1; 
} 
}

Im Gegenteil, die meisten rekursiven Programme können auch direkt sein geschlungen zu erreichen. Das Folgende ist eine Funktion in Form einer Schleife, die den größten gemeinsamen Teiler findet.

function gcd2(a, b){ 
var temp; 
if (a<b){ 
temp=a; 
a=b; 
b=temp; 
} 
var c=a%b; 
while (c!==0){ 
a=b; 
b=c; 
c=a%b; 
} 
return b; 
}

Allerdings ist die Umstellung von Rekursion auf Schleife nicht immer so einfach. Der Teil des rekursiven Pseudocodes, der neue Argumente für den erneuten Aufruf dieser Funktion generiert

new_arguments:=conditional_get_next(arguments);

, ist flexibler als der entsprechende Teil der Schleife. Die Rekursion kann entsprechend der Anzahl der neu generierten Parametergruppen in zwei Kategorien unterteilt werden (alle für die Funktion erforderlichen Parameter sind eine Gruppe). Der erste Typ ist, wenn die Anzahl der Parametergruppen fest ist und die Rekursion in eine Schleife umgewandelt werden kann, wie zum Beispiel die Fibonacci-Folge, und der zweite Typ ist, wenn die Anzahl der Parametergruppen unsicher ist – genau wie beim Durchlaufen eines Diagramms oder Baums Auf diese Weise hat jeder Punkt eine beliebige Anzahl benachbarter Punkte – diese Rekursion kann nicht direkt in eine Schleife umgewandelt werden.

Weil Schleifen nur eindimensionale Wiederholungen durchführen können, während eine Rekursion zweidimensionale Strukturen durchlaufen kann. In einem Baum befinden sich beispielsweise sowohl die untergeordneten Knoten als auch die Knoten eines Knotens auf derselben Ebene. Eine einfache eindimensionale Schleife kann nicht in beide Richtungen durchlaufen. Aber auch die zweite Art der Rekursion kann mit einer Schleife implementiert werden, wenn wir uns mithilfe einer Datenstruktur in der Schleife einige Informationen über die Knotenposition merken.

Um es zusammenzufassen. Alle Schleifen können durch Rekursion implementiert werden; alle Rekursionen können durch Schleifen implementiert werden. Welche Methode verwendet wird, hängt davon ab, welche Idee für das spezifische Problem und die Vorlieben des Benutzers bequemer und intuitiver ist.

Das obige ist der detaillierte Inhalt vonDetaillierte Code-Erklärung der jeweiligen Vorteile von Rekursion und Schleifen in JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!