Question

情况：

两个具有整数值的数组（两者的长度相同）。

我需要什么：

Array1应该与arrays2具有相同的顺序。这意味着，array1的最大值应该在array2的最大值的位置，依此类推。

示例：

1) 
Array1= [2, 3, 5, 7]
Array2= [4, 9, 6, 1]
Target= [3, 7, 5, 2]

说明：4是array2的第二个最小值，所以在目标数组中这个位置应该是array1的第二个最小值，即3. ...

2) 
Array1= [9, 1, 4, 8]
Array2= [1, 2, 3, 4]
Target= [1, 4, 8, 9]

说明：array2从最低到最高排序，因此array1必须以相同的方式排序。

问题：

对于长度为[10] - [999]的数组，在短时间内完成此操作的最佳方法是什么？当然，我可以编写一个循环来遍历所有数组的数组并检查每个数组，它具有哪个位置（循环内部循环），为两个数组执行此操作，然后使用正确的顺序构建新数组。这需要很长时间，需要大量资源（大多数CPU和一些MEM）。我正在寻找最有效的方法。（对时间的最优化不是mem，更重要的是快速执行以保存mem）。

我希望它清楚，我想要什么。

感谢您的帮助。

Answer 1

这是O（n log（n））时间复杂度。按Array2的值对索引列表进行排序，并将相反的顺序应用于Array1：

public class EqualizeOrder {
    public static void main(String[] args) {
        final int[] array1 = new int[] { 2, 3, 5, 7 };
        final int[] array2 = new int[] { 4, 9, 6, 1 };
        final Integer[] indices = new Integer[] { 0, 1, 2, 3 };

        //sort the indices accordingly to array2
        Arrays.sort(indices, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(array2[o1], array2[o2]);
            }
        });


        //array1 must be sorted before applying reverse order
        Arrays.sort(array1);

        int[] target = new int[array1.length];
        //applying the reverse order to output array
        for (int i = 0; i<target.length; i++) {
            target[indices[i]] = array1[i];
        }

        System.out.println("Array1 = "+Arrays.toString(array1));
        System.out.println("Array2 = "+Arrays.toString(array2));
        System.out.println("indices= "+Arrays.toString(indices));
        System.out.println("Target = "+Arrays.toString(target));
    }
}

输出：

Array1 = [2, 3, 5, 7]
Array2 = [4, 9, 6, 1]
indices= [3, 0, 2, 1]
Target = [3, 7, 5, 2]

均衡两个数组的顺序

1 个答案: