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

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

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

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

你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

先排序后选择

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        srand(time(0));
        return quickSelect(nums, 0, nums.size() - 1, nums.size() - k);
    }
private:
    int quickSelect(vector<int>& nums, int left, int right, int index) {
        int q = randomPartation(nums, left, right);
        if (q == index) {
            return nums[q];
        }
        if (q < index) {
            return quickSelect(nums, q + 1, right, index);    
        } else {
            return quickSelect(nums, left, q - 1, index);
        }
    }
    int randomPartation(vector<int>& nums, int left, int right) {
        int index = rand() % (right - left + 1) + left;
        swap(nums[index], nums[right]);
        return selectSort(nums, left, right);
    }
    int selectSort(vector<int>& nums, int left, int right) {
        int index = left - 1;
        for (int i = left; i < right; ++i) {
            if (nums[i] < nums[right]) {
                swap(nums[++index], nums[i]);
            }
        }
        swap(nums[++index], nums[right]);
        return index;
    }
};

最大堆

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        int heapSize = nums.size();
        buildMaxHeap(nums);
        for (int i = 0; i < k - 1; ++i) {
            --heapSize;
            swap(nums[0], nums[nums.size() - i - 1]);
            maxHeapify(nums, 0, heapSize);
        }
        return nums[0];
    }
private:
    void buildMaxHeap(vector<int>& nums) {
        for (int i = nums.size() / 2; i >= 0; --i) {
            maxHeapify(nums, i, nums.size());
        }
    }
    void maxHeapify(vector<int>& nums, int i, int heapSize) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int largest = i;
        if (left < heapSize && nums[left] > nums[largest]) {
            largest = left;
        }
        if (right < heapSize && nums[right] > nums[largest]) {
            largest = right;
        }
        if (largest != i) {
            swap(nums[largest], nums[i]);
            maxHeapify(nums, largest, heapSize);
        }
    }
};