Сортировка Хоара (быстрая сортировка) по убыванию

#include <stdio.h>
#include <stdlib.h>
// Функция быстрой сортировки
void quickSort(int *numbers, int left, int right)
{
  int pivot; // разрешающий элемент
  int l_hold = left; //левая граница
  int r_hold = right; // правая граница
  pivot = numbers[left];
  while (left < right) // пока границы не сомкнутся
  {
    while ((numbers[right] >= pivot) && (left < right))
      right--; // сдвигаем правую границу пока элемент [right] больше [pivot]
    if (left != right) // если границы не сомкнулись
    {
      numbers[left] = numbers[right]; // перемещаем элемент [right] на место разрешающего
      left++; // сдвигаем левую границу вправо
    }
    while ((numbers[left] <= pivot) && (left < right))
      left++; // сдвигаем левую границу пока элемент [left] меньше [pivot]
    if (left != right) // если границы не сомкнулись
    {
      numbers[right] = numbers[left]; // перемещаем элемент [left] на место [right]
      right--; // сдвигаем правую границу вправо
    }
  }
  numbers[left] = pivot; // ставим разрешающий элемент на место
  pivot = left;
  left = l_hold;
  right = r_hold;
  if (left < pivot) // Рекурсивно вызываем сортировку для левой и правой части массива
    quickSort(numbers, left, pivot - 1);
  if (right > pivot)
    quickSort(numbers, pivot + 1, right);
}
int main()
{
  int a[10];
  // Заполнение массива случайными числами
  for (int i = 0; i<10; i++)
    a[i] = rand() % 20 - 10;
  // Вывод элементов массива до сортировки
  for (int i = 0; i<10; i++)
    printf("%d ", a[i]);
  printf("\n");
  quickSort(a, 0, 9); // вызов функции сортировки
            // Вывод элементов массива после сортировки
  for (int i = 0; i<10; i++)
    printf("%d ", a[i]);
  printf("\n");
  getchar();
  return 0;
}

#include <functional>
#include <algorithm>
#include <iterator>
 
template< typename BidirectionalIterator, typename Compare >
void quick_sort( BidirectionalIterator first, BidirectionalIterator last, Compare cmp ) {
  if( first != last ) {
    BidirectionalIterator left  = first;
    BidirectionalIterator right = last;
    BidirectionalIterator pivot = left++;
 
    while( left != right ) {
      if( cmp( *left, *pivot ) ) {
         ++left;
      } else {
         while( (left != --right) && cmp( *pivot, *right ) )
           ;
         std::iter_swap( left, right );
      }
    }
 
    --left;
    std::iter_swap( first, left );
 
    quick_sort( first, left, cmp );
    quick_sort( right, last, cmp );
  }
}
// для вещественных
 
int partition (double *a, int p, int r)
 
 {
   double x = *(a+r);
   int i = p - 1;
   int j;
   double tmp;
   for (j = p; j < r; j++)
   {
     if (*(a+j) <= x)
     {
       i++;
       tmp = *(a+i);
       *(a+i) = *(a+j);
       *(a+j) = tmp;
     }
   }
   tmp = *(a+r);
   *(a+r) = *(a+i+1);
   *(a+i+1) = tmp;
   return i + 1;
 }
 
void quicksort (double *a, int p, int r)
 
 {
   int q;
   if (p < r)
   {
     q = partition (a, p, r);
     quicksort (a, p, q-1);
     quicksort (a, q+1, r);
   }
 }
template< typename BidirectionalIterator >
inline void quick_sort( BidirectionalIterator first, BidirectionalIterator last ) {
  quick_sort( first, last,
    std::less_equal< typename std::iterator_traits< BidirectionalIterator >::value_type >()
  );

unsigned __int64 func(unsigned __int64 n)
{
  if (n == 0)
    return 1;
  else if (n == 1)
    return 2;
  else
    return func(n - 1) + 3 * func(n - 2);
}