Question

我在尝试使用Divide和conquer实现算法时遇到了问题。

给定一个未排序的数组 T v [] 找到该数组的de v [k] 元素，就像数组已排序但没有对数组进行排序 v

例如，如果 k = 3 且 v = {2，-1，-6,7,4} ，该数组的k元素为 2

由于我无法编辑传递的数组，因此我无法想出另一种方法来对数组进行排序而不将其保存在另一个局部变量上，或者尝试将数组分成快速排序并返回最后一个元素的位置 v 应该是。

如果有帮助，这是我的代码：

public static <T extends Comparable<? super T>> T kesimoRec(T v[], int izq, int der, int k) {
    if(izq < der){
    int inf = izq-1;
    T pivote = v[der];
       for(int i = izq; i < der; ++i){
           if(pivote.compareTo(v[i]) >= 0){
               ++inf;
           }
       }
       ++inf;
       if(inf > izq + k-1){
           return (kesimoRec(v, izq, inf-1, k));
       }else if( inf < izq + k-1){
           return (kesimoRec(v, inf+1, der, k-inf+izq-1));
       }else{
           return v[inf];
       }
    }else{
        return v[der];
    }
}

Answer 1

为什么你使用分而治之？

我建议你使用PriorityQueue。您可以更多地了解PriorityQueue。一旦了解了它的工作原理，您就会发现很容易找到解决方案。我的java代码：

public class Solution {
    public int findKthLargest(int[] nums, int k) {
        PriorityQueue<Integer> queue = new PriorityQueue<Integer>(nums.length);

        for (int num : nums) {
            queue.offer(num);
        }

        for (int i = 0; i < nums.length - k; i++) {
            queue.poll();
        }

        return queue.peek();
    }
}

嗯，对不起，我的解决办法是找到第k个最大的，但是你可以修改它来找到最小的第k个。

Answer 2

分而治之

public static <T extends Comparable<? super T>> T kesimoRec(T v[], int izq,
            int der, int k) {
        if (izq == der) {
            return v[izq];
        }
        int pivote = partir(v, v[der], izq, der);
        if (k == pivote) {
            return v[k];
        } else if (k < pivote) {
            return kesimoRec(v, izq, pivote - 1, k);
        } else {
            return kesimoRec(v, pivote + 1, der, k);
        }
    }

划分和征服 - 未排序数组的k元素

2 个答案: