剑指offer-68、调整数组顺序使奇数位于偶数前⾯(⼆)

题⽬描述

输⼊⼀个⻓度为 n 整数数组，数组⾥⾯可能含有相同的元素，实现⼀个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前⾯部分，所有的偶数位于数组的后⾯部分，对奇数和奇数，偶数和偶数之间的相对位置不做要求，但是时间复杂度和空间复杂度必须如下要求。

数据范围：0 ≤ n ≤ 50000，数组中每个数的值 0 ≤ val ≤ 10000

要求：时间复杂度 O(n)，空间复杂度 O(1)

示例 1
输⼊：[1,2,3,4]
返回值：[1,3,2,4]
说明：[3,1,2,4]或者[3,1,4,2]也是正确答案

示例 2
输⼊：[1,3,5,6,7]
返回值：[1,3,5,7,6]
说明：[3,1,5,7,6]等也是正确答案

思路及解答

两次遍历

第一次遍历收集奇数，第二次遍历收集偶数

这种方法虽然简单易懂，但需要额外空间，不符合题目要求

public class Solution {
    public int[] reorderArray(int[] nums) {
        if (nums == null || nums.length == 0) {
            return new int[0];
        }
        
        int[] result = new int[nums.length];
        int index = 0;
        
        // 第一次遍历：收集所有奇数
        for (int num : nums) {
            if (num % 2 == 1) {
                result[index++] = num;
            }
        }
        
        // 第二次遍历：收集所有偶数
        for (int num : nums) {
            if (num % 2 == 0) {
                result[index++] = num;
            }
        }
        
        return result;
    }
}

• 时间复杂度：O(n)
• 空间复杂度：O(n)

双指针交换（推荐）

这道题需要奇数在⼀半，偶数在另外⼀半就可以，并没有要求他们之间的顺序，那么就可以⽤双指针，⼀个指针在左边，⼀个指针在右边，⽐如 1,3,5,6,7 :

左指针往右遍历直到找到偶数，也就是 6 停下来，

右指针往左⾛，直到找到第⼀个奇数，也就是 7 停下来。

两者交换:

左指针继续往右边⾛，两个指针相遇，结束，这个时候其实偶数已经全部在右边了。

这个例⼦⾥⾯只经过⼀次交换，如果是多次交换，那么结束的条件同样也是两个指针相遇。

public class Solution {
    public int[] reorderArray(int[] nums) {
        if (nums == null || nums.length <= 1) {
            return nums;
        }
        
        int left = 0;                    // 左指针，从数组开头开始
        int right = nums.length - 1;     // 右指针，从数组末尾开始
        
        while (left < right) {
            // 左指针向右移动，直到找到偶数
            while (left < right && nums[left] % 2 == 1) {
                left++;
            }
            
            // 右指针向左移动，直到找到奇数
            while (left < right && nums[right] % 2 == 0) {
                right--;
            }
            
            // 如果左指针仍在右指针左边，交换奇偶数
            if (left < right) {
                int temp = nums[left];
                nums[left] = nums[right];
                nums[right] = temp;
                left++;
                right--;
            }
        }
        
        return nums;
    }
}

• 时间复杂度：O(n)，每个元素最多被访问一次
• 空间复杂度：O(1)，只使用了常数级别的额外空间