Разбиение массива на отдельные положительные и отрицательные массивы C++

Question

Мне нужно написать функцию, которая принимает заданный массив, а затем разбивает его на два отдельных массива с элементами одного массива, являющимися положительными элементами основного массива, а остальные элементы являются отрицательными элементы основного массива. Кажется, я не могу понять, как будет выглядеть этот цикл.

я написал отдельную функцию, чтобы определить, сколько положительных и отрицательных значений в главном массиве:

void count(int ARRAY[], int SIZE, int&NEG, int&POS) 
{ 

    for (int x=0; x<SIZE; x++) 
    { 
     if(ARRAY[x]>=0) 
     { 
     POS=POS+1 ; 
     } 
     if(ARRAY[x]<0) 
     { 
     NEG=NEG+1 ; 
     } 
    } 
} 

Это подсчитывает позитивы и негативы и количество каждого будет размер соответствующего положительной и отрицательные массивы после раскола.

Я определил функцию как таковые:

void split(int ARRAY[], int SIZE, int&NEG_ARRAY, int NEG, int&POS_ARRAY, int POS) 

Я просто не знаю, как установить каждый из положительных элементов в основном массиве в качестве элементов в новом Положительно Только массив и также для отрицательный массив.

Благодарим за помощь!

После использования полученных ответов и выполнения моих лучших действий с остальной частью кода, я получил около миллиона строк ошибок при попытке скомпилировать его. Есть ли проблема с тем, как я удаляю три динамически распределенных массива? Какая огромная ошибка предотвращает компиляцию? Вот мой код:

#include <iostream> 
using namespace std; 


void count(int ARRAY[], int SIZE, int&NEG, int&POS); 
void split(int ARRAY[], int SIZE, int&NEG_ARRAY, int NEG, int&POS_ARRAY, int POS); 
void print_array(int ARRAY[], int SIZE); 


int main() 
{ 

    int SIZE (0); 
    int * ARRAY ; 

    cout<<"Enter number of elements: " ; 
    cin>> SIZE ; 

    ARRAY = new int[SIZE] ; 
    int x(0); 
    int numEle(0); 

    cout<<"Enter list: " <<endl; 

    while(numEle<SIZE) 
    { 
     ARRAY[numEle] = x ; 
     numEle++; 
     cin>>x; 
    } 

    int POS(0), NEG(0) ; 
    count(ARRAY, SIZE, NEG, POS) ; 

    int * NEG_ARRAY; 
    NEG_ARRAY = new int[NEG]; 

    int * POS_ARRAY; 
    POS_ARRAY = new int[POS]; 


    split(ARRAY, SIZE, NEG_ARRAY, NEG, POS_ARRAY, POS) ; 

    cout<<"Negative elements: "<<endl; 
    cout<<print_array(NEG_ARRAY, NEG) <<endl; 

    cout<<"Non-negative elements: "<<endl; 
    cout<<print_array(POS_ARRAY, POS)<<endl; 


    delete[] ARRAY; 
    delete[] NEG_ARRAY; 
    delete[] POS_ARRAY; 

    return 0; 
} 



void count(int ARRAY[], int SIZE, int&NEG, int&POS) 
{ 

    for (int x=0; x<SIZE; x++) 
    { 
     if(ARRAY[x]>=0) 
     { 
     POS=POS+1 ; 
     } 
     if(ARRAY[x]<0) 
     { 
     NEG=NEG+1 ; 
     } 
    } 
} 

void split(int ARRAY[], int SIZE, int&NEG_ARRAY, int NEG, int&POS_ARRAY, int POS) 
{ 

    NEG=POS=0; 
    for(int x=0; x<SIZE; x++) 
    { 
     if(ARRAY[x]<0) 
    { NEG_ARRAY[NEG++]=ARRAY[x]; } 
     else {POS_ARRAY[POS++]=ARRAY[x]; } 

    } 
} 

void print_array(int ARRAY[], int SIZE) 
{ 

    for(int i=0; i<SIZE; i++) 
    { 

     cout << ARRAY[i] << " " ; 
    } 
    cout<<endl; 
} 

код должен прочитать в массив и отображать новые положительные и отрицательные массивы. Заранее спасибо!

Answer 1

Этот код будет делить отрицательные & положительные числа в отдельные массивы,

void split(int ARRAY[], int SIZE, int NEG_ARRAY[], int&NEG, int POS_ARRAY[], int&POS) 
{ 
    NEG=POS=0; 
    for (int i(0); i<SIZE; i++) 
    { 
     if (ARRAY[i]<0) NEG_ARRAY[NEG++]=ARRAY[i]; 
     else POS_ARRAY[POS++]=ARRAY[i]; 
    } 
} 

Answer 2

Его легко модифицировать count() функции:

void split(int ARRAY[], int SIZE, int NEG [], int POS []) 
{ 
    int ncount = 0, pcount = 0; 
    for (int x=0; x<SIZE; x++) 
    { 
     if(ARRAY[x]>=0) 
     { 
      POS[pcount++] = ARRAY[x]; 
     } 
     if(ARRAY[x]<0) 
     { 
      NEG[ncount++] = ARRAY[x]; 
     } 
    } 
} 

Answer 3

Вы можете получить некоторый C стиль отвечает

Но здесь, как я хотел бы сделать с помощью алгоритмов STL, так как это помечено для C++

std::partition

bool is_pos(int i) { return i > 0; } 

auto p = std::partition(std::begin(ARRAY), 
     std::end(ARRAY), std::ptr_fun(is_pos)); 

std::copy(std::begin(ARRAY), p, std::begin(POS_ARRAY)); 

std::copy(p, std::end(ARRAY), std::begin(NEG_ARRAY)); 

Кроме того, вы должны использовать std::vector для таких операций

Demo Here