Функция должна реорганизовать масив , переставив все нечетные в лево

[BDA]

Тогда можно без дополнительного массива просто сортировать исходный массив:

void segregateEvenOdd(int *array, const int size)
{
    for (int i = 0; i < size - 1; ++i)
        for (int j = i + 1; j < size; ++j)
            if (
                (array[i] % 2 == 0 && array[j] % 2 != 0) ||
                (array[i] % 2 == array[j] % 2 && array[i] > array[j])
            )
            {
                int v = array[i];
                array[i] = array[j];
                array[j] = v;
            }
}

[vovamakarovych]

Сообщение от BDA

Из такого примера может следовать не сортировка, а наоборот сохранение порядка следования чисел из исходного массива.

Я еще заметил, что у меня при каждом запуске программы одни и те же значения генерирует програма. Неужели std::rand не достаточно, чтобы рандомные значения всегда записывались?

[vovamakarovych]

нашел и додал std::srand(std::time(nullptr));

[Алексей1153]

vovamakarovych, если вдруг интересно, есть вот такая замечательная функция std::stable_partition

#include <iostream>
#include <algorithm>

int main()
{
    int A[]{1, 4, 5, 8, 9};
    
    std::stable_partition(std::begin(A),std::end(A),[](auto& i){return i%2;});
    
    for(auto& i:A){std::cout<<i<<',';}
}

1,5,9,4,8,

[vovamakarovych]

Сообщение от BDA

[CODE]
Удалять надо оба массива и в конце работы программы, а не в функции segregateEvenOdd. Вы уверены, что требуется сортировка, а не только разделение на четные и нечетные?

Мне все таки нужно сделать не сортировку а разделение на четные и не четные , но чтобы они ишли как в стартовом масиве. Например: стартовый массив- 3 6 9 12 2 15 23 26 41 55
Масив который я вывожу на екран- 3 9 15 23 41 55 6 12 2 26 . Я переделал функцию, она выводит четные и нечетные но не так как нужно.

Мой код:

int* segregateEvenOdd(int* array, const size_t size) 
{
    for (size_t i = 0; i < size - 1; ++i) 
    {
        if (array[i] % 2 != 0) 
        {
            continue;
            ++i;
        }
        
            for (size_t j = i + 1; j < size; ++j)
            {
                if (array[j] % 2 != 0)

                    std::swap(array[i], array[j]);
            }   
    }
    return array;
}

int main()
{
    size_t size = 10;
    int* array = new int8_t[size];
    std::srand(std::time(nullptr));

    std::cout << "Before:" << std::endl;
    for (int i = 0; i < size; ++i)
    {
        array[i] = std::rand() % 100;
        std::cout << static_cast<int>(array[i]) << " ";
    }
    std::cout << std::endl;

    array = segregateEvenOdd(array, size);
    std::cout << "After:" << std::endl;
    for (int i = 0; i < size; ++i)
    {
        std::cout << static_cast<int>(array[i]) << " ";
    }
    std::cout << std::endl;

    delete[] array;

    return 0;
}

Вывод:
Before:
62 8 67 93 13 38 99 58 43 41
After:
41 43 99 13 93 67 8 58 62 38

[сфинкс]

5 минут ... 5 минут ... и готово
на языке высочайшего уровня qbasic qb64
и далее переделываем сами на функции и на др.яз

Уникальная идея: смотрим массив справа и слева
да-да как в моём уникальном алгоритме

N = 8: Randomize Timer ' prlev.bas
Dim d(N), a(N)
For i = 1 To N: d(i) = Int(Rnd * 88)+10: Print d(i);: Next: Print

k = 1: m = N: For i = 1 To N
    If Int(d(i) / 2) <> d(i) / 2 Then a(k) = d(i): k = k+1
    If Int(d(N-i+1) / 2) = d(N-i+1) / 2 Then a(m) = d(N-i+1): m = m-1
Next

Print: For i = 1 To N: Print a(i);: Next

59 53 18 54 36 81 82 64
59 53 81 18 54 36 82 64



Попробую проверить онлайн и возможно добавлю ссылку

[BDA]

Сообщение от vovamakarovych

Мне все таки нужно сделать не сортировку а разделение на четные и не четные , но чтобы они ишли как в стартовом масиве.

Тогда возвращайтесь к предыдущей реализации, когда в новый массив переписывались сначала нечетные, а потом четные из исходного массива.
Или вот такая "наивная" реализация без дополнительного массива:

void segregateEvenOdd(int* array, const size_t size) 
{
    for (size_t i = 0; i < size - 1; ++i) 
    {
        if (array[i] % 2 != 0) 
            continue;
        
        size_t j = i + 1;
        while (j < size && array[j] % 2 == 0)
            ++j;
        if (j == size)
            break;
        
        int v = array[j];
        for (size_t k = j; k > i; --k)
            array[k] = array[k - 1];
        array[i] = v;
    }
}

Четные сдвигаются "блоками" вправо, а нечетные по одному переносятся влево.

[vovamakarovych]

еще такой вопрос
если я создаю в стек массив

const size_t size = 10;
int array[size];

на array куда я записываю результат функции кричит

 array = segregateEvenOdd(array, size);

как мне тут передавать?

[BDA]

Тонкости не объясню. Просто не возвращайте ничего из функции, вы же все равно меняете содержимое массива, а не новый массив формируете.

[Алексей1153]

vovamakarovych, у массива нет оператора копирования