Provide an explanation of recursion,

including an example.
Here we will try to explain recursion as simply as possible, without getting into the extremely
theoretical and mathematical aspect of it. We want to provide a practical explanation that
would be easy to understand so think of this as an easy to understand tutorial on recursion (for
beginners or dummies). Defining recursion is easy any routine that calls itself is a
recursive routine. You may be more familiar with the term method or function, but we use
routine since that encompasses both. Although the definition of recursion is simple, using and
understanding recursion is difficult so you will need to read this article with patience and you
will (hopefully) understand it.

What is recursion used for?

Recursion is best used for problems where a large task can be broken down into a repetitive
sub-task. Because a recursive routine calls itself to perform those sub-tasks, eventually the
routine will come across a sub-task that it can handle without calling itself. This is known as a
<bbase case and it is needed to prevent the routine from calling itself over and over again
without stopping. So, one can say that the base case stops the recursion. </b

Base cases and Recursion

In the base case, the routine does not call itself. But, when a routine does have to call itself in
order to complete its sub-task, then that is known as the <brecursive case. So, there are 2 types
of cases when using a recursive algorithm: <bbase cases and recursive cases. This is very
important to remember when using recursion, and when you are trying to solve a problem you
should ask yourself: What is my base case and what is my recursive case?. </b</b

Example of recursion in Java the factorial

Lets start out with a simple example of recursion to best illustrate how it works: the factorial is
probably the most commonly used example. What is a factorial? Well, any number written like
this: x! is said to be the factorial of x. A factorial of a number x is just the product of all
integers between 1 and x. So, if x is equal to the number 5, then the factorial of x would be
5*4*3*2*1, which equals 120. We could also say that the factorial of is equal to 5 multiplied by
the factorial of 4, which would be 5 * 4!, or 5*4*3*2*1 So, the factorial of any number x
could also be defined as:

x! = x * (x - 1)!

And, something else that is important to know is the fact that the factorial of 0 is equal to 1 as is
the factorial of 1.
0! = 1! = 1

Breaking down the factorial to find the recursive case

Note how we defined the factorial of a number as that number multiplied by the factorial of the
integer that is 1 less than the number (x * (x-1)! ). So, what we have done is essentially break the
problem down into a sub-task, and in order to find the factorial of a number we just keep finding
the factorials of the integers below that number and multiplying. So, the factorial of 3 is equal to
3 multiplied by the factorial of 2 and the factorial of 2 is equal to 2 multiplied by the factorial of
1. So, if we have a function called factorial that is meant to find the factorial of a given number
then our code for the recursive case would look something like:

function factorial (x) {

return (x * factorial(x-1) ) ;
}

Where x is the number whose factorial we want to find. And that is what recursion is all about
finding repetitive patterns, and breaking a problem down into repetitive sub-tasks.

Finding the base case to stop the recursion in factorial

But, there is still one issue we seem to have found a recursive case, in which the routine will
call itself, but what about the base case? Remember that we must have both a recursive case and
a base case. The base case is what will stop the routine from calling itself infinitely, and will stop
the recursion.

Think about this what do you think would be a good base case for this problem when does it
make sense to stop the recursion? Well, it turns out that the base case would occur when the
factorial function hits a value of 1 because at that point we know the factorial of 1 is 1, so we
should stop right there. And, it doesnt make sense to allow the function to find the factorial of
numbers less than 1, since the factorial is defined for integers between x and 1.

So, heres what the Java code for our recursive factorial method would look like:

public int factorial (int x)

{
if (x > 1)
{
//recursive case:
return factorial(x-1) * x;
}

else /*base case*/

return 1;

}
Call Stacks, Recursion, and Stack Frames
A call stack is a data structure used by the program to store information about the active
subroutines (like functions in C++ or methods in Java) in a program. The main reason for
having a call stack is so that the program can keep track of where a subroutine should return
control to once it finishes executing. For example, suppose we have a method CreateBox
which calls another method CreateLine in 4 different places. If the program has finished
executing the method CreateLine, then it needs to know where in the CreateBox method it needs
to return to. This is why the program uses a call stack so that it can keep track of these details.

A call stack is composed of stack frames

A stack frame is a part of the call stack, and a new stack frame is created every time a subroutine
is called. So, in our recursive Factorial method above, a new stack frame is created every time
the method is called. The stack frame is used to store all of the variables for one invocation of a
routine. So, remember that a call stack is basically a stack of stack frames.

Stack Frames in Recursion

A diagram of how the stack frames work in recursion will really help to clarify things so lets
take a look at one. Lets suppose that we try to find the factorial of 3 using the function that we
created above (so x is equal to 3), this is what the stack frames would look like:

You can see that the first stack frame is created with x equal to 3. And then a call to Factorial(2)
is made so the first call to Factorial(3) does not run to completion because another call
(Factorial(2)) is made before the very first call to Factorial can run to completion. A stack frame
is used to hold the state of the first call to Factorial it will store the local function
variables (and their values) of the current invocation of Factorial, and it will also store the
return address of the method that called it (since we are talking about the very first non-
recursive invocation of Factorial, whatever routine invoked Factorial in the first place is where
Factorial would return when it is completely done with everything) . Because the stack frame
also stores the return address, the Factorial function knows where to return to when it finishes
running.

Finally, in the 3rd stack frame, we run into our base case, which means the recursive calls are
finished and then control is returned to the 2nd stack frame, where Factorial(1) * 2 is calculated
to be 2, and then control is returned to the very first stack frame. Finally, our result of 6 is
returned.

Without a base case in recursion the stack overflows

What would happen if there were no base case in our example above? Well, recursive calls will
be made continuously, and each time a recursive call is made a new stack frame is created.
Every new stack frame created needs more memory, which then means that there is less memory
on the call stack. The call stack has limited memory, which is usually determined at the start of
the program and when that limited memory is exceeded then the stack is said to overflow,
which will usually result in the program crashing. So, if we did not have a base case, then the
stack would overflow.

Conclusion
Hopefully, this article helped you understand recursion better. Now, if you would like to read
some more interview questions that have to do with recursion then continue on in this section, or
you can read one of our personal favorites right here: Recursion Interview Question.

Factorial program in c using recursion

#include<stdio.h>

long factorial(int);

int main()
{
int n;
long f;

printf("Enter an integer to find factorial\n");

scanf("%d", &n);

if (n < 0)
 printf("Negative integers are not allowed.\n");
else
{
f = factorial(n);
printf("%d! = %ld\n", n, f);
}

return 0;
}

long factorial(int n)
{
if (n == 0)
return 1;
else
return(n * factorial(n-1));
}

Recursion is a technique in which a function calls itself, for example in above code factorial
function is calling itself. To solve a problem using recursion you must first express its solution in
recursive form.

C program to Calculate Factorial of a

Number Using Recursion
This program takes a positive integer from user and calculates the factorial of that number.
Instead of loops to calculate factorial, this program uses recursive function to calculate the
factorial of a number.

Source Code to Calculate Factorial Using Recursion

/* Source code to find factorial of a number. */

#include<stdio.h>
int factorial(int n);
int main()
{
int n;
printf("Enter an positive integer: ");
scanf("%d",&n);
printf("Factorial of %d = %ld", n, factorial(n));
return 0;
}
int factorial(int n)
{
if(n!=1)
return n*factorial(n-1);
}

Output

Enter an positive integer: 6

Factorial of 6 = 720

Source Code to Calculate Factorial Using Recursion

/* Source code to find factorial of a number. */

#include<stdio.h>
int factorial(int n);
int main()
{
int n;
printf("Enter an positive integer: ");
scanf("%d",&n);
printf("Factorial of %d = %ld", n, factorial(n));
return 0;
}
int factorial(int n)
{
if(n!=1)
return n*factorial(n-1);
}