There are many ways to categorize a recursive function. Listed below are
some of the most common.

####
Linear Recursive

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.

Another example of a linear recursive function would be one to compute the
square root of a number using Newton's method (assume `EPSILON` to be
a very small number close to 0):

`
double my_sqrt(double x, double a)
{
double difference = a*x-x;
if (difference < 0.0) difference = -difference;
if (difference < EPSILON) return(a);
else return(my_sqrt(x,(a+x/a)/2.0));
}
`

####
Tail recursive

Tail recursion is a form of linear recursion. In tail recursion, the
recursive call is the last thing the function does. Often, the value of
the recursive call is returned. As such, tail recursive functions can
often be easily implemented in an iterative manner; by taking out the
recursive call and replacing it with a loop, the same effect can generally
be achieved. In fact, a good compiler can recognize tail recursion and
convert it to iteration in order to optimize the performance of the code.

A good example of a tail recursive function is a function to compute the
GCD, or Greatest Common Denominator, of two numbers:

`
int gcd(int m, int n)
{
int r;
if (m < n) return gcd(n,m);
r = m%n;
if (r == 0) return(n);
else return(gcd(n,r));
}
`

####
Binary Recursive

Some recursive functions don't just have one call to themself, they have
two (or more). Functions with two recursive calls are referred to as
binary recursive functions.