Let me explain by way of an example. There is a function called "factorial"
and it has results like this:
  factorial(0) == 1
  factorial(1) == 1
  factorial(2) == 1 * 2
  factorial(3) == 1 * 2 * 3
  factorial(4) == 1 * 2 * 3 * 4
  factorial(5) == 1 * 2 * 3 * 4 * 5
  ...

The best way to implement this function is NOT through recursion. However
there is a simple recursive implementation which can be useful to help
beginners to understand how recursion works.

  int factorial(int n)
  {
    if(n == 0)
    {
      return 1;
    }
    else
    {
      return n * factorial(n - 1);
    }
  }

Here are the steps of decomposition that you can follow if you evaluate
each recursive call by hand.
  factorial(5)
  5 * factorial(4)
  5 * 4 * factorial(3)
  5 * 4 * 3 * factorial(2)
  5 * 4 * 3 * 2 * factorial(1)
  5 * 4 * 3 * 2 * 1 * factorial(0)
  5 * 4 * 3 * 2 * 1 * 1

First make sure you can get your head around a simple example before trying
to understand a quicksort :-)

Sort the first part of the array, then return here and sort the
other half of the array (that's mainly it, apart from the code
that determines where the division between the two parts is to
be made).

1. Run the program.
2. Study the output, using the code as a guide.
3. If you do not yet understand it, execute Algorithm A.
4. Apply what you have just learned to the question you originally
asked.
5. Stop.

#include <stdio.h>

void printspace(int n)
{
  int space = 0;

  while(space++ < n)
  {
    putchar(' ');
  }

  if(i < 10)
  {
    recurse(i + 1);
  }

  printspace(i * 3);
  printf("This is the last print in recurse(): i is %d\n", i);

  return 0;