Kth Largest Element in an Array

题目

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.

For example,
Given [3,2,1,5,6,4] and k = 2, return 5.

Note:
You may assume k is always valid, 1 ≤ k ≤ array’s length.

哇，这个题其实可以用暴力求解，用快排后在返回nums[k-1];就可以了；

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end());
        return nums[k - 1];
    }
}; 

分部

但是显然这个不是我们做题的目的，根据分治算法的理念，可以用课上老师讲过的方法将数组划分：
取任意值（默认为左边第一个）pivot；然后将数组分为三部分

<pivot;
=pivot;
>pivot

然后根据K和最后pivot的位置再决定在哪个子数组中寻找，直到找到

class Solution { 
public:
    int partition(vector<int>& nums, int left, int right) {
        int pivot = nums[left];
        int l = left + 1, r = right;
        while (l <= r) {
            if (nums[l] < pivot && nums[r] > pivot)
                swap(nums[l++], nums[r--]);
            if (nums[l] >= pivot) l++; 
            if (nums[r] <= pivot) r--;
        }
        swap(nums[left], nums[r]);
        return r;
    }

    int findKthLargest(vector<int>& nums, int k) {
        int left = 0, right = nums.size() - 1;
        while (true) {
            int pos = partition(nums, left, right);
            if (pos == k - 1) return nums[pos];
            if (pos > k - 1) right = pos - 1;
            else left = pos + 1;
        }
    }
};

答案中最强的分部

class Solution {
public:
    int partition(vector<int> &nums, int lo, int hi) {
        swap(nums[lo], nums[lo + rand() % (hi - lo + 1)]);
        int pivot = nums[lo];
        while (lo < hi) {
            while ((lo < hi) && pivot <= nums[hi]) {
                --hi;
            }
            nums[lo] = nums[hi];
            while ((lo < hi) && nums[lo] <= pivot) {
                ++lo;
            }
            nums[hi] = nums[lo];
        }
        nums[lo] = pivot;
        return lo;
    }

    int findKthLargest(vector<int>& nums, int lo, int hi, int k) {
        if(hi-lo<1){
            return nums[lo];
        }
        int p = partition(nums, lo, hi);
        if(p == k){
            return nums[p];
        }
        if(p > k){
            return findKthLargest(nums,lo, p-1,k);
        }else{
            return findKthLargest(nums,p+1, hi,k);
        }
    }

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

    }
};

priority

使用priority队列，让队列大小保持为nums.size() - k + 1

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        priority_queue<int> pq;
        for(auto n : nums){
            pq.push(n);
            if(pq.size() > nums.size() - k + 1) pq.pop();
        }
        return pq.top();
    }
};