Java 如何高效地按一个数组对另一个数组排序

假设我有以下设置：

double[] vectorUsedForSorting = new double[] { 5.8,6.2,1.5,5.4 }
double[] vectorToBeSorted = new double[] {1.1,1.2,1.3,1.4}

我想根据排序时使用的

向量的自然数字顺序对
向量tobesorted
进行排序

例如，自然排序为
[1.5,5.4,5.8,6.2]
，对应于索引
[2,3,0,1]
，这意味着我希望排序函数的输出为
[1.3,1.4,1.1,1.2]

我如何以最绝对有效/最快速的方式完成这项工作？我最关心的是时间复杂性，因为我将对1000000个长度的数组执行此操作

快速/高效的回答将获得巨额奖金。
对第一个表执行合并排序，同时对第二个表执行相同的操作。复杂性保证
对第一个表执行合并排序，同时对第二个表执行相同的操作。复杂性保证
简单的解决方案：

class D implements Comparable<D> {
    double key;
    double value;

    @Override
    public int compareTo(D other) {
        return Double.compare(key, other.key);
    }
}

public class Test {
    public static void main(String[] args) {
        double[] vectorUsedForSorting = new double[] { 5.8,6.2,1.5,5.4 };
        double[] vectorToBeSorted = new double[] {1.1,1.2,1.3,1.4};

        D[] array = new D[vectorUsedForSorting.length];
        for (int i = 0; i < array.length; i++) {
            array[i] = new D();
            array[i].key = vectorUsedForSorting[i];
            array[i].value = vectorToBeSorted[i];
        }

        Arrays.sort(array);

        for (int i = 0; i < array.length; i++) {
            vectorToBeSorted[i] = array[i].value;
        }

        System.out.println(Arrays.toString(vectorToBeSorted));

    }
}

D类实现了可比较的{
双键；
双重价值；
@凌驾
公共国际比较（D其他）{
返回Double.compare（key，other.key）；
}
}
公开课考试{
公共静态void main（字符串[]args）{
double[]vectorUsedForSorting=新的double[]{5.8,6.2,1.5,5.4}；
double[]vectorToBeSorted=新的double[]{1.1,1.2,1.3,1.4}；
D[]数组=新的D[vectorUsedForSorting.length]；
for（int i=0；i

对于辅助数组和对象，这确实需要一些额外的内存，但在执行时间上应该接近最优
 简单解决方案：

class D implements Comparable<D> {
    double key;
    double value;

    @Override
    public int compareTo(D other) {
        return Double.compare(key, other.key);
    }
}

public class Test {
    public static void main(String[] args) {
        double[] vectorUsedForSorting = new double[] { 5.8,6.2,1.5,5.4 };
        double[] vectorToBeSorted = new double[] {1.1,1.2,1.3,1.4};

        D[] array = new D[vectorUsedForSorting.length];
        for (int i = 0; i < array.length; i++) {
            array[i] = new D();
            array[i].key = vectorUsedForSorting[i];
            array[i].value = vectorToBeSorted[i];
        }

        Arrays.sort(array);

        for (int i = 0; i < array.length; i++) {
            vectorToBeSorted[i] = array[i].value;
        }

        System.out.println(Arrays.toString(vectorToBeSorted));

    }
}

D类实现了可比较的{
双键；
双重价值；
@凌驾
公共国际比较（D其他）{
返回Double.compare（key，other.key）；
}
}
公开课考试{
公共静态void main（字符串[]args）{
double[]vectorUsedForSorting=新的double[]{5.8,6.2,1.5,5.4}；
double[]vectorToBeSorted=新的double[]{1.1,1.2,1.3,1.4}；
D[]数组=新的D[vectorUsedForSorting.length]；
for（int i=0；i

对于辅助数组和对象，这确实需要一些额外的内存，但在执行时间上应该接近最优
 嗯，我不确定，你能写一个方法吗？我会奖励奖金的。是的，很好。我会写一些东西，如果它比梅里顿快，我会告诉你答案。干杯。嗯，我不确定，你能写一个方法吗？我会奖励奖金的。是的，很好。我会写一些东西，如果它比梅里顿快，我会告诉你答案。干杯。A）写排序B）传递两个数组C）仅根据第一个数组的值同时排序。你改变主意了吗？现在你真的需要排序了吗？A）写排序B）传递两个数组C）只根据第一个数组的值同时排序。你改变主意了吗？现在你真的需要排序了吗？这个算法是O（nlogn），因为Arrays.sort（）是O（nlogn）。这可能是它得到的最好的结果，100万个数据点对应560毫秒。很好，这个算法是O（nlogn），因为Arrays.sort（）是O（nlogn）。这可能是它得到的最好的结果，100万个数据点对应560毫秒。很好。