Тонкости быстрой сортировки

//Функция должна разделять массив на два подмассива - левый и правый.
//В левом подмассиве должны содержаться все элементы массива, меньшие или равные partition.
//В правом подмассиве должны содержаться все элементы массива, большие partition.
// Функция возвращает индекс массива, который служит начальным элементом правого подмассива.
int section(double* array, int size, double partition)
{
    double* head = array;
    double* tail = array + size - 1;
    do 
    {
        while (head < tail && *head <= partition)
            ++head;
        while (tail > head && *tail > partition)
            --tail;
        if (head < tail)
        {
            double temp = *head;
            *head= *tail;
            *tail = temp;
        }
    } while (head < tail);
    return head - array;
}

void QuickSort (int *a, int l, int r)
{
            int i, j;
            int x, buf;
            i = l;
            j = r;
            x = a[(l+r)/2];
            do
            {
                while (a[i] < x)
                   i++;
                while (x < a[j])
                   j--;
                if (i <= j)
                {
                    buf = a[i];
                    a[i] = a[j];
                    a[j] = buf;
                    i++;
                    j--;
                }
            } while( i <= j);
            if (l < j) QuickSort (a, l, j);
            if (r > i) QuickSort (a, i, r);
}

void quick_sort_asc(double* array, int size) //Быстрая сортиировка массива в возрастающе порядке
{
    switch (size)
    {
        case 1: //Приммитивный случай
            return;
        case 2: //Приммитивный случай
            if (array[0] > array[1])
            {
                double temp = array[0];
                array[0] = array[1];
                array[1] = temp;
                return;
            }
        default: //Основная работа
            double* head = array;
            double* tail = array + size - 1;
            double partition = array[0];
            
            do 
            {
                while (head < tail && *head <= partition)
                    ++head;
                while (tail > head && *tail > partition)
                    --tail;
                if (head < tail)
                {
                    double temp = *head;
                    *head= *tail;
                    *tail = temp;
                }
            } while (head < tail);
 
            //Левый подмассив состоит из одного элемента, стоящего на своем  месте (Если)
            if (head == array + 1) 
            {
                quick_sort_asc(array + 1, size - 1);
                break;
            }
            //Левый подмассив включает все элементы массива, кроме может быть последнего (Если)
            //Ведь указатель tail не двигался
            if  (head == array + size - 1)
            {
                if (*head <= array[0]) //Левый подмассив включает все элементы массива, а его первый элемент максиальный (Если)
                                              //Значит надо поставить его на последнее место
                {   
                    double temp = array[0];
                    array[0] = *head;
                    *head = temp;
                }
                quick_sort_asc(array, size - 1);
                break; //Хорошо, что мы находимся внутри switch
            }
            //Если пришли сюда значит оба указателя head и tail находятся внутри массива
            quick_sort_asc(array, head - array);
            quick_sort_asc(tail, size - (head - array));
    }
}

double a[ARRSIE] = {6.2, 5.4, 1.2, 9.4, 100.4, 9.5, 2.1, 1.4, 5.5, 5.9};
 
double a[ARRSIE] = {100, 99, 34, 9, 5.4, 4.2, 4.1, 3.4, 2.5, 2.5};
 
double a[ARRSIE] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
double a[ARRSIE] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};

array[0]

double partition = array[0];

array[size - 1], array[size / 2]

for (int count = 0; count < 32000; ++count)
    {
        int lo = count;
        for(int i = 0; i < ARRSIE; ++i)
            a[i] = arr[lo++];
        QuickSort (a, 0, ARRSIE - 1);
        for (int i = 0; i < ARRSIE; ++i)
        {
            cout << a[i] << '\t';
        }
    }