高频率算法题【数组中的第K个最大元素】

数组中的第K个最大元素

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。
请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

1 <= k <= nums.length <= 105
-104 <= nums[i] <= 104

示例 1:
输入: [3,2,1,5,6,4], k = 2
输出: 5

示例 2:
输入: [3,2,3,1,2,4,5,5,6], k = 4
输出: 4

想法

题目要求 O(n) 的时间复杂度
想法1.
那就意味着，一遍循环就能找到想要的数
如果是寻找最大值，或者最小值，我们暂存一个数，遍历比较一遍就能得到正确的结果了。
如果我们暂存k个数， 那 需要循环 将近 n* k 次，能否消化掉这k次的比较？
我没有想到合适的方法。跳过。

想法2
第k个最大的数 => 可以转换为 数据从小到大排序 第 m = n-k+1个数字
每次取出一个数字 将小于该数字的数放左侧，大于该数字的数 放右侧
该数字的顺序 就是 左侧数字加1 当前顺序
如果 当前顺序 大于m 则丢弃右侧数字(包含m)，如果当前顺序小于m 则丢弃左侧数字（包含m）
每当丢弃左侧数字的时候 m 减去 左侧数字量+1（重新计数m）
如果当前数字等于m 返回
这样的类似二分的检索 。但是时间复杂度不对 有大量相同数字的时候 会超时。

想法3
优化2.将数组分为三部分 1 小于当前值的， 2 等于当前值的 ，3 大于当前值的。
能排除掉大量相同数字的问题。

总结：
代码耗时和内存消耗都比较大。还有很大的优化空间 。但是胜在容易理解。就这样啦。

想法2 代码实现

class Solution {
    public int findKthLargest(int[] nums, int k) {
        // 将问题转换为 从小到达排序位置在m位的数
        int m = nums.length - k + 1;
        /**
         * 方式 每次取出一个数字 将小于该数字的数放左侧，大于该数字的数 放右侧
         * 该数字的顺序 就是 左侧数字加1 当前顺序
         * 如果 当前顺序 大于m 则丢弃右侧数字(包含m)，如果当前顺序小于m 则丢弃左侧数字（包含m）
         * 每当丢弃左侧数字的时候 m 减去 左侧数字量+1（重新计数m）
         * 如果当前数字等于m 返回
         */
        List<Integer> input = Arrays.stream(nums).boxed().collect(Collectors.toList());

        int result = 0;
        int top = 0;

        while (top != m) {

            int length = input.size();
            int temp = input.get(0);
            result = temp;
            if (length == 1) break;

            List<Integer> left = new ArrayList<>();
            List<Integer> right = new ArrayList<>();
            for (int i = 1; i < length; i++) {
                int current = input.get(i);
                if (current > temp) {
                    right.add(current);
                } else {
                    left.add(current);
                }
            }
            top = left.size() + 1;

            if (top == m) {
                continue;
            } else if (top < m) {
                m = m - top;
                top = 0;// 重置top 防止m 是top 的二倍 减去后 直接相等 得到错误结果
                input = right;
            } else {
                input = left;
            }

        }
        return result;

    }
}

想法3 代码实现

class Solution {
    public int findKthLargest(int[] nums, int k) {
        // 将问题转换为 从小到达排序位置在m位的数
        int m = nums.length - k + 1;
        /**
         * 方式 每次取出一个数字 将小于该数字的数放左侧，大于该数字的数 放右侧， 等于的放中间
         */
        List<Integer> input = Arrays.stream(nums).boxed().collect(Collectors.toList());

        int result = 0;

        while (true) {

            int length = input.size();
            int temp = input.get(0);
            result = temp;
            if (length == 1) break;

            List<Integer> left = new ArrayList<>();
            List<Integer> middle = new ArrayList<>();
            List<Integer> right = new ArrayList<>();
            for (int i = 1; i < length; i++) {
                int current = input.get(i);
                if (current > temp) {
                    right.add(current);
                } else if (current < temp){
                    left.add(current);
                }else {
                    middle.add(current);
                }
            }
            int top = left.size() + 1;
            int topMax = top + middle.size();

            if (top == m || top< m && m <= topMax) {
                break;
            } else if (topMax < m) {
                m = m - topMax;
                input = right;
            } else {
                input = left;
            }

        }
        return result;

    }
}