Can this code be called Recursion. If not, which is more advanatgeous, given below code or recursion?

Question

1. I am having difficulty finding how recursion works. Some text books says that "Recursion is when a function calls itself again and again until some base condition is satisfied".

2. Some books says that "Recursion is when a function calls another function again and again till some base condition is satisfied".

3. Which is true? If both are true, can we consider below given example as a Recursion? If NO, then which is better in terms of performance,

   below code or recursion?

---

    def Function1()
    {
        /* do something */
    }

    def Function2()
    {
        for(i=0; i<=10; i++)
        {
             call Function1()
        }
    }

Answer 1

As it is, the code shows iterative calls to Function1(), if within the body of Function1() there is a call to Function2(), then it would be an indirect recursion - a function calling second function, which then calls the first again.

In general, a recursive function calls itself, either directly or indirectly. In direct recursion function, foo(), makes another call to itself. In indirect recursion, function foo() makes a call to function moo(), which in turn calls function foo(), until the base case is reached. (and then, the final result is accumulated in the exact reverse order of the initial recursive function call.)

Now, to answer your question:

Can this code be called Recursion. If not, which is more advanatgeous, given below code or recursion?

No. Iteration lacks multiple activation records (or stack frames), which makes it a better alternative.

Answer 2

Recursion should be used according to requirement and when you know the base condition and don't know how many times your loop should be called. Recursion can be of different types like there can be normal recursion, infinite recursion, indirect recursion etc. A normal recursion means calling the same function itself until a base condition is satisfied An infinite recursion is where there will not be any base condition. An indirect recursion is like when a calls b and b calls c and c calls back a then 'a' is being called indirectly.

Example of basic recursion:

foo() 
{
    base_condition;
        return;
    foo();
}
main()
{
    foo();
}

Your example base condition can be variable equals runs for 10 times.

fun(int x)
{
    if(x == 0)
        return;
    fun(--x);
}
main
{
    fun(10);
}

Please look into the below URL for performance criteria.

performance between looping and recursion

Answer 3

Let me put the pieces together: The code you provided could be recursive or it couldn't. This depends on the fact whether Function1 calls Function2. If this is the case, then you would have a mutual exclusion recursion, as pointed out by EOF.

However, this is a case that does not occur as often as normal recursion (except in pure functional environments). A normal recursion simply consists of a function which calls itself (insteaf of another function).

For further explanations and an introduction how, e. g., the recursive factorial works, see here.

Answer 4

Recursion is when

The control flow passes from a function into the very same function (directly or indirectly) repeatedly without returning first.

In your example, Function1is repeatedly called from Function2, but does return from each call before being called again, so it's not recursively called.

Answer 5

Recursion is when a function calls itself, either directly or indirectly.

Normally in the C-like languages we use recursion only when the data is tree-like. For example, you have a tree consisting of nodes, with a "next" member to indicate siblings and a "child" member to indicate children (maybe it's an XML file, or a directory tree). You want the the number of nodes so

int getNodes(Node root)
{
    int answer = 1;
    for(sib = root.next; sib != null; sib = sib.next)
    {
       answer += 1;
       if(sib.child != null)
          answer += getNnodes(sib.child);
    }
    if(node.child != null)
       answer += getNodes(node.child);
    return answer;
}

You can make the code a bit neater but less efficient by return 0 if root == null.

However you can use recursion for iteration. Think of it as delivering letters to a street. You can go down the street removing letters from your sack (iteration). Or you can deliver letters to the first house in the street, declare the street to be one house shorter, and repeat until the street disappears (recursion). The latter seems eccentric, but it has some advantages for automatic checking of algorithm correctness. If you forget to increment it you can't get stuck in an infinite loop, for example.

Answer 6

Recursion occurs when a thing is defined in terms of itself or of its type. Recursion is used in a variety of disciplines ranging from linguistics to logic. The most common application of recursion is in mathematics and computer science, where a function being defined is applied within its own definition. While this apparently defines an infinite number of instances (function values), it is often done in such a way that no loop or infinite chain of references can occur.

Source.

So, if you have a foo and in order to calculate or execute foo, you need to recur to foo at least once more, then you have a recursion. Example:

n! = 1 * 2 * 3 * ... * n

This is an iterative definition:

int fact(n) {
    int ret = 1;
    int i = 1;
    while (++i < n) ret *= i;
    return ret;
}

This is a recursive definition:

int fact(n) {
    return (n == 1) ? 1 : (n * fact(n - 1));
}

Since your code calculates Function2 with multiple usages of Function1, it is not recursive, since you did not need to call Function2 in order to evaluate Function2, nor did you need to call Function1 in order to evaluate Function1. Recursion occurs when something is its own dependency, while your code has a function which depends on another function. Your question about performance is next to impossible to answer, since there are infinite ways to implement a thing with or without recursion, when you compare a recursive approach with a non-recursive approach, then you need to have concrete implementations, or at least very strict ideas of how the two cases would be implemented. However, in general it is a good idea to prefer non-recursive approaches, as recursive approaches often have problems with the stack part of the memory, including stack overflow or infinite function calls and crashes due to bugs.