如何跳过某些数组索引？

Question

只需要对数组中的奇数进行排序，但偶数必须保留在原位。

这是我的代码：

public static int[] sortArray(int[] array) {

    int length = array.length;
    int temp = 0;


    for (int i = 0; i < length; i++) {
        for (int j = 1; j < length - i; j++) {
            if (j > 0 && array[j] % 2 == 0)continue;

                if (array[j - 1] > array[j]){
                    temp = array[j - 1];
                    array[j - 1] = array[j];
                    array[j] = temp;
                }
            }
        }

    return array;
}

输入：new int[]{5, 3, 2, 8, 1, 4, 0}

输出：[1, 3, 5, 2, 8, 4, 0]

但我需要：[1, 3, 2, 8, 5, 4, 0]

如何跳过数组中的某些索引？

认为这应该与continue操作符连接，但我不知道该怎么做。

Answer 1

改用此代码：

public static int[] sortArray(int[] array) {

    int length = array.length;

    for (int i = 0; i < length - 1; i++) {
        int k = -1; // The index of last odd element
        for (int j = 0; j < length - i; j++)
            if (array[j] % 2 != 0) {
                if (k >= 0 && array[k] > array[j]) {
                    int temp = array[k];
                    array[k] = array[j];
                    array[j] = temp;
                }
                k = j;
            }
    }

    return array;
}

Answer 2

对于像冒泡排序这样的简单算法，您可以使用continue 忽略偶数

for(int i=0; i<ar.length; i++) {
    if(ar[i] % 2 == 0) continue;
    for(int j=i; j<ar.length; j++) {
        if(ar[j] % 2 == 0) continue;

        if(ar[i] > ar[j]) {
        int temp = ar[i];
        ar[i] = ar[j];
        ar[j] = temp;
    }
}

Answer 3

只是为了好玩：

使用 Lamda 和 Stream ;-)

import java.util.Arrays;

public class IntSort {

    public static void main(String[] args) {
        int[] array = new int[]{5, 3, 2, 8, 1, 4, 0};

        sortOnlyOddRemainEven(array);

        System.out.println(Arrays.toString(array));
    }

    public static void sortOnlyOddRemainEven(int[] array) {

        // get list of sorted odd numbers
        int[] odd = Arrays.stream(array).filter( x -> x % 2 != 0).sorted().toArray();

        int c = 0;
        for (int i = 0; i < array.length; i++) {
            if(array[i] % 2 != 0)
            {
                // replace each odd number in the array with the sorted one
                array[i] = odd[c++];
            }
        }
    }
}

Answer 4

另一种可能的解决方案是将原始数组包装在 OddArray 类中，这使得底层原始数组看起来只包含奇数条目。比如：

class OddArray {

  int[] baseArray;

  // Constructor
  OddArray(int[] base) {
    this.baseArray = base;
  }

  // Getter
  public int get(int index) {
    return baseArray[2 * index + 1];  // Odd entries only.
  }

  // Setter
  public void set(int index, int value) {
    baseArray[2 * index + 1] = value;  // Odd entries only.
  }

  // Return changed baseArray.
  public int[] getBaseArray() {
    return baseArray;
  }

} // end class OddArray

这需要添加一些错误检查等，但它隐藏了所有偶数位置，允许您将数组视为仅存在奇数位置并且编号为 0、1、2，... 一旦数组排序，调用OddArray.getBaseArray() 检索整个数组。

Answer 5

在我看来，这段代码在逻辑上是错误的。 因为如果你用这个代码切换号码，

temp = array[j - 1];
array[j - 1] = array[j];
array[j] = temp;

你不能保持偶数的位置。

只搜索数组中的奇数，然后对奇数进行排序怎么样？

Answer 6

另一个关于流的答案：

import java.util.Arrays;
import java.util.LinkedList;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

class IntSort {

    public static void main(String[] args) {
        int[] array = new int[]{5, 3, 2, 8, 1, 4, 0};
        final int[] result = sortOnlyOddRemainEven(array);
    }

    public static int[] sortOnlyOddRemainEven(int[] array) {
        final LinkedList<Integer> collect;
        collect = Arrays.stream(array)
                        .filter(x -> x % 2 != 0)
                        .boxed()
                        .sorted()
                        .collect(Collectors.toCollection(LinkedList::new));

        return IntStream.of(array)
                        .map(value -> value % 2 != 0 ? collect.pop() : value)
                        .toArray();
    }
}