《剑指Offer》面试题14：调整数组顺序使奇数位于偶数前面

《剑指Offer》面试题14：调整数组顺序使奇数位于偶数前面

知识点

    重排序

题目描述

    输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。

解题思路

• 最简单思路

    不考虑时间复杂度，最简单的思路是从头扫描这个数组，每碰到一个偶数时，拿出这个数字，并把位于这个数字后面的所有数字往前挪动一位。将拿出的偶数放到数组末尾空位。由于每碰到一个偶数就要挪动O(n)个数字，因此总的时间复杂度为O(n^2)。

• 只完成基本功能的解法（仅适用于初级程序员）

    

• 可扩展性的解法（秒杀Offer）

    考虑类似题目：

    将题目改成将数组分成两部分，所有负数在非负数前面；

    将题目改成将数组分成两部分，能被3整除的在不能被3整除的前面；

    为了让代码的扩展性更强，可以将这些判断标准单独写成一个函数接口，而主代码框架保持不变。即将逻辑框架抽象出来，而把判断标准变成一个函数指针，也就是用一个函数来判断数字是不是符合标准。这样，将函数解耦成两个部分：一是判断数字应该是在数组前半部分还是后半部分，而是拆分数组的操作。

测试用例

代码（原书）

/* 《剑指Offer——名企面试官精讲典型编程题》代码
著作权所有者：何海涛*/

#include "stdio.h"
#include <cstdlib>

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)
	{
		// 向后移动pBegin，直到它指向偶数
		while (pBegin < pEnd && (*pBegin & 0x1) != 0)
			pBegin++;

		// 向前移动pEnd，直到它指向奇数
		while (pBegin < pEnd && (*pEnd & 0x1) == 0)
			pEnd--;

		if (pBegin < pEnd)
		{
			int temp = *pBegin;
			*pBegin = *pEnd;
			*pEnd = temp;
		}
	}
}

// ====================方法二：可扩展性的解法（秒杀Offer）====================
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)
	{
		// 向后移动pBegin
		while (pBegin < pEnd && !func(*pBegin))
			pBegin++;

		// 向前移动pEnd
		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\t", numbers[i]);

	printf("\n");
}

void Test(char* testName, int numbers[], int length)
{
	if (testName != NULL)
		printf("%s begins:\n", testName);

	int* copy = new int[length];
	for (int i = 0; i < length; ++i)
	{
		copy[i] = numbers[i];
	}

	printf("Test for solution 1:\n");
	PrintArray(numbers, length);
	ReorderOddEven_1(numbers, length);
	PrintArray(numbers, length);

	printf("Test for solution 2:\n");
	PrintArray(copy, length);
	ReorderOddEven_2(copy, length);
	PrintArray(copy, length);

	delete[] copy;
}

void Test1()
{
	int numbers[] = { 1, 2, 3, 4, 5, 6, 7 };
	Test("Test1", numbers, sizeof(numbers) / sizeof(int));
}

void Test2()
{
	int numbers[] = { 2, 4, 6, 1, 3, 5, 7 };
	Test("Test2", numbers, sizeof(numbers) / sizeof(int));
}

void Test3()
{
	int numbers[] = { 1, 3, 5, 7, 2, 4, 6 };
	Test("Test3", numbers, sizeof(numbers) / sizeof(int));
}

void Test4()
{
	int numbers[] = { 1 };
	Test("Test4", numbers, sizeof(numbers) / sizeof(int));
}

void Test5()
{
	int numbers[] = { 2 };
	Test("Test5", numbers, sizeof(numbers) / sizeof(int));
}

void Test6()
{
	Test("Test6", NULL, 0);
}

int main()
{
	Test1();
	Test2();
	Test3();
	Test4();
	Test5();
	Test6();
	system("pause");
	return 0;
}

代码（牛客网）

class Solution {
public:
    // 法1：新建一个数组
    void reOrderArray(vector<int> &array) {
         vector<int> result;
        int num=array.size();
        for(int i=0;i<num;i++)
        {
            if((array[i]& 0x1) ==1)
                result.push_back(array[i]);
        }
        for(int i=0;i<num;i++)
            {
            if((array[i] & 0x1) ==0)
                result.push_back(array[i]);
        }
        array=result;
    }*
    //法2：类似于冒泡排序
    void reOrderArray(vector<int> &array) {
        int num = array.size();
        for(int i = 0; i < num; i++)
        {
            for(int j = num-1; j >i; j--)
            {
                if(array[j] % 2 ==1 && array[j-1] % 2 ==0)
                    swap(array[j-1], array[j]);
            }
        }
    }    
};