## When we call a function from its own body, it is known as recursion and the function is called a recursive function. The most relevant example of recursion in real life will be two parallel mirrors facing each other. Java supports recursive function calls. The call may be direct or indirect; usually, when more than one function is involved, the call is considered to be indirect. If the recursive call is made implicitly, we call it “anonyms recursion.”In recursion, we use a stack store, all the called functions.

Most of us are familiar with functions; they can be defined as blocks of code that are executed

only when they are called. The primary advantage of a function is that it ensures code re-usability. Functions can be both in-built or user-defined. The implementation of function involves three main steps: Function declaration, function definition and function call. The return type of a function must also be specified while declaring it.

A stack is a data structure that follows the LIFO implementation. This means that the last function call will be executed fist, and the return value will be stored until all the functions present in the stack are cleared. The graph traversal problems are best handled with the help of recursion.

Writing recursive functions reduces the time complexity of code significantly and also reduces

the developer’s time required to write and debug the code. However, recursion increases the overall space complexity of a thread, As all the function calls have to be stored in a stack and

during execution, the returned value from each function also adds to the memory requirements.

For each recursive problem, there is an iterative alternate.

The basic arithmetic programs that are used for learning recursion are the Fibonacci series, power of a number, factorial of a number, etc. Some problems in which recursion is used conventionally are searching and sorting algorithms, Breadth-first search, Tower of Hanoi, Graph traversal strategies: In-order, Pre-order and Post-order, etc.

There are three main steps for implementing recursion:

**Step One: Base case generation**

We provide the solution of the smallest possible input and express the higher inputs in terms of

the smaller cases. The terminating case is known as the base case. For one code, there can be

more than one test case. We break large problems into multiple smaller problems. We compute

the final result by combining the output of all the problems that we store in the stack. While choosing the base case, we must keep in mind that it should be reachable. If the base case is not reachable, infinite function calls will be stored in the stack, and stack overflow will take place,

and ultimately our thread will be dumped, or the system will crash. If the base case is incorrect as the test cases will fail, hence this step must be carried out with utmost care.

**For Example:** To find the nth Fibonacci term (0,1,1,2,3,5,8…….)

We use the formula:

Fib(n)=Fib(n-1)+ Fib(n-2)

To compute the 3rd term of the series, we can add the first and second terms. Therefore, we need the value of the first two terms to compute the series. We have to provide a solution for n=0 and n=1. Here,n=0 and n=1 are the base cases.

**Step Two: Problem-solving methodology**

Like in the problem of Fibonacci numbers, we used the addition operator to combine the outputs and decrement operator to change the value of the parameter. We assume that some part of the solution will be given by recursion, and for the remaining part, we have to write the code in the function’s body. A problem-solving algorithm must be constructed logically so that the output is according to our requirements. Most of these algorithms are based on the principle of mathematical induction that, if a statement says P(n) is true for n=1,n=k, and n=k+1, then it is true for all values of n. Generally, first, a recurrence relation is created, and then it is implemented using programming languages.

A relationship between the base case and the higher values must be derived so that the base

case is reached. After each function call, there should be an appropriate change in the parameters, based on our requirement. We must analyse which parameters require a change. It

is not mandatory to change all the parameters. Always dry run the code using some test cases to check the logic or presence of bugs. We have to include constraints for handling duplicates and exceptions. In some cases, the recursive call is made first, whereas, in others, the calculation

part is done first. The order of the steps are totally specific to the problem statement and the output required.

**Step Three: Recursive Call**

The recursive call should be necessarily made to call the function again. A recursive call can be

made in two ways: from the function itself, directly or by using a helper function, indirectly. The

recursive call is made multiple times till the base is reached. All the recursive calls made are

stored in a stack, in the order in which they are called. The return value is given in the reverse

order as the stack uses the LIFO approach. The number of recursive calls should be minimised,

as a higher number of recursive calls required higher stack memory. We must make sure that

our code doesn’t lead to an infinite number of recursive calls. There are some codes that end

with a recursive call. They can be placed anywhere in code, depending upon the problem

statement.

**Types of Recursion:**

As mentioned already, recursion is of two types, namely direct and indirect recursion. Indirect

recursion is also known as mutual recursion. Direct recursion can be categorised into six different types, depending upon the number or position of the function call:

**Linear Recursion**: In linear recursion, each function calls itself once only.

Example: Linear Search, Power of a number, Print n numbers, factorial of a number, etc.

**Binary Recursion**: In binary recursion, each non-base case calls the function twice.

Example: Search In a Binary Search Tree, Fibonacci numbers, etc.

**Tree Recursion: **In Tree recursion, each function calls itself multiple times. The parameters of each call are generally different.

Example: Searching an element in a Generic Tree Tree, Merge Sort, Quick Sort, etc.

**Head Recursion**: With respect to the order of statements in a function, if the recursive call is the first statement of the code, it is said that you have implemented head recursion.

Example:

int head_recur(int n)

{

if(n=0)

{

//The function begings with a recursive call

head_recur(n-1);

}

System.out.printf(n);

}

**Tail Recursion: **With respect to the order of statements in a function, if the recursive call is the last statement of the code, it is said that you have implemented tail recursion.

Example:

int tail_recur(int n)

{

if(n=0)

{

System.out.printf(n);

}

//The function ends with a recursive call

tail_recur(n-1);

}

**Nested Recursion**: It can be basically defined as “recursion within the recursion.”This signifies that one of the parameters of the initial recursive function is computed with the help of recursion. A separate function may be created for computing the values of the recursive parameters. Depending on the number of recursive functions, the number of stacks required is decided. The use of nested recursion should be minimised to reduce the memory application.**Example: **Ackerman’s function, which shows us that total computable functions are not

primitive recursive.

**Recursive V/S iterative Approach:**

**Time Complexity**

Recursion reduces the time complexity of code significantly. When the rum time of the thread is

our priority, then we must use recursion only. Every iterative code can be converted into a recursive code. There are very few exceptions, in which we can’t write a recursive alternate for an iterative code.

**Space Complexity**

Recursive codes have a higher space complexity than the iterative codes of the same problem.

Each function call and its return value is stored in the stack until the base case is reached. All

this data requires a very high memory. If a proper base case is not reached, this may even cause a stack overflow, and core will be dumped. After the execution of a recursive function, the memory needs to be deallocated.

**Code Clarity**

Recursive codes are preferred over iterative codes as they are more concise. Generally, recursive codes are smaller than iterative codes in terms of LOC(Line of Code). This helps in-code documentation and maintenance also.

**Debugging**

Recursive codes are easy to debug as they are well structured. They reduce the developer’s time

significantly. Many times it happens that one developer writes the code, and the other updates

it; using recursion helps in writing concise and easy to debug codes.

**Output**

When it comes to computational power, the recursive and iterative approach, both stand in the

same place. Both have the capability to solve any problem if coded logically.

**System Malfunctioning**

If recursive algorithms are not well designed, they made lead to StackOverflow. They have a higher tendency to cause system failure than iterative codes.

To read more about Java, click here.

**By Vanshika Singolia**

Nicely written & done my friend!

I’ve only just beegun writing in the last few

days and realized lot off people merely rehash old content

but add very little of value. It’s great tto read

a helpful artyicle of some true value to me and your readers.

It’s goinng down on my list of details I need

to emulate being a new blogger. Visitor engagement and content quality are king.

Many terrific suggestions; you’ve definitelky

made it on my list of people to follow!

Keep up the fantastic work!

Alll the best,

Alexandrina

Thanks for sharing your thoughts on python. Regards