It won't last for 70 days. The k-largest number in the array

 Calling array sort Api
 In ascending order , Take the penultimate k Elements .
 Time complexity ：O(n*logn)

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

    }
}

 author ：fen-zi-yun-he
 link ：https://leetcode.cn/problems/xx4gT2/solution/-by-fen-zi-yun-he-4qjy/
 source ： Power button （LeetCode）
 The copyright belongs to the author . Commercial reprint please contact the author for authorization , Non-commercial reprint please indicate the source .





 Use priority queues PriorityQueue
PriorityQueue The default is ascending , So if PriorityQueue There are more than k individual , Just remove the smallest element in the pile .
 The last remaining k The first of the elements , It's what you want .
 Time complexity ：O(n*logn), Spatial complexity ：O(n)


class Solution {
    public int findKthLargest(int[] nums, int k) {
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for(int i = 0; i < nums.length; i ++) {
            pq.offer(nums[i]);
            if(pq.size() > k) {
                // If the stack storage quantity exceeds k, Remove the smallest element of the stack 
                pq.poll();
            }
        }
        return pq.poll();
    }
}

 author ：fen-zi-yun-he
 link ：https://leetcode.cn/problems/xx4gT2/solution/-by-fen-zi-yun-he-4qjy/
 source ： Power button （LeetCode）
 The copyright belongs to the author . Commercial reprint please contact the author for authorization , Non-commercial reprint please indicate the source .



 Sort by hand 
 Time complexity ：O(n*logn), Spatial complexity ：O(n)

class Solution {
    public int findKthLargest(int[] nums, int k) {
       nums = queueSort(nums, 0, nums.length - 1);
       return nums[nums.length - k];
    }

    private int[] queueSort(int[] nums, int left, int right) {
        if(left == right) {
            //  This is not a return nums, Instead, it returns a length of 1 New array 
            return new int[]{nums[left]};
        }
        int mid = left + (right - left >> 1);
        int[] leftArr = queueSort(nums, left, mid);
        int[] rightArr = queueSort(nums, mid + 1, right);
        return merge(leftArr, rightArr);
    }

    private int[] merge(int[] left, int[] right) {
        int len1 = left.length, len2 = right.length;
        int[] tmp = new int[len1 + len2];
        int i = 0, j = 0;
        int idx = 0;
        while(i < len1 && j < len2) {
            if(left[i] < right[j]) {
                tmp[idx ++] = left[i ++];
            } else {
                tmp[idx ++] = right[j ++];
            }
        }
        while(i < len1) {
            tmp[idx ++] = left[i ++];
        }
        while(j < len2) {
            tmp[idx ++] = right[j ++];
        }
        return tmp;
    }
}

 author ：fen-zi-yun-he
 link ：https://leetcode.cn/problems/xx4gT2/solution/-by-fen-zi-yun-he-4qjy/
 source ： Power button （LeetCode）
 The copyright belongs to the author . Commercial reprint please contact the author for authorization , Non-commercial reprint please indicate the source .




 Sort by handwriting pile 
 Time complexity ：O(n*logn), Spatial complexity ：O(1)

class Solution {
    public int findKthLargest(int[] nums, int k) {
        for(int i = 0; i < nums.length; i ++) {
            heapInsert(nums, i);
        }
        int size = nums.length;
        if(k == 1) {
            return nums[0];
        } else {
            for(int i = 0; i < k - 1; i ++) {
                swap(nums, 0, -- size);
                heapify(nums, 0, size);
            }
            return nums[0];
        }
    }

    private void heapInsert(int[] nums, int index) {
        while(nums[index] > nums[(index - 1) / 2]) {
            swap(nums, index, (index - 1) / 2);
            index = (index - 1) / 2;
        }
    }

    private void heapify(int[] nums, int index, int size) {
        int largest = 2 * index + 1;
        //  It should not be written here  index < size
        while(largest < size) {
            largest = largest + 1 < size && nums[largest + 1] > nums[largest] ? largest + 1 : largest;
            largest = nums[index] > nums[largest] ? index : largest;
            if(largest == index) {
                break;
            }
            swap(nums, index, largest);
            index = largest;
            largest = 2 * index + 1;
        }
    }

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

 author ：fen-zi-yun-he
 link ：https://leetcode.cn/problems/xx4gT2/solution/-by-fen-zi-yun-he-4qjy/
 source ： Power button （LeetCode）
 The copyright belongs to the author . Commercial reprint please contact the author for authorization , Non-commercial reprint please indicate the source .