剑指offer：第k大元素

第k大元素 

 

给出数组 [9,3,2,4,8]，第三大的元素是 4

给出数组 [1,2,3,4,5]，第一大的元素是 5，第二大的元素是 4，第三大的元素是 3，以此类推

 

这是一道非常重要的笔试题，思路有三：

1. 最直观的，就是排下序，取第k大的元素就行了。但是时间复杂度有点高， O(nlgn)

2.利用类似于快速排序中的分治法，每次找到首元素（随意，这里设为首元素）应该在的位置，如果找到了第k个位置上的元素，则返回。

3.上述方法的平均时间复杂度是 O(n), 但是必须要修改数组。 可以选择一个数据容器，每次保存前k小个数，使用小根堆来实现，每次比较一个新元素，查看它与小根堆的堆顶大小，如果比堆顶大的话，将堆顶元素poll，然后把这个新元素add进去，最后堆顶元素就是第k大元素了，可用红黑树来实现。

代码   思路2：

    public int kthLargestElement(int k, int[] nums) {
        if(k<0||k>nums.length){return 0;}
        int pre = 0;
        int last = nums.length-1;
        int mid = patition(nums, pre, last);
        while (mid!=k){
            if(mid<k){
                mid = patition(nums, mid, last);
            }else{
                mid = patition(nums, pre, mid);
            }
        }
        return nums[mid];
    }
    public int patition(int[] arr, int pre, int last){
        int pivot = arr[pre];
        while (pre<last){
            while(pre<last && arr[last]>=pivot){last--;}
            arr[pre] = arr[last];
            while (pre<last && arr[pre]<=pivot){pre++;}
            arr[last] = arr[pre];
        }
        arr[pre] = pivot;
        return pre;
    }

代码 思路3：

    public int top_K(int[] arr, int k){
        PriorityQueue<Integer> pq = new PriorityQueue<>(k, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        int i = 0;
        for(;i<k;i++){
            pq.add(arr[i]);
        }
        for(;i<arr.length;i++){
            if(arr[i]>pq.peek()){
                pq.poll();
                pq.add(arr[i]);
            }
        }
        return pq.peek();
    }