Algorithm 在任意数组中查找给定秩的元素

我正在做的是使用快速排序算法，以便将我的枢轴元素（始终是数组的第一个元素）定位到其在已排序数组中的适当位置，我将再次调用此方法，直到我不将元素定位到给定的秩。有更好的解决方案吗

这是我的密码：

public static int arbitrary(int a[],int x,int y,int rank)//x and y are first and last indecies of the array
{
    int j=y,temp;
    if(x<y)
    {
        for(int i=y;i>x;i--)
        {
            if(a[i]>a[x])
            {
                temp=a[i];
                a[i]=a[j];
                a[j]=temp;
                j--;
            }
        }
        temp=a[x];
        a[x]=a[j];
        a[j]=temp;
        //System.out.println("j is "+j);
        if(j==rank)
            return a[j];
        else if(rank<j)
            return arbitrary(a,x,j-1,rank);
        else
            return arbitrary(a,j+1,y,rank);
    }
    else
        return 0;

}

publicstaticintarbitral（inta[]，intx，inty，intrank）//x和y是数组的第一个和最后一个索引
{
int j=y，温度；
如果（xx；i--）
{
如果（a[i]>a[x]）
{
温度=a[i]；
a[i]=a[j]；
a[j]=温度；
j--；
}
}
温度=a[x]；
a[x]=a[j]；
a[j]=温度；
//System.out.println（“j是”+j）；
if（j==秩）
返回a[j]；
否则，如果（rank调用您实现的算法。
只需选择一个随机支点，就可以摆脱时间复杂度为O（n²）的最坏情况。

预期的运行时间现在大约是
3.4n+o（n）


Quickselect可能是性能和简单性之间的最佳折衷方案

更高级的轴心选择策略会导致
1.5n+o（n）
预期时间
（）

有趣的事实：使用确定性算法，你无法比
2n
更好。例如，需要大约
2.95n
来选择中值。
使用快速排序方法查找排名元素的最佳方法：


在快速排序中，在每次迭代中，您都能够固定一个枢轴元素

当RankElement==PivotIndex时，则中断该条件并返回值


公共类{
公共无效查找（int[]arr、int low、int high、int k）{
如果（低<高）{
int pivot=分区（arr、低、高、k）；
查找（arr，低位，枢轴-1，k）；
查找（arr，枢轴+1，高，k）；
}
}
公共int分区（int[]arr、int-low、int-high、int-k）{
数据透视指数=高；
while（低<高）{
而（低<高&&arr[low]高&&arr[high]>=arr[pivotIndex]）{
高--；
}
如果（低<高）{
交换（arr、低、高）；
}
}
掉期（arr、数据透视指数、高）；
如果（数据透视索引==k）{
System.out.println（“数组值：+arr[k]+”索引：+k）；
返回k；
}
高回报；
}
私有无效交换（整数[]arr，整数低，整数高）{
内部温度=arr[低]；
arr[低]=arr[高]；
arr[高]=温度；
}
}
你所说的秩元素是什么意思？如果说“秩”，你的意思是“如果对元素进行排序，那么元素在数组中的位置”，构造一个并用它来找到第n个最大的元素。@Kevin是的，这就是我所说的秩。你能详细说明你的答案吗？因为我不完全明白minheap是如何帮助我的，因为在构建minheap之后，我能知道的是，所有最大的n/2元素都在叶中，其他什么都没有……谢谢你的回答
public class FindRank {
 public void find(int[] arr, int low, int high, int k) {
    if (low < high) {
        int pivot = partition(arr, low, high, k);
        find(arr, low, pivot - 1, k);
        find(arr, pivot + 1, high, k);
    }
}

public int partition(int[] arr, int low, int high, int k) {
    int pivotIndex = high;
    while (low < high) {
        while (low < high && arr[low] <= arr[pivotIndex]) {
            low++;
        }
        while (low > high && arr[high] >= arr[pivotIndex]) {
            high--;
        }
        if (low < high) {
            swap(arr, low, high);
        }
    }
    swap(arr, pivotIndex, high);
    if (pivotIndex == k) {
        System.out.println("Array Value:" + arr[k] + " index:" + k);
        return k;
    }
    return high;
}

private void swap(int[] arr, int low, int high) {
    int temp = arr[low];
    arr[low] = arr[high];
    arr[high] = temp;
 }
}