Java &引用；删除“；数组中的偶数和向前移动的奇数

首先——这不是家庭作业——我在上次面试中得到了这个问题，但没能完成

所以问题是这样的：“给定长度为n的int数组k，'删除'所有偶数，并将奇数移到前面”。它的措辞有点奇怪，因为他们说删除，但示例表明我应该将所有奇数放在数组前面（从0-index开始），偶数可以在所有奇数之后保留在数组中（或者不保留，这无关紧要）。 例如：

{1, 4, 6, 8, 7, 2} -> {1, 7, whatever}
{2, 4, 6, 9, 5} -> {9, 5, whatever}

我希望尽可能的高效。我无法使用任何其他库或临时数组

到目前为止，我得到了这个，但我被卡住了：

private static void removeEven(int[] k, int n) {
for (int i = 0; i < n; i++) {
  if (k[i] % 2 == 0) {
    k[i] = // don't know
  }
}

private static void removeven（int[]k，int n）{
对于（int i=0；i

下面的伪代码将首先返回具有赔率的数组，最后返回偶数，并保留奇数和偶数子集的原始顺序

if array.length < 2 
  return array
else
  p=0
  while array[p].odd and p < array.length
    p++
  q = p+1
  if q < array.length
    repeat
      if array[q].odd
        swap(array,p,q) p++ q++
      else
        q++
    until q >= array.length

如果array.length<2
返回数组
其他的
p=0
而数组[p]。奇数和p=array.length

我会颠倒这个方法，我的意思是不是去掉偶数，我会把奇数移到前面，这就是它们，它们不关心数组中剩下的东西，所以我的方法是

private static int moveOddToFront(int[] k) {
    int frontIndex = 0;
    for (int i = 0; i < k.length; i++) {
        boolean isOdd = k[i] % 2 != 0;
        if (isOdd) {
            k[frontIndex] = k[i];
            frontIndex++;
        }
    }

    int newSize = frontIndex;
    return newSize;
}

私有静态int-moveOddToFront（int[]k）{
int frontIndex=0；
for（int i=0；i

我想在循环中需要一个计数器来记忆返回数组的位置。 我使用了这段代码，将所有剩余的数组位置置为0

private static void removeEven(int[] k, int n) {
    int counter = 0;
    for (int i = 0; i < n; i++) 
        if (k[i] % 2 == 1)
            k[counter++] = k[i];
    for (int i=counter; i<n; i++)
        k[i] = 0;
}

private static void removeven（int[]k，int n）{
int计数器=0；
对于（int i=0；i对于（int i=counter；i您可以使用一个临时变量来设置要移动的值，而不是使用另一个变量来设置要移动的值的位置

代码：

for (int i = 0, j = 0; i < n; i++) {
        if (k[i] % 2 != 0 ) {
            int tempInt = k[j];
            k[j] = k[i];
            k[i] = tempInt;
            j++;
        }
    }

for（int i=0，j=0；i
我想我只需要维护两个变量，它们指向数组中的位置。一个指向下一个偶数（从开头开始），另一个指向下一个奇数（从结尾开始）。虽然下一个偶数的索引比下一个奇数的索引低，但可以交换它们。下面是工作和测试的代码：

public static void main(String[] args) {
    int[] test = {2, 4, 6, 9, 5};
    int currentEven = -1;
    int currentOdd = test.length;
    while (currentEven < currentOdd) {
        currentEven = nextEvenIndex(currentEven + 1, test);
        currentOdd = nextLastOddIndex(currentOdd - 1, test);

        if (currentEven < currentOdd) {
            swap(currentOdd, currentEven, test);
        }
    }

    for (int i = 0; i < test.length; i++) {
        System.out.print(test[i]);
    }
}

private static int nextEvenIndex(int start, int[] array) {
    while (start < array.length) {
        if (array[start] % 2 == 0) {
            return start;
        }
        start++;
    }
    return -1;
}

private static int nextLastOddIndex(int start, int[] array) {
    while (start >= 0) {
        if (array[start] % 2 == 1) {
            return start;
        }
        start--;
    }
    return -1;
}

private static void swap(int index1, int index2, int[] array) {
    int swap = array[index1];
    array[index1] = array[index2];
    array[index2] = swap;
}

publicstaticvoidmain（字符串[]args）{
int[]测试={2,4,6,9,5}；
int current偶数=-1；
int currentOdd=测试长度；
while（电流偶数<电流奇数）{
Current偶数=下一个偶数（Current偶数+1，测试）；
currentOdd=nextLastOddIndex（currentOdd-1，测试）；
if（电流偶数<电流奇数）{
交换（电流奇数、电流偶数、测试）；
}
}
对于（int i=0；i=0）{
if（数组[开始]%2==1）{
返回启动；
}
开始--；
}
返回-1；
}
专用静态无效交换（int index1、int index2、int[]数组）{
int swap=数组[index1]；
数组[index1]=数组[index2]；
数组[index2]=交换；
}

这是O（n），这是我认为你在这里能得到的最好的表现

这也比这里的许多其他答案表现得更好，因为一个数字永远不会交换两次；也就是说，大多数其他解决方案迭代整个数组（有时进行不必要的交换），而这只迭代了一半。
以下是解决方案：

 private static int[] removeEven(int[] k, int n) {
            for (int i = 0; i < n; i++) {
              if (k[i] % 2 == 0) {
                  for(int j=i+1; j<n; j++){
                      if(k[j] % 2 != 0){
                          k[i] = k[i] + k[j];
                          k[j] = k[i] - k[j];
                          k[i] = k[i] - k[j];
                          break;//if we get a odd number then we swap it with the even one and so we need not need to proceed the inner loop as the k[i] is already swaped with an oddd number
                      }
                  }
              }
            }
            return k;
         }

private static int[]removeEven（int[]k，int-n）{
对于（int i=0；i对于（intj=i+1；j使用下面的代码，我们可以从数组中删除所有偶数，并写入其余数组

public static void main (String[] args) {
        int a[]={7,9,7,8,4};

        for(int i=0;i<a.length;i++){
            boolean x=false;
            if(a[i]%2==0){
                x=true;
            }
            if(!x){
                System.out.println(a[i]);
            }
        }

    }

publicstaticvoidmain（字符串[]args）{
int a[]={7,9,7,8,4}；
对于（inti=0；i一个简单的python解决方案

def moveEven(arr):
    start, end = 0, len(arr)-1
    while start <= end:
        if arr[start] % 2 == 0:
            arr[start], arr[end] = arr[end], arr[start]
            end -= 1
        else:
            start += 1

def移动偶数（arr）：
开始，结束=0，长度（arr）-1
当开始时，它必须是相同的数组。你将偶数放在前面！！不，我正在删除偶数，将奇数放在前面。请尝试执行我的代码，结果将与你要求的相同！抱歉，这根本不起作用。我用{5，4，3，8，6，4，9，7，6}测试了它，结果是{5,3,9,7,6,4,9,7,6}。如果你看原始数组，你会发现你有4个奇数，在调用之后，它们被放在数组的前面，新的大小将是4，问题是{奇数，随便什么}我希望正确的答案能涵盖所有数组长度，而不仅仅是上面给出的长度。无论如何，现在这并不重要。我真的不明白这个答案有什么错，如果数组的其余部分让你感到困扰，那么你可以将它们设为0或其他什么，问题是它不关心数组的其余部分。请进一步澄清好的，如果你完全忽略偶数元素，你的解决方案是有效的。我发现有些解决方案不会忽略偶数元素。