What is a recursion in computer science?

Recursion in computer science is a method where the solution to a problem depends on

solutions to smaller instances of the same problem (as opposed to iteration).
Most computer programming languages support recursion by allowing a function to call itself
within the program text.
A proper recursive function must always have a base case. The base case is used to terminate
the task of recurring. If base case is not defined, then the function will recur infinite number of
times.
Recursion is a process in which problem is defined in terms of itself. In C, a function can call
itself. A function that calls itself is called a recursive function. Recursion is often termed as
“circular definition”.

Let's take a simple example:

int main()
{
rec();
...
return 0;
}

void rec()
{
statement
1;
...
rec();
}
In the beginning main() function called rec(), then inside rec() function, it called itself again. As
you can guess this process will keep repeating indefinitely. So, in a recursive function, there
must be a terminating condition to stop the recursion. This condition is known as the base
condition.

int main()
{
callme();
}

void callme()
{
if(base_condition)
{
// terminating
condition
}
statement 1;
...
callme();
}
Often recursion can be used where loops can be used. Generally, recursive solutions are elegant
but less efficient than loop solutions. So why use recursion at all? because some algorithms can
be implemented more clearly and easily using recursion like quicksort.

The recursive function works in two phases:

1. Winding phase.
2. Unwinding phase.
Winding phase: In Winding phase, the recursive function keeps calling itself. This phase ends
when the base condition is reached.
Unwinding phase: When the base condition is reached, unwinding phase starts and control
returns back to the original call.
Let's take an example:

Example 1:

#include<stdio.h>
void rec();

int main()
{
rec(1);

// signal to operating system program ran

fine
return 0;
}

void rec(int n)
{
printf("Winding phase: Level = %d\n", n);

if(n<3)
{
rec(n+1);
}

printf("Unwinding phase: Level = %d\n",

n);
}
Expected Output:

Winding phase: Level =

1
Winding phase: Level =
2
Winding phase: Level =
3
Unwinding phase: Level
= 3
Unwinding phase: Level
= 2
Unwinding phase: Level
= 1

Difference between Recursion and Iteration:

Iteration uses a repetition statement whereas recursion does repetition through repeated
function calls.
Iteration terminates when the loop condition fails whereas recursion terminates when the base
became true.

Advantages of Recursion:
Recursion provides a clean and simple way to write code.
Some problems are inherently recursive like tree traversals, Tower of Hanoi, etc. For problems,
it is preferred to write recursive code.
Using recursion, the length of the program can be reduced.

Disadvantages of Recursion:
Recursive programs are generally slower than non-recursive programs because it needs to
function call, so the program must save all its current state and retrieve them again later,
consumes more time making recursive programs slower.
Recursive programs require more memory to hold intermediate states in a stack. Non-programs
don’t have any intermediate states; hence they don’t require any extra memory.
If the programmer forgets to specify the exit condition in the recursive function, the program
execute out of memory.
Types of Recursion
There are many ways to categorize a recursive function. Listed below are some of
the most common.
Linear recursion
A linear recursive function is a function that only makes a single call to itself each time the
function runs (as opposed to one that would call itself multiple times during its execution). The
factorial function is a good example of linear recursion.
OR
It is the most commonly used recursion, where a function calls itself in simple manner and a
terminating condition is used to terminate the recursion.
long factorial(int n)
{
int f;
if(n==1) /* terminating condition */
return 1;
f=n*factorial(n-1); /* calling function itself */
return f;
}

Tail recursion
Tail recursion is a form of linear recursion. In tail recursion, the recursive call is the last thing
the function does. A good example of a tail recursive function is a function to compute the GCD,
or Greatest Common Denominator, of two numbers:
Binary Recursion
As name suggests, in binary recursion a function makes two recursive calls to itself when
invoked, it uses binary recursion. Fibonacci series is a very nice example to demonstrate binary
recursion. See the example below:
fib (1) = fib (2) = 1
 fib (n) = fib (n-1) + fib (n-2), if n > 2

Multiple Recursion
Multiple recursion can be treated a generalized form of binary recursion. When a function
makes multiple recursive calls possibly more than two, it is called multiple recursion.
Mutual recursion:
Calling two or more functions mutual is called mutual recursion. Say for example, if function A is
calling B and function B is calling A recursively then it is said that, they are in mutual recursion.
Nested recursion:
When a recursive method has a parameter defined in terms of itself then it is called nested
recursion
#include<stdio.h>
int main()
{
int a,b,c,d,s;
printf("Enter four integers:\n");
scanf("%d%d%d%d",&a,&b,&c,&d);
s=sum(sum(sum(sum(a,b),c),d));
printf("Sum of four numbers %d",s);
return 0;
}
int sum(int x,int y)
{
return x+y;
}

Direct and Indirect Recursion

When in the body of a method there is a call to the same method, we say that the method
is directly recursive.
If method A calls method B, method B calls method C, and method C calls method A we call the
methods A, B and C indirectly recursive or mutually recursive.
Direct recursion occurs when a method invokes itself. Indirect recursion occurs when a method
invokes another method, eventually resulting in the original method being invoked again.