Java 有效地交替使用整数数组

我有一个快速的小程序，它将取一个

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

---

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

请注意，我们甚至不必使用

System.arraycopy（）

，为输出创建一个新的数组非常方便：

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

---

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

请注意，我们甚至不必使用

System.arraycopy（）

，为输出创建一个新的数组非常方便：

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

---

通过利用

cA

和

dA

数组中的半拆分，可以减少正在执行的循环数量：

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

for（int c=0；c

您可以利用

cA

和

dA

数组中的半拆分来减少正在执行的循环数量：

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

for（int c=0；c

稍微调整一下@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];
    }

int n=arr.length；
int-middle=n/2；
int[]输出=新的int[n]；
对于（int i=0，j=middle；i

稍微调整一下@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];
    }

int n=arr.length；
int-middle=n/2；
int[]输出=新的int[n]；
对于（int i=0，j=middle；i

这里有一个更简单的版本：

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

int n=arr.length；
int-middle=n/2；
int[]输出=新的int[n]；
for（int i=0；i

---

这里有一个更简单的版本：

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

int n=arr.length；
int-middle=n/2；
int[]输出=新的int[n]；
for（int i=0；i

---

预期输出是多少？请给出一个例子@ÓscarLópez添加了一个。很抱歉忘记包含Yes，还有一种更快的方法可以完成上述操作，将循环展开2次，这样你就可以去掉其中的

if

。@harold很抱歉，如果这很明显，但我不确定你所说的“展开循环”是什么意思，在新循环的一次迭代中，从旧循环展开两次迭代。所以双元素i和do

arr[i]=cA[c]；arr[i+1]=dA[c++]-无
如果需要，预期输出是什么？请给出一个例子@ÓscarLópez添加了一个。很抱歉忘记包含Yes，还有一种更快的方法可以完成上述操作，将循环展开2次，这样你就可以去掉其中的
if
。@harold很抱歉，如果这很明显，但我不确定你所说的“展开循环”是什么意思，在新循环的一次迭代中，从旧循环展开两次迭代。所以双元素i和do
arr[i]=cA[c]；arr[i+1]=dA[c++]
-no
如果必要，请注意循环条件可以简化为：
i
（或
j
，相同）@scarLópez:这是真的！谢谢。另外，请注意循环条件可以简化为：
i
（或者
j
，都是一样的）@scarLópez：真的！谢谢你。我不知道为什么你写了2*（i-middle）+1，而下面的代码是有效的：这是最简单的。是的，这是最简单的一个。我是这样写的，因为在我的两个循环中，
arr[I]
部分保持不变。我不知道为什么在以下情况下编写了2*（I-middle）+1：这是最简单的。是的，这是最简单的一个。我这样写是因为在我的两个循环中，
arr[I]
部分保持不变。