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中文網其他相關文章！