Question

注意：这个问题是昨天发布的，深夜，并没有得到足够的答案。我添加了一些细节并重新发布。

作为一项任务，我的任务是创建中位数排序的中位数，这也可以确定数组的第n个最小元素（即排序数组的索引0是第1个最小的元素）。这种类型是递归的，这导致我的问题理解它，因为我没有广泛地使用递归。

通过拼凑教程和我对算法的研究，我已经非常接近成功创建该方法;但是，我目前正在返回错误的值。当我希望它返回索引0处的值时，QS（A，1）的输入将返回索引1中包含的值：

public static int QS(int[] A, int k){

    List<Integer> AList = new ArrayList<Integer>();

    if(k < 1 || k >= A.length){
        System.out.println("Code called because k = "+k);
        return -1;
    }

    for (int i = 0; i < A.length; i++){
            AList.add(A[i]);
    }

    if (AList.size() < 14) {
        Collections.sort(AList);
        return AList.get(k);
    }

    ArrayList<Integer> medians = new ArrayList<Integer>();

    for (int i = 0; i < AList.size() - AList.size() % 7; i = i + 7){
        medians.add(medianFind(AList.subList(i, i + 7)));
    }

    int a = medianFind(medians);
    ArrayList<Integer> left = partitionFind(AList, a, true);
    ArrayList<Integer> right = partitionFind(AList, a, false);
    int[] leftArray = new int[left.size()];
    int[] rightArray = new int[right.size()];

    for(int i = 0; i < left.size(); i++){
        leftArray[i] = left.get(i);
    }

    for(int i = 0; i < right.size(); i++){
        rightArray[i] = right.get(i);
    }   

    if(left.size() + 1 == k){
        return a;
    }
    else if(left.size() > k){
        return QS(leftArray, k);
    }
    else{
        return QS(rightArray, k - left.size());
    }

}

/////////

public static int medianFind(List<Integer> AList) {
    Collections.sort(AList);
    return AList.get(AList.size() / 2);
}

/////////

public static ArrayList<Integer> partitionFind(List<Integer> AList, int b, boolean lessThan) {
    ArrayList<Integer> store = new ArrayList<Integer>();
    for (int element : AList)
        if (element < b && lessThan)
                store.add(element);
        else if (element >= b && !lessThan)
                store.add(element);
    return store;
}

为了将最终返回的索引修改为-1，我很难在此算法中绕过递归。我不能简单地做出以下改变：

    if (AList.size() < 14) {     //old 
        Collections.sort(AList);
        return AList.get(k);
    }

    if (AList.size() < 14) {     //new 
        Collections.sort(AList);
        return AList.get(k-1);
    }

因为这有时会导致return QS(rightArray, k - left.size())传递小于1的参数。我也不认为我可以添加：

if(nothing left to sort){
    return AList.get(k-1) 
}

语句由于算法的递归性质。我已经在这方面工作了很长时间但没有成功，并且非常感谢我应该对这个问题采取哪些措施。

Answer 1

//returns the k^th smallest element in the array A for 0<k<A.length  
public static int QuickSelect(int[] A, int k){

        List<Integer> AList = new ArrayList<Integer>();

        if(A.length<k||k<1){
            System.out.println("k out of range, got k: "+k +", but A.length: "+A.length);
            return -1;
        }

        for (int i = 0; i < A.length; i++){
                AList.add(A[i]);
        }

此时我们知道AList.size()>0，所以得到元素k-1，这是列表中第k个最小的元素

        if (AList.size() < 14) {
            Collections.sort(AList);
            return AList.get(k-1);
        }

        ArrayList<Integer> medians = new ArrayList<Integer>();


        for (int i = 0; i < AList.size() - AList.size() % 7; i = i + 7){
            medians.add(medianFind(AList.subList(i, i + 7)));
        }

***您忘记查找上一个AList.size()-( AList.size() % 7)元素的中位数

      int a = medianFind(medians);
            ArrayList<Integer> left = partitionFind(AList, a, true);
            ArrayList<Integer> right = partitionFind(AList, a, false);

添加med变量来计算中位数

的出现次数

            int med=AList.size()-(left.size()+right.size())
            int[] leftArray = new int[left.size()];
            int[] rightArray = new int[right.size()];

        for(int i = 0; i < left.size(); i++){
            leftArray[i] = left.get(i);
        }

        for(int i = 0; i < right.size(); i++){
            rightArray[i] = right.get(i);
        }

不完全确定其余部分的逻辑，但我认为以下更有意义（注意我修改了PartitionFind）

        if(left.size() >= k){
            return QuickSelect(leftArray, k);
        }
        else if(left.size()+med<k){
            return QuickSelect(rightArray, k-(left.size()+med));
        }
        else{
            return a;
        }

    }

    /////////

    public static int medianFind(List<Integer> AList) {
        Collections.sort(AList);
        return AList.get(AList.size() / 2);
    }

    /////////

注意：我对此进行了修改，以便子问题变得非常小（例如，你可以将b作为列表中最大的元素，例如，右数组仍然包含整个列表）

    public static ArrayList<Integer> partitionFind(List<Integer> AList, int b, boolean lessThan) {
        ArrayList<Integer> store = new ArrayList<Integer>();
        for (int element : AList)
            if (element < b && lessThan)
                    store.add(element);
            else if (element > b && !lessThan)
                    store.add(element);
        return store;
    }

让我知道这是否有效

修改在中位数Quickort中位数找到的第k个元素

1 个答案: