LeetCode215 数组的第k个最大元素

题目

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:
输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
示例 2:
输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4
提示：
1 <= k <= nums.length <= 104
-104 <= nums[i] <= 104

方法

暴力法

先排序再取第k大元素

• 时间复杂度：O（nlogn）
• 空间复杂度：O（）

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

最小堆法

创建容量为k的最小堆，若堆未满则添加，若堆满了，则比较堆顶最小值和数组当前值，若小于最小值则舍弃，如大于等于则去除堆顶加入当前值

• 时间复杂度：O（）
• 空间复杂度：O（）

class Solution {
    public int findKthLargest(int[] nums, int k) {
        Queue<Integer> queue = new PriorityQueue<>();
        for(int num:nums){
            if(queue.size()<k){
                queue.offer(num);
            }else if(num>queue.peek()){
                queue.offer(num);
                queue.poll();
            }
        }
        return queue.poll();
    }
}

快排法

根据快排的思想

• 时间复杂度：O（n）
• 空间复杂度：O（logn）

class Solution {
    public int findKthLargest(int[] nums, int k) {
        return quickSortSearch(nums, 0, nums.length - 1, nums.length - k);
    }
    private int quickSortSearch(int[] nums, int l, int r, int index) {
        int pos = quickSortPostition(nums, l, r);
        if (pos == index) {
            System.out.println(Arrays.toString(nums));
            return nums[pos];
        }
        return pos > index ? quickSortSearch(nums, l, pos - 1, index) : quickSortSearch(nums, pos + 1, r, index);
    }
    private int quickSortPostition(int[] nums, int l, int r) {
        int i = new Random().nextInt(r - l + 1) + l;
        int piort = nums[i];
        swap(nums, i, r);
        i = l - 1;
        for (int j = l; j < r; j++) {
            if (nums[j] <= piort) {
                i++;
                swap(nums, i, j);
            }
        }
        swap(nums, i + 1, r);
        return i + 1;
    }
    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

堆排序法

• 时间复杂度：O（nlogn）
• 空间复杂度：O（logn）

class Solution {
    public int findKthLargest(int[] nums, int k) {
        int length = nums.length,heapSize = length-1;
        buildMaxHeap(nums,heapSize);
        for(int i=0;i<k-1;i++){
            swap(nums,0,length-1-i);
            heapSize--;
            maxHeapify(nums,heapSize,0);
        }
        return nums[0];

    }
    private void buildMaxHeap(int[] nums,int heapSize){
        for(int i=heapSize/2;i>=0;i--){
            maxHeapify(nums,heapSize,i);
        }
    }
    private void maxHeapify(int[] nums,int heapSize,int i){
        int l = i*2+1,r = i*2+2;
        int large = i;
        if(l<=heapSize&&nums[l]>nums[large]){
            large = l;
        }
        if(r<=heapSize&&nums[r]>nums[large]){
            large = r;
        }
        if(large!=i){
            swap(nums,i,large);
            maxHeapify(nums,heapSize,large);
        }
    }
    private void swap(int[] nums,int i,int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}