Question

我正在做的是使用快速排序算法，以便我的pivot元素（它始终是数组的第一个元素定位到排序数组中的适当位置，我再次调用此方法，直到我做不要将元素置于给定的等级。是否有更好的解决方案？

这是我的代码：

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;

}

Answer 1

您实施的算法称为Quickselect。只需选择一个随机的枢轴，摆脱O（n²）时间复杂度的最坏情况预期的运行时间现在约为3.4n + o(n) Quickselect可能是性能和简单性之间的最佳权衡。

更高级的枢轴选择策略会产生1.5n + o(n)预期时间（Floyd-Rivest Algorithm）。

有趣的事实：使用确定性算法，您不能比2n更好。 BFPRT例如需要大约2.95n来选择中位数。

Answer 2

使用QuickSort方法查找Rank元素的最佳方法：

在QuickSort中，每次迭代都可以固定一个枢轴元素。



当RankElement == PivotIndex时，打破条件并返回值。

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;
 }
}

在任意数组中查找给定等级的元素

2 个答案: