文章目录

  • 215. 数组中的第K个最大元素
  • 解题
  • 方法一：时间复杂度为O（n）的做法-转换数组下标
  • 方法二：堆排序


215. 数组中的第K个最大元素

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

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

你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

示例 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 <= 105
-10^4 <= nums[i] <= 10 ^ 4

解题

方法一：时间复杂度为O（n）的做法-转换数组下标

特别注意：-10^4 <= nums[i] <= 10 ^ 4。所以我们可以把题目中数组转成另外一个数组的下标，依此来求每个数出现的次数，并进行了排序。

// 时间O(n),空间O(1) ，因为需要借助的辅助数组大小是规定的
class Solution {
    public int findKthLargest(int[] nums, int k) {
        int[] bucket = new int[20001];
        // 把题目中数组转成另外一个数组的下标，依此来求每个数出现的次数，并进行了排序。
        // 特别注意：-10^4 <= nums[i] <= 10 ^ 4
        for (int i = 0; i < nums.length; i++) {
            bucket[nums[i] + 10000]++;
        }
        // 倒着遍历bucket数组，就是从大到小遍历nums中的值
        // 注意bucket数组的下标 与 nums数组中的值 两者的对应关系。
        for (int i = 20000; i >= 0; i--) {
            // bucket[i] 表示 i-10000 这个数出现的次数
            k = k - bucket[i];
            if (k <= 0) {
                return i - 10000;
            }
        }
        return 0;
    }
}

方法二：堆排序

注意这个方法的时间复杂度为O(nlog⁡n)，空间复杂度：O(log⁡n)

class Solution {
    // 堆排序
    public int findKthLargest(int[] nums, int k) {
        
        int n = nums.length;
        // 将现有的数组，构建成大顶堆,数组第一个元素为最大数
        buildMaxHeap(nums, n);

        // 求数组中的第K个最大元素，将前k-1个大的删去就好，所以需要操作k-1次
        for (int i = nums.length - 1; i >= nums.length - k + 1; i--) {
            // 将nums[0]移到下标i处
            swap(nums, 0, i);
            // 长度-1，排除掉刚刚交换到最后的最大数
            n--;
            // 将剩下的构建成大顶堆
            maxHeap(nums, 0, n);
        }

        return nums[0];
    }

    private void buildMaxHeap(int[] nums, int length) {
        // 从最后一个父节点开始构建，（i-1）/2 ，这里i = length - 1，i代表最后一个下标
        for (int i = (length-2)/2; i >= 0; i--) {
            maxHeap(nums, i, length);
        }
    }

    // 将下标i~length 范围的数构建成大顶堆
    private void maxHeap(int[] nums, int i, int length) {
        // 当前下标i 的两个孩子节点的下标
        int c1 = 2*i + 1;
        int c2 = 2*i + 2;
        // 找到 三者中最大的
        int maxSumIndex = i;
        if (c1 < length && nums[c1] > nums[maxSumIndex]) {
            maxSumIndex = c1;
        }
        if (c2 < length && nums[c2] > nums[maxSumIndex]) {
            maxSumIndex = c2;
        }

        // 父亲节点不是最大的，需要交换，i代表的是父亲节点的位置
        if (maxSumIndex != i) {
            swap(nums, i, maxSumIndex);
            // 由于交换了父节点和子节点，因此可能对子节点的子树造成影响，
            // 所以对子节点的子树进行调整。
            maxHeap(nums, maxSumIndex, length);
        }
    }
    
    private void swap(int[] a, int left, int right) {
        int temp = a[left];
        a[left] = a[right];
        a[right] = temp;
    }
}