编程之法：面试和算法心得（奇偶调序）

内容所有来自编程之法：面试和算法心得一书，实现是本身写的使用的是java

题目描述

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

分析与解法

最容易想到的办法是从头扫描这个数组，每碰到一个偶数，拿出这个数字，并把位于这个数字后面的全部数字往前挪动一位。挪完以后在数组的末尾有一个空位，而后把该偶数放入这个空位。因为每碰到一个偶数，须要移动O(n)个数字，因此这种方法总的时间复杂度是O(n^2)，不符合题目要求。

事实上，若把奇数看作是小的数，偶数看作是大的数，那么按照题目所要求的奇数放在前面偶数放在后面，就至关于小数放在前面大数放在后面，联想到快速排序中的partition过程，不就是经过一个主元把整个数组分红大小两个部分么，小于主元的小数放在前面，大于主元的大数放在后面。

而partition过程有如下两种实现：

• 一头一尾两个指针往中间扫描，若是头指针遇到的数比主元大且尾指针遇到的数比主元小，则交换头尾指针所分别指向的数字；
• 一前一后两个指针同时从左往右扫，若是前指针遇到的数比主元小，则后指针右移一位，而后交换各自所指向的数字。

相似这个partition过程，奇偶排序问题也能够分别借鉴partition的两种实现解决。

为什么？好比partition的实现一中，若是最终是为了让整个序列元素从小到大排序，那么头指针理应指向的就是小数，而尾指针理应指向的就是大数，故当头指针指的是大数且尾指针指的是小数的时候就不正常，此时就当交换。

解法一

借鉴partition的实现一，咱们能够考虑维护两个指针，一个指针指向数组的第一个数字，咱们称之为头指针，向右移动；一个指针指向最后一个数字，称之为尾指针，向左移动。

这样，两个指针分别从数组的头部和尾部向数组的中间移动，若是第一个指针指向的数字是偶数而第二个指针指向的数字是奇数，咱们就交换这两个数字。

由于按照题目要求，最终是为了让奇数排在数组的前面，偶数排在数组的后面，因此头指针理应指向的就是奇数，尾指针理应指向的就是偶数，故当头指针指向的是偶数且尾指针指向的是奇数时，咱们就当当即交换它们所指向的数字。

思路有了，接下来，写代码实现：

//判断是否为奇数
    public static boolean isOdd(int number)
    {
        return number%2==1;
    }
    /*
     * 解法一
     * 借鉴partition的实现一，咱们能够考虑维护两个指针，一个指针指向数组的第一个数字，咱们称之为头指针，向右移动；一个指针指向最后一个数字，称之为尾指针，向左移动。
     * 这样，两个指针分别从数组的头部和尾部向数组的中间移动，若是第一个指针指向的数字是偶数而第二个指针指向的数字是奇数，咱们就交换这两个数字。
     * 由于按照题目要求，最终是为了让奇数排在数组的前面，偶数排在数组的后面，因此头指针理应指向的就是奇数，尾指针理应指向的就是偶数，故当头指针指向的是偶数且尾指针指向的是奇数时，咱们就当当即交换它们所指向的数字。
     */
    public static void solution1(int[] arr)
    {
        int i=0;
        int j=arr.length-1;
        while(i<j)
        {
            if(isOdd(arr[i]))
            {
                i++;
            }
            else if(!isOdd(arr[j]))
            {
                j--;
            }
            else
            {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }

解法二

咱们先来看看快速排序partition过程的第二种实现是具体怎样的一个原理。

partition分治过程，每一趟排序的过程当中，选取的主元都会把整个数组排列成一大一小的序列，继而递归排序完整个数组。以下伪代码所示：

PARTITION(A, p, r) 1 x ← A[r] 2 i ← p - 1 3 for j ← p to r - 1 4 do if A[j] ≤ x 5 then i ← i + 1 6 exchange A[i] <-> A[j] 7 exchange A[i + 1] <-> A[r] 8 return i + 1 

举个例子以下：现要对数组data = {2, 8,7, 1, 3, 5, 6, 4}进行快速排序，为了表述方便，令i指向数组头部前一个位置，j指向数组头部元素，j在前，i在后，双双从左向右移动。

① j 指向元素2时，i 也指向元素2，2与2互换不变

i p/j 2 8 7 1 3 5 6 4(主元) 

② 因而j 继续后移，直到指向了1，1 <= 4，因而i++，i 指向8，故j 所指元素1 与 i 所指元素8 位置互换：

i j 2 1 7 8 3 5 6 4 

③ j 继续后移，指到了元素3,3 <= 4，因而一样i++，i 指向7，故j 所指元素3 与 i 所指元素7 位置互换：

i j 2 1 3 8 7 5 6 4 

④ j 一路后移，没有再碰到比主元4小的元素：

i j 2 1 3 8 7 5 6 4 

⑤ 最后，A[i + 1] <-> A[r]，即8与4交换，因此，数组最终变成了以下形式：

2   1   3   4   7   5   6   8

这样，快速排序第一趟完成。就这样，4把整个数组分红了俩部分，2 1 3,7 5 6 8，再递归对这两部分分别进行排序。

借鉴partition的上述实现，咱们也能够维护两个指针i和j，一个指针指向数组的第一个数的前一个位置，咱们称之为后指针i，向右移动；一个指针指向数组第一个数，称之为前指针j，也向右移动，且前指针j先向右移动。若是前指针j指向的数字是奇数，则令i指针向右移动一位，而后交换i和j指针所各自指向的数字。

由于按照题目要求，最终是为了让奇数排在数组的前面，偶数排在数组的后面，因此i指针理应指向的就是奇数，j指针理应指向的就是偶数，因此，当j指针指向的是奇数时，不正常，咱们就当让i++，而后交换i和j指针所各自指向的数字。

参考代码以下：

/*
     * 借鉴partition的上述实现，咱们也能够维护两个指针i和j，
     * 一个指针指向数组的第一个数的前一个位置，咱们称之为后指针i，向右移动；
     * 一个指针指向数组第一个数，称之为前指针j，也向右移动，且前指针j先向右移动。
     * 若是前指针j指向的数字是奇数，则令i指针向右移动一位，而后交换i和j指针所各自指向的数字。
     * 由于按照题目要求，最终是为了让奇数排在数组的前面，偶数排在数组的后面，因此i指针理应指向的就是奇数，j指针理应指向的就是偶数，因此，当j指针指向的是奇数时，不正常，咱们就当让i++，而后交换i和j指针所各自指向的数字。
     */
    public static void solution2(int[] arr)
    {
        int i=-1;
        int j=0;
        for(;j<arr.length;j++)
        {
            if(isOdd(arr[j]))
            {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }