调整数组顺序使奇数位于偶数前面

题目：输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。要求时间复杂度为O(n)。

分析：如果不考虑时间复杂度，最简单的思路应该是从头扫描这个数组，每碰到一个偶数时，拿出这个数字，并把位于这个数字后面的所有数字往前挪动一位。挪完之后在数组的末尾有一个空位，这时把该偶数放入这个空位。由于碰到一个偶数，需要移动O(n)个数字，因此总的时间复杂度是O(n^２)。

要求的是把奇数放在数组的前半部分，偶数放在数组的后半部分，因此所有的奇数应该位于偶数的前面。也就是说我们在扫描这个数组的时候，如果发现有偶数出现在奇数的前面，我们可以交换他们的顺序，交换之后就符合要求了。

因此我们可以维护两个指针，第一个指针初始化为数组的第一个数字，它只向后移动；第二个指针初始化为数组的最后一个数字，它只向前移动。在两个指针相遇之前，第一个指针总是位于第二个指针的前面。如果第一个指针指向的数字是偶数而第二个指针指向的数字是奇数，我们就交换这两个数字。

#include<stdio.h>
#include<tchar.h>

void Reorder(int *pData, unsigned int length, bool (*func)(int));
bool isEven(int n);

/*思路:使用两个指针，一个指向数组的一个数字，只向后移动，
一个指向数组的最后一个数字， 只向前移动，再两个指针相遇前，
如果第一个指针指向的是偶数，第二个指向的是奇数，就交换这两个数字
*/ 
void ReorderOddEven_1(int *pData, unsigned int length)
{
    if(pData == NULL || length == 0)
        return;
    
    int *pBegin = pData;
    int *pEnd = pData + length - 1;
    
    while(pBegin < pEnd)
    {
        while(pBegin < pEnd && (*pBegin & 0x1) != 0)
            pBegin ++;
        while(pBegin < pEnd && (*pEnd & 0x1) == 0)
            pEnd --;
        
        if(pBegin < pEnd)
        {
            int temp = *pBegin;
            *pBegin = *pEnd;
            *pEnd = temp;
        }
    }
}

//方法2和方法1思路是一样的，只是将方法1的函数给解耦成两部分，提高了代码的复用性。 
void ReorderOddEven_2(int *pData, unsigned int length)
{
    Reorder(pData, length, isEven);
}

void Reorder(int *pData, unsigned int length, bool (*func)(int))
{
    if(pData == NULL || length == 0) 
        return;
    
    int *pBegin = pData;
    int *pEnd = pData + length - 1;
    
    while(pBegin < pEnd)
    {
        while(pBegin < pEnd && !func(*pBegin))
            pBegin ++;
        
        while(pBegin < pEnd && func(*pEnd))
            pEnd --;
        
        if(pBegin < pEnd)
        {
            int temp = *pBegin;
            *pBegin = *pEnd;
            *pEnd = temp;
        }
    }
}

bool isEven(int n)
{
    return (n & 1) == 0;
}

void PrintArray(int numbers[], int length)
{
    if(length < 0)
        return;
    for(int i = 0 ; i < length ; ++i)
        printf("%d	", numbers[i]);
    
    printf("
");
}

int main()
{
    //使用方法1测试 
    int numbersOne[] = {1, 2, 3, 4, 5, 6, 7};
    int lengthOne = sizeof(numbersOne) / sizeof(int);
    printf("Test for solution 1:
");
    PrintArray(numbersOne, lengthOne);
    ReorderOddEven_1(numbersOne,lengthOne);
    PrintArray(numbersOne, lengthOne);
    printf("
");
    
    //使用方法2测试 
    int numbersTwo[] = {2, 4, 6, 1, 3, 5, 7};
    int lengthTwo = sizeof(numbersTwo) / sizeof(int);
    printf("Test for solution 2:
");
    PrintArray(numbersTwo,lengthTwo);
    ReorderOddEven_2(numbersTwo,lengthTwo);
    PrintArray(numbersTwo, lengthTwo);
    
    return 0 ;
}

还有一种思路，使用两个指针，一个在前一个在后，当在前的遇到奇数时，就和在后的数进行交换。有一个细节是，若数组一开始就是奇数，则在前的和在和的指向的是同一个数，交换后数组不变，直到遇到第一个偶数时，在前的指针超过在后的指针。

#include<iostream>
//#include<algorithm>    可省略swap 
using namespace std;

void swap(int* num1, int* num2) 
{
    int temp = *num1;
    *num1 = *num2;
    *num2 = temp;
}
bool isEven(int n)
{
    return (n & 1)==0;
}

void Reorder(int *pData, unsigned int length, bool (*func)(int))
{
    if(length < 0 || pData == NULL)
        return; 
    else{
        int i = -1;
        for(int j =0 ; j < length; j++)
        {
            /*当数组中的数字为奇数时，交换i,j指向的两个数字
            当起始数字为奇数时，此时交换的数字是相同的，
            当中间有偶数时，条件语句不满足，跳过，此时j继续增加，i不变，
             然后遇到奇数时，j指向奇数,满足条件，i指向前一个奇数，i++后，
             此时i指向此奇数后面的偶数,交换两数。 
             */ 
            if(!func(*(pData+j))) 
            {
                i++;
                swap(*(pData+i), *(pData+j));
            }
        }
    }
}

void PrintArray(int numbers[], int length)
{
    if(length < 0)
        return;
    for(int i = 0 ; i < length ; ++i)
        printf("%d	", numbers[i]);
    
    printf("
");
}

int main()
{
    int numbers[] = {3,4,5,6,7,8,9,10,1,2};
    int length = sizeof(numbers) / sizeof(int);
    
    PrintArray(numbers, length) ;

    Reorder(numbers, length, isEven);

    PrintArray(numbers, length);
    
    return 0;
}