What is the difference between looping and recursion?

Answer 1

Both Iteration and Recursion run a part of an algorithm repeatedly. We typically use them when, in a part of an algorithm, we have to do or calculate something (i,e. the logic remains the same though the data changes) for a certain number of times. However,in Recursion, we simply run a loop for a certain number of times in the algorithm, such as printing a statement ten times is recursion. In Iteration, we specifically run a loop, such that, the second run of the loop makes use of the computation/result from the first run, the third run (or iteration) makes use of the result from the second run and so on. Hence, in Iteration, the n th run of the loop makes use of the result from the n-1 th run. Consider the following example for calculating the summation, which we will denote as sum(n), meaning n + n-1 + n-2 + n-3 + ... + 2 + 1 + 0. Hence, sum(5) = 5+4+3+2+1+0 = 15. Now we will write psuedo-code to calculate the sum(n) using Iteration and Recursion. Iterative Version:- ----------------- start sum(n) { i = 0; total = 0; do while i is not greater than n, { total = total + i; i = i + 1; } return total; } Recursive Version:- ----------------- start sum(n) { if n is equal to 0, then return(0); otherwise, return (n + sum(n - 1)); } Notice that the Iterative version calculates the sum by repeatedly accumulating the sum in the variable total. In contrast, the recursive version simply repeatedly calls itself, each time with a decremented value.

.

Answer 2

A recursive function works through the process of calling itself until a condition is met.

e.g. While creating Fibonacci series or

calculating multiple of a number

We simply call the function repeatedly.

Iteration uses a looping control structure (while, do while, for) to repeat a section of code until a condition is met.

Frankly, Anything done in one style of looping, can be done in the other.

Answer 3

Some problems are easier to solve with recursion, even if the easier solution is often the less effective. Example: Calculating the Fibonacci numbers.

Recursive:

int Fib (int n)

{

if (n<=2) return 1;

else return Fib (n-1)+Fib (n-2);

}

Iterative

int Fib (int n)

{

int f1=1, f2=1, j;

for (j=2; j<n; ++j) {

tmp = f1;

f1= f2;

f2= f2+tmp;

}

return f2;

}

Answer 4

Recursion and iteration are two different ways to solve a problem by executing the same code repeatedly. Generally, the code will repeatedly perform the exact same algorithm upon some data, changing that data in some way until some exit condition is satisfied. Recursion is typically used in divide-and-conquer algorithms where a large problem is repeatedly divided into one or more smaller instances of the same problem until each instance is small enough to be resolved. The algorithm then backtracks through the instances, re-combining the smaller solutions into the larger solution until the whole problem is solved. Iteration is typically used for trivial loops where backtracking is not a requirement.

1. Recursion is implemented by calling a function that calls itself whereas iteration uses a structured loop statement (such as for, while or do-while).

2. With iteration there is only one set of local variables involved whereas recursion instantiates a new set of local variables each time the function is invoked.

3. Recursion allows automatic backtracking whereas iteration does not.

4. Recursive algorithms can be inline expanded whereas iterative algorithms cannot.

5. Recursive algorithms can be computed at compile-time whereas iterative algorithms cannot.

6. Although iteration can occasionally be more efficient than recursion, the complexity of the code can hinder readability and increase maintenance costs.

7. If an algorithm is not naturally recursive, iteration is the only option.

8. If an exit condition can never be satisfied, a recursive loop will eventually consume the stack and crash the program, whereas an iterative loop may execute indefinitely.

Answer 5

Mostimpotentdifference between recursion and looping is that,

recursion is based upon 2 basic rules.

1. There must be a base statement on which recursion is to be dependent.

2. At each call ofrecursion, the calling statement must be coming near the base statement.

Looping may or may notfollowtheserules but recursion must follow these rules.

ex

get(int i)

{

if(i = 0)//Base Criteria

return;

else {

cout<

i--;

get(i);//Recursive Call

}
}

void main()

{

int num =5;

get(num);//54321 by recursion

while(num>0)//By looping

{

cout<

num--;//It is Optional, but recomended if we r not requiring infinite looping

}

}

Answer 6

Synonyms.