Java：操作数组

我知道如何按升序和降序对

数组进行排序，但我正在尝试创建一个特定的模式。例如，我有一个随机排列的
数组。如何在模式中对该
数组
进行排序？“最小的，最大的，第二小的，第二大的，第三小的，第三大的……”等等。有什么想法吗

int[] pattern = {8, 6, 1, 2, 3, 80, 56};

//这是开始

public class Test2 {

    public static void main(String[] args) {
        int[] array = {1,4,2,6,9,3,65,77,33,22};
        for (int i = 0; i < array.length; i++) {
            System.out.print(" " + array[i]);
        }
        wackySort(array);

    }

    //This sorts the array    
    public static void wackySort(int[] nums) {
        int sign = 0;
        int temp = 0;
        int temp2 = 0;
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums.length -1; j++) {
                if (nums[j] > nums[j+1]) {
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;

                }
            }
        }
        System.out.println();
        int firstPointer = 0;
        int secondPointer = nums.length -1;
        int[] newarray = new int[nums.length];
        for (int i = 0; i < nums.length; i+=2) {
            newarray[i] = nums[firstPointer++];
            newarray[i] = nums[secondPointer--];
        }
        for (int i = 0; i < newarray.length; i++) {
            System.out.print(" " + newarray[i]);
        }
    }
}

公共类Test2{
公共静态void main（字符串[]args）{
int[]数组={1,4,2,6,9,3,65,77,33,22}；
for（int i=0；inums[j+1]）{
温度=毫微秒[j]；
nums[j]=nums[j+1]；
nums[j+1]=温度；
}
}
}
System.out.println（）；
int firstPointer=0；
int secondPointer=nums.length-1；
int[]newarray=newint[nums.length]；
对于（int i=0；i
您可以先对其排序，然后从第二个元素开始，与最后一个元素交换，等等。
也许您可以（或必须）先对数组排序，然后按顺序排列元素。
实现Comparable或Comparator，以便定义数组中元素的排序方式。以下页面可能会有所帮助：
看起来像是家庭作业。这是一个简单的提示

步骤1:按升序对数组排序

{1, 2, 3, 6, 8, 56, 80};

步骤2:分配一个相同大小的新数组

步骤3迭代第一个数组，两个计数器。一分在前，另一分在后。现在在新数组中，分配第一个计数器的数据，然后将计数器增加1。接下来分配最后一个计数器的数据，并将其减少1

    int firstPointer = 0;
    int secondPointer = nums.length - 1;
    int[] newarray = new int[nums.length];
    int i = 0;
    for (i = 0; i < nums.length-1; i += 2) {
        newarray[i] = nums[firstPointer++];
        newarray[i+1] = nums[secondPointer--];
    }
    if(i<nums.length-1)
        newarray[i] = nums[firstPointer++];

int firstPointer=0；
int secondPointer=nums.length-1；
int[]newarray=newint[nums.length]；
int i=0；
对于（i=0；i如果（i尝试使用列表而不是数组

public <T extends Comparable<? super T>> List<T> interleave(List<T> list) {
    final int size = list.size();
    final List<T> sorted =  new ArrayList<T>(list);
    Collections.sort(sorted);  // Now, it's sorted.
    final List<T> reversed = new ArrayList<T>(sorted);
    Collections.reverse(reversed); // Now, it's reverse sorted.
    final List<T> interleaved = new ArrayList<>();
    for (int i= 0; i < size/2; ++i) {
        interleaved.add(sorted.get(i));
        interleaved.add(reversed.get(i));
    }
    if (size % 2 == 1) {
        interleaved.add(sorted.get(size/2 + 1));
    }
    return interleaved;
}

public此代码有古怪的分类：

public static void wackySort(int[] nums) {
    Arrays.sort(nums);
    int size = nums.length;
    int[] result = new int[size];
    for (int i = 0; i < size / 2; i++) {
        result[i * 2] = nums[i];
        result[i * 2 + 1] = nums[size - 1 - i];
    }
    // one extra copy is required to handle both odd and even array sizes
    result[size - 1] = nums[size / 2];
    System.arraycopy(result, 0, nums, 0, size);
}

输出：

[1, 80, 2, 56, 3, 8, 6]
[1, 80, 2, 56, 3, 8, 5, 6]

我的方法是使用
数组列表
，然后会有数百万种排序方法。1.对数组排序。2.先取，后取，后取，再取n-1，等等。我认为这是正确的方法。我正在试图弄清楚for循环会是什么样子。有什么帮助吗？按照@defaultlocale的建议进行排序最容易找到通过分别处理偶数长度数组和奇数长度数组来计算交换逻辑。我认为这是正确的方法。我正在尝试弄清楚for循环会是什么样子。有什么帮助吗？您可以跟踪两个索引。一个从索引1开始，另一个在数组长度-1。交换，然后增加/减少两个，然后重复直到t嘿，cross.将索引增加2.不需要跟踪两个索引我不认为特定的交换会起作用。例如，
长度/2
处的元素需要结束在数组的末尾，但你的索引不可能实现这一点。嗯，是的，我想你必须从中间开始。我会的想一想…我想这可能就是我想要的。这只是一个伪代码来说明问题。写一个完整的check@Binka稍微修改了我的代码..现在检查.在未分配输出[i+1]的数组中使用相同alsto我刚刚指出了这个概念。你需要处理排列长度异常的情况。谢谢，它越来越近了。它正在向后做并打印zzeros。
[1, 80, 2, 56, 3, 8, 6]
[1, 80, 2, 56, 3, 8, 5, 6]