这题是经典题中的经典题。
解法主要有3个:
解法1: 用quickSort的思路,每次选一个pivot(可以去中间,也可以取两边)。然后把array分成3部分,左边[start, j]都小于等于pivot,右边[i, end]都大于等于pivot,中间的那个刚好就是pivot。
情况1:那我们把start+k-1与j相比,如果start+k-1<=j,那说明这个第k大的数混在左边部分。为什么这里不是start+k<=j呢? 我们看看极端情况,如果k=1,start=j这种情况我们也是要从左边找,那么start+k<=j就不对了,所以必须要k-1。
情况2:我们把start+k-1与i相比,如果start+k-1>=i,那说明这个第k大的数混在右边部分。这个时候我们把k减掉(i-start), 因为左边和中间那个不用管了。
情况3:如果情况1和情况2都不满足,我们就返回pivot,那就是nums[j+1]。
注意:
- 除了最开始的比较是start==end之外,其他比较都是left和right比较。
- 因为是求Kth largest element,所以元素要从大到小排列。所以两个内while循环是用的nums[left] > pivot和 nums[right] < pivot,与正常的quickSort相反。
- 时间复杂度O(n)。
代码如下:
class Solution {
public:
/**
* @param n: An integer
* @param nums: An array
* @return: the Kth largest element
*/
int kthLargestElement(int n, vector<int> &nums) {
int len = nums.size();
if (len == 0 || len < n) return -1;
return quickSelect(n, nums, 0, len - 1);
}
private:
int quickSelect(int n, vector<int> &nums, int start, int end) {
if (start == end) return nums[start];
int left = start, right = end;
int pivot = nums[start + (end - start) / 2];
while(left <= right) {
while(left <= right && nums[left] > pivot) {
left++;
}
while(left <= right && nums[right] < pivot) {
right--;
}
if (left <= right) {
swap(nums[left], nums[right]);
left++;
right--;
}
}
if (start + n - 1 <= right) {
quickSelect(n, nums, start, right);
} else if (start + n - 1 >= left) {
quickSelect(n - (left - start), nums, left, end);
} else {
return nums[right + 1];
}
}
};
二刷
class Solution {
public:
/**
* @param k: An integer
* @param nums: An array
* @return: the Kth largest element
*/
int kthLargestElement(int k, vector<int> &nums) {
int n = nums.size();
return quickSelect(nums, 0, nums.size() - 1, n - k + 1);
}
private:
int quickSelect(vector<int> &nums, int start, int end, int k) {
if (start >= end) return nums[start];
int pivot = nums[start + (end - start) / 2];
int left = start, right = end;
while (left <= right) {
while (left <= right && nums[left] < pivot) left++;
while (left <= right && nums[right] > pivot) right--;
if (left <= right) {
int tmp = nums[left];
nums[left] = nums[right];
nums[right] = tmp;
left++;
right--;
}
}
if (right - start + 1 >= k) return quickSelect(nums, start, right, k);
if (left - start < k) return quickSelect(nums, left, end, k - left + start);
return nums[right + 1];
}
};
解法2:最小堆。空间复杂度O(k),时间复杂度O(nlogk)。
class Solution {
public:
/**
* @param n: An integer
* @param nums: An array
* @return: the Kth largest element
*/
int kthLargestElement(int n, vector<int> &nums) {
int len = nums.size();
priority_queue<int, vector<int>, greater<int>> pq;
for (int i = 0; i < len; ++i) {
int number = nums[i];
if (i < n) {
pq.push(number);
} else {
if (number > pq.top()) {
pq.pop();
pq.push(number);
}
}
}
return pq.top();
}
};
二刷:
下面这个不如上面的好。上面的算法,在i>n后,minHeap内已经有了k个元素,minHeap.top()就是前k个元素里第k大的元素,那么如果比minHeap.top()还小的话,肯定不会是全局第k大的元素(至少是第k+1大),所以也就不用push进去了。下面的算法是不管三七二十一都push进去,然后把最小的一个pop出来(也就是比旧的minHeap.top()还小的pop()出来)。这里做了很多无用功。实际上,应该像上面的算法一样,第k个元素以后的新元素,如果比当前的minHeap.top()还小,也就没有必要push进去了。
class Solution {
public:
/**
* @param k: An integer
* @param nums: An array
* @return: the Kth largest element
*/
int kthLargestElement(int k, vector<int> &nums) {
priority_queue<int, vector<int>, greater<int>> minHeap;
int len = nums.size();
for (int i = 0; i < len; i++) {
minHeap.push(nums[i]);
if (minHeap.size() > k) {
minHeap.pop();
}
}
return minHeap.top();
}
};
解法3:最大堆。这个空间复杂度是O(n),时间复杂度O(nlogn)。其实这个还不如直接排序,时间复杂度是一样的,空间复杂度O(n) (因为递归,最坏情况)。
代码如下:
int findKthLargest(vector<int> &nums, int k)
{
priority_queue<int> pq(nums.begin(), nums.end());
for (int i = 0; i < k - 1; i++)
{
pq.pop();
}
return pq.top();
}