template
inline void quickSort( T* sort, const unsigned size )
{
quickSortHelp( sort, 0, size – 1 );
}

template
void quickSortHelp( T* sort, const unsigned begin, const unsigned end )
{
if ( begin < end )
{
register unsigned L = begin;
register unsigned R = end;

unsigned index = rand() % ( end – begin + 1 ) + begin;

register T pivot = sort[ index ];

swappy( sort[ index ], sort[ end ] );

while ( L < R )
{
while ( sort[ L ] < pivot && L < R )
L++;

if ( L pivot && L < R )
R–;

if ( L < R )
sort[ L++ ] = sort[ R ];
}

sort[ L ] = pivot;

if ( R < 1 )
R++;

quickSortHelp( sort, begin, R – 1 );
quickSortHelp( sort, L + 1, end );
}
}

There is only the iteretive version, but the recursive one can be very easy implemented based on that.

It completely eliminates the need for two more arrays “left” and “right” each time the function calls itself and I belive it is much faster than any other implementation.