Split Parity Function ordering odds and evens - c++

Question

I've been staring at this and I can't figure out what i'm doing wrong. I'm trying to write a function that reorders odd to be in front of evens in the array. The inner order of odds and evens is not important meaning [3, 1, 4, 2] or [1, 3, 2, 4] are both acceptable.
Currently if I initialize int arr[5] = {3,6,4,1,12} I get an output of 3,4,1,6,2 Struggling to figure out what I'm doing wrong.
Code below:
void SplitParity(int arr[], int arrSize)
{
int tempValueHolder;
for (int indexCounter = 0; indexCounter < arrSize; indexCounter++)
{
//Iterate through each index checking for odd
if (arr[indexCounter] % 2 == 0)
{
tempValueHolder = arr[indexCounter];
//If Odd.....shift all indexes forward and move current to the back
for (int innerCounter = indexCounter; innerCounter < arrSize; innerCounter++)
arr[innerCounter] = arr[innerCounter + 1];
arr[arrSize - 1] = tempValueHolder;
}
}
}

Answer 1

You forgot that after shifting everything, you must look at indexCounter once again (you don't know if the value that arrived in the first iteration of the loop when you did arr[indexCounter] = arr[indexCounter+ 1]; is correct or not)
Simplest fix is to add indexCounter --; just after arr[arrSize - 1] = tempValueHolder;
It's also incredibly innefficient and I suggest you look at std::partition

Answer 2

Use standard algorithms with the correct custom comparison function:
#include <iterator>
#include <iostream>
#include <algorithm>
template<class T>
bool is_odd(const T& value)
{
if (value & 1)
return true;
return false;
}
struct odd_first
{
template<class T>
bool operator()(const T& l, const T& r) const {
if (is_odd(l))
{
if (is_odd(r))
return false;
return true;
}
else
return false;
}
};
int main()
{
int vals[] = { 5, 6, 7, 8, 9, 1, 2, 3, 4, 0 };
std::sort(std::begin(vals), std::end(vals), odd_first());
std::copy(std::begin(vals), std::end(vals), std::ostream_iterator<int>(std::cout, ", "));
std::cout << std::endl;
}
expected output:
5, 7, 9, 1, 3, 6, 8, 2, 4, 0,
As per Fezvez's suggestion, std::partition:
#include <iterator>
#include <iostream>
#include <algorithm>
struct is_odd
{
template<class T>
bool operator()(const T& value) const
{
if (value & 1)
return true;
return false;
}
};
int main()
{
int vals[] = { 5, 6, 7, 8, 9, 1, 2, 3, 4, 0 };
std::partition(std::begin(vals), std::end(vals), is_odd());
std::copy(std::begin(vals), std::end(vals), std::ostream_iterator<int>(std::cout, ", "));
std::cout << std::endl;
}

Answer 3

You can do this much, much easier with std::sort: Demo
std::sort(std::begin(arr), std::end(arr), [](int lhs, int rhs){
return (lhs % 2 == 1 && rhs % 2 == 0);
});
Output:
3 1 6 4 12
Or, if you desire internal sorting within odd and even: Demo
std::sort(std::begin(arr), std::end(arr), [](int lhs, int rhs){
int l_res = lhs % 2;
int r_res = rhs % 2;
if (l_res == r_res)
return lhs < rhs;
return (l_res == 1 && r_res == 0);
});
Output:
1 3 4 6 12