【小白爬Leetcode215】2.6 数组中的第K个最大元素 Kth Largest Element in an Array

Leetcode 215 $medium$

点击进入原题链接：Leetcode215 数组中的第K个最大元素 Kth Largest Element in an Array

题目

Description

Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.

中文描述

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

思路一 最朴素的解法，把整个数组排序

已知最好的排序方法的时间复杂度为 O(NlogN) ，则这个方法的时间复杂度为 O(NlogN)，空间复杂度为O(1)。这种解法面试肯定要被毙掉，就略过了。

思路二 最小二叉堆（最简洁解法）

这里直接放上bilibili上的解法，视频链接
思路是维护一个大小为2的最小二叉堆，堆顶是最小的元素。
当堆未满k个元素时，直接往堆里push元素；
当堆满了之后，pop掉堆顶元素（也就是 遍历到目前 第k大的元素），然后push新元素入堆，堆会自动排序，这个过程的时间复杂度是O(logk)
时间复杂度： 最坏的情况下每个元素都会进入长度为k的最小堆（其实一开始那几个不是的），那么时间复杂度为O(nlogk)，
空间复杂度： 由于创建了二叉堆，空间复杂度为O(k)。

举例如下：(图片来源是上面那个视频链接)


这里mark一下：

1. 最小二叉堆的声明：std::priority_queue<int,std::vector<int>,std::greater<int>>第一个模板参数是int型，代表这是一个int二叉堆，第二个模板参数是vector<int>因为注意二叉堆是基于vector容器实现的；第三个参数是排序规则std::greater<int>，注意这里greater的意思是向下遍历更大，而不是堆顶最大，所以是greater不是greatest；
2. 最大二叉堆的声明：std::priority_queue<int,std::vector<int>,std::less<int>>同理这里less的意思是向下遍历更小，而不是堆顶最小，所以是less不是least。

代码实现如下：

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        std::priority_queue<int,std::vector<int>,std::greater<int>> small_heap;
        for(int i=0;i<nums.size();i++){
            if(small_heap.size()<k){
                small_heap.push(nums[i]);
            }
            else{
                if(nums[i]>small_heap.top()){
                    small_heap.pop();
                    small_heap.push(nums[i]);
                }
            }
        }
        return small_heap.top();
    }
};

思路三 快速选择（最优解法）

这个解法来自 LeetCode官方
“快速选择算法 的平均时间复杂度为O(N)。就像快速排序那样，本算法也是 Tony Hoare 发明的，因此也被称为 Hoare选择算法。”

由于找第k大的元素也就是找第n-k小的元素，所以这里以第找第k小的元素说明：

1. 首先随机选择一个元素作为pivot(轴)，然后将所有小于pivot值的元素排在pivot左边，相应地，所有大于pivot的值都排在pivot的右边，那么在这个数组里，假设 pivot是第i+1小的数，pivot此时的位置就恰好在第i个位置上(从0开始计数)；
2. 如果此时i正好就是我们要找的n-k，那么很幸运我们完成了任务，直接return第i个元素；如果i<n-k，说明我们找的值小了，那么我们在i+1到n之间继续重复步骤1；如果i>n-k，说明我们找的值小了，那么我们在0到i-1之间继续重复步骤1，最终，一定会使得i==n-k
3. 至此，我们就找到了第k大的元素。

时间复杂度 : 平均情况 O(N)，最坏情况 O(N²)。
时间复杂度： O(1)

完整代码如下：

class Solution {
public:
	//交换函数
    void swap(int a,int b,vector<int>&nums){
        int temp = nums[a];
        nums[a] = nums[b];
        nums[b] = temp;
    }
    //快速选择函数
    int fastSelect(int left,int right,vector<int>&nums,int k_smallest){
        if(left==right) return nums[left];
        unsigned seed;
        seed = time(0);
        srand(seed);
        int i = left+rand()%100/float(100)*(right-left);
        int pivot = nums[i];

        //1.先把pivot放到最右边再说
        swap(i,right,nums);
        //2.将小于pivot的值全放到左边
        int cur_index = left;
        for(int j=left;j<right;j++){
            if(nums[j]<pivot){
                swap(cur_index,j,nums);
                cur_index++;
            }
        }
        swap(cur_index,right,nums); //别忘了把pivot放到它该放的位置上
        //3.判断找到的位置是不是k_smallest
        if(cur_index==k_smallest){
            return nums[cur_index];
        }
        else if(cur_index<k_smallest)
            return fastSelect(cur_index+1,right,nums,k_smallest);
        else
            return fastSelect(left,cur_index-1,nums,k_smallest);
    }
    //主函数
    int findKthLargest(vector<int>& nums, int k) {
        int len = nums.size();
        return fastSelect(0,len-1,nums,len-k);
    }

};

这里需要注意一个问题：

       //2.将小于pivot的值全放到左边
        int cur_index = left;
        for(int j=left;j<right;j++){
            if(nums[j]<pivot){
                swap(cur_index,j,nums);
                cur_index++;
            }
        }

在执行将小于pivot的值全放到左边，这一步骤的时候，由于上一步已经讲pivot放到了最右边，所以这里不用再遍历nums数组中的最后一个数，因此很容易写成

		for(int j=left;j<right-1;j++){

但是，因为一开始调用 fastSelect的时候，第二个参数right==len-1，所以right一直是是从0开始算的位置索引：

    int findKthLargest(vector<int>& nums, int k) {
        int len = nums.size();
        return fastSelect(0,len-1,nums,len-k);
    }