# What is recursion?

Recursion is a way to write a program where the function calls itself. A function is called recursive if it calls itself directly or indirectly.

When a function calls itself directly:

```
void function1(){
.
.
function1();
}
```

When a function calls itself indirectly:

```
void function1(){
.
.
function2();
}
void function2(){
.
.
function1();
}
```

# Applications of recursion:

π― Dynamic programming

π― Backtracking

π― Searching algorithms like Binary search

π― Sorting algorithms like merge sort and quick sort

π― Tree traversals ... etc.

# Is recursion better than iteration?

Even though recursion might look like its better than iteration since the length of the code is less, it is the iteration that is always efficient when it comes to the time complexity of the code. This is because, when recursive code is being compiled, the number of arguments in the function call stack increases and this increases the time complexity of the code.

# Printing 1 to N using Recursion

```
class Test{
static void print1toN(int n)
{
if(n==0)
return;
print1toN(n-1);
System.out.print(n+" ");
}
public static void main(String[] args)
{
int n=10;
print1toN(n);
}
}
```

# Printing N to 1 using Recursion

```
class test{
static void printNto1(int n)
{
if(n==0)
return;
System.out.print(n+" ");
printNto1(n-1);
}
}
public static void main(String args[])
{
int n=10;
PrintNto1(n);
}
```

# Some Recursive problems to explore:

# Basic Problems:

- Fibonacci series using recursion
- Sum of natural numbers using recursion
- Palindrome check using recursion
- Sum of digits using recursion

# Advanced Problems:

- Tower of Hanoi
- Rod cutting problem
- Josephus problem

To get good at recursion, practice is the key. After a significant amount of practice, you'll easily recognize the questions that you can solve using recursion!

To start off, you can practice the above-listed problems on GeeksforGeeks or Leetcode. π©π»βπ»

... to be continued π

keep learning, keep coding! πΈ

## Top comments (3)

Shouldn't the indirect recursion be something like this:

Also Would like to point out the slight error in the 1 to N logic, unless I am wrong it should look something like this:

Other than these things, interesting topic, keep it up...v

Thank you for pointing out the typo!

and regarding the print 1 to N, problem, I did not focus on the base cases, I just wanted to show how recursion works!

Oh no problem. Happy to help π