Question

首先 - 这不是作业 - 我在上一次采访中得到了这个问题而且无法完成。

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

{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
  }
}

Answer 1

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

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;
}

Answer 2

我想在循环中需要一个计数器来记忆返回数组的位置。我已经使用了这个代码，将所有剩余的数组位置都设置为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;
}

我希望这会回答你的回答！

Answer 3

我想我只会维护指向数组中位置的两个变量。一个人会指向下一个偶数（从头开始），一个指向下一个奇数（从结尾开始）。虽然下一个偶数的索引低于下一个奇数，但交换它们。这是经过工作和测试的代码：

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;
}

这是O（n），这是我认为你可以在这里获得的最佳表现。

这也比其他许多答案都要好，因为数字永远不会交换两次;也就是说，大多数其他解决方案遍历整个数组（有时会进行不必要的交换），而迭代只有一半。

Answer 4

以下是解决方案：

 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;
         }

Answer 5

像下面的伪代码一样，首先返回带有赔率的数组，最后一次，并保留奇数和偶数子集的原始顺序。

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

Answer 6

您可以使用临时变量放置要移动的值，而不是使用其他变量来设置要移动值的位置。

代码：

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++;
        }
    }

Answer 7

使用下面的代码，我们可以从数组中删除所有偶数，然后写入其余数组。

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]);
            }
        }

    }

Answer 8

一个简单的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

Answer 9

我的解决方案将所有奇数放在数组的前面，其余位置为零。

测试用例：

int[] array1 = { 1, 4, 6, 8, 7, 2 };
int[] array2 = { 2, 4, 6, 9, 5 };

reverse(array1,6);  // result: [1, 7, 0, 0, 0, 0]
reverse(array2,5);  // result: [9, 5, 0, 0, 0]

代码：

public static void reverse(int[] array, int N) {
    if (N < 2) {
        return;
    }
    int index = 0;  // index at which the next odd number should be placed
    for (int i = 0; i < N; i++) {
        if (array[i] % 2 == 1) {
            array[index] = array[i];
            if (i > index) {
                array[i] = 0;
            }
            index++;
        } else {
            array[i] = 0;
        }
    }
}

“从数组中删除”偶数并将奇数移到前面

9 个答案: