Java 查找数组中第n个最大数的最有效方法？

我想知道这是否是在未排序数组中查找第n个最大数的最有效方法。我所做的是用mergeSort排序，然后找到第n个最高数字的索引。我认为这比大多数搜索更有效，但我不太确定

import java.util.Arrays;
public class ThirdHighest {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    int [] a = new int[]{3,5,6,7,8,2,1,10,9};
    System.out.print(Arrays.toString(a));
    mergeSort(a);
    System.out.print(Arrays.toString(a));
    System.out.print(nHighestValue(a, 3));

}
public static void mergeSort(int[] arr) {
    if(arr.length > 1) {
        int lengthLeft = arr.length / 2;

        int [] left = Arrays.copyOfRange(arr, 0, lengthLeft);
        int [] right = Arrays.copyOfRange(arr, lengthLeft, arr.length);
        mergeSort(left);
        mergeSort(right);
        merge(arr, left, right);
    }
}
public static void merge(int[] result, int[] left, int[] right){
    int l1 = 0;
    int r2 = 0;
    while(l1 < left.length || r2 < right.length) {
        if(l1 == left.length) {
            result[l1+r2] = right[r2];
            r2 += 1;
        } else if(r2 == right.length){
            result[l1+r2] = left[l1];
            l1 += 1;
        } else if(left[l1] < right[r2]) {
            result[l1 + r2] = left[l1];
            l1 += 1;
        } else {
            result[l1+r2] = right[r2];
            r2 += 1;
        }
    }
}
public static int nHighestValue(int[] a, int n) {
    int index = a.length - n;
    return a[index];

}

}

导入java.util.array；
公务舱第三名{
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
int[]a=新的int[]{3,5,6,7,8,2,1,10,9}；
System.out.print（Arrays.toString（a））；
合并（a）；
System.out.print（Arrays.toString（a））；
系统输出打印（nHighestValue（a，3））；
}
公共静态无效合并排序（int[]arr）{
如果（arr.length>1）{
int lengthLeft=阵列长度/2；
int[]left=Arrays.copyOfRange（arr，0，lengthLeft）；
int[]right=Arrays.copyOfRange（arr，lengthLeft，arr.length）；
合并排序（左）；
合并排序（右）；
合并（arr、左、右）；
}
}
公共静态无效合并（int[]结果，int[]左，int[]右）{
int l1=0；
int r2=0；
而（l1

如@alitereralmind所示，可以在O（n）中找到未经统计的数据中的最低值或最高值

---

查找第n个最高值（根据要求）更为复杂，因为您需要跟踪最佳候选人。这将扫描变成一个N深度的插入排序，其值不在前N之内，并从末尾掉出来。虽然这可能比进行完整排序更有效，但我不确定它是否值得对正常大小的问题进行额外的编码工作。。。特别是如果可能再次发出类似的查询，并且可以重用初始排序。

随机算法的平均大小写复杂度为O（n）。实际上，O（n^2）是非常罕见的。它使用快速排序的分区函数

排序为O（n log n）。我认为这可以在O（k*n）中完成。该死的，我在堆栈上的第一个问题太糟糕了(