Recursion involves calling a function from within itself. It has two phases - the winding phase where the function keeps calling itself, and the unwinding phase where the calls return back once the base case is reached. Recursion can be used to calculate things like factorials, sums, and powers by defining a base case and a general recursive case that calls itself with a reduced problem. Examples provided calculate factorials and powers recursively.

1. RECURSION

2. How recursion works?

3. Writing a Recursive Function
• Identification of base case and its solution: the case where solution
can be achieved without recursion.
• Identification of general case or recursive case: the case in which
recursive call will be made.
• Winding and 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.

5. Example: Sum of Natural Numbers Using
Recursion

7. Factorial
• n!= 1 * 2* 3*…..*(n-1)*n
• Let n=5, 5!=5*4*3*2*1
• 5!=5*4!
• similarly, 4!=4*3!, 3!=3*2! , 2!=2*1!
• In general n!=n*(n-1)!
• Recursion,
• 1 n=0
• n!=
• n*(n-1)! N>0

8. #include<stdio.h>
long int factorial(int n);
int main(void)
{ int num;
printf("Enter a number: ");
scanf("%d", &num);
if(num<0)
printf (“no factorial for negative number”);
else
printf("%d! = %ld", num, factorial(num)); // signal to operating system program ran fine
return 0;
}
long int factorial(int n)
{
if(n==0) // base condition
return 1;
else
return n * factorial(n-1);
}

9. Let's say we want to calculate factorial of 5.
main() calls factorial(5)
since 5 != 0 - factorial(5) calls factorial(4)
since 4 != 0 - factorial(4) calls factorial(3)
since 3 != 0 - factorial(3) calls factorial(2)
since 2 != 0 - factorial(2) calls factorial(1)
since 1 != 0 - factorial(1) calls factorial(0)
When factorial() is called with n = 0, if condition becomes true and
recursion stops and control returns to factorial(1).
From now on every called function will return a value to the previous
function in reverse order of function calls.

10. C program to calculates the power of a number using recursion.

11. Arrays as functions arguments