Question

我有一个快速的小程序，需要int[]并用最小的数字替换其中最大的数字。

值得注意的是，该程序只需要处理长度为偶数的int[]。

是否有更快的方法来完成数组的交替，而不将数组的两半复制到单独的数组中，然后将它们合并回初始数组？

import java.util.Arrays;

public class Main {
    public void run() {
        int[] arr = {1, 9, 14, 12, 2, 5, 8, 7, 3, 6, 4, 13, 10, 11};
        Arrays.sort(arr);

        int length = arr.length;
        int length2 = length / 2;

        int[] cA = new int[length2];
        int[] dA = new int[length2];

        int c = 0;

        System.arraycopy(arr, 0, cA, 0, length2);
        System.arraycopy(arr, length2, dA, 0, length2);

        for(int i = 0; i < length; i++) {
            if(i % 2 == 0) {
                arr[i] = cA[c];
            } else {
                arr[i] = dA[c];
                c++;
            }
        }

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

    public static void main(String[] args) {
        new Main().run();
    }
}

上述示例的预期输出为

[1, 8, 2, 9, 3, 10, 4, 11, 5, 12, 6, 13, 7, 14]

Answer 1

假设输入数组具有偶数长度，我们可以对原始数组进行单次传递，遍历前半部分然后遍历后半部分，将值复制到正确的位置。

请注意，我们甚至不必使用int n = arr.length; int middle = n / 2; int[] output = new int[n]; for (int i = 0; i < middle; i++) output[2 * i] = arr[i]; for (int i = middle; i < n; i++) output[2 * (i - middle) + 1] = arr[i];，为输出创建一个新数组就派上用场了：

System.out.println(Arrays.toString(output));
=> [1, 8, 2, 9, 3, 10, 4, 11, 5, 12, 6, 13, 7, 14]

结果如预期：

Answer 2

您可以利用cA和dA数组中的半分割来降低正在进行的循环次数：

for(int c = 0; c < length2; c++) {
    arr[c*2] = cA[c];
    arr[c*2 + 1] = dA[c];
}

Answer 3

稍微调整@Oscar的解决方案，我们可以将循环次数减少一半。

    int n = arr.length;
    int middle = n / 2;
    int[] output = new int[n];

    for (int i = 0, j = middle; i < middle; i++, j++){
        output[2 * i] = arr[i];
        output[2 * (j - middle) + 1] = arr[j];
    }

Answer 4

这是一个更简单的版本：

    int n = arr.length;
    int middle = n / 2;
    int[] output = new int[n];

    for (int i = 0; i < middle; i++){
        output[2 * i] = arr[i];
        output[2 * i + 1] = arr[i + middle];
    }

Demo.

有效地交替int数组

4 个答案: