JavaScript 中递归的详细讨论

递归是一种函数调用自身的技术。它是一种通过将较大问题分解为较小问题来解决较大问题的编程模式。在 JavaScript 中使用递归我们可以做循环或迭代之类的事情，但是递归可以更简单、更透明地解决一些问题。

递归是如何工作的？

递归有两个主要部分：

1. 基本情况：这是函数不再调用自身的情况。它充当递归函数的停止点。没有基本情况的递归函数有时会导致堆栈溢出（即，由于重复调用函数而导致内存不足）。
2. 递归案例：这是函数调用自身的部分，试图通过将其分解为更小的部分来解决问题。

例如：

1. 阶乘计算：阶乘是从一个数到1的所有数字的乘积之和。例如，n!=n×(n−1)×(n−2)×...×1 5! = 5 * 4 * 3 * 2 * 1 = 120.

阶乘是从该数字到 1 的所有正整数的乘积。

function factorial(n) {
    // Base case: n যদি 1 হয়, তাহলে 1 রিটার্ন করো
    if (n === 1) {
        return 1;
    }
    // Recursive case: n * factorial(n-1)
    return n * factorial(n - 1);
}

console.log(factorial(5)); // Output: 120

这里，阶乘函数不断调用自身，直到 n 变为 1。当n为1时，函数不再调用自身并返回1。这个结果是通过之前的调用逐步返回的，原来的调用返回120作为最终结果。

当调用factorial(5)时，它会首先调用5 * Factorial(4)，依此类推，直到满足基本情况条件的factorial(0)。

1. 斐波那契数列：斐波那契数列是一个著名的例子，其中每个数字都是前两个数字的总和。 F(n)=F(n−1)+F(n−2)

斐波那契数列是一系列数字，其中前两个数字是 0 和 1，后面的每个数字都是前面两个数字的总和。例如，0、1、1、2、3、5、8、…

function fibonacci(n) {
    // Base cases: n যদি 0 বা 1 হয়, সরাসরি n রিটার্ন করো
    if (n === 0 || n === 1) {
        return n;
    }
    // Recursive case: fibonacci(n-1) + fibonacci(n-2)
    return fibonacci(n - 1) + fibonacci(n - 2);
}

console.log(fibonacci(6)); // Output: 8

说明：

• 基本情况：如果 n 的值为 0，fibonacci(0) 返回 0。如果 n 的值为 1，fibonacci(1) 返回 1。
• 递归情况：在任何其他情况下，fibonacci(n) 都会用 n−1 和 n−2 调用自身并返回它们的和。

答案说明：

1. fibonacci(0) = 0
2. fibonacci(1) = 1
3. fibonacci(2) = fibonacci(1) + fibonacci(0) = 1 + 0 = 1
4. fibonacci(3) = fibonacci(2) + fibonacci(1) = 1 + 1 = 2
5. fibonacci(4) = fibonacci(3) + fibonacci(2) = 2 + 1 = 3
6. fibonacci(5) = fibonacci(4) + fibonacci(3) = 3 + 2 = 5
7. fibonacci(6) = fibonacci(5) + fibonacci(4) = 5 + 3 = 8

এভাবে fibonacci(6) এর মান দাঁড়ায় 8, যা 6-তম ফিবোনাচি সংখ্যা।

1. Tree Traversal: Tree ডেটা স্ট্রাকচারে একটি Recursive Function ব্যবহার করে DFS (Depth-First Search) করা যেতে পারে।

javascriptCopy code
function traverseTree(node) {
    console.log(node.value);
    node.children.forEach(child => traverseTree(child));
}

const tree = {
    value: 1,
    children: [
        { value: 2, children: [] },
        { value: 3, children: [
            { value: 4, children: [] },
            { value: 5, children: [] }
        ] }
    ]
};

traverseTree(tree);
// Output:
// 1
// 2
// 3
// 4
// 5

Recursion এর উপকারিতা এবং অসুবিধা

1. উপকারিতা
2. কোড সরলতা: Recursion জটিল সমস্যাকে সহজভাবে প্রকাশ করতে সাহায্য করে, বিশেষ করে এমন সমস্যা যেখানে সমস্যাগুলি নিজের অনুরূপ।
3. কোড পুনরাবৃত্তি: Recursion প্রায়শই কোডের পুনরাবৃত্তি দূর করে এবং সমাধানগুলোকে ছোট এবং পরিষ্কার করে।
4. কিছু নির্দিষ্ট সমস্যা সমাধানে কার্যকর: যেমন Tree এবং Graph ডেটা স্ট্রাকচার traversal, অথবা Mathematical series এবং sequences।
5. অসুবিধা
6. পারফরম্যান্স: প্রত্যেকটি recursive কল একটি নতুন execution context তৈরি করে, যা stack memory তে সংরক্ষণ করা হয়। অতিরিক্ত recursion এর ফলে stack overflow এর ঝুঁকি থাকে।
7. জটিলতা: সাধারণ লুপের তুলনায় কিছু ক্ষেত্রে recursion বোঝা কঠিন হতে পারে, বিশেষ করে শুরুতে।
8. অকার্যকর ফাংশন: কিছু ক্ষেত্রে, recursion অকার্যকর হতে পারে, যদি recursive ফাংশনের প্রতিটি কলের ফলে অনেক অপ্রয়োজনীয় গণনা হয়। এক্ষেত্রে Memoization বা Iterative পদ্ধতির ব্যবহার অধিক কার্যকরী।

以上是JavaScript 中递归的详细讨论的详细内容。更多信息请关注PHP中文网其他相关文章！