Let's sort the following array of ten integers:

[6 24 80 4 19 84 1 10 13 7]

Let's choose our pivot to arbitrarily be the first 
element, a 6. In addition, let's create two 
pointer iterators to walk through the array looking 
for things to swap--one from the beginning and the 
other from the end. We'll call these variable p, m, 
and n.

Thus:

 p
[6 24 80 4 19 84 1 10 13 7]
   m                     n

If array[m] is greater than array[p] and array[n] is 
less than array[p] we'll simply swap array[m] and 
array[n]. If one of the conditions matches, and 
the other doesn't we'll just keep moving the pointers 
until we can do a swap:

 p
[6 24 80 4 19 84 1 10 13 7]
   m             n        

Swap:

 p
[6 1 80 4 19 84 24 10 13 7]
   m             n        

Advance pointers:

 p
[6 1 80 4 19 84 24 10 13 7]
     m  n

Swap again:

 p
[6 1 4 80 19 84 24 10 13 7]
     m  n

Advance pointers:

 p
[6 1 4 80 19 84 24 10 13 7]
     n m

Now we see that our pointers have crossed each other. 
At this point we can safely move our pivot to where n is. 
This will put the pivot item in its final position in 
the sorted array:

     p
[4 1 6 80 19 84 24 10 13 7]


At this point, everything before p is less than array[p] 
and everything after p is greater that array[p]. Now 
we just need to sort both halves. To sort the first half, 
we don't need to make a call to quicksort--that would be 
a waste of time since it's only a few elements in length. 
Instead, we can use a more elementary sorting algorithm, 
like selection sort, which will yield the following array:

     p     
[1 4 6 80 19 84 24 10 13 7]

we also need to sort the array after p. For this we 
will call quicksort recursively on that part. I'll rewrite 
the array to show only what we're interested in and we'll 
again choose the first element as the pivot:

 p     
[80 19 84 24 10 13 7]
       m           n

I've already moved m to the first element greater 
than array[p], and the last element less than array[p] 
is the last element in the array. We can then swap those:

 p     
[80 19 7 24 10 13 84]
       m           n

You'll notice that there are no more swaps that will occur 
in this step, and our pointers will cross like this:

 p     
[80 19 7 24 10 13 84]
               n  m

We can then swap p and n, giving us:

               p     
[13 19 7 24 10 80 84]

We obviously do not need to sort the right hand side, 
but the left hand could use a little work:

 p                   
[13 19 7 24 10]
    m       n
               
 p                   
[13 10 7 24 19]
    m       n

 p                   
[13 10 7 24 19]
       n m

       p                   
[7 10 13 24 19]


Each side of this can be easily sorted using selection 
sort (or similar), giving:

[7 10 13 19 24]

If then look at the whole array we've sorted in pieces, we'll have:

[1 4]6[7 10 13 19 24]80[84] -- perfectly sorted!

public class Array
{
    int[] array;
    int numItems;

    public Array(int size) 
    {
        array=new int[size];
        numItems=0;
    }
    public void Add(int i) 
    {
        array[numItems++]=i;
    }
}

    private int Pivot(int beg, int end)
    {
        //set pivot to beginning of array
        int p=array[beg];
        //m also starts at beginning
        int m=beg;
        //n starts off end (we'll decrement it before it's used)
        int n=end+1;
        do 
        {
            m=m+1;
        } while (array[m]<=p && m<end);//find first larger element
        do 
        {
            n=n-1;
        } while (array[n] >p);//find last smaller element
        //loop until pointers cross
        while (m<n) 
        {
            //swap
            int temp=array[m];
            array[m]=array[n];
            array[n]=temp;
            //find next values to swap
            do 
            {
                m=m+1;
            } while (array[m]<=p);
            do 
            {
                n=n-1;
            } while (array[n] >p);
        }
        //swap beginning with n
        int temp2=array[n];
        array[n]=array[beg];
        array[beg]=temp2;
        return n;// n is now the division between two unsorted halves
    }

    private void SelectionSort(int beg, int end) 
    {
        for (int i=beg;i<end;i++) 
        {
            int minj=i;        
            int minx=array[i];
            for (int j=i+1;j<=end;j++) 
            {
                if (array[j]<minx) 
                {
                    minj=j;
                    minx=array[j];
                }                
            }
            array[minj]=array[i];
            array[i]=minx;
              
        }
    }

    public void Sort() 
    {
        QuickSort(0,array.numItems-1);
    }
    private void QuickSort(int beg, int end) 
    {
        if (end==beg) return;
        if (end-beg<9) //an arbitrary limit to when we call selectionsort
            SelectionSort(beg,end);
        else 
        {
            int l=Pivot(beg,end);
            QuickSort(beg,l-1);
            QuickSort(l+1,end);
        }
    }

    public void Dump() 
    {
        foreach(Object o in array)
            System.Console.Write(o.ToString()+ " ");
        System.Console.WriteLine("");
    }

class MainClass
    {
    [STAThread]
    static int Main(string[] args)
    {
        if (args.Length==0) 
        {
            Console.WriteLine("You must enter an integer to specify array size.");
            return 1;
        }
        int size=Convert.ToInt32(args[0]);
        Array array=new Array(size);
        Random r=new Random();
        for (int i=0;i<size;i++)
            array.Add(r.Next(size));
        array.Dump();
        array.Sort();
        array.Dump();
        return 0;
    }
}