如何分隔数组中的奇数和偶数？

Question

I am trying to segregate odd and even numbers in an array. But, it does not seem to work. This is my approach in writing the function so far. It works only if I put even number of inputs. Example, if I enter {1,2,3,4,5,6} as an input then it gives me {1,5,3,6,2,4} as output but if I give odd number of input then it gives me some random output. What is the problem with the code ?

edit1 : I am a beginner in c++.

void segregateEvenOdd() {

for (int i = 0; i < endofarray; i++){
    int temp;
    if (array[i] % 2 == 0) //check if the number is odd or even
        temp = array[i];
        for(int j = i; j <= endofarray; j++){ //start from 1 cuz we dont want to touch the numbers that are already segregated
            array[j] = array[j+1];

        }
        array[endofarray] = temp;
}
}

Answer 1

There is actually a Standard Algorithm for that:

#include <algorithm>
#include <ciso646>
#include <cmath>
#include <iostream>
#include <iterator>

int main()
{
  int xs[] = { -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 };

  std::stable_partition( std::begin(xs), std::end(xs), []( int x ) 
  { 
    return x and ((std::abs(x) % 2) == 0);
  } );

  for (int x : xs) std::cout << x << " "; 
  std::cout << "\n";
}

This will get you a correctly ordered:

-4 -2 2 4 -5 -3 -1 0 1 3 5

If relative order does not matter, use std::partition() .
If you wish zero to be considered as even, adjust the condition.
Always be careful to handle conditions properly.

Answer 2

Your way is very inefficient. I suggest you do the following: 1) Create two lists (std::list): one for odd numbers, and one for even numbers 2) Iterate over the array and populate the odd_nums and even_nums lists 3) Go over the odd_nums list and then over the even_nums list, and override the contents of the original array. This takes O(n) memory, but is very fast.

Answer 3

Here is a way you can do it using std::vector and the library algorithms, since in C++ it is normally preferable to use library containers such as std::vector 's rather than raw arrays because they are generally safer, are more compatible with the design of the standard library, and have a dynamic size which grows efficiently:

#include <iostream>
#include <iterator>
#include <algorithm>
#include <vector>

int main() {
    std::vector<int> iVec { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    std::sort(iVec.begin(), iVec.end(), [](int a, int b) { return (b & 1) && !(a & 1); });

    return 0;
}

It will sort the vector so that even numbers are in the first half, and odd numbers in the second half. When printed with:

std::copy(iVec.begin(), iVec.end(), std::ostream_iterator<int>(std::cout, " "));

The output is:

0 2 4 6 8 10 1 3 5 7 9

If you want the odd numbers to come first you can simply swap the positions of a and b in the predicate (b & 1) && !(a & 1) . The predicate basically checks if b is odd and a is not, and the result of that is passed to the std::sort algorithm which will sort the elements thereafter.

If you afterwards want to split the even and odd numbers into separate containers, you can use the find_if algorithm to find the first odd number, and construct two vectors from the given range:

auto it = std::find_if(iVec.begin(), iVec.end(), [](int a) { return (a & 1); });
std::vector<int> evenNumbers(iVec.begin(), it);
std::vector<int> oddNumbers(it, iVec.end());

Which will produce one vector with even numbers, and one with odd numbers.