215. Kth Largest Element in an Array

一、题目

　　1、审题

　　

　　2、分析

　　　　在一个无序的整形数组中找出第 K 大的元素。

二、解答

　　1、思路：

　　　　方法一、

　　　　　　排序后直接返回。

    public int findKthLargest1(int[] nums, int k) {
        int len = nums.length;
        Arrays.sort(nums);
        return nums[len - k];
    }

　　　　方法二、采用 PriorityQueue

　　　　　　PriorityQueue 对进入的元素进行排序，每次出队的都是最小的元素；

    public int findKthLargest2(int[] nums, int k) {
        // 优先队列
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for(int val: nums) {
            pq.offer(val);
            if(pq.size() > k)
                pq.poll();
        }
        return pq.peek();
    }

　　　　方法三、

　　　　　　1、对数组采用快速排序，确定第一个元素在有序时的下标 j

　　　　　　2、若 j == k 则返回此元素

　　　　　　　　若 j > k 则 high = j - 1; 在对数组左半部分进行快速排序；

　　　　　　　　若 j < k，则 low =  j + 1； 在对数组右半部分进行快速排序；

　　　　　　　　直到 j == k, 返回此元素即可

    public int findKthLargest3(int[] nums, int k) {
        
        k = nums.length - k;
        int low = 0, high = nums.length - 1;
        while(low < high) {
            int j = partition(nums, low, high);
            if(j < k)
                low = j + 1;
            else if(j > k)
                high = j - 1;
            else 
                break;
        }
        return nums[k];
    }
    
    //. 快速排序
    private int partition(int[] nums, int low, int high) {
        int i = low, j = high + 1;
        while(true) {
            while(i < high && nums[++i] < nums[low]);
            while(j > low && nums[low] < nums[--j]);
            if(i >= j)
                break;
            exchange(nums, i, j);
        }
        exchange(nums, low, j);
        return j;
    }

    private void exchange(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }

　　

　　对方法三进行优化：

　　　　为了防止输入的是有序的元素，所造成的效率最差的情况，可以先对数组元素进行乱序。

    public int findKthLargest(int[] nums, int k) {
        shuffle(nums);
        k = nums.length - k;
        int low = 0;
        int high = nums.length - 1;
        while(low < high) {
            int j = partition(nums, low, high);
            if(j < k) 
                low = j + 1;
            else if(j > k)
                high = j - 1;
            else
                break;
        }
        return nums[k];
    }
    
    // we can randomize the input, so that even when the worst case input would be provided the algorithm wouldn't be affected. 
    // So all what it is needed to be done is to shuffle the input.
    private void shuffle(int[] nums) {
        Random random = new Random();
        for (int i = 1; i < nums.length; i++) {
            int r = random.nextInt(i + 1);
            exchange(nums, i, r);
        }
    }
    
    //. 快速排序
    private int partition(int[] nums, int low, int high) {
        int i = low, j = high + 1;
        while(true) {
            while(i < high && nums[++i] < nums[low]);
            while(j > low && nums[low] < nums[--j]);
            if(i >= j)
                break;
            exchange(nums, i, j);
        }
        exchange(nums, low, j);
        return j;
    }

    private void exchange(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }