advantage:using recursion we can avoid unnecessary calling 
of functions.
disadvantage:by too many recursive functions there may be 
confusion in the code.

Advantages:
Through Recursion one can Solve problems in easy way while
its iterative solution is very big and complex.
Ex : tower of Hanoi 
You reduce size of the code when you use recursive call.

Disadvantages :
Recursive solution is always logical and it is very
difficult to trace.(debug and understand)

Before each recursive calls current values of the varibles
in the function is stored in the PCB, ie process control
block and this PCB is pushed in the OS Stack. 
So sometimes alot of free memory is require for recursive
solutions.

Remember : whatever could be done through recursion could be
done through iterative way but reverse is not true.

advantages ;
recursive functions can be effectively used to solve 
problems where the solution is expressed in terms of 
applying the same solution.
disadvantages ;
in recursive we must have an if statement somewhere to 
force the func. to return without the recursive call being 
executed.otherwise the funct. will never return.

Advantage :

Recursion is used to divide the problem into same problem 
of subtypes and hence replaces complex nesting code.

Disadvantage :

Recursion takes a lot of stack space, usually not 
considerable when the program is small and running on a PC.

It is very hard to debug or extend the functionality in 
case of recursive logic.

advantage:using recursion we can avoid unnecessary callingof
functions.
disadvantage:recursive calling increase the space complexity.

Why is recursion frowned upon??

User space programs: memory consumption
----------------------------------------
User stack is a dynamic stack i.e. we page fault on the 
stack virtual addresses and resolve the fault by allocating 
a physical page. Many recursions can lead to a lot of (user 
stack) memory being consumed. In a traditional programming 
model, when a thread blocks, then all the memory is stuck 
with the thread, until the paging daemon kicks it out. So, 
effectively, many threads doing recursive calls can consume 
a lot of memory and force memory pressure to occur in the 
system i.e. system slows down.
 
Kernel Space program: stack depth
---------------------------------
A kernel stack is fixed in size i.e. 8K or 16K usually. And 
this stack does not grow dynamically in most OSes. So, 
there is a bound on how much memory can be used for the 
kernel stack, unlike user programs. But, this bound on the 
stack size is the reason why recursion is discouraged. More 
recursive levels can lead to a stack overflow and this will 
panic the box. One might say: hey, my recursive depth is 
only 10. But, what is unknown is what amount of kernel 
stack is already used up && the stack frame consumption 
depends on the chip architecture that is being used.
 
For both of the above reasons, recursion is avoided in 
general kernel programming.

Use of recursion in an algorithm has both advantages and 
disadvantages. The main advantage is usually simplicity. 
The main disadvantage is often that the algorithm may 
require large amounts of memory if the depth of the 
recursion is very large. High memory consumption is due to 
large function call number (recursion means that function 
calls itself multiple times).

the advantage of recursion is      
1). by using this tag we call a function continuosly uptill 
to specific condion

by using this tag we call a function continuosly uptill 
to specific condion

advantage : A recursive definition defines an object in simpler cases of itself reducing nested looping complexity

disadvantage : less efficient as compared to the non-recursive counterparts as the overhead involved in entering,re-entering and exiting a block is avoided in case of the non recursive forms. its also possible to identify a number of local variables which need not be saved and restored with the help of stacks and this unwanted stacking activity is avoided in the non-recursive versions.

disadvantage:
Recursive procedures are huge memory hogs. Also, they're a 
nightmare to debug. Finally, it's pretty rare to find an 
application that actually needs recursion as opposed to a 
simpler, more friendly methodolgy.