调整数组顺序使奇数位于偶数前面【不保持相对位置】

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

方法一：                                                                                                         
    如果不考虑时间复杂度，最容易想到的思路就是：从头扫描这个数组，每碰到一个偶数时，取出这个数字，并把位于这个数字后面的所有数字往前挪动一位。挪完之后再数组的末尾有一个空位，这时把该偶数放入这个空位。由于每碰到一个偶数，需要移动O(n)个数字，所以，总的时间复杂度是O(n^2 )。
方法二：                                                                                                         
    要求是把奇数放在数组的前半部分，偶数放在数组的后半部分，因此所有的奇数应该位于偶数的前面。也就是说在扫描这个数组的时候，如果发现有偶数出现在奇数的前面，可以交换它们的顺序，交换之后就符合要求了。
    因此，可以维护两个指针：第一个指针初始化为数组的第一个数字，它只向后移动；第二个指针初始化为数组的最后一个数字，它只向前移动。在两个指针相遇之前，第一个指针总是位于第二个指针的前面。如果第一个指针指向的数字是偶数而第二个指针指向的数字是奇数，就交换这两个数字。
    基于这个思路，写出如下代码。

1. void Swap(int *a, int *b)
   
2. {
   
3.     int tmp = *a;
   
4.     *a = *b;
   
5.     *b = tmp;
   
6. }
   
7. 
   
8. void OddBeforeEven(int *array, int length)
   
9. {
   
10.     if(array == NULL || length == 0)
    
11.     {
    
12.         return;
    
13.     }
    
14.     int start = 0;
    
15.     int end = length - 1;
    
16.     while(start < end)
    
17.     {
    
18.         //从后往前寻找奇数
    
19.         while((start < end) && (array[end] & 1 != 1))
    
20.         {
    
21.             end--;
    
22.         }
    
23. 
    
24.         //从前往后寻找偶数
    
25.         while((start < end) && (array[start] & 1 != 0))
    
26.         {
    
27.             start++;
    
28.         }
    
29.         //如果start < end表明仍然有偶数array[start]在奇数array[end]之前，则交换两者 
    
30.         //如果start >= end，则表明所有的奇数都在偶数左面了 
    
31.         if(start < end)
    
32.         {
    
33.             Swap(&array[start], &array[end]);
    
34.             start++;
    
35.             end--;
    
36.         }
    
37.     }
    
38. }

方法三：                                                                                                             
    参见算法导论快速排序的数组划分（这个方法没有想到）。

1. #include <iostream>
   
2. #include <algorithm>
   
3. using namespace std;
   
4. 
   
5. bool isEven(int n)
   
6. {
   
7.     return (n & 1)==0;
   
8. }
   
9. 
   
10. void Partition(int *pData, unsigned int length, bool (*func)(int))//算法导论上快排的划分思想，实现奇数在前，偶数在后
    
11. {
    
12.     int i=-1;
    
13.     for(int j=0; j<length; j++)
    
14.     {
    
15.         if(!func(*(pData+j)))
    
16.         {
    
17.             i++;
    
18.             swap(*(pData+i), *(pData+j));
    
19.             
    
20.         }
    
21.     }
    
22. }
    
23. 
    
24. void main()
    
25. {
    
26.     int a[]={1,3,6,4,9,10,13};
    
27.     Partition(a, 7,isEven);
    
28.     for(int i=0; i<7; i++)
    
29.         cout<<a[i]<<" ";
    
30.     cout<<endl;
    
31. }