0

我必须创建一个程序，该程序接受一个包含偶数和奇数的数组，并将所有偶数放入一个数组中，将所有奇数放入另一个数组中。我使用 for 循环遍历所有数字并确定它们是偶数还是奇数，但我遇到的问题是，由于原始数组中的数字是随机的，我不知道偶数的大小或奇数数组，因此无法弄清楚如何将原始数组中的数字分配给偶数/奇数数组，而不会留下一堆点，或者没有足够的点容纳所有数字。有任何想法吗？

4

7 回答 7

4

尝试使用 ArrayList。您可以使用

num % 2 == 0

查看 num 是偶数还是奇数。如果它确实 == 0 那么它是偶数，否则它是奇数。

List<Integer> odds = new ArrayList(); 
List<Integer> evens = new ArrayList();

for (int i = 0; i< array.length; i++) {
   if (array[i] % 2 == 0) {
      evens.add(array[i]);
   }
   else {
       odds.add(array[i]);
   }
}

将 ArrayLists 转换回您可以执行的数组

int[] evn = evens.toArray(new Integer[evens.size()]);

（注：未经测试的代码，所以可能有一些错别字）

编辑：

如果您不允许使用 ArrayLists，请考虑以下仅使用 Arrays 的内容。它的效率不如原始数组的两次传递

int oddSize = 0; 
int evenSize = 0; 

for (int i = 0; i< array.length; i++) {
   if (array[i] % 2 == 0) {
      evenSize++;
   }
   else {
      oddSize++;
   }
}


Integer[] oddArray = new Integer[oddSize];
Integer[] evenArray = new Integer[evenSize];

int evenIdx = 0;
int oddIdx = 0;

for (int i = 0; i< array.length; i++) {
   if (array[i] % 2 == 0) {
      evenArray[evenIdx++] = array[i];
   }
   else {
      oddArray[oddIdx++] = array[i];
   }
}
于 2012-09-03T21:27:10.503 回答
1

您可以在不使用数组或任何 '%' 的情况下做到这一点只是一个简单的想法

input = new Scanner(System.in);
    int x;
    int y = 0; // Setting Y for 0 so when you add 2 to it always gives even
                // numbers
    int i = 1; // Setting X for 1 so when you add 2 to it always gives odd
                // numbers
    // So for example 0+2=2 / 2+2=4 / 4+2=6 etc..
    System.out.print("Please input a number: ");
    x = input.nextInt();

    for (;;) { // infinite loop so it keeps on adding 2 until the number you
                // input is = to one of y or i
        if (x == y) {
            System.out.print("The number is even ");
            System.exit(0);
        }
        if (x == i) {
            System.out.print("The number is odd ");
            System.exit(0);
        }
        if (x < 0) {
            System.out.print("Invald value");
            System.exit(0);
        }
        y = y + 2;
        i = i + 2;

    }

}
于 2015-03-28T14:47:57.977 回答
0

改用 a List。然后你不需要提前声明大小，它们可以动态增长。

如果你真的需要一个数组，你总是可以toArray()在之后使用该方法。List

于 2012-09-03T21:26:25.127 回答
0

上述答案是正确的，并描述了人们通常如何实现这一点。但是你的问题的描述让我认为这是一个动态列表可能不受欢迎的类分配。

所以这里有一个替代方案。

将数组排序为奇数和偶数两部分。然后计算有多少奇数/偶数并将值复制到两个数组中。

像这样的东西：

static void insertionSort(final int[] arr) {
    int i, j, newValue;
    int oddity;
    for (i = 1; i < arr.length; i++) {
        newValue = arr[i];
        j = i;
        oddity = newValue % 2;
        while (j > 0 && arr[j - 1] % 2 > oddity) {
            arr[j] = arr[j - 1];
            j--;
        }
        arr[j] = newValue;
    }

}

public static void main(final String[] args) {
    final int[] numbers = { 1, 3, 5, 2, 2 };
    insertionSort(numbers);

    int i = 0;
    for (; i < numbers.length; i++) {
        if (numbers[i] % 2 != 0) {
            i--;
            break;
        }
    }

    final int[] evens = new int[i + 1];
    final int[] odds = new int[numbers.length - i - 1];
    if (evens.length != 0) {
        System.arraycopy(numbers, 0, evens, 0, evens.length);
    }
    if (odds.length != 0) {
        System.arraycopy(numbers, i + 1, odds, 0, odds.length);
    }

    for (int j = 0; j < evens.length; j++) {
        System.out.print(evens[j]);
        System.out.print(" ");
    }
    System.out.println();
    for (int j = 0; j < odds.length; j++) {
        System.out.print(odds[j]);
        System.out.print(" ");
    }
}
于 2012-09-03T22:15:00.337 回答
0

使用以下代码：

public class ArrayComparing {

    Scanner console= new Scanner(System.in);
    String[] names;
    String[] temp;
    int[] grade;

    public static void main(String[] args) {
        new ArrayComparing().getUserData();
    }

    private void getUserData() {
        names = new String[3];    
        for(int i = 0; i < names.length; i++) {
            System.out.print("Please Enter Student name: ");
            names[i] =console.nextLine();
            temp[i] = names[i];
        }

        grade = new int[3];    
        for(int i =0;i<grade.length;i++) {
            System.out.print("Please Enter Student marks: ");
            grade[i] =console.nextInt();
        }          

        sortArray(names);     
    }

    private void sortArray(String[] arrayToSort) {
        Arrays.sort(arrayToSort);

        getIndex(arrayToSort);
    }

    private void getIndex(String[] sortedArray) {
        for(int x = 0; x < sortedArray.length; x++) {
            for(int y = 0; y < names.length; y++) {
                if(sortedArray[x].equals(temp[y])) {
                    System.out.println(sortedArray[x] + " " + grade[y]);
                }
            }
        }
    }
}
于 2012-09-06T17:41:38.713 回答
0

我想象有两种可能性，如果你不能使用列表，你可以迭代两次来计算偶数和奇数的数量，然后构建两个具有该大小的数组并再次迭代以在每个数组中分配数字，但是这个解决方案是缓慢而丑陋的.

我想象另一种解决方案，仅使用一个数组，即包含所有数字的同一个数组。您可以对数组进行排序，例如在左侧设置偶数，在右侧设置奇数。然后你有一个索引与数组中的位置与这两个部分的分离。在同一个数组中，您有两个带有数字的子数组。当然使用有效的排序算法。

于 2012-09-04T22:17:56.513 回答
0

遍历您的源数组两次。第一次通过，计算奇数和偶数的数量。由此，您将知道两个目标数组的大小。创建它们，然后再通过源数组，这次将每个值复制到相应的目标数组。

于 2012-09-03T22:52:05.247 回答