剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

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

示例：
输入：nums = [1,2,3,4]
输出：[1,3,2,4]
注：[3,1,2,4] 也是正确的答案之一。

提示：
1 <= nums.length <= 50000
1 <= nums[i] <= 10000

---

思路1

在原有数组上做操作，遍历数组
如果该数字为奇数，那么直接跳过
如果该数字为偶数，从下一个数字开始遍历，找到一个奇数数字，将奇数偶数相交换，i遍历完。很遗憾，这种做法超时了。。。

class Solution {
    public int[] exchange(int[] nums) {
        //边界条件
        if(nums == null || nums.length == 1) return nums;

        int count = nums.length;
        for(int i = 0; i < count; i++){

            if(nums[i] % 2 == 1) continue;

            //说明nums[i]为偶数
            for(int j = i + 1; j < count; j++){
                if(nums[j] % 2 == 1){//奇数
                    int temp = nums[i];
                    nums[i] = nums[j];
                    nums[j] = temp;
                    break;
                }
            }
        }
        return nums;
    }
}

复杂度分析

时间复杂度：
最好情况：全是奇数O(n)
最坏情况：全是偶数O(n^2)
空间复杂度：O(1)

改进1

如果，在剩余数组里面，已经找不到奇数了，说明剩余的数组里面的元素都是偶数，那么，可以直接停止循环。
也就是，定义一个布尔值isAllTwo（是否全部都是偶数），默认是true
当剩余数组里面发现奇数的时候，将isAllTwo = false;
如果剩余数组里面没有奇数，全部为偶数，那么isAllTwo为true，这样，在外面的大循环里面，可以直接停止循环，此时，nums里面的数组即为所求

class Solution {
    public int[] exchange(int[] nums) {
        //边界条件
        if(nums == null || nums.length == 1) return nums;

        int count = nums.length;
        for(int i = 0; i < count; i++){

            if(nums[i] % 2 == 1) continue;

            //说明nums[i]为偶数
            boolean isAllTwo = true;
            for(int j = i + 1; j < count; j++){
                if(nums[j] % 2 == 1){//奇数
                    int temp = nums[i];
                    nums[i] = nums[j];
                    nums[j] = temp;
                    isAllTwo = false;
                    break;
                }
            }

            if(isAllTwo){
                break;
            }
        }

        return nums;
    }
}

好在时间不超时了

复杂度分析

时间复杂度：
最好情况：全是奇数O(n)
最坏情况：前半段是偶数，最半段是奇数，这种情况下，isAllTwo相当于没起作用O(n^2)
空间复杂度：O(1)

不过，算法还有改进空间

改进2

当在里面的循环，找到奇数的时候，下一次的内部循环就没有必要从i + 1开始了，可以直接从上次找到奇数位置的下一个位置开始。
基于以上思路，可以得到以下代码：

class Solution {
    public int[] exchange(int[] nums) {
        //边界条件
        if(nums == null || nums.length == 1) return nums;

        int count = nums.length;
        //上次找到的奇数位置
        int preJiShuIndex = 0;
        
        for(int i = 0; i < count; i++){
            if(nums[i] % 2 == 1) continue;

            //说明nums[i]为偶数
            boolean isAllTwo = true;
            
            preJiShuIndex = preJiShuIndex > 0 ? preJiShuIndex : i;
            for(int j = preJiShuIndex + 1; j < count; j++){
                if(nums[j] % 2 == 1){//奇数
                    int temp = nums[i];
                    nums[i] = nums[j];
                    nums[j] = temp;
                    isAllTwo = false;
                    preJiShuIndex = j;
                    break;
                }
            }

            if(isAllTwo){
                break;
            }
        }

        return nums;
    }
}

从原来的1588ms变为了3ms，还是有很大的进步的。

复杂度分析

时间复杂度：
最好情况：全是奇数O(n)
最坏情况：前半段是偶数，最半段是奇数（或者一个奇数一个偶数的穿插）O(n)
空间复杂度：O(1)

也难怪时间确实少了很多，量级不一样了。

这个思路以及改进思路，是从冒泡排序的优化得来的，具体可参考：
数据结构与算法—排序—冒泡排序

---

思路2

以上最好的优化方法2也才超过27.79%的提交者
那么，是不是有更好的方法呢？

借助空间换时间，新建一个数组，是奇数放前面，是偶数从后面放

class Solution {
    public int[] exchange(int[] nums) {
        //边界条件
        if(nums == null || nums.length == 1) return nums;

        int count = nums.length;
        
        int[] resultArray = new int[count];
        int jiShuIndex = 0;
        int ouShuIndex = count - 1;
        for(int i = 0; i < count; i++){
            if(nums[i] % 2 == 1){
                resultArray[jiShuIndex] = nums[i];
                jiShuIndex++;
            }else{
                resultArray[ouShuIndex] = nums[i];
                ouShuIndex--;
            }
        }

        return resultArray;
    }
}

复杂度分析

时间复杂度：
最好最坏：O(n)
空间复杂度：O(n)

这个结果还行

其实，这个的时间复杂度与思路1的改进方法2的时间复杂度一样，但是改进方法2的操作有更多的判断，也许就是因为多了这些判断，导致没有思路2这种时间用的更少一些。不过，改进方法2的空间复杂度是O(1)，比思路2的空间复杂度O(n)要好不少。因此，也不能一味的追求时间上的优化吧。

---

思路3

书上有种做法，使用两个指针
第一个指针初始化时指向数组的第一个数字，它只向后移动；
第二个指针初始化时指向数组的最后一个数字，它只向前移动；
当第一个指针指向的数字为偶数，第二个指针指向的数字为奇数，则交换两个数字；

class Solution {
    public int[] exchange(int[] nums) {
        //边界值
        if(nums == null) return nums;

        int p1 = 0;
        int p2 = nums.length - 1;

        while(p1 <= p2){
            if(nums[p1] % 2 == 1){//p1指向数字为奇数
                p1++;
            }else{//p1指向数字为偶数
                if(nums[p2] % 2 == 0){//p2指向数字为偶数
                    p2--;
                }else{//p2指向数字为奇数
                    int temp = nums[p1];
                    nums[p1] = nums[p2];
                    nums[p2] = temp;
                }
            }
        }
        return nums;
    }
}