Leetcode_215_数组中的第K个最大元素_快速排序

九幽孤翎

已于 2022-03-12 11:20:56 修改

阅读量100

点赞数

分类专栏： daily_algorithm 排序文章标签： leetcode 算法

于 2021-08-26 15:59:51 首次发布

本文链接：https://blog.csdn.net/HDUCheater/article/details/119933625

版权

daily_algorithm 同时被 2 个专栏收录

230 篇文章 0 订阅

订阅专栏

排序

7 篇文章 0 订阅

订阅专栏

这篇博客介绍了如何避免在面试中使用最小堆实现TopK问题，并提供了一个使用随机快速选择算法来查找数组中第K大元素的解决方案。代码展示了如何通过随机化快速排序的方式有效地找到目标值的下标，并根据需要调整搜索范围。

摘要由CSDN通过智能技术生成

不要拿最小堆做topk，我上次面试因为用最小堆被挂了

class Solution {
    Random random = new Random();

    public int findKthLargest(int[] nums, int k) {
        return quickSort(nums, 0, nums.length - 1, nums.length - k);
    }

    int quickSort(int[] nums, int start, int end, int target) {
        // 随机以区间内的数组中的某个元素作为flag，进行快排
        // 返回该随机元素的下标
        int index = randomFlag(nums, start, end);
        if (index == target) {
            return nums[index];
        } else if (index < target) {
            return quickSort(nums, index + 1, end, target);
        } else {
            return quickSort(nums, start, index - 1, target);
        }
    }

    int randomFlag(int[] nums, int start, int end) {
        int flag = start + random.nextInt(end - start + 1);
        swap(nums, end, flag);
        int ed = nums[end];
        int st = start - 1;
        for (int i = end - 1; i > st; ) {
            if(nums[i] <= ed) {
                swap(nums, ++st, i);
            } else {
                i--;
            }
        }
        swap(nums, st + 1, end);
        return st + 1;
    }

    void swap(int[] nums, int first, int second) {
        int temp = nums[first];
        nums[first] = nums[second];
        nums[second] = temp;
    }
}

2022/3/12重写

class Solution {
    int[] nums;
    int len;
    Random random = new Random();

    public int findKthLargest(int[] nums, int k) {
        len = nums.length;
        this.nums = nums;
        int l = 0;
        int r = len - 1;
        while(l != r) {
            int index = quickSort(l, r);
            if(index == len - k) {
                return nums[index];
            }
            if(index < len - k) {
                l = index + 1;
            } else {
                r = index - 1;
            }
        }
        return nums[l];
    }

    // 随机以范围内的一个数作为分割线，返回这个数的下标
    int quickSort(int l, int r) {
        int index = l + random.nextInt(r - l);
        swap(l, index);
        int st = l;
        for (int i = l + 1; i <= r; i++) {
            if(nums[i] <= nums[l]) {
                swap(++st, i);
            }
        }
        swap(st, l);
        return st;
    }

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