Написать две функции сортировки массива целых чисел, реализующих заданные алгоритмы сортировки – один из класса квадрат

 #include <stdio.h>
#include "stdafx.h" 
#include "iostream" 
#include <stdlib.h> 
#include <time.h> 
int main()
{
    int sort;
    do
    {
        printf("1- Шейкер сортировка\n");
        printf("2- Пирамидальная сортировка\n");
        printf("0-Выход\n");
        scanf("%i\n", &sort);
        if (sort == 0)
            break;
        switch (sort)
        {
        case 1:
        {
            void shekerSort(double *mass, int count);
            {
                double *mass;
                int count;
                int left = 0, right = count - 1; // левая и правая границы сортируемой области массива
                int flag = 1;  // флаг наличия перемещений
                               // Выполнение цикла пока левая граница не сомкнётся с правой
                               // или пока в массиве имеются перемещения
                while ((left < right) && flag > 0)
                {
                    flag = 0;
                    for (int i = left; i < right; i++)  //двигаемся слева направо
                    {
                        if (mass[i] > mass[i + 1]) // если следующий элемент меньше текущего,
                        {             // меняем их местами
                            double t = mass[i];
                            mass[i] = mass[i + 1];
                            mass[i + 1] = t;
                            flag = 1;      // перемещения в этом цикле были
                        }
                    }
                    right--; // сдвигаем правую границу на предыдущий элемент
                    for (int i = right; i > left; i--)  //двигаемся справа налево
                    {
                        if (mass[i - 1] > mass[i]) // если предыдущий элемент больше текущего,
                        {            // меняем их местами
                            double t = mass[i];
                            mass[i] = mass[i - 1];
                            mass[i - 1] = t;
                            flag = 1;    // перемещения в этом цикле были
                        }
                    }
                    left++; // сдвигаем левую границу на следующий элемент
                }
            }
            int main();
            {
                double m[10];
                // Вводим элементы массива
                for (int i = 0; i < 10; i++) {
                    printf("m[%d]=", i);
                    scanf("%lf", &m[i]);
                }
                shekerSort(m, 10); // вызываем функцию сортировки
                                   // Выводим отсортированные элементы массива
                for (int i = 0; i < 10; i++)
                    printf("%.2lf ", m[i]);
                getchar(); getchar();
                return 0;
            }
            break;
        case 2:
        {
            void siftDown(int *numbers, int root, int bottom);
            {
                int *numbers;
                int root;
                int bottom;
                int maxChild; // индекс максимального потомка
                int done = 0; // флаг того, что куча сформирована
                              // Пока не дошли до последнего ряда
                while ((root * 2 <= bottom) && (!done))
                {
                    if (root * 2 == bottom)    // если мы в последнем ряду, 
                        maxChild = root * 2;    // запоминаем левый потомок
                                                // иначе запоминаем больший потомок из двух
                    else if (numbers[root * 2] > numbers[root * 2 + 1])
                        maxChild = root * 2;
                    else
                        maxChild = root * 2 + 1;
                    // если элемент вершины меньше максимального потомка
                    if (numbers[root] < numbers[maxChild])
                    {
                        int temp = numbers[root]; // меняем их местами
                        numbers[root] = numbers[maxChild];
                        numbers[maxChild] = temp;
                        root = maxChild;
                    }
                    else // иначе
                        done = 1; // пирамида сформирована
                }
            }
            // Функция сортировки на куче
            void heapSort(int *numbers, int array_size);
            {
                int *numbers;
                int array_size;
                // Формируем нижний ряд пирамиды
                for (int i = (array_size / 2) - 1; i >= 0; i--)
                    siftDown(numbers, i, array_size - 1);
                // Просеиваем через пирамиду остальные элементы
                for (int i = array_size - 1; i >= 1; i--)
                {
                    int temp = numbers[0];
                    numbers[0] = numbers[i];
                    numbers[i] = temp;
                    siftDown(numbers, 0, i - 1);
                }
            }
            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");
                heapSort(a, 10); // вызов функции сортировки
                                 // Вывод элементов массива после сортировки
                for (int i = 0; i < 10; i++)
                    printf("%d ", a[i]);
                printf("\n");
                getchar();
                return 0;
            }
            break;
        default:
            printf("Не выбран ни один из пунктов текстового меню");
            break;
        }
        }
        system("pause");
        return 0;
        }
    }

#include <iostream>
#include <random>  
#include <ctime>
#include <iomanip>
 
//-------------------------------------------------------------------------------------------------
void fill_array(int* arr, int size);
void print_array(const int* arr, int size);
void shaker_sort(int* arr, int size);
void down_heap(int* arr, int k, int size);
void heap_sort(int* arr, int size);
//-------------------------------------------------------------------------------------------------
int main()
{
    std::cout << "1 - shaker_sort" << std::endl;
    std::cout << "2 - heap_sort" << std::endl;
    std::cout << "0 - exit" << std::endl;
 
    int choice = 0;
    std::cin >> choice;
 
    while (choice != 0)
    {
        std::cout << "Enter the size of the array: ";
        size_t size = 0;
        std::cin >> size;
 
        int* a = new int[size];
 
        switch (choice)
        {
        case 1:
            fill_array(a, size);
            std::cout << "array = ";
            print_array(a, size);
            std::cout << std::endl;
 
            std::cout << "shaker_sort = ";
            shaker_sort(a, size);
            print_array(a, size);
            std::cout << std::endl;
            break;
        case 2:
            fill_array(a, size);
            std::cout << "array = ";
            print_array(a, size);
            std::cout << std::endl;
 
            std::cout << "heap_sort = ";
            heap_sort(a, size);
            print_array(a, size);
            std::cout << std::endl;
            break;
        default:
            choice = 0;
            std::cout << "exit" << std::endl;
            break;
        }
        std::cin >> choice;
        delete[] a;
    }
    return 0;
}
//-------------------------------------------------------------------------------------------------
void shaker_sort(int* arr, int size)
{
    int left = 0;
    int right = size - 1;
    while (left < right)
    {
        for (size_t i = left; i < right; i++)
        {
            if (arr[i + 1] < arr[i])
            {
                std::swap(arr[i], arr[i + 1]);
            }
        }
        right--;
 
        for (size_t i = right; i > left; i--)
        {
            if (arr[i - 1] > arr[i])
            {
                std::swap(arr[i - 1], arr[i]);
            }
        }
        left++;
    }
}
//-------------------------------------------------------------------------------------------------
void down_heap(int* arr, int k, int size)
{
    int new_elem = arr[k];
    int child = 0;
 
    while (k <= size / 2)
    {
        child = 2 * k;
 
        if (child < size && arr[child] < arr[child + 1])
        {
            child++;
        }
        if (new_elem >= arr[child])
        {
            break;
        }
        arr[k] = arr[child];
        k = child;
    }
    arr[k] = new_elem;
}
//-------------------------------------------------------------------------------------------------
void heap_sort(int* arr, int size)
{
    int temp = 0;
 
    for (int i = size / 2 - 1; i >= 0; --i)
    {
        down_heap(arr, i, size - 1);
    }
 
    for (int i = size - 1; i > 0; --i)
    {
        temp = arr[i];
        arr[i] = arr[0];
        arr[0] = temp;
 
        down_heap(arr, 0, i - 1);
    }
}
//-------------------------------------------------------------------------------------------------
void fill_array(int* arr, int size)
{
    std::mt19937 gen(time(0));
    std::uniform_int_distribution<int> uid(0, 100);
    
    for (size_t i = 0; i < size; i++)
    {
        arr[i] = uid(gen);
    }
}
//-------------------------------------------------------------------------------------------------
void print_array(const int* arr, int size)
{
    for (size_t i = 0; i < size; i++)
    {
        std::cout << arr[i] << ' ';
    }
}
//-------------------------------------------------------------------------------------------------