diff --git a/docs/dsa/recursion/_category_.json b/docs/dsa/recursion/_category_.json
new file mode 100644
index 000000000..1af68bcf8
--- /dev/null
+++ b/docs/dsa/recursion/_category_.json
@@ -0,0 +1,8 @@
+{
+ "label": "Recursion",
+ "position": 10,
+ "link": {
+ "type": "generated-index",
+ "description": "In data structures, The process in which a function calls itself directly or indirectly is called recursion and the corresponding function is called a recursive function. Using a recursive algorithm, certain problems can be solved quite easily. "
+ }
+}
diff --git a/docs/dsa/recursion/recursion.md b/docs/dsa/recursion/recursion.md
new file mode 100644
index 000000000..ff8563344
--- /dev/null
+++ b/docs/dsa/recursion/recursion.md
@@ -0,0 +1,249 @@
+---
+id: recursion-in-dsa
+title: Recursion in Data Structures and Algorithms
+sidebar_label: Recursion
+sidebar_position: 3
+description: "Recursion is a programming technique where a function calls itself directly or indirectly to solve a problem. It is used in various applications such as solving mathematical problems, implementing data structures, and more."
+tags:
+ [
+ dsa,
+ algorithms,
+ recursion,
+ recursive-functions,
+ recursion-in-dsa,
+ recursion-in-algorithm,
+ recursion-in-dsa-example,
+ recursion-in-dsa-explanation,
+ recursion-in-dsa-conclusion,
+ recursion-in-dsa-importance,
+ recursion-in-dsa-syntax,
+ recursion-in-dsa-implementation,
+ recursion-in-dsa-applications,
+ recursion-in-dsa-problems,
+ recursion-in-dsa-solutions,
+ recursion-in-dsa-code,
+ recursion-in-dsa-js,
+ recursion-in-dsa-java,
+ recursion-in-dsa-python,
+ recursion-in-dsa-c,
+ recursion-in-dsa-cpp,
+ recursion-in-dsa-ts,
+ ]
+---
+
+Recursion is a programming technique where a function calls itself directly or indirectly to solve a problem. It is used in various applications such as solving mathematical problems, implementing data structures, and more.
+
+## Why is Recursion important?
+
+Recursion is important because it provides a simple and elegant way to solve complex problems. It allows problems to be broken down into smaller, more manageable subproblems, making it easier to understand and implement solutions.
+
+## How to implement Recursion?
+
+Recursion can be implemented in various programming languages using the following syntax:
+
+## Recursive Function Structure
+
+```python
+def recursive_function(parameters):
+ if base_condition(parameters):
+ return base_case_value
+ else:
+ return recursive_function(modified_parameters)
+```
+
+## Examples of Recursive Functions
+
+### Factorial
+
+
+
+
+ ```js
+ function factorial(n) {
+ if (n === 0) {
+ return 1;
+ }
+ return n * factorial(n - 1);
+ }
+ ```
+
+
+
+ ```java
+ public class RecursionExample {
+ public static int factorial(int n) {
+ if (n == 0) {
+ return 1;
+ }
+ return n * factorial(n - 1);
+ }
+ }
+ ```
+
+
+
+ ```python
+ def factorial(n):
+ if n == 0:
+ return 1
+ return n * factorial(n - 1)
+ ```
+
+
+
+ ```c
+ int factorial(int n) {
+ if (n == 0) {
+ return 1;
+ }
+ return n * factorial(n - 1);
+ }
+ ```
+
+
+
+ ```cpp
+ int factorial(int n) {
+ if (n == 0) {
+ return 1;
+ }
+ return n * factorial(n - 1);
+ }
+ ```
+
+
+
+ ```ts
+ function factorial(n: number): number {
+ if (n === 0) {
+ return 1;
+ }
+ return n * factorial(n - 1);
+ }
+ ```
+
+
+Fibonacci
+
+
+
+ ```js
+ function fibonacci(n) {
+ if (n <= 1) {
+ return n;
+ }
+ return fibonacci(n - 1) + fibonacci(n - 2);
+ }
+ ```
+
+
+
+ ```java
+ public class RecursionExample {
+ public static int fibonacci(int n) {
+ if (n <= 1) {
+ return n;
+ }
+ return fibonacci(n - 1) + fibonacci(n - 2);
+ }
+ }
+ ```
+
+
+
+ ```python
+ def fibonacci(n):
+ if n <= 1:
+ return n
+ return fibonacci(n - 1) + fibonacci(n - 2)
+ ```
+
+
+
+ ```c
+ int fibonacci(int n) {
+ if (n <= 1) {
+ return n;
+ }
+ return fibonacci(n - 1) + fibonacci(n - 2);
+ }
+ ```
+
+
+
+ ```cpp
+ int fibonacci(int n) {
+ if (n <= 1) {
+ return n;
+ }
+ return fibonacci(n - 1) + fibonacci(n - 2);
+ }
+ ```
+
+
+
+ ```ts
+ function fibonacci(n: number): number {
+ if (n <= 1) {
+ return n;
+ }
+ return fibonacci(n - 1) + fibonacci(n - 2);
+ }
+ ```
+
+
+
+## Applications of Recursion
+
+1. Mathematical computations: Factorial, Fibonacci series, power functions, etc.
+2. Data structures: Tree and graph traversals.
+3. Algorithm design: Divide and conquer algorithms like merge sort and quicksort.
+4. Dynamic programming: Recursive definitions with memoization.
+5. Common Recursive Problems
+6. Tower of Hanoi: Moving disks between rods following specific rules.
+7. Permutations and combinations: Generating all possible arrangements or selections.
+8. Backtracking: Solving puzzles and constraint satisfaction problems.
+
+## Advanced Recursive Techniques
+
+1. Tail Recursion: A special form of recursion where the recursive call is the last statement in the function. Optimized by compilers to prevent stack overflow.
+2. Memoization: Caching the results of expensive function calls to improve performance.
+
+## Resources and References
+
+### Books:
+
+1. "Introduction to Algorithms" by Cormen, Leiserson, Rivest, and Stein
+2. "The Art of Computer Programming" by Donald Knuth
+
+### Online Courses:
+
+1. Coursera: Data Structures and Algorithms Specialization
+2. edX: Algorithms and Data Structures
+
+### Websites:
+
+1. GeeksforGeeks
+2. LeetCode
+3. HackerRank
+
+By understanding and mastering these recursion concepts and techniques, you will be well-equipped to tackle a wide range of problems in data structures and algorithms.
+
+## Conclusion
+
+Recursion is a powerful technique in computer science that enables elegant and efficient solutions to complex problems. This guide covers the essential concepts and applications of recursion, providing a comprehensive understanding of how to implement and utilize recursive functions in different programming languages.
+
+Understanding recursion is crucial for solving numerous problems in computer science, from basic mathematical computations to complex algorithm design. The examples provided demonstrate how to work with recursion effectively, ensuring a robust foundation for tackling more advanced DSA concepts. Mastery of recursion enhances your ability to handle algorithmic challenges and perform operations crucial in both everyday programming and competitive coding.
+
+## Problems for Practice
+
+To further practice and test your understanding of recursion, consider solving the following problems from LeetCode:
+
+1. Fibonacci Number
+2. Climbing Stairs
+3. Permutations
+4. Subsets
+5. Combination Sum
+
+
+ Engaging with these problems will help reinforce the concepts learned and provide practical experience in using recursion effectively. By practicing these problems, you will enhance your problem-solving skills and deepen your understanding of recursive algorithms in various contexts.
diff --git a/docs/dsa/recursion/recursionVsIteration.md b/docs/dsa/recursion/recursionVsIteration.md
new file mode 100644
index 000000000..84d0b0067
--- /dev/null
+++ b/docs/dsa/recursion/recursionVsIteration.md
@@ -0,0 +1,157 @@
+---
+id: recursion-vs-iteration-in-dsa
+title: Difference between Recursion and Iteration in Data Structures and Algorithms
+sidebar_label: Recursion vs Iteration
+sidebar_position: 3
+description: "Understanding the differences between recursion and iteration is crucial for selecting the appropriate approach for solving various problems in data structures and algorithms. This guide highlights the key differences, advantages, and use cases of both recursion and iteration."
+tags:
+ [
+ dsa,
+ data-structures,
+ algorithms,
+ recursion,
+ iteration,
+ recursion-vs-iteration,
+ recursion-in-dsa,
+ iteration-in-dsa,
+ recursion-vs-iteration-in-dsa,
+ recursion-vs-iteration-examples,
+ recursion-vs-iteration-differences,
+ recursion-vs-iteration-advantages,
+ recursion-vs-iteration-disadvantages,
+ recursion-vs-iteration-usage,
+ ]
+---
+
+Understanding the differences between recursion and iteration is crucial for selecting the appropriate approach for solving various problems in data structures and algorithms. This guide highlights the key differences, advantages, and use cases of both recursion and iteration.
+
+## Introduction
+
+### Recursion
+
+Recursion is a technique where a function calls itself in order to solve a smaller instance of the same problem until a base case is reached. Recursive solutions can be elegant and easy to understand but may come with performance overheads due to repeated function calls.
+
+### Iteration
+
+Iteration involves using loops (such as for, while, or do-while) to repeat a block of code until a certain condition is met. Iterative solutions are often more efficient in terms of memory usage and execution time compared to recursion, but they can be less intuitive for problems that have a naturally recursive structure.
+
+## Key Differences
+
+| Feature | Recursion | Iteration |
+| ------------ | ------------------------------------------------------ | ------------------------------------------- |
+| Definition | Function calls itself | Loop repeatedly executes block of code |
+| Termination | Base case | Loop condition |
+| Memory Usage | Uses call stack, can lead to stack overflow | Uses constant or linear memory |
+| Readability | Often more readable for problems with recursive nature | Can be less readable for complex conditions |
+| Performance | Higher overhead due to function calls | Generally more efficient |
+| Use Cases | Divide and conquer, tree and graph traversal | Simple loops, repetitive tasks |
+
+## Examples
+
+### Factorial Calculation
+
+#### Recursion
+
+```python
+def factorial(n):
+ if n == 0:
+ return 1
+ else:
+ return n * factorial(n - 1)
+```
+
+#### Iteration
+
+```python
+def factorial(n):
+ result = 1
+ for i in range(1, n + 1):
+ result *= i
+ return result
+```
+
+### Fibonacci Series
+
+#### Recursion
+
+```python
+def fibonacci(n):
+ if n <= 1:
+ return n
+ else:
+ return fibonacci(n - 1) + fibonacci(n - 2)
+```
+
+#### Iteration
+
+```python
+def fibonacci(n):
+ a, b = 0, 1
+ for _ in range(n):
+ a, b = b, a + b
+ return a
+```
+
+## Advantages and Disadvantages
+
+### Recursion
+
+#### Advantages:
+
+ 1. Simplifies the code for problems that have a natural recursive structure.
+ 2. Makes the code easier to write and understand for problems like tree traversals.
+
+#### Disadvantages:
+
+ 1. Can lead to stack overflow if the recursion depth is too large.
+ 2. Generally less efficient in terms of time and space due to function call overhead.
+
+### Iteration
+
+#### Advantages:
+
+ 1. More efficient in terms of memory and execution time.
+ 2. Avoids the risk of stack overflow.
+
+#### Disadvantages:
+
+ 1. Can result in more complex and less readable code for problems with recursive nature.
+ 2. Requires explicit management of loop conditions and state.
+
+## When to Use Recursion vs Iteration
+
+### Use Recursion When:
+
+The problem has a naturally recursive structure (e.g., tree and graph traversal).
+Code readability and simplicity are more important than performance.
+You are dealing with divide-and-conquer algorithms (e.g., quicksort, mergesort).
+
+### Use Iteration When:
+
+Performance and memory efficiency are critical.
+The problem involves simple repetitive tasks or loops.
+You want to avoid the risk of stack overflow for deep recursion.
+
+## Conclusion
+
+Both recursion and iteration are fundamental techniques in data structures and algorithms, each with its own strengths and weaknesses. The choice between recursion and iteration depends on the specific problem at hand, the importance of performance and memory usage, and the need for code readability and simplicity. By understanding the differences and appropriate use cases for each approach, you can make informed decisions in your algorithmic implementations.
+
+## Resources and References
+
+#### Books:
+
+ 1. "Introduction to Algorithms" by Cormen, Leiserson, Rivest, and Stein
+ 2. "Data Structures and Algorithm Analysis in C" by Mark Allen Weiss
+
+#### Online Courses:
+
+ 1. Coursera: Data Structures and Algorithms Specialization
+ 2. edX: Algorithms and Data Structures
+
+#### Websites:
+
+ 1. GeeksforGeeks
+ 2. LeetCode
+ 3. HackerRank
+
+ Understanding and mastering both recursion and iteration will significantly enhance your ability to solve a wide range of problems in data structures and algorithms. This guide provides a comprehensive overview of the differences, advantages, and use cases for each approach, enabling you to make the best choice for your specific needs.
diff --git a/docs/dsa/recursion/recursion_leetcode_questions.md b/docs/dsa/recursion/recursion_leetcode_questions.md
new file mode 100644
index 000000000..3010abf3c
--- /dev/null
+++ b/docs/dsa/recursion/recursion_leetcode_questions.md
@@ -0,0 +1,75 @@
+---
+id: recursion-leetcode-questions
+title: Recursion Leetcode Questions
+sidebar_label: Recursion Leetcode Questions
+sidebar_position: 4
+description: "A collection of 20 Leetcode questions focused on recursion, categorized into easy, medium, and hard levels."
+tags:
+ [
+ dsa,
+ data-structures,
+ algorithms,
+ recursion,
+ leetcode,
+ recursion-leetcode,
+ recursion-leetcode-easy,
+ recursion-leetcode-medium,
+ recursion-leetcode-hard,
+ recursion-leetcode-questions,
+ ]
+---
+
+A collection of 20 Leetcode questions focused on recursion, categorized into easy, medium, and hard levels.
+
+## Easy
+
+1. **[Factorial](https://leetcode.com/problems/factorial)**
+ - Description: Calculate the factorial of a given number using recursion.
+2. **[Fibonacci Number](https://leetcode.com/problems/fibonacci-number)**
+ - Description: Compute the n-th Fibonacci number using recursion.
+3. **[Reverse String](https://leetcode.com/problems/reverse-string)**
+ - Description: Reverse a string using recursion.
+4. **[Sum of Digits of a Number](https://leetcode.com/problems/sum-of-digits-of-a-number)**
+ - Description: Find the sum of digits of a given number using recursion.
+5. **[Power of Three](https://leetcode.com/problems/power-of-three)**
+ - Description: Determine if a number is a power of three using recursion.
+6. **[Climbing Stairs](https://leetcode.com/problems/climbing-stairs)**
+ - Description: Find the number of ways to climb a staircase using recursion.
+7. **[Palindrome Linked List](https://leetcode.com/problems/palindrome-linked-list)**
+ - Description: Check if a linked list is a palindrome using recursion.
+8. **[Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree)**
+ - Description: Find the maximum depth of a binary tree using recursion.
+
+## Medium
+
+1. **[Subsets](https://leetcode.com/problems/subsets)**
+ - Description: Generate all possible subsets of a set using recursion.
+2. **[Permutations](https://leetcode.com/problems/permutations)**
+ - Description: Generate all possible permutations of a sequence using recursion.
+3. **[Unique Binary Search Trees II](https://leetcode.com/problems/unique-binary-search-trees-ii)**
+ - Description: Generate all unique BSTs that store values 1 to n using recursion.
+4. **[Word Search](https://leetcode.com/problems/word-search)**
+ - Description: Search for a word in a 2D grid using recursion.
+5. **[Combination Sum](https://leetcode.com/problems/combination-sum)**
+ - Description: Find all unique combinations of numbers that sum to a target using recursion.
+6. **[Letter Combinations of a Phone Number](https://leetcode.com/problems/letter-combinations-of-a-phone-number)**
+ - Description: Generate all possible letter combinations that a phone number could represent using recursion.
+7. **[Generate Parentheses](https://leetcode.com/problems/generate-parentheses)**
+ - Description: Generate all combinations of well-formed parentheses using recursion.
+
+## Hard
+
+1. **[N-Queens](https://leetcode.com/problems/n-queens)**
+ - Description: Solve the N-Queens problem using recursion.
+2. **[Sudoku Solver](https://leetcode.com/problems/sudoku-solver)**
+ - Description: Solve a given Sudoku puzzle using recursion.
+3. **[Regular Expression Matching](https://leetcode.com/problems/regular-expression-matching)**
+ - Description: Implement regular expression matching with support for '.' and '\*' using recursion.
+4. **[Longest Valid Parentheses](https://leetcode.com/problems/longest-valid-parentheses)**
+ - Description: Find the length of the longest valid parentheses substring using recursion.
+5. **[Interleaving String](https://leetcode.com/problems/interleaving-string)**
+ - Description: Determine if a string is an interleaving of two other strings using recursion.
+
+---
+
+These questions provide a comprehensive overview of recursion techniques and are a great way to practice and improve your recursion skills in data structures and algorithms.