Функции - сортировка массива в зависимости от выбора пользователя

#include<iostream>
#include<time.h>
#include<stdlib.h>
using namespace std;
void arr(int arr[], int size, bool dir)
{
    int start, end;
    for (int i = 0; i < size; i++)
    {
        if (arr[i] > 0)
        {
            start = i;
            break;
        }
    }
    for (int i = 0; i < size; i++)
    {
        if (array1[i] > 0)
        {
            end = i;
        }
    }
    int tmp;
    if (dir == true)
    {
        for (int i = start; i >= 0; i--)
        {
            for (int j = 0; j < i; j++)
            {
                if (arr[j] > arr[j + 1])
                {
                    tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
        }
        for (int i = size - 1; i >= end; i--)
        {
            for (int j = end; j < i; j++)
            {
                if (arr[j] > arr[j + 1])
                {
                    tmp= arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
        }
    }
    else 
    {
        for (int i = start; i >= 0; i--)
        {
            for (int j = 0; j < i; j++)
            {
                if (arr[j] < arr[j + 1])
                {
                    tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
        }
        for (int i = size - 1; i >= end; i--)
        {
            for (int j = end; j < i; j++)
            {
                if (arr[j] > arr[j + 1])
                {
                    tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
        }
    }
}
Делаю в меню вызов - cout<< " Выберите направление == по убыванию (v), по возрастанию (y) ";
            char ans;
            cin>>ans;
            if (ans == 'v')
            {
                show(arr, size);
                arr(arr, size, false);
            }
            else if (answer == 'y')
            {
                show(arr, size);
                arr(arr, size, true);
            }
            else
            {
                cout<<" ERROR \n";
            }
            show(arr, size);

#include<iostream>
#include<time.h>
#include<stdlib.h>
#include<Windows.h>
 
using namespace std;
 
enum Color {
    Black = 0, Blue, Green, Cyan, Red, Magenta, Brown, LightGray, DarkGray, LightBlue,
    LightGreen, LightCyan, LightRed, LightMagenta, Yellow, White
};
 
HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
 
void SetColor(Color text, Color background)
{
    SetConsoleTextAttribute(hStdOut, (WORD)((background << 4) | text));
}
 
/*Описать набор функций. Организовать спомощью этих функций меню.
1.Заполнение массива случайными числами в диапазоне, указанном пользователем
2.Вывод массива на экран. Все положительные числа выводятся зелёным, отрицательные - красным.
3.Сортировка массива в зависимости от выбора пользователя,по убыванию или по возрастанию.
Функция НИЧЕГО НЕ ВЫВОДИТ на экран!
4.Польователь указывает позиции. Сортировка происходит МЕЖДУ указанными позициями.
Функция НИЧЕГО НЕ ВЫВОДИТ на экран!
5.Функция находит два крайних отрицательных числа и сортирует массив МЕЖДУ этими позициями.
Функция НИЧЕГО НЕ ВЫВОДИТ на экран!
6.Функция находит два крайних положительных числа и сортирует массив слева от левого элемента, и справа - от правого.Функция НИЧЕГО НЕ ВЫВОДИТ на экран!
7.Функцию, которая будет наводить хаос в массиве.
8.Функцию,которая будет переносить все положительные элементы вправо. Положительные НЕ СОРТИРУЮТСЯ.
 
Сделать так, чтобы у пользователя не было возможности обратиться к неинициализированному массиву.
Нужно отслеживать - был ли заполнен массиив.*/
 
//1.Заполнение массива случайными числами в диапазоне, указанном пользователем
void array_fill(int array1[], int size, int start, int end)
{
    int temporary;
    if (start > end)
    {
        temporary = start;
        start = end;
        end = temporary;
    }
    for (size_t i = 0; i < size; i++)
    {
        array1[i] = rand() % (end + 1 - start) + start;
    }
}
//2.Вывод массива на экран. Все положительные числа выводятся зелёным, отрицательные - красным.
void array_print(int array1[], int size/*, int color*/)
{
    for (size_t i = 0; i < size; i++)
    {
        SetColor(White, Black);
        cout << "[" << i << "]\t";
        if (array1[i] > 0)
        {
            SetColor(Green, Black);
        }
        else
        {
            SetColor(Red, Black);
        }
        cout << array1[i] << "\n";
    }
    SetColor(White, Black);
    cout << '\n';
}
//3.Сортировка массива в зависимости от выбора пользователя,по убыванию или по возрастанию.
//Функция НИЧЕГО НЕ ВЫВОДИТ на экран!
void array_sort(int arr[], int size, bool direction)
{
    for (size_t i = 0; i < size; i++)
    {
        for (size_t i = 0; i < size - 1; i++)
        {
            if (direction == true)
            {
                if (arr[i] > arr[i + 1])
                {
                    int tmp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = tmp;
                }
            }
            else
            {
                if (arr[i] < arr[i + 1])
                {
                    int tmp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = tmp;
                }
            }
        }
    }
}
//4.Польователь указывает позиции. Сортировка происходит МЕЖДУ указанными позициями.Функция НИЧЕГО НЕ ВЫВОДИТ на экран!
void array_position(int position1, int position2, int array1[], int size, bool direction)
{
    for (size_t i = position1; i < position2; i++)
    {
        for (size_t i = position1; i < position2 - 1; i++)
        {
            if (direction == true)
            {
                if (array1[i] > array1[i + 1])
                {
                    int temporary = array1[i];
                    array1[i] = array1[i + 1];
                    array1[i + 1] = temporary;
                }
            }
            else
            {
                if (array1[i] < array1[i + 1])
                {
                    int temporary = array1[i];
                    array1[i] = array1[i + 1];
                    array1[i + 1] = temporary;
                }
            }
        }
    }
}
void array1_extreme_of1(int array1[], int size)
{
    int start, end;
    for (size_t i = 0; i < size; i++)
    {
        if (array1[i] < 0)
        {
            start = i;
            break;
        }
    }
    for (int i = 0; i < size; i++)
    {
        if (array1[i] < 0)
        {
            end = i;
        }
    }
    int choise = 1, temporary;
    //cout << " Выберите : если возрастанию == v, если по убыванию == y ";
    char selection;
    cin >> selection;
    if (selection == 'v')
    {
        do
        {
            choise = 0;
            for (size_t i = start; i < end; i++)
            {
                if (array1[i] > array1[i + 1])
                {
                    temporary = array1[i];
                    array1[i] = array1[i + 1];
                    array1[i + 1] = temporary;
                    choise = 1;
                }
            }
        } while (choise == 1);
    }
    else if (selection == 'y')
    {
        do
        {
            choise = 0;
            for (size_t i = start; i < end; i++)
            {
                if (array1[i] < array1[i + 1])
                {
                    temporary = array1[i];
                    array1[i] = array1[i + 1];
                    array1[i + 1] = temporary;
                    choise = 1;
                }
            }
        } while (choise == 1);
    }
}
/*6.Функция находит два крайних положительных числа и сортирует массив слева от левого элемента,
и справа - от правого.Функция НИЧЕГО НЕ ВЫВОДИТ на экран!*/
 
void array1_extreme_of2(int array1[], int size, bool direction)
{
    int start, end;
    for (int i = 0; i < size - 1; i++)
    {
        if (array1[i] > 0)
        {
            start = i;
            break;
        }
    }
    for (int i = 0; i < size - 1; i++)
    {
        if (array1[i] > 0)
        {
            end = i;
        }
    }
    int temporary;
    if (direction == true)
    {
        for (int i = start; i >= 0; i--)
        {
            for (int j = 0; j < i; j++)
            {
                if (array1[j] > array1[j + 1])
                {
                    temporary = array1[j];
                    array1[j] = array1[j + 1];
                    array1[j + 1] = temporary;
                }
            }
        }
        for (int i = size - 1; i >= end; i--)
        {
            for (int j = end; j < i; j++)
            {
                if (array1[j] > array1[j + 1])
                {
                    temporary = array1[j];
                    array1[j] = array1[j + 1];
                    array1[j + 1] = temporary;
                }
            }
        }
    }
    else 
    {
        for (int i = start; i >= 0; i--)
        {
            for (int j = 0; j < i; j++)
            {
                if (array1[j] < array1[j + 1])
                {
                    temporary = array1[j];
                    array1[j] = array1[j + 1];
                    array1[j + 1] = temporary;
                }
            }
        }
        for (int i = size - 1; i >= end; i--)
        {
            for (int j = end; j < i; j++)
            {
                if (array1[j] > array1[j + 1])
                {
                    temporary = array1[j];
                    array1[j] = array1[j + 1];
                    array1[j + 1] = temporary;
                }
            }
        }
    }
}
void array_show(int arr[], int size)
{
    for (int i = 0; i < size; i++)
    {
        cout << arr[i] << ' ';
    }
    cout << '\n';
}
/*7.Функцию, которая будет наводить хаос в массиве.*/
void haos(int array1[], int size)
{
    for (size_t i = 0; i < size; ++i)
    {
        int j = rand() % (size - i) + i;
        int temporary = array1[i];
        array1[i] = array1[j];
        array1[j] = temporary;
    }
}
/*8.Функцию,которая будет переносить все положительные элементы вправо.
Положительные НЕ СОРТИРУЮТСЯ.*/
void array1_transfer(int array1[], int size)
{
    int temporary;
    for (size_t i = 0; i < size; i++)
    {
        for (size_t j = 0; j < size; j++)
        {
            if (array1[i] < 0)
            {
                temporary = array1[i];
                array1[i] = array1[i - 1];
                array1[i - 1] = temporary;
            }
        }
    }
}
 
//Описать набор функций. Организовать с помощью этих функций меню.
//Сделать так, чтобы у пользователя не было возможности обратиться к неинициализированному массиву. 
//Нужно отслеживать - был ли заполнен массиив.
void menu(int array1[], int size)
{
    char selection;
    int start, end, color, position1 = 0, position2 = 0;
    cout << " Диапазон от : ";
    cin >> start;
    cout << " Диапазон до : ";
    cin >> end;
    array_fill(array1, size, start, end);
    char choise = 'y';
    do
    {
        cout << " Вывод массива на экран. \n"
            << " 1. Все положительные числа выводятся зелёным, отрицательные - красным \n"
            << " 2. Сортировка массива в зависимости от выбора пользователя,по убыванию или по возрастанию.\n"
            << " 3. Польователь указывает позиции.\n"
            << " Сортировка происходит МЕЖДУ указанными позициями.\n"
            << " 4. Функция находит два крайних отрицательных числа и сортирует массив МЕЖДУ этими позициями.\n"
            << " 5. Функция находит два крайних положительных числа и сортирует массив слева от левого элемента, \n"
            << " и справа - от правого.\n"
            << " 6. Функцию, которая будет наводить хаос в массиве.\n"
            << " 7. Функцию,которая будет переносить все положительные элементы вправо. \n"
            << " Положительные НЕ СОРТИРУЮТСЯ.\n"
            << " Выберите вышеуказаный номер задания : ";
        cin >> selection;
        if (selection == '1')
        {
            array_print(array1, size);
        }
        else if (selection == '2')
        {
            array_fill(array1, size, start, end);
        }
        else if (selection == '3')
        {
            array_sort(array1, size, 1);
        }
        else if (selection == '4')
        {
            array_position(position1, position2, array1, size, 1);
        }
        else if (selection == '5')
        {
            array1_extreme_of1(array1, size);
        }
        else if (selection == '6')
        {
            cout<< " Выберите направление == по убыванию (v), по возрастанию (y) ";
            char answer;
            cin>>answer;
            if (answer == 'v')
            {
                array_show(array1, size);
                array1_extreme_of2(array1, size, false);
            }
            else if (answer == 'y')
            {
                array_show(array1, size);
                array1_extreme_of2(array1, size, true);
            }
            else
            {
                cout<<" ERROR \n";
            }
            array_show(array1, size);
        }
        else if (selection == '7')
        {
            haos(array1, size);
        }
        else if (selection == '8')
        {
            array1_transfer(array1, size);
        }
        else
        {}
    } while (selection != '0');
}
void main()
{
    setlocale(LC_ALL, "ru");
    srand(time(NULL));
 
    const int size = 10;
    int arr[size];
    menu(arr, size);
 
}

#include <iostream>
#include <iomanip>
 
void print(int arr[], int size) {
    for (int i = 0; i < size; ++i)
        std::cout << std::setw(4) << arr[i] << " ";
    std::cout << std::endl;
}
 
bool firstPredicate(int first, int second) {
    return first > second;
}
bool secondPredicate(int first, int second) {
    return first < second;
}
 
bool sort(int arr[], int size, bool predicate(int, int) = firstPredicate, int start = 0, int end = -1) {
    //сортировка с направлением оптимизация сортировки с выбором направления
    if (end == -1) end = size;
    if (start < end && start >= 0 && end <= size) {
        for (int i = start; i < end - 1; ++i)
            for (int j = start; j < end - 1; ++j)
                if (predicate(arr[j], arr[j + 1])) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
        return true;
    }
    return false;
}
 
void splitArr(int arr[], int size) {//перекидывает все отрицательные элементы влево в том же порядке как и шли а положительные вправо задание 8
    int negatives = 0, positives = 0;
 
    for (int i = 0; i < size; ++i)
        arr[i] >= 0 ? ++positives : ++negatives;
 
    int *posBuf = new int[positives];
    int *negBuf = new int[negatives];
 
    for (int i = 0, j = 0, k = 0; i < size; ++i)
        arr[i] >= 0 ? posBuf[j++] = arr[i] : negBuf[k++] = arr[i];
 
    for (int i = 0; i < negatives; ++i)
        arr[i] = negBuf[i];
 
    for (int i = negatives; i < negatives + positives; ++i)
        arr[i] = posBuf[i - negatives];
 
    delete[] posBuf;
    delete[] negBuf;
}
 
bool sortBetwenPositives(int arr[], int size, bool predicate(int, int) = firstPredicate) {//сортировка между двумя положительными
    if (size > 2) {
        int start = -1, end = -1;
        for (int i = 0; i < size; ++i)
            if (arr[i] > 0) {
                start = i;
                break;
            }
        for (int i = size - 1; i >= 0; --i)
            if (arr[i] > 0) {
                end = i;
                break;
            }
 
        if (start != end && start != -1 && end != -1) {
            sort(arr, size, predicate, start + 1, end - 1);
            return true;
        }
    }
    return false;
}
 
int main(int argc, char* argv[]) {
    setlocale(LC_ALL, "Russian");
 
    const int size = 10;
    int arr[size]{ -10, 5, 1, -3, -9, 3 ,2 ,-7 ,-9 , 4 };
 
    std::cout << "Проверки сортировок: " << std::endl;
 
    print(arr, size);
    sort(arr, size, firstPredicate);
    print(arr, size);
    sort(arr, size, secondPredicate);
    print(arr, size);
 
    std::cout << "\n\nПроверки отрицательных сортировок: " << std::endl;
 
    int arrSecond[size]{ -10, 5, 1, -3, -9, 3 ,2 ,-7 ,-9 , 4 };
 
    print(arrSecond, size);
    splitArr(arrSecond, size);
    print(arrSecond, size);
 
    std::cout << "\n\nПроверки сортировоки между положительными: " << std::endl;
 
    int arrThird[size]{ -10, 5, 1, -3, -9, 3 ,2 ,-7 ,10 , -10 };
 
    print(arrThird, size);
    sortBetwenPositives(arrThird, size);
    print(arrThird, size);
 
 
 
    std::cin.ignore();
    return EXIT_SUCCESS;
}

/*8.Функцию,которая будет переносить все положительные элементы вправо. Положительные НЕ СОРТИРУЮТСЯ.*/

void array1_transfer(int array1[], int size)
{
    int temporary;
    for (size_t i = 0; i < size; i++)
    {
        for (size_t j = 0; j < size; j++)
        {
            if (array1[i] < 0)
            {
                temporary = array1[i];
                array1[i] = array1[i - 1];
                array1[i - 1] = temporary;
            }
        }
    }
}
array1_transfer(array1, size);

#include <iostream>
#include <iomanip>
 
 
const int size = 10;
 
void print(int arr[], int size) {
    for (int i = 0; i < size; ++i)
        std::cout << std::setw(4) << arr[i] << " ";
    std::cout << std::endl;
}
 
void splitArr(int arr[], int size) {//перекидывает все отрицательные элементы влево в том же порядке как и шли а положительные вправо задание 8
    int negatives = 0, positives = 0;
 
    for (int i = 0; i < size; ++i)
        arr[i] >= 0 ? ++positives : ++negatives;
 
    int posBuf[::size], negBuf[::size];
 
    for (int i = 0, j = 0, k = 0; i < size; ++i)
        arr[i] >= 0 ? posBuf[j++] = arr[i] : negBuf[k++] = arr[i];
 
    for (int i = 0; i < negatives; ++i)
        arr[i] = negBuf[i];
 
    for (int i = negatives; i < negatives + positives; ++i)
        arr[i] = posBuf[i - negatives];
}
 
int main(int argc, char** argv)
{
    int arrSecond[size]{ -10, 5, 1, -3, -9, 3 ,2 ,-7 ,-9 , 4 };
    splitArr(arrSecond, size);
    print(arrSecond, size);
 
    system("pause");
}