Sortings 2

void Exchange(int i, int j, int* array)//костыль swap
{
    int tmp;
    tmp = array[i];
    array[i] = array[j];
    array[j] = tmp;
}

void Hoar_Sort(int size, int* array)
{
    Quick_Sort(0, size - 1, array);
}

void Quick_Sort(int left, int right, int* array)
{
    int i, j, m;
    i = left;
    j = right;

    m = array[(i + j + 1) / 2];
    do
    {
        while (array[i] < m && compare1++)
            i++;
        while (array[j] > m && compare1++)
            j--;
        if (i <= j)
        {
            Exchange(i, j, array);
            replace1++;
            i++;
            j--;
        }

    } while (i <= j);
    if (left < j && compare1++) Quick_Sort(left, j, array);
    if (i < right && compare1++) Quick_Sort(i, right, array);
}

void Binary_Pyramid_Sort(int size, int* array)
{
    //преобразование массива в пирамиду
    Build_Pyramid(size / 2 + 1, size - 1, array);
    //сортировка пирамиды
    Sort_Piramid(size - 1, array);
}

void Build_Pyramid(int size, int r, int* array)
{
    //просеивание элементов пирамиды
    Sifting(size, r, array);
    if (size > 0)
        //рекурсивно вызываем функцию построения
        Build_Pyramid(size - 1, r, array);
}

void Sort_Piramid(int size, int* array)
{
    //переставляем первый элемент пирамиды с последним
    Exchange(0, size, array);
    replace2++;
    //исключаем последний элемент пирамиды
    Sifting(0, size - 1, array);
    //добиваемся того, чтобы массив снова стал пирамидой
    if (size > 1)
        Sort_Piramid(size - 1, array);
}

void Sifting(int left, int right, int* array)
{
    //принцип: каждый потомок должен быть меньше, чем родитель
    int q, p;
    q = 2 * left + 1;  //индекс левого элемента
    p = q + 1;  //индекс правого элемента
    if (q <= right && compare2++)
    {

        if (p <= right && array[p] > array[q] && compare2++)
            q = p;

        if (array[left] < array[q] && compare2++)
        {
            Exchange(left, q, array);
            replace2++;
            Sifting(q, right, array);
        }
    }
}

void BubbleSort(int size, int* array)//сортировка пузырьком
{
    int i, j, buf;
    for (i = size - 1; i > 0; i--)
        for (j = 0; j < i; j++)
        {
            compare3++;
            if (array[j] > array[j + 1])
            {
                buf = array[j];
                array[j] = array[j + 1];
                array[j + 1] = buf;
                replace3++;
            }
        }
}

void Shaker(int k, int* x)//шейкерная сортировка
{
    int i, t;
    bool exchange;
    do {
        exchange = false;
        for (i = k - 1; i > 0; --i) {
            if (x[i - 1] > x[i]) {
                t = x[i - 1];
                x[i - 1] = x[i];
                x[i] = t;
                exchange = true;

            }
        }

        for (i = 1; i < k; ++i) {
            if (x[i - 1] > x[i]) {
                t = x[i - 1];
                x[i - 1] = x[i];
                x[i] = t;
                exchange = true;

            }
        }
    } while (exchange);
}

void InsertSort(int k, int* x)//вставками
{
    int i, j, temp;
    for (i = 0; i < k; i++) {
        //цикл проходов, i - номер прохода
        temp = x[i];
        //поиск места элемента
        for (j = i - 1; j >= 0 && x[j] > temp; j--)
            x[j + 1] = x[j];//сдвигаем элемент вправо, пока не дошли
            //место найдено, вставить элемент
        x[j + 1] = temp;
    }
}

void Shell(int size, int* a)//Сортировка Шелла
{
    int step = size / 2;//инициализируем шаг.
    while (step > 0)//пока шаг не 0
    {
        for (int i = 0; i < (size - step); i++)
        {
            int j = i; //будем идти начиная с i-го элемента
            while (j >= 0 && a[j] > a[j + step])
    //пока не пришли к началу массива
    //и пока рассматриваемый элемент больше
    //чем элемент находящийся на расстоянии шага
            {
                //меняем их местами
                int temp = a[j];
                a[j] = a[j + step];
                a[j + step] = temp;
                j--;
            }
        }
        step = step / 2;//уменьшаем шаг
    }
}

void Quick_Sort(int* mas, int first, int last)//быстрая сортировка Хоара
{
    int mid, count;
    int f = first, l = last;
    mid = mas[(f + l) / 2]; //вычисление опорного элемента
    do
    {
        while (mas[f] < mid) f++;
        while (mas[l] > mid) l--;
        if (f <= l) //перестановка элементов
        {
            count = mas[f];
            mas[f] = mas[l];
            mas[l] = count;
            f++;
            l--;
        }
    } while (f < l);
    if (first < l) Quick_Sort(mas, first, l);
    if (f < last) Quick_Sort(mas, f, last);
}