首页 文章

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

提问于
浏览 次
3

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

所以问题是这样的：“给定长度为n的int数组k，'删除'所有偶数并将奇数移到前面” . 它的措辞有点奇怪，因为他们说删除，但实例表明我应该把所有奇数放在数组前面（从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
  }
}
java arrays

7 回答

  • 0

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

    我希望这能回应你的回答！

    回复于
  • 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;
}
    回复于
  • 1

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

    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），这是我认为你可以在这里获得的最佳表现 .

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

    回复于
  • 1

    这是解决方案：

    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;
         }
    回复于
  • 1

    如下所示的类似下面的伪代码将首先返回带有赔率的数组，最后一次，并将保留奇数和偶数子集的原始顺序 .

    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
    回复于
  • 0

    您可以使用临时变量放置要移动的值，而不是使用另一个变量来设置要移动值的位置 .

    代码：

    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++;
        }
    }
    回复于
  • 0

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

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

    }
    回复于

相关问题