Question

给定一个int s数组，我想交替重新排列它，即第一个元素应该是最小值，第二个应该是最大值，第三个是第二个 - 最小值，第四个是第二个 - 最大值等等......

我完全迷失在这里......

Answer 1

另一种方法不需要三个独立数组的空间，但不像重新排序那样复杂，就是对原始数组进行排序，然后创建一个新数组。然后开始使用指向新数组的当前第i个索引的指针和从第0个索引开始的指针和已排序数组的最后一个索引进行迭代。

public class Foo {

    public static void main(String[] args) {
        // Take your original array
        int[] arr = { 1, 4, 5, 10, 6, 8, 3, 9 };
        // Use the Arrays sort method to sort it into ascending order (note this mutates the array instance)
        Arrays.sort(arr);
        // Create a new array of the same length
        int[] minMaxSorted = new int[arr.length];
        // Iterate through the array (from the left and right at the same time)
        for (int i = 0, min = 0, max = arr.length - 1; i < arr.length; i += 2, min++, max--) {
            // the next minimum goes into minMaxSorted[i]
            minMaxSorted[i] = arr[min];
            // the next maximum goes into minMaxSorted[i + 1] ... but
            // guard against index out of bounds for odd number arrays
            if (i + 1 < minMaxSorted.length) {
                minMaxSorted[i + 1] = arr[max];
            }
        }
        System.out.println(Arrays.toString(minMaxSorted));
    }
}

Answer 2

提示：

创建两个新数组，第一个按照同意顺序排序，另一个按降序排序。然后从第二个数组中选择第一个元素，从第一个数组中选择第一个元素，重复此选择，直到达到第一个和第二个数组的一半。你会得到你想要的阵列。

希望这会对你有所帮助。

Answer 3

@ Kaushal28的回答方法是初学者的最佳方法。它需要更多空间（数组的2个额外副本），但它易于理解和编码。

高级程序员可能会考虑对数组进行一次排序，然后重新排列元素。它应该工作，但逻辑很复杂。

提示：你玩过“Clock Patience”吗？

Answer 4

这是另一种选择：监控已排序的索引，并搜索其余的下一个最小值/最大值：

import java.util.Arrays; import java.util.Set;

/**
 * Demonstrates an option for sorting an int[] array as requested,
 * by keeping a list of the array indices that has been sorted, and searching
 * for the next min / max.
 * This code is not optimal nor robust. It serves a demo for this option only.
 *
 */
public class AltSort  {

    //list of array elements that were sorted
    static Set<Integer> indexSorted ;

    public static void main (String[] args) throws java.lang.Exception      {
        //test case
        int[] array = new int[]{7,22,4,67,5,11,-9,23,48, 3, 73, 1, 10};
        System.out.println(Arrays.toString(altSort2(array)));

        //test case
        array = new int[]{ 1, 4, 5, 10, 6, 8, 3, 9 };
        System.out.println(Arrays.toString(altSort2(array)));
    }

    private static int[] altSort2(int[] array) {

        if((array == null) || (array.length == 0)) {
            System.err.println("Empty or null array can not be sorted.");
        }

        //returned array
        int[] sortedArray = new int[array.length];

        //flag indicating wether to look for min or max
        boolean lookForMin = true;

        int index = 0;
        while(index < array.length) {

            if(lookForMin) {
                sortedArray[index] = lookForArrayMin(array);

            }else {
                sortedArray[index] = lookForArrayMax(array);
            }

            index++;
            //alternate look for min / look for max
            lookForMin = ! lookForMin;
        }

        return sortedArray;
    }

    private static int lookForArrayMin(int[] array) {

        int minValue = Integer.MAX_VALUE;
        int minValueIndex = 0;

        for( int i =0; i< array.length; i++ ){

            //if array[i] is min and was not sorted before, keep it as min
            if( (array[i]< minValue) && ! indexSorted.contains(i) ) {

                minValue = array[i]; //keep min
                minValueIndex = i;   //keep min index
            }
        }

        //add the index to the list of sorted indices
        indexSorted.add(minValueIndex);
        return minValue;
    }

    private static int lookForArrayMax(int[] array) {

        int maxValue = Integer.MIN_VALUE; //max value
        int maxValueIndex = 0;   //index of max value

        for( int i =0; i< array.length; i++ ){

            //if array[i] is max and was not sorted before, keep it as max
            if( (array[i] > maxValue) && ! indexSorted.contains(i)) {
                maxValue = array[i]; //keep max
                maxValueIndex = i;   //keep max index
            }
        }

        //add the index to the list of sorted indices
        indexSorted.add(maxValueIndex);
        return maxValue;
    }
}

Answer 5

此解决方案基于Aaron Davis解决方案。我试图让循环更容易理解：

public class AltSort  {

    //list of array elements that were sorted
    static Set<Integer> indexSorted = new HashSet<Integer>();

    public static void main (String[] args) throws java.lang.Exception

    {
        //test case
        int[] array = new int[]{7,22,4,67,5,11,-9,23,48, 3, 73, 1, 10};
        System.out.println(Arrays.toString(altSort(array)));

        //test case
        array = new int[]{ 1, 4, 5, 10, 6, 8, 3, 9 };
        System.out.println(Arrays.toString(altSort(array)));
    }

    private static int[] altSort(int[] array) {

        if((array == null) || (array.length == 0)) {
            System.err.println("Empty or null array can not be sorted.");
        }

        Arrays.sort(array);

        //returned array
        int[] sortedArray = new int[array.length];
        int firstIndex = 0, lastIndex = array.length-1;

        for (int i = 0; i < array.length; i++) {

            if((i%2) == 0) { //even indices

                sortedArray[i] = array[firstIndex++];
            }
            else {
                sortedArray[i] = array[lastIndex --];
            }
        }

        return sortedArray;
    }
}

在最小和最大java中重新排列数组

5 个答案: