数组奇偶元素分离排序问题求助（仅用数组实现）

嘿，我完全懂你现在卡在哪了——这个需求看起来简单，但要只用数组实现确实得捋清楚步骤。你的思路方向非常对：先分离奇偶，再分别排序，咱们把这个思路落地成可运行的代码，而且完全不碰集合类：

方案一：临时数组分离+分别排序+合并 #

这个方案逻辑直观，先把奇偶分开存到临时数组，各自排序后再合并回原数组：

public class SortEvenOdd {
    public static void main(String[] args) {
        int[] a = {3,2,5,6,4,9,11,7};
        sortEvenThenOdd(a);
        // 打印验证结果
        for (int num : a) {
            System.out.print(num + " ");
        }
        // 预期输出：2 4 6 3 5 7 9 11
    }

    public static void sortEvenThenOdd(int[] arr) {
        // 1. 统计偶数和奇数的数量，用来创建对应长度的临时数组
        int evenCount = 0, oddCount = 0;
        for (int num : arr) {
            if (num % 2 == 0) evenCount++;
            else oddCount++;
        }

        // 2. 分离偶数和奇数到临时数组
        int[] evenArr = new int[evenCount];
        int[] oddArr = new int[oddCount];
        int evenIdx = 0, oddIdx = 0;
        for (int num : arr) {
            if (num % 2 == 0) evenArr[evenIdx++] = num;
            else oddArr[oddIdx++] = num;
        }

        // 3. 分别对偶数、奇数数组做升序排序（这里用选择排序，也可以换冒泡/插入排序）
        sortAsc(evenArr);
        sortAsc(oddArr);

        // 4. 合并回原数组
        System.arraycopy(evenArr, 0, arr, 0, evenCount);
        System.arraycopy(oddArr, 0, arr, evenCount, oddCount);
    }

    // 基础的升序排序方法（选择排序实现）
    private static void sortAsc(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) minIndex = j;
            }
            // 交换当前位置和最小元素的位置
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

方案二：原地分区+局部排序（更节省空间） #

如果不想用额外的临时数组，可以先在原数组里把偶数移到前面、奇数移到后面，再分别对前后两个区域排序：

public class SortEvenOddInPlace {
    public static void main(String[] args) {
        int[] a = {3,2,5,6,4,9,11,7};
        sortEvenThenOddInPlace(a);
        for (int num : a) {
            System.out.print(num + " ");
        }
    }

    public static void sortEvenThenOddInPlace(int[] arr) {
        // 1. 原地分区：把所有偶数交换到数组前半部分
        int evenPointer = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 2 == 0) {
                // 交换当前元素和evenPointer位置的元素
                int temp = arr[i];
                arr[i] = arr[evenPointer];
                arr[evenPointer] = temp;
                evenPointer++;
            }
        }

        // 2. evenPointer就是奇数区域的起始索引，分别对前后两部分排序
        sortAscRange(arr, 0, evenPointer - 1); // 排序偶数区域
        sortAscRange(arr, evenPointer, arr.length - 1); // 排序奇数区域
    }

    // 对数组指定范围做升序排序
    private static void sortAscRange(int[] arr, int start, int end) {
        for (int i = start; i < end; i++) {
            int minIndex = i;
            for (int j = i + 1; j <= end; j++) {
                if (arr[j] < arr[minIndex]) minIndex = j;
            }
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

关键说明 #

• 两种方案都完全依赖数组操作，没有使用任何集合类；
• 排序部分用的是基础的选择排序，你也可以换成冒泡排序、插入排序，逻辑都是相通的；
• 方案二的原地分区思路类似快速排序的分区逻辑，能节省额外的数组空间。

内容的提问来源于stack exchange，提问作者Diaz diaz