Was ist der Unterschied zwischen Rekursion und Iteration in Java?-javaLernprogramm-php.cn

1. Der Unterschied zwischen Rekursion und Iteration

Wenn sich eine Entität selbst aufruft, wird das Programm rekursiv genannt. 调用自身时，程序称为递归。
当存在循环（或重复）时，程序称为迭代调用。
示例：求一个数的阶乘的程序

时间复杂度比较

查找递归的时间复杂度比迭代更难。
递归：递归的时间复杂度可以通过根据先前的调用找到第 n 次递归调用的值来找到。因此，根据基本情况找到目标情况，并根据基本情况求解，可以让我们了解递归方程的时间复杂度。
迭代：迭代的时间复杂度可以通过找到循环内重复的循环数来找到。

用法比较

使用这些技术中的任何一种都是时间复杂度和代码大小之间的权衡。
如果时间复杂度是重点，递归调用的次数会很大，那么最好使用迭代。
但是，如果时间复杂度不是问题而代码的短小是问题，那么递归将是可行的方法。
递归：递归涉及再次调用相同的函数，因此代码长度非常短。然而，正如我们在分析中看到的那样，当递归调用数量相当多时，递归的时间复杂度可能会呈指数级增长。因此，递归的使用在更短的代码中是有利的，但时间复杂度更高。
迭代：迭代是代码块的重复。这涉及较大的代码量，但时间复杂度通常低于递归。

开销

与迭代相比，递归有大量的开销。
递归：递归有函数重复调用的开销，即由于重复调用同一个函数，代码的时间复杂度增加了很多倍。
迭代：迭代不涉及任何此类开销。

无限重复

递归中的 Infinite Repetition 会导致 CPU crash，但在迭代中，当内存耗尽时它会停止。
递归：在Recursion中，由于指定的基本条件错误，可能会出现无限递归调用，在永远不会为假的情况下，不断调用函数，这可能会导致系统CPU崩溃。
迭代

Wenn es eine Schleife (oder Wiederholung) gibt, wird das Programm als iterativer Aufruf bezeichnet. ZeitkomplexitätsvergleichDas Ermitteln der zeitlichen Komplexität einer Rekursion ist schwieriger als die Iteration. Rekursion: Die zeitliche Komplexität der Rekursion kann ermittelt werden, indem der Wert des n-ten rekursiven Aufrufs basierend auf den vorherigen Aufrufen ermittelt wird. Daher können wir die zeitliche Komplexität der rekursiven Gleichung verstehen, indem wir den Zielfall basierend auf dem Basisfall finden und ihn basierend auf dem Basisfall lösen. Iteration: Die zeitliche Komplexität der Iteration kann ermittelt werden, indem die Anzahl der innerhalb der Schleife wiederholten Schleifen ermittelt wird. Nutzungsvergleich Die Verwendung einer dieser Techniken ist ein Kompromiss zwischen zeitlicher Komplexität und Codegröße. Wenn die zeitliche Komplexität im Vordergrund steht und die Anzahl der rekursiven Aufrufe groß ist, ist es am besten, die Iteration zu verwenden. Wenn jedoch die Zeitkomplexität kein Problem darstellt und die Kürze des Codes schon, dann wäre Rekursion der richtige Weg. Rekursion: Bei der Rekursion wird dieselbe Funktion erneut aufgerufen, sodass die Codelänge sehr kurz ist. Wie wir jedoch in unserer Analyse gesehen haben, kann die zeitliche Komplexität der Rekursion exponentiell zunehmen, wenn die Anzahl der rekursiven Aufrufe beträchtlich ist. Daher ist die Verwendung von Rekursion bei kürzerem Code, jedoch bei höherer Zeitkomplexität, von Vorteil. Iteration: Iteration ist die Wiederholung eines Codeblocks. Dies erfordert eine größere Menge an Code, aber die zeitliche Komplexität ist normalerweise geringer als bei einer Rekursion. Overhead Im Vergleich zur Iteration hat die Rekursion einen hohen Overhead. Rekursion: Die Rekursion hat den Overhead wiederholter Funktionsaufrufe, d. h. aufgrund wiederholter Aufrufe derselben Funktiondie zeitliche Komplexität des Codes erhöht sich um ein Vielfaches code>. Iteration: Die Iteration bringt keinen solchen Overhead mit sich. Unendliche Wiederholung Unendliche Wiederholung in der Rekursion führt zu einem CPU-Absturz, stoppt jedoch in der Iteration, wenn der Speicher erschöpft ist. Rekursion: Bei der Rekursion können aufgrund von Fehlern in den angegebenen Grundbedingungen unendlich viele rekursive Aufrufe auftreten. Funktionen werden kontinuierlich aufgerufen, obwohl sie nie falsch sind, was zu CPU-Abstürzen führen kann. Iteration: Eine unendliche Iteration aufgrund eines Iteratorzuweisungs- oder Inkrementierungsfehlers oder eines Beendigungsbedingungsfehlers führt zu einer Endlosschleife, die möglicherweise zu einem Systemfehler führt, aber definitiv stoppt die weitere Ausführung des Programms. Die Funktion ruft sich selbst auf. Eine Reihe von Anweisungen, die wiederholt ausgeführt werden. Appsfür Funktionalität. Für Schleifen. BeendigungIm Basisfall gibt es hier keine Funktionsaufrufe. Wenn die Beendigungsbedingung des Iterators nicht mehr erfüllt ist. VerwendungVerwenden Sie ihn, wenn die Codegröße klein sein muss und die Zeitkomplexität kein Problem darstellt. Verwenden Sie es, wenn die zeitliche Komplexität gegen die skalierte Codegröße abgewogen werden muss. Codegröße. Weniger Code. Mehr Code.

Beispiel: Programm zum Ermitteln der Fakultät einer Zahl

Die zeitliche Komplexität ist relativ gering (im Allgemeinen Polynom-Logarithmus).

🎜🎜🎜Raumkomplexität🎜🎜Die Raumkomplexität ist höher als die Iteration. 🎜🎜Die räumliche Komplexität ist gering. 🎜🎜🎜🎜Heap🎜🎜Der Stapel hier wird zum Speichern lokaler Variablen verwendet, wenn Funktionen aufgerufen werden. 🎜🎜Verwendet keinen Stapel. 🎜🎜🎜🎜Geschwindigkeit🎜🎜Die Ausführung ist langsam, da der Aufwand für die Wartung und Aktualisierung des Stapels anfällt. 🎜🎜Im Allgemeinen ist es schneller als die Rekursion, da der Stapel nicht verwendet wird. 🎜🎜🎜🎜Speicher🎜🎜Rekursion benötigt im Vergleich zur Iteration mehr Speicher. 🎜🎜Kein Overhead, da es in der Iteration keine Funktionsaufrufe gibt. 🎜🎜🎜🎜Elevated🎜🎜hat den Overhead wiederholter Funktionsaufrufe. 🎜🎜Kein Overhead, da es in der Iteration keine Funktionsaufrufe gibt. 🎜🎜🎜🎜Unendliche Wiederholung🎜🎜Wenn eine rekursive Funktion die Beendigungsbedingung nicht erfüllt oder undefiniert ist oder der Basisfall nie erreicht wird, führt dies zu einem Stapelüberlauffehler und das System kann bei unendlicher Rekursion abstürzen. 🎜🎜Wenn die Kontrollbedingung der Iterationsanweisung niemals falsch ist oder die Kontrollvariable den Endwert nicht erreicht, führt dies zu einer Endlosschleife. In einer Endlosschleife nutzt es immer wieder CPU-Zyklen. 🎜🎜🎜🎜🎜2. Code🎜

public class Test {
    // ----- 递归 -----
    // 求给定数的阶乘的方法
    static int factorialUsingRecursion(int n)
    {
        if (n == 0)
            return 1;

        // 递归呼叫
        return n * factorialUsingRecursion(n - 1);
    }

    // -----迭代 -----
    //求给定数的阶乘的方法
    static int factorialUsingIteration(int n)
    {
        int res = 1, i;

        // 迭代
        for (i = 2; i <= n; i++)
            res *= i;

        return res;
    }

    public static void main(String[] args)
    {
        int num = 5;
        System.out.println("Factorial of " + num
                + " using Recursion is: "
                + factorialUsingRecursion(5));

        System.out.println("Factorial of " + num
                + " using Iteration is: "
                + factorialUsingIteration(5));
    }
}

Nach dem Login kopieren

rrree

Das obige ist der detaillierte Inhalt vonWas ist der Unterschied zwischen Rekursion und Iteration in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!