微软面试题： LeetCode 215. 数组中的第K个最大元素 出现次数：6

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

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

最大的元素，而不是第 k 个不同的元素。

方法 0 ： 直接 std::sort 排序  时间O(n*logn)    空间O(1)

     求 数组中的第K个最大元素 直观解法就是，先将数组 nums 排好序，然后取nums[n - k]即可。

 int findKthLargest(vector<int>& nums, int k) {
        std::sort(nums.begin(),nums.end());
        return nums[nums.size()-k];
    }

分析：时间复杂度就是 std::sort 的时间复杂度  O（n*logn）。

 

方法 1 ：快速选择算法     时间O(n)    空间O(1) 

     求解 k-th Element 问题 通常还可以使用快速选择算法，即快速排序的 “partition 算法思想” 。

class Solution {
public:
//time:O(n*logn)  space:O(1);
    // int findKthLargest(vector<int>& nums, int k) {
    //     std::sort(nums.begin(),nums.end());
    //     return nums[nums.size()-k];
    // }
    
    int findKthLargest(vector<int>& nums, int k) 
    {
        random_shuffle(nums.begin(), nums.end());//洗牌算法
        int l = 0,r = nums.size() - 1;
        int target_index = nums.size() - k;
        while(l <= r)
        {
            int mid = quickSelcetion(nums,l,r);
            if(mid == target_index)
            {
                return nums[mid];
            }
            else if(mid < target_index)
            {
                l = mid + 1;
            }
            else
            {
                r = mid - 1;
            }
        }
        return INT_MAX; 
    }
//快速排序的partition思想
//以nums[l] 为 pivot ,把 nums[l] 放在它最终的位置上
//快速排序就是执行一次partition划分，确定一个元素的最终位置，
//直到最后所有的元素到放到最终的位置，排序完成。
    int quickSelcetion(vector<int>& nums,int l,int r)
    {
        int i = l + 1, j = r;
        while(true)
        {   
            //i 没有和j 交错 且 遇到的 nums[i] 都不大于 pivot，
            //就一直往右走,走过的路径上的所有元素以后都会放在 pivot的左边
            while(i <= j && nums[i] <= nums[l])
            {
                ++i;
            }
            //j走过的路径上的所有元素以后都会放在pivot的右边
            while(j >= i && nums[j] >= nums[l])
            {
                --j;
            }
            //i和j交错了，直接跳出外层循环
            if(j < i)
            {
                break;
            }
            std::swap(nums[i],nums[j]);
        }
        //此时nums [j+1,r]一定都 >= nums[l],
        std::swap(nums[l],nums[j]);
        return j;
        //或者
        // std::swap(nums[l],nums[i - 1]);
        // return i - 1;
    }
};

 

分析：在 方法 一  中使用了 c++ STL 中提供的std::sort ，std::sort 是个复杂同时也非常高效的排序算法，

　　主要使用了 快速排序的思想，整体性能很高。快速排序的逻辑是：

若要对nums[lo..hi]进行排序，我们先找一个分界点p，通过交换元素使得nums[lo..p-1]都小于等于nums[p]，

且nums[p+1..hi]都大于nums[p]，然后递归地去nums[lo..p-1]和nums[p+1..hi]中寻找新的分界点，

最后整个数组就被排序了。

 

　　但是本题只需要知道 在 nums 排序好后，在target_index =  nums.size() - k 的位置上的元素。

不需要再继续对区间[0,target_index-1]和区间 [target_index+1,nums.size()-1 ]排序了。所以只需要借助 快速排序的 partition 划分思想，

partition 的算法框架需要记住！！！

疑问 ：

      1.   为什么时间 是 O（n）?如何分析证明？

      答： O(N)的时间复杂度是个均摊复杂度，需要在算法开始的时候对nums数组来一次随机打乱。上面代码加了

random_shuffle(nums.begin(), nums.end());  直接从12% 提升到 99%。

 

      2.  为什么在上面的代码中 返回 j 或 i - 1,而不能返回 i ?

      答：细节问题。下面代码代码参考《算法4》，是众多写法中最漂亮简洁的一种。可以先背下 partition框架。

再慢慢体会。

       

int partition(int[] nums, int lo, int hi) {
    if (lo == hi) return lo;
    // 将 nums[lo] 作为默认分界点 pivot
    int pivot = nums[lo];
    // j = hi + 1 因为 while 中会先执行 --
    int i = lo, j = hi + 1;
    while (true) {
        // 保证 nums[lo..i] 都小于 pivot
        while (nums[++i] < pivot) {
            if (i == hi) break;
        }
        // 保证 nums[j..hi] 都大于 pivot
        while (nums[--j] > pivot) {
            if (j == lo) break;
        }
        if (i >= j) break;
        // 如果走到这里，一定有：
        // nums[i] > pivot && nums[j] < pivot
        // 所以需要交换 nums[i] 和 nums[j]，
        // 保证 nums[lo..i] < pivot < nums[j..hi]
        swap(nums, i, j);
    }
    // 将 pivot 值交换到正确的位置
    swap(nums, j, lo);
    // 现在 nums[lo..j-1] < nums[j] < nums[j+1..hi]
    return j;
}

// 交换数组中的两个元素
void swap(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

 

方法 2：遍历nums,维护一个大小为 k 的 小顶堆  时间O(n* logK)     空间O(k) 

小顶堆可以使用 c++ STL 中的   priority_queue

　　priority_queue：最大值先出的数据结构，默认基于vector实现堆结构。它可以在O(n log n)
的时间排序数组，O(log n) 的时间插入任意值，O(1) 的时间获得最大值，O(log n) 的时
间删除最大值。priority_queue 常用于维护数据结构并快速获取最大或最小值。

       维护1 个大小为 k 的小顶堆，堆顶就是堆中的最小元素，遍历nums,要是堆内的元素个数 小于

k，直接将 nums[i]   元素 push 到堆中。

       要是堆的大小已经是 k 了，将堆顶元素和 nums[i] 比较，要是nums[i] <= 堆顶元素，则nums[i] 

肯定不在 nums 的前 k 个最大元素中，不用考虑，直接跳过。否则才将堆中元素pop 掉一个，再插入nums[i] 到堆中。

    代码如下：

      int findKthLargest(vector<int>& nums, int k) 
 2     {
 3        //基于vector 的 小顶堆,默认是大顶堆的 ，需加上greater<int> 
           std::priority_queue<int,vector<int>,greater<int>> pq;
 4         for(auto num : nums)
 5         {
 6             // 不在前k个最大元素内的，直接跳过
                if(pq.size() == k && pq.top() >= num ) continue;
 7             if(pq.size() == k)
 8             {
 9                 pq.pop();
10             }
11             pq.push(num);
12         }
13         return pq.top();
14     }
15