Add files via upload

Author: prathimacode-hub

15 Algorithms - Recursion.ipynb

@@ -0,0 +1,205 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "83b2b8de",
+   "metadata": {},
+   "source": [
+    "# Recursion\n",
+    "\n",
+    "Recursion in Python is a programming technique where a function calls itself within its own definition. This approach is used to solve problems that can be broken down into smaller, self-similar subproblems. \n",
+    "\n",
+    "Key Concepts:\n",
+    "Base Case:\n",
+    "A condition that stops the recursion. Without a base case, the function would call itself infinitely, leading to a stack overflow error.\n",
+    "Recursive Case:\n",
+    "The part of the function where it calls itself with a modified input, working towards the base case.\n",
+    "How it Works:\n",
+    "A recursive function is called with an initial input.\n",
+    "The function checks for the base case. If the base case is met, it returns a value, stopping the recursion.\n",
+    "If the base case is not met, the function executes the recursive case, calling itself with a modified input.\n",
+    "This process continues until the base case is reached, and the results of each recursive call are combined to produce the final output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "243d91de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def factorial(n):\n",
+    "  if n == 0:  # Base case: factorial of 0 is 1\n",
+    "    return 1\n",
+    "  else:       # Recursive case: n! = n * (n-1)!\n",
+    "    return n * factorial(n-1)\n",
+    "\n",
+    "print(factorial(5)) # Output: 120"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66c502ca",
+   "metadata": {},
+   "source": [
+    "Types of Recursion:\n",
+    "    \n",
+    "Direct Recursion: A function directly calls itself.\n",
+    "Indirect Recursion: A function calls another function, which in turn calls the first function. \n",
+    "    \n",
+    "Advantages:\n",
+    "Can provide elegant and concise solutions for certain problems.\n",
+    "Can simplify complex algorithms by breaking them into smaller subproblems.\n",
+    "\n",
+    "Disadvantages:\n",
+    "Can be less efficient than iterative solutions due to function call overhead.\n",
+    "Can lead to stack overflow errors if the recursion depth is too large.\n",
+    "May be harder to understand and debug compared to iterative approaches.\n",
+    "\n",
+    "Use Cases:\n",
+    "Tree traversals (e.g., depth-first search).\n",
+    "Mathematical problems (e.g., factorial, Fibonacci sequence).\n",
+    "Parsing hierarchical data structures (e.g., XML, JSON).\n",
+    "Divide-and-conquer algorithms (e.g., quicksort, mergesort)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a1db9ee3",
+   "metadata": {},
+   "source": [
+    "Recursion involves a function calling itself directly or indirectly to solve a problem by breaking it down into simpler and more manageable parts. In Python, recursion is widely used for tasks that can be divided into identical subtasks.\n",
+    "\n",
+    "In Python, a recursive function is defined like any other function, but it includes a call to itself. The syntax and structure of a recursive function follow the typical function definition in Python, with the addition of one or more conditions that lead to the function calling itself."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8806d749",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def factorial(n):\n",
+    "    if n == 0:\n",
+    "        return 1\n",
+    "    else:\n",
+    "        return n * factorial(n-1)\n",
+    "\n",
+    "print(factorial(5))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f2a9ef37",
+   "metadata": {},
+   "source": [
+    "Explanation: The factorial of a number n (denoted as n!) is the product of all positive integers less than or equal to n. The recursive approach involves the function calling itself with a decremented value of n until it reaches the base case of 1.\n",
+    "\n",
+    "Let's understand recursion in python deeply:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "65163d30",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def recursive_function(parameters):\n",
+    "\n",
+    "    if base_case_condition:\n",
+    "\n",
+    "        return base_result\n",
+    "\n",
+    "    else:\n",
+    "\n",
+    "        return recursive_function(modified_parameters)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23bb548a",
+   "metadata": {},
+   "source": [
+    "Base Case and Recursive Case\n",
+    "Base Case: This is the condition under which the recursion stops. It is crucial to prevent infinite loops and to ensure that each recursive call reduces the problem in some manner. In the factorial example, the base case is n == 1.\n",
+    "Recursive Case: This is the part of the function that includes the call to itself. It must eventually lead to the base case. In the factorial example, the recursive case is return n * factorial(n-1)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0f6d02bd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fibonacci(n):\n",
+    "    if n == 0:\n",
+    "        return 0\n",
+    "    elif n == 1:\n",
+    "        return 1\n",
+    "    else:\n",
+    "        return fibonacci(n-1) + fibonacci(n-2)\n",
+    "\n",
+    "print(fibonacci(10))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "64d4ce84",
+   "metadata": {},
+   "source": [
+    "Explanation:\n",
+    "\n",
+    "Base Cases: If n == 0, the function returns 0. If n == 1, the function returns 1. These two cases are necessary to stop the recursion.\n",
+    "Recursive Case: The function calls itself twice with the decrements of n (i.e., fibonacci(n-1) and fibonacci(n-2)), summing the results of these calls. This division into smaller subproblems continues until the base cases are reached."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8dc2e8b",
+   "metadata": {},
+   "source": [
+    "Recursion vs Iteration\n",
+    "\n",
+    "Recursion:\n",
+    "Recursion is often more intuitive and easier to implement when the problem is naturally recursive, like tree traversals.\n",
+    "It can lead to solutions that are easier to understand compared to iterative ones.\n",
+    "\n",
+    "Iteration:\n",
+    "Iteration involves loops (for, while) to repeat the execution of a block of code.\n",
+    "It is generally more memory-efficient as it does not involve multiple stack frames like recursion.\n",
+    "\n",
+    "Advantages of using recursion\n",
+    "Simplicity: Recursive code is generally simpler and cleaner, especially for problems inherently recursive in nature (e.g., tree traversals, dynamic programming problems).\n",
+    "Reduced Code Length: Recursion can reduce the length of the code since the repetitive tasks are handled through repeated function calls.\n",
+    "Disadvantages of using recursion\n",
+    "Memory Overhead: Each recursive call adds a new layer to the stack, which can result in significant memory use, especially for deep recursion.\n",
+    "Performance Issues: Recursive functions may lead to slower responses due to overheads like function calls and returns.\n",
+    "Risk of Stack Overflow: Excessive recursion can lead to a stack overflow error if the recursion depth exceeds the stack limit."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}