Node:

Quick Select: Avg O(N)

Thought: put all the element less(more) than pivot to the first part, the rest to the second part. And Kth only falls to one of the two sections. Just using the same idea to process that part is enough.

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 || nums.length == 0) {
            return -1;
        }
        return quickSelect(nums, 0, nums.length - 1, k);
    }
    
    private int quickSelect(int[] nums, int start, int end, int k)  {
        
 
if (start == end) {
            return nums[start];
        }
        
        int pivot = nums[start + (end - start) / 2];
        int left = start;
        int right = end;
        while (left <= right) {
            while (left <= right && nums[left] > pivot) {
                left
 
++;
            }
            while (left <= right && nums[right] < pivot) {
                right--;
            }
            if (left <= right) {
                int tmp = nums[left];
                nums[left] = nums[right];
                nums[right] = tmp;
                left++;
                right--;
            }
        }
        
        if (start + k - 1 <= right) {
            return quickSelect(nums, start, right, k);
        }
        if (start + k - 1 >= left) {
            //This is the k -(left - start)th of the last part
            return quickSelect(nums, left, end, k - (left - start));
        }  
        
        return nums[right + 1];
    }
};

Kth Largest Element