Java冒泡排序后分离奇偶数组出现冗余0值的问题

问题根源 #

int类型数组初始化时，未赋值的元素默认值为0。如果直接创建与原数组（长度15）等长的奇偶数组，当偶数/奇数数量少于15时，数组中未填充的位置会保留默认的0，导致输出出现冗余值。

原始问题代码示例（推测） #

import java.util.Scanner;

public class SortAndSplit {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] original = new int[15];
        
        // 输入15个数字
        for (int i = 0; i < 15; i++) {
            original[i] = sc.nextInt();
        }
        
        // 冒泡排序
        int[] sorted = original.clone();
        for (int i = 0; i < sorted.length - 1; i++) {
            for (int j = 0; j < sorted.length - i - 1; j++) {
                if (sorted[j] > sorted[j+1]) {
                    int temp = sorted[j];
                    sorted[j] = sorted[j+1];
                    sorted[j+1] = temp;
                }
            }
        }
        
        // 拆分奇偶数组（问题所在：直接用原长度创建数组）
        int[] evens = new int[15];
        int[] odds = new int[15];
        int evenIndex = 0, oddIndex = 0;
        
        for (int num : sorted) {
            if (num % 2 == 0) {
                evens[evenIndex++] = num;
            } else {
                odds[oddIndex++] = num;
            }
        }
        
        // 输出结果
        System.out.println("原数组：");
        for (int num : original) {
            System.out.print(num + " ");
        }
        System.out.println("\n排序后的偶数数组：");
        for (int num : evens) {
            System.out.print(num + " ");
        }
        System.out.println("\n排序后的奇数数组：");
        for (int num : odds) {
            System.out.print(num + " ");
        }
    }
}

实际输出示例 #

原数组：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
排序后的偶数数组：
2 4 6 8 10 12 14 0 0 0 0 0 0 0 0
排序后的奇数数组：
1 3 5 7 9 11 13 15 0 0 0 0 0 0 0

预期输出示例 #

原数组：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
排序后的偶数数组：
2 4 6 8 10 12 14
排序后的奇数数组：
1 3 5 7 9 11 13 15

解决方案 #

核心思路：先统计排序后数组中偶数和奇数的数量，再创建对应长度的数组，避免多余的默认0值。

修正后的代码 #

import java.util.Scanner;

public class SortAndSplitFixed {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] original = new int[15];
        
        // 输入15个数字
        for (int i = 0; i < 15; i++) {
            original[i] = sc.nextInt();
        }
        
        // 冒泡排序
        int[] sorted = original.clone();
        for (int i = 0; i < sorted.length - 1; i++) {
            for (int j = 0; j < sorted.length - i - 1; j++) {
                if (sorted[j] > sorted[j+1]) {
                    int temp = sorted[j];
                    sorted[j] = sorted[j+1];
                    sorted[j+1] = temp;
                }
            }
        }
        
        // 统计偶数和奇数的数量
        int evenCount = 0, oddCount = 0;
        for (int num : sorted) {
            if (num % 2 == 0) {
                evenCount++;
            } else {
                oddCount++;
            }
        }
        
        // 创建对应长度的奇偶数组
        int[] evens = new int[evenCount];
        int[] odds = new int[oddCount];
        int evenIndex = 0, oddIndex = 0;
        
        // 填充数组
        for (int num : sorted) {
            if (num % 2 == 0) {
                evens[evenIndex++] = num;
            } else {
                odds[oddIndex++] = num;
            }
        }
        
        // 输出结果
        System.out.println("原数组：");
        for (int num : original) {
            System.out.print(num + " ");
        }
        System.out.println("\n排序后的偶数数组：");
        for (int num : evens) {
            System.out.print(num + " ");
        }
        System.out.println("\n排序后的奇数数组：");
        for (int num : odds) {
            System.out.print(num + " ");
        }
    }
}

代码说明 #

1. 统计数量：遍历排序后的数组，分别计数偶数和奇数的个数，确保数组长度刚好匹配实际元素数量。
2. 按需创建数组：根据统计的数量创建奇偶数组，避免多余的存储空间。
3. 填充并输出：填充完成后，数组中所有位置都被有效元素占据，输出时不会出现冗余0。

内容的提问来源于stack exchange，提问作者Anuj Kulkarni