Java 获取双数组的最大k元素

我面临的问题是：

我有一个

double

s数组，我想从中保留顶部

k

更大的值

我见过一些涉及

数组.sort

的实现。例如，对于相关问题，建议使用此方法

因为我只对第一个

k

元素感兴趣，所以我也尝试了

MinMaxPriorityQueue

。我创建了一个

MinMaxPriorityQueue

，其最大大小为

maximumSize

：

当然还有自动装箱

Builder<Comparable> builder = MinMaxPriorityQueue.maximumSize(maximumSize);
MinMaxPriorityQueue<Double> top2 = builder.create();

Builder=MinMaxPriorityQueue.maximumSize（maximumSize）；
MinMaxPriorityQueue top2=builder.create（）；

问题是，顺序是上升的，与我想要的相反。所以我不能这样使用它

为了说明问题的实际参数，我的数组长度约为

50

个元素，我对最上面的

k=5

个元素感兴趣

那么，有没有办法用第二种方法绕过这个问题呢？即使我真的不需要对所有元素进行排序，我是否应该继续使用第一个元素？你知道在速度性能上是否有任何显著的差异（我将不得不在很多情况下使用它，所以这就是需要速度的地方）？有没有其他的解决方案我可以使用

---

至于性能，我知道理论上我可以自己检查，但我有点时间不够了，如果有人有任何解决方案，我很高兴听到（或阅读）

您可以在排序的数组上使用

System.arraycopy

：

double[] getMaxElements(double[] input, int k) {
    double[] temp = Arrays.copyOf(input, input.length);
    Arrays.sort(temp); // Sort a copy to keep input as it is since Arrays.sort works in-place.
    return Arrays.copyOfRange(temp, temp.length - k, temp.length); // Fetch largest elements
}

对于50个元素，排序数组要比处理泛型和可比较项快得多。
我会写一个额外的“快速”算法

double[] getMaxElements2(double[] input, int k) {
    double[] res = new double[k];
    for (int i = 0; i < k; i++) res[i] = Double.NEGATIVE_INFINITY; // Make them as small as possible.
    for (int j = 0; j < input.length; j++) // Look at every element
        if (res[0] < input[j]) { // Keep the current element
            res[0] = input[j];
            Arrays.sort(res); // Keep the lowest kept element at res[0]
        }
    return res;
}

double[]getMaxElements2（double[]input，int k）{
double[]res=新的double[k]；
对于（inti=0；i

---

这是

O（N*k*log（k））

，而第一个是

O（N*log（N））

，如果您只有大约50个元素，正如我在评论中所指出的，只需对其进行排序并获取最后的

k

元素。只有两行：

public static double[] largests(double[] arr, int k) {
    Arrays.sort(arr);
    return Arrays.copyOfRange(arr, arr.length - k, arr.length);
}

这将修改（排序）原始数组。如果希望原始阵列不被修改，则只需+1行：

public static double[] largests2(double[] arr, int k) {
    arr = Arrays.copyOf(arr, arr.length);
    Arrays.sort(arr);
    return Arrays.copyOfRange(arr, arr.length - k, arr.length);
}

---

Arrays.sort（new double[]{…}）

不涉及自动装箱。是的，但它不能以相反的顺序使用

double[]

，为什么需要相反的顺序？只需对它进行排序，然后取最后的

k

元素。是的，这一点你是对的。如果你只有50个元素，那么你就太担心性能了，除非你打算在一个非常小的设备上运行你的程序（旧的安卓手机？）。您是否要扩展它以处理非常大的数组？这将改变

arr

中元素的顺序，请注意，当您尝试使用它时。是的，您是对的。添加了一个不修改原始数组的修改版本。这是我的第一个算法^^^注意，根据javadoc的运行时间是

O（N*log（N））

。我已经用

O（N*k*log（k））

写了一个，它对于小

k

和大

N

更快，特别是当

k

是常数时，线性。是的，我只是利用

数组将代码行减半。注意
数组。copyOf（）
也需要长度（否则编译错误）。@icza谢谢，修复了。