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

我认为，此代码在逻辑上是错误的。因为如果您使用此代码切换号码，

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

您不能保留偶数。

只在数组中搜索奇数，然后对奇数排序怎么办？

Answer 2

对于像冒泡排序这样的简单算法，您可以使用cars[]

来忽略偶数。

continue

Answer 3

改为使用以下代码：

            lineItem.values.update({attribute:value})

Answer 4

只是为了好玩：

使用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 5

另一种可能的解决方案是将原始数组包装在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 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();
    }
}

如何跳过某些数组索引？

6 个答案: