What is the difference between iteration and recursion?

Difference between Iteration and Recursion?

Recursion and iteration are just two different code structures with the same end result: Execution of a set of sequential instructions repeatedly.

The emphasis of Iteration: The repeated execution of some groups of code statements in a program until a task is done.

The emphasis of recursion: Here we solve the problem via the smaller sub-problems till we reach the trivial version of the problem i.e. base case.

Comparison: Iteration vs Recursion

Which is better: Iteration or Recursion?

Sometime finding the time complexity of recursive code is more difficult than that of Iterative code. (Think!)
Recursion has a large amount of overhead as compared to Iteration. It is usually much slower because all function calls must be stored in a stack to allow the return back to the caller functions. Iteration does not involve any such overhead.
Infinite recursion can lead to CPU crash because infinite recursive calls may occur due to some mistake in base condition, which on never becoming false, keeps calling the function, which may lead to system CPU crash.
Infinite iteration due to mistake in iterator assignment or increment, or in the terminating condition, will lead to infinite loops, which may or may not lead to system errors, but will surely stop program execution any further.
Every recursion can be modeled as a kind of loop, that's what the CPU will ultimately do. And the recursion itself, more directly, means putting the function calls and scopes in a stack. But changing your recursive algorithm to a looping one might need a lot of work and make your code less maintainable.

If recursion is usually slower then what is the technical reason for using it over iteration?

Because some algorithms are hard to solve it iteratively. Try to solve the depth-first search both recursively and iteratively. You will get the idea that it is plain hard to solve DFS with iteration. Try to write Merge sort iteratively. It will take you quite some time.
It's more intuitive in many cases when it mimics our approach to the problem. For example, Data structures like trees are easier to explore using recursion (or would need stacks in any case)

Comparative Examples

We will now see the code of following questions implemented as both recursion and iteration to help you better see the difference

Example 1: Finding nth Fibonacci number

Recursive Code

int fib(int n)
{
    if(n <= 1)
    {
        return n
    }
    return fib(n-1) + fib(n-2)
}

Iterative Code

int fib(int n)
{
    if( n <= 1 )
        return n
    a = 0, b = 1
    for( i = 2 to n )
    {
        c = a + b
        a = b
        b = c
    }
    return c
}

Complexity Analysis

Time complexity of recursive code = O(2^n)
Time Complexity of iterative code = O(n)
Space Complexity of recursive code = O(n) (for recursion call stack)
Space Complexity of iterative code = O(1)

Critical ideas to think!

Here recursive algorithm is a little difficult to analyse and inefficient in comparison with the iterative algorithms.

Example 2: In-order traversal of a binary tree

Recursive Code

void inorderRecursive(Node root)
{
    if( root == NULL )
        return
    inorderRecursive(node.left)
    print(root.data)
    inorderRecursive(node.right)
}

Iterative Code

void inorderIterative(Node root) 
{ 
    Node current, pre 
  
    if (root == NULL) 
        return
  
    current = root
    while (current != NULL) { 
  
        if (current.left == NULL) { 
            print(current.data)
            current = current.right
        } 
        else 
        { 
            pre = current.left
            while (pre.right != NULL && pre.right != current) 
                pre = pre.right
            if (pre.right == NULL) 
            { 
                pre.right = current
                current = current.left 
            } 
            else
            { 
                pre.right = NULL 
                print(current.data)
                current = current.right
            }
        }
    }
}

Critical Ideas to think

Worst-case time and space complexities of both the approaches are nearly same but the recursive approach looks intuitive, clean and easy to understand.
The iterative code is longer with complex flow and implementation. The complex part in the iteration is the stack maintenance which is done by the compiler in recursion.

Example 3: Insertion Sort

Recursive Code

void insertionSortRecursive(int A[], int n) 
{ 
    if (n <= 1) 
    insertionSortRecursive(A, n-1)
    int last = A[n-1]
    int j = n-2
    while (j >= 0 && A[j] > last) 
    { 
        A[j+1] = A[j]
        j-- 
    } 
    A[j+1] = last
}

Iterative Code

void insertionSort(int A[], int n)  
{  
    int i, key, j
    for (i = 1 to n-1) 
    {  
        key = A[i]
        j = i - 1
        while (j >= 0 && A[j] > key) 
        {  
            A[j + 1] = A[j]
            j = j - 1
        }  
        A[j + 1] = key
}

Complexity Analysis

Time complexity of recursive code = O(n)
Time Complexity of iterative code = O(n)
Space Complexity of recursive code = O(n) (for recursion call stack)
Space Complexity of iterative code = O(1)

Critical ideas to think!

Here the recursive algorithm is difficult to analyse and less intuitive to think. It includes the overhead of function calls and recursion call stack.
The Iterative approach looks intuitive, clean and easy to understand.