《剑指offer》面试题21：调整数组顺序使奇数位于偶数前面(扩展)

更多剑指offer面试习题请点击：《剑指offer》（第二版）题集目录索引

一、题目

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

---

二、解法思路

　　这题如果不考虑算法的效率可以直接从头到尾扫描这个数组，遇到偶数就拿出来然后把这个偶数后面的数字全部往前挪一位，最后把这个偶数放在数组末尾空出来的那个位置。但这里每碰到一个偶数就需要移动$O(n)$个数字，所以总的时间复杂度是$O(n^2)$ 。下面介绍一种效率更高的方法。

---

1.初级版本

    题目要求是把奇数放在数组前半部分，偶数放在数组后半部分，那程序运行完后所有的奇数都在偶数前面。这里我们可以设置两个指针：pBegin和pEnd。pBegin指向数组首元素，pEnd指向数组尾元素。
①如果 *pBegin是奇数，那就让pBegin往后移动直到遇到偶数停下来。
②如果 *pEnd是偶数，那就让pEnd往前移动直到遇到奇数停下来。
③此时 *pBegin是偶数且 *pEnd是奇数那就交换这两个元素的位置。

    下面以数组{1, 2, 3, 4, 5}为例：
（1）首先pBegin指向首元素‘1’，pEnd指向尾元素‘5’。如图一所示。
（2）*pBegin是奇数， *pEnd也是奇数，此时pEnd不动，pBegin往后移动一个位置，此时如图二所示。
（3）这时候发现 pBegin指向2，是偶数；pEnd指向5，是奇数，交换两数位置。交换完后如图三所示。
（4）pBegin再次往后移动一次，pEnd再次往前移动一次。此时数组已经调整完毕。

---

< code 1>

void ReorderOddEven_1(int* pDate, unsigned int length)
{
    if (NULL == pDate || 0 == length)
        return;

    int* pBegin = pDate; //指向首元素
    int* pEnd = pDate + length - 1; //指向尾元素

    while (pBegin < pEnd)
    {
        // 向后移动pBegin，直到它指向偶数
        while (pBegin < pEnd && 1 == (*pBegin & 1))
            pBegin++;

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

        if (pBegin < pEnd)
        {
            *pBegin ^= *pEnd;
            *pEnd ^= *pBegin;
            *pBegin ^= *pEnd;

            /* 也可以创建第三方变量来完成交换
            int temp = *pBegin;
            *pBegin = *pEnd;
            *pEnd = temp;*/
        }
    }
}

---

2.高级版本

    写到这里，这道题已经算是很好的解决了，但如果你还能想到扩展解法那就更完美了。如果这题改成把负数放前面，非负数放后面，你该怎么解决呢？一看这还不好弄吗，把第二个和第三个while循环的判断条件改一下就好了。那再改成把素数放前面合数放后面呢？也好写啊，我们可以巴拉巴拉……但我们得知道这道题的改法千变万化，难道就没有一种万精油式解法吗？有！

    我们发现要做出一种万金油式解法只需要更改那两个while循环的判断条件就可以了，其他的则不需要改动。于是我们可以把这两个判断条件框架抽象出来，把判断的标准改为一个函数指针，也就是说我们可以单独写一个函数来判断数字是否符合标准。

---

< code 2>

void ReorderOddEven_2(int *pData, unsigned int length)
{
    Reorder(pData, length, isEven);
}

void Reorder(int *pData, unsigned int length, int(*func)(int))
{
    if (NULL == pData || 0 == length)
        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)
        {
            *pBegin ^= *pEnd;
            *pEnd ^= *pBegin;
            *pBegin ^= *pEnd;

            /*int temp = *pBegin;
            *pBegin = *pEnd;
            *pEnd = temp;*/
        }
    }
}

int isEven(int n)
{
    /*返回1代表偶数；返回0代表奇数*/
    return (n & 1) == 0;
}

---

3.测试代码

#include "ReorderOddEven.h"

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 = (int*)malloc(sizeof(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("\n\n");

    printf("Test for solution 2:\n");
    PrintArray(copy, length);
    ReorderOddEven_2(copy, length);
    PrintArray(copy, length);
    printf("\n************************************************************\n");
    free(copy);
    copy = NULL;
}

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(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();

    system("pause");
    return 0;
}

测试结果：

---

三、题目进阶

　　输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。并保证奇数和奇数，偶数和偶数之间的相对位置不变。

1. 解法一

　　类似于直插法，遇到奇数且它前面是偶数，就让它一直与前一个数进行交换，直到它前一个数不是偶数或者到达数组尽头为止。

void ReorderOddEven_3(int* pDate, int length)
{
    if (length < 2)
        return;
    int odd_index = 0;

    int i = 0;
    for (i = 0; i < length; ++i)
    {
        //遇到奇数
        if (!isEven(pDate[i]))
        {
            odd_index = i;
            while (odd_index > 0 && isEven(pDate[odd_index - 1]))
            {
                swap(pDate[odd_index], pDate[odd_index - 1]);
                --odd_index;
            }
        }
    }
}

---

2. 解法二

　　先遍历一遍数组，遇到偶数把它放到队列当中，遇到奇数往前挪。遍历结束后，奇数都按正确位置排在了前面，后面有一片空余的位置，此时把队列里的偶数放到这。

void ReorderOddEven_4(int* pDate, int length)
{
    if (length < 2)
        return;

    queue<int> q;
    int i = 0;

    //记录偶数的个数
    int even_count = 0;
    for (; i < length; ++i)
    {
        //遇到偶数
        if (isEven(pDate[i]))
        {
            ++even_count;
            q.push(pDate[i]);
        }
        else
        {
            // 奇数往前挪
            pDate[i - even_count] = pDate[i];
        }
    }

    for (i = length - even_count; i < length; ++i)
    {
        int tmp = q.front();
        pDate[i] = tmp;
        q.pop();
    }
}