Recursion হল একটি কৌশল যেখানে একটি ফাংশন নিজেই নিজেকে কল করে। এটি একটি প্রোগ্রামিং প্যাটার্ন যা একটি বড় সমস্যা সমাধান করতে সেই সমস্যাকে ছোট সমস্যায় বিভক্ত করে। JavaScript-এ recursion ব্যবহার করে আমরা loop বা iteration-এর মতো কাজ করতে পারি, তবে কিছু সমস্যা সমাধানের জন্য recursion আরও সহজ এবং স্বচ্ছ হতে পারে।

Recursion কীভাবে কাজ করে?

Recursion এর দুটি প্রধান অংশ রয়েছে:

1. Base Case (বেস কেস): এটি হলো সেই শর্ত যেখানে ফাংশন আর নিজেকে কল করবে না। এটি Recursive function-এর জন্য স্টপিং পয়েন্ট হিসেবে কাজ করে। বেস কেস ছাড়া একটি রিকার্সিভ ফাংশন এক সময় stack overflow (অর্থাৎ, ফাংশনের ক্রমাগত কলের কারণে মেমোরি শেষ হয়ে যাওয়া) হতে পারে।
2. Recursive Case: এটি হলো সেই অংশ যেখানে ফাংশন নিজেই নিজেকে কল করে, সমস্যাটিকে ছোট ছোট অংশে ভেঙ্গে সমাধান করার চেষ্টা করে।

যেমনঃ

1. Factorial গণনা: Factorial একটি সংখ্যা থেকে 1 পর্যন্ত সমস্ত সংখ্যার গুণফলের সমষ্টি। উদাহরণস্বরূপ, n!=n×(n−1)×(n−2)×...×1 5! = 5 * 4 * 3 * 2 * 1 = 120।

Factorial হলো একটি সংখ্যার সেই সংখ্যা থেকে ১ পর্যন্ত সমস্ত ধনাত্মক পূর্ণসংখ্যার গুণফল।

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

এখানে, factorial ফাংশনটি নিজেই নিজেকে কল করছে যতক্ষণ না n 1 হয়ে যায়। যখন n 1 হয়, তখন ফাংশনটি নিজেকে আর কল করে না এবং 1 রিটার্ন করে। এই ফলাফলটি ধীরে ধীরে আগের কলগুলোর মাধ্যমে ফেরত আসে এবং মূল কলটি চূড়ান্ত ফলাফল হিসেবে 120 রিটার্ন করে।

factorial(5) কল হলে, এটি প্রথমে 5 * factorial(4) কল করবে এবং এটি ক্রমান্বয়ে factorial(0) পর্যন্ত চলবে যেখানে base case এর শর্ত পূরণ হবে।

1. Fibonacci Series: Fibonacci সিরিজ একটি বিখ্যাত উদাহরণ যেখানে প্রতিটি সংখ্যা পূর্বের দুটি সংখ্যার যোগফল হয়। F(n)=F(n−1)+F(n−2)

Fibonacci সিরিজ একটি সংখ্যা সিরিজ যেখানে প্রথম দুটি সংখ্যা 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

ব্যাখ্যা:

• Base Cases: n এর মান 0 হলে, fibonacci(0) 0 রিটার্ন করে। n এর মান 1 হলে, fibonacci(1) 1 রিটার্ন করে।
• Recursive Case: অন্য যেকোনো ক্ষেত্রে, 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 পদ্ধতির ব্যবহার অধিক কার্যকরী।