leetcode 215. 数组中的第K个最大元素

方法1：排序

class Solution {
    public int findKthLargest(int[] nums, int k) {
        int n = nums.length;
        Arrays.sort(nums);
        return nums[n-k];
    }
}

方法2：最小堆

class Solution {
    //优先队列来解决该问题，维护一个最小堆，如果当堆中元素等于k，来新元素时，如果新元素大于最小的堆元素，则进行替换
    public int findKthLargest(int[] nums, int k) {
        PriorityQueue<Integer> pq = new PriorityQueue<>((a,b)->a-b);//维护一个最小堆
        int n = nums.length;
        for(int i=0 ; i<n ; ++i){
            if(pq.size() == k){
                if(nums[i] > pq.peek()){
                    pq.poll();
                    pq.offer(nums[i]);
                }
            }else{
                pq.offer(nums[i]);
            }
        }

        return pq.peek();
    }
}

快速排序

class Solution {
    //快速排序版本
    Random r = new Random();
    int res=Integer.MIN_VALUE; //最终答案
    public int findKthLargest(int[] nums, int k) {
        quickSort(nums, 0, nums.length-1, k);
        return res;
    }

    public void quickSort(int[] nums, int left, int right, int k){
        if(res != Integer.MIN_VALUE){ //如果最终答案出现了，则不再递归
            return;
        }
        int ran = r.nextInt(right-left+1)+left; //随机选择要排序的元素作为要确定位置的元素
        if(left > right){
            return;
        }
        swap(nums, left, ran);
        int pivot = nums[left];
        int l=left, r=right;
        while(l<r){
            while(l<r && nums[r] >= pivot){ //这里一定要先移动后面的r指针
                --r;
            }
            while(l<r && nums[l] <= pivot){
                ++l;
            }
            if(l<r){
                swap(nums, l, r);
            }
        }
        //System.out.println(l);
        swap(nums, l, left);
        if(l > nums.length-k){
            quickSort(nums, left, l, k);
        }else if(l<nums.length-k){
            quickSort(nums, l+1, right, k);
        }else{
            res = nums[l]; //如果确定的位置在第k大处，则改变res，退出递归
            return;
        }

    }

    public void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

堆排序（自己建堆）

class Solution {
    //建堆
    public int findKthLargest(int[] nums, int k) {
        buildHeap(nums);
        int n = nums.length;
        //System.out.println(1);
        for(int i=0 ; i<k-1 ; ++i){
            swap(nums, 0, n-i-1);
            adjustHeap(nums, 0, n-i-1);
        }
        return nums[0];
    }

    public void buildHeap(int[] nums){
        int n = nums.length;
        for(int i=(n/2)-1 ; i>=0 ; --i){
            adjustHeap(nums, i, n);
            //System.out.println(Arrays.toString(nums));
        }
    }

    public void adjustHeap(int[] nums, int k, int end){
        int num = nums[k];
        for(int i=k ; 2*i+1<end ; ){
            int temp = 2*i+1;
            if(2*i+2 < end && nums[2*i+2] > nums[temp]){
                temp = 2*i+2;
            }
            if(num<nums[temp]){
                swap(nums, i, temp);
                i = temp;
            }
            else{
                break;
            }
        }
    }

    public void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}