Apakah perbezaan antara rekursi dan lelaran di Jawa?

1. Perbezaan antara rekursi dan lelaran

• Apabila entiti adalah 调用自身, atur cara dipanggil 递归.

• Apabila 循环（或重复） hadir, program itu dipanggil 迭代调用.

• Contoh: Program untuk mencari pemfaktoran nombor

Perbandingan kerumitan masa

• 查找递归的时间复杂度比迭代更难。

• 递归: Kerumitan masa rekursi boleh didapati dengan mencari nilai panggilan rekursif ke-n berdasarkan panggilan sebelumnya. Oleh itu, mencari kes sasaran berdasarkan kes asas, dan menyelesaikannya berdasarkan kes asas, membolehkan kita memahami kerumitan masa persamaan rekursif.

• 迭代: Kerumitan masa lelaran boleh didapati dengan mencari bilangan gelung yang diulang dalam gelung.

Perbandingan penggunaan

• Menggunakan mana-mana teknik ini adalah pertukaran antara kerumitan masa dan perdagangan saiz kod- dimatikan.

• Jika kerumitan masa menjadi tumpuan dan bilangan panggilan rekursif akan menjadi besar, maka sebaiknya gunakan lelaran.

• Walau bagaimanapun, jika kerumitan masa tidak menjadi isu dan kekurangan kod adalah, maka pengulangan adalah cara yang perlu dilakukan.

• Rekursi: Rekursi melibatkan memanggil semula fungsi yang sama, jadi panjang kod adalah sangat pendek. Walau bagaimanapun, seperti yang kita lihat dalam analisis kami, kerumitan masa rekursi boleh berkembang secara eksponen apabila bilangan panggilan rekursif adalah banyak. Oleh itu, penggunaan rekursi adalah berfaedah dalam kod yang lebih pendek, tetapi pada kerumitan masa yang lebih tinggi.

• Lelaran: Lelaran ialah pengulangan blok kod. Ini melibatkan jumlah kod yang lebih besar, tetapi kerumitan masa biasanya lebih rendah daripada rekursi.

Overhed

• Rekursi mempunyai banyak overhed berbanding lelaran.

• 递归: Rekursi mempunyai overhed panggilan fungsi berulang, iaitu disebabkan oleh 重复调用同一个函数, 代码的时间复杂度增加了很多倍.

• 迭代: Lelaran tidak melibatkan sebarang overhed sedemikian.

Ulangan Tak Terhingga

• Ulangan Tak Terhingga dalam 递归 akan menyebabkan ranap CPU, tetapi semasa lelaran, apabila Ia berhenti apabila ingatan sudah habis.

• 递归: Dalam Rekursif, panggilan rekursif tak terhingga mungkin berlaku disebabkan keadaan asas yang salah yang dinyatakan, dan fungsi dipanggil secara berterusan tanpa pernah palsu, yang boleh menyebabkan CPU sistem untuk terhempas.

• 迭代: Lelaran tak terhingga disebabkan penetapan iterator atau ralat kenaikan atau ralat keadaan penamatan akan mengakibatkan gelung tak terhingga yang mungkin atau mungkin tidak mengakibatkan ralat sistem tetapi pasti akan menghentikan pelaksanaan selanjutnya program tersebut.

	递归	迭代
定义	函数调用自身。	重复执行的一组指令。
应用	对于功能。	对于循环。
终止	通过 base case，这里不会有函数调用。	当不再满足迭代器的终止条件时。
用法	当代码大小需要很小并且时间复杂度不是问题时使用。	当时间复杂度需要与扩展的代码大小进行平衡时使用
代码大小	更少的代码	更多的代码
时间复杂度	非常高（通常是指数）的时间复杂度。	时间复杂度相对较低（一般为多项式-对数）。
空间复杂度	空间复杂度高于迭代。	空间复杂度较低。
堆	这里的栈是用来存放函数调用时的局部变量的。	不使用堆栈。
速度	执行速度很慢，因为它有维护和更新堆栈的开销。	通常，它比递归更快，因为它不使用堆栈。
存储	与迭代相比，递归使用更多内存。	没有开销，因为迭代中没有函数调用。
高架	拥有重复函数调用的开销。	没有开销，因为迭代中没有函数调用。
无限重复	如果递归函数不满足终止条件或未定义或从未达到基本情况，则会导致堆栈溢出错误，并且系统有可能在无限递归中崩溃。	如果迭代语句的控制条件永远不为假或控制变量没有达到终止值，就会造成死循环。在无限循环中，它一次又一次地使用 CPU 周期。

Kod

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));
    }
}

Factorial of 5 using Recursion is: 120
Factorial of 5 using Iteration is: 120

Atas ialah kandungan terperinci Apakah perbezaan antara rekursi dan lelaran di Jawa?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!