数组的第k大值

需求：

求数组nums中的第k大数，即从大到小排列的第k个数字。

分析：

1、思路一

借助最小堆求解，创建一个大小是k的最小堆（优先队列），遍历数组，当最小堆大小小于k时，存储数组元素，否则，比较数组元素和队列头元素，如果比队列头元素大，就替换队列头元素，否则继续遍历，最终返回队列头部元素。

2、思路二

借助快排的思想，每次排序，都能将基准数归位，假设归位角标是i，将基准数和第k大的数的位置进行比较，如果相同，那么直接返回基准数，如果基准数在第k大前面，那么求基准数后面数组的第k大，如果基准数在第k大后面，那么求基准数前面数组的第k-(nums.length-i)大，递归求解

代码：

class Solution {
    /*
     * @param k : description of k
     * @param nums : array of nums
     * @return: description of return
     */
    public int kthLargestElement(int k, int[] nums) {
        // write your code here
        if(nums == null || k < 0){
            throw new IllegalArgumentException("illegal parameters");
        }
        
        if(k == 0 || k > nums.length || nums.length == 0){
            return 0;//这几种情况下，理论上什么都不能返回，这里姑且将0作为这种特殊情况下的返回值
        }
        
        //思路一：借助优先队列，复杂度是O(n)
        PriorityQueue<Integer> queue = new PriorityQueue<Integer>(k);
        for(int i = 0; i < nums.length; i++){
            if(queue.size() < k){
                queue.offer(nums[i]);
            }
            else if(nums[i] > queue.peek()){
                queue.poll();
                queue.offer(nums[i]);
            }
        }
        
        return queue.peek();
    }
};

class Solution {
    /*
     * @param k : description of k
     * @param nums : array of nums
     * @return: description of return
     */
    public int kthLargestElement(int k, int[] nums) {
        // write your code here
        if(nums == null || k < 0){
            throw new IllegalArgumentException("illegal parameters");
        }
        
        if(k == 0 || k > nums.length || nums.length == 0){
            return 0;//这几种情况下，理论上什么都不能返回，这里姑且将0作为这种特殊情况下的返回值
        }
       
        //思路二：借助快速排序的方式进行求解，每次快排之后，都会将基准数进行归位，我们将其归位后的角标和nums.length-k进行比较，如果相等，那么直接返回该基准数，如果第k大在基准数之后，那么需要求基准数后面的数组中第k大，如果第k大在基准数之前，那么需要求基准数之前的数组中第k-(nums.length-i)大数，递归求
        int i = 0, j = nums.length-1;
        int key = nums[0];//基准数
        while(i < j){
            while(i < j && nums[j] >= key)
            {
                j--;
            }
            
            while(i < j && nums[i] <= key){
                i++;
            }
            
            if(i == j)
            {
                swap(nums, 0, i);
                break;
            }
            
            swap(nums, i, j);
        }
        
        //基准数已经归位，比较基准数和第k大的位置
        if(i == nums.length-k){
            return nums[i];//如果基准数刚好是第k大，那么直接返回
        }
        else if(i < nums.length-k){
            //如果基准数在第k大前面，那么求基准数后面数组的第k大
            int[] arr1 = new int[nums.length-i-1];
            for(int k1 = 0; k1 < arr1.length; k1++){
                arr1[k1] = nums[k1+i+1];
            }
            
            return kthLargestElement(k, arr1);
        }
        
        //如果基准数在第k大后面，那么求基准数前面数组的第k-(nums.length-i)大
        int[] arr2 = new int[i];
        for(int k2 = 0; k2 < arr2.length; k2++){
            arr2[k2] = nums[k2];
        }
        
        return kthLargestElement(k-(nums.length-i), arr2);
    }
    
    public void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
};