题目1：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。
如果不考虑时间复杂度，最简单的思路应该是从头扫描这个数组，每碰到一个偶数时，拿出这个数字，并把位于这个数字后面的所有的数字往前面挪动一位。挪完之后在数组的末尾有一个空位，这时把该偶数放入这个空位。由于每碰到一个偶数就需要移动O(n)个数字，因此总的时间复杂度是O(）。但是，这种方法是不能让面试官满意的。不过如果我们在听到题目之后马上能够说出这个解法，面试官至少会觉得我们的思维非常灵敏。
-
只完成基本功的解法，仅适用于初级程序员
这个题目要求把奇数放在数组的前半部分，偶数放在数组的后半部分，因此所有的奇数应该位于偶数的前面，也就是说我们在扫描这个数组的时候，如果发现有偶数在奇数的前面，我们可以交换他们的数序，交换之后就符合要求了。
因此我们可以维护两个指针，第一个指针初始化时指向数组的第一个数字，它只向后移动；第二个指针初始化时指向数组的最后一个数字，它指向前移动。在两个指针相遇之前，第一个指针总是位于第二个指针的前面。如果第一个指针的数字是偶数，并且第二个指针指向的数字是奇数，我们就交换两个数字。
下面看一个案例：
基于这个分析，我们可以写出如下代码：
public class OddBeforeEven {
public int[] recorderOddEven(int[] data, int length){
if(data == null && length <= 0){
return null;
}
int begin = 0;
int end = length - 1;
// begin指针要位于end指针前面
while(begin < end){
// 向后移动begin指针，直到它指向偶数
if(begin < end && (data[begin] & 0x1) != 0){
begin++;
}
// 向前移动end指针，直到它指向奇数
if(begin < end && (data[end] & 0x1) == 0){
end--;
}
// 交换奇数和偶数的位置
if(begin < end){
int temp = data[begin];
data[begin] = data[end];
data[end] = temp;
}
}
return data;
}
// 测试
public static void main(String[] args) {
OddBeforeEven obe = new OddBeforeEven();
int[] arr= {1,2,3,4,5,6,12,7,8,9,10};
int[] data = obe.recorderOddEven(arr, arr.length);
System.out.println(Arrays.toString(data));
}
}-
考虑可扩展的解法，能秒杀 Offer
如果是面试应届毕业生或者工作时间不长的程序员，面试官会满意前面的代码，但如果应聘者申请的是资深的开发职位，那面试官可能会接着问几个问题。
面试官：如果把题目改成数组中的数按照大小分为两部分，所有的负数在所有的非负数的前面，该怎么做？
如果再把题目改改，变成把数组中的数分成两部分，能被3整除的数都在不能被3整除的数的前面，怎么办？
这就是面试官在考察我们对可扩展性的理解，即希望我们能够给出一个模式，在这个模式下能够很方面第把已有的解决方案扩展到同类型的问题上去。
于是我们写出下面可扩展性的代码：
public class OddBeforeEvenExtension {
public int[] recorderOddEven(int[] data, int length){
if(data == null && length <= 0){
return null;
}
int begin = 0;
int end = length - 1;
// begin指针要位于end指针前面
while(begin < end){
// 向后移动begin指针，直到它指向偶数
if(begin < end && !isEven(data[begin])){
begin++;
}
// 向前移动end指针，直到它指向奇数
if(begin < end && isEven(data[end])){
end--;
}
// 交换奇数和偶数的位置
if(begin < end){
int temp = data[begin];
data[begin] = data[end];
data[end] = temp;
}
}
return data;
}
// 扩展函数
private boolean isEven(int data) {
return (data & 0x1) == 0;
}
// 测试
public static void main(String[] args) {
OddBeforeEvenExtension obe = new OddBeforeEvenExtension();
int[] arr= {1,2,3,4,5,6,12,7,8,9,10};
int[] data = obe.recorderOddEven(arr, arr.length);
System.out.println(Arrays.toString(data));
}
}
这样如果增加额外的判断条件，只需要改变isEven函数中的逻辑即可，对于recorderOddEven函数中的主体逻辑框架无需改变，这样就实现了解耦。
上面的案例中只需要保证奇数在偶数之前就可以了，但是可以看出来，上面的代码会改变原有的奇数和奇数、偶数和偶数之间的顺序。那么如果现在不能改变这个顺序又要如何实现呢？
牛客网：https://www.nowcoder.com/questionTerminal/beb5aa231adc45b2a5dcc5b62c93f593
题目2：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
1、要想保证原有的次序，则只能顺序移动或者相邻交换；
2、i 从左到右开始遍历，找到第一个偶数；
3、j 从 i+1 开始向后找，直到找到第一个奇数；
4、将 [ i , ... . j - 1 ] 的元素整体后移一位，最后将找到的奇数放入 i 位置，然后 i++；
5、终止条件，j 向后遍历查找失败，即后面没有奇数了。
/**
* 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，
* 所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
*/
public class OddBeforeEven_Improved {
public int[] reOrderArray(int[] arr) {
if(arr == null && arr.length <= 0){
return null;
}
int i = 0, j;
while(i < arr.length){
while(i < arr.length && !isEven(arr[i])){
i++;
}
// i指向偶数时，j从i+1开始向后遍历找奇数
j = i + 1;
while(j < arr.length && isEven(arr[j])){
j++;
}
if(j < arr.length){
// 将[i,...,j-1]的元素整体后移1位，最后将找到的奇数放入i位置
int temp = arr[j];
for(int k = j - 1; k >= i; k--){
arr[k + 1] = arr[k];
}
arr[i++] = temp;
}else{
// 查找失败
break;
}
}
return arr;
}
// 判断n是否是偶数
private boolean isEven(int n) {
if(n % 2 == 0){
return true;
}
return false;
}
// 测试
public static void main(String[] args) {
OddBeforeEven_Improved obe = new OddBeforeEven_Improved();
int[] arr= {1,2,3,4,5,6,12,7,8,9,10};
int[] data = obe.reOrderArray(arr);
System.out.println(Arrays.toString(data));
}
}
上面这种解法每次发现一个奇数在偶数后面，就需要搬移他们之间所有的元素，时间复杂度为O()，下面我们将使用一种空间换时间的思想，将时间复杂度降低为O(n)。具体做法如下:
首先统计奇数的个数，然后新建一个与原数组等长的数组，设置两个指针，奇数指针从0开始，偶数指针从奇数个数的末尾开始遍历填数。
public class OddBeforeEven_Improving {
public int[] reOrderArray(int[] arr){
if(arr.length == 0 || arr.length == 1){
return arr;
}
int oddCount = 0, oddBegin = 0;
int[] newArr = new int[arr.length];
// 统计原数组中奇数的个数
for (int i = 0; i < arr.length; i++) {
if((arr[i] & 1) == 1){
oddCount++;
}
}
for (int i = 0; i < arr.length; i++) {
if((arr[i] & 1) == 1){
// 在新数组中，先放奇数，从头开始放
newArr[oddBegin++] = arr[i];
}else{
// 偶数从奇数总个数后开始放
newArr[oddCount++] = arr[i];
}
}
for (int i = 0; i < arr.length; i++) {
arr[i] = newArr[i];
}
return arr;
}
// 测试
public static void main(String[] args) {
OddBeforeEven_Improving obe = new OddBeforeEven_Improving();
int[] arr= {1,2,3,4,5,6,12,7,8,9,10};
int[] data = obe.reOrderArray(arr);
System.out.println(Arrays.toString(data));
}
}
