Leetcode 215、数组中第k个最大的元素

题目链接：kth-largest-element-in-an-array

方法1：

使用快速排序。

1、对数组进行partition，从left到right随机选择一个主元pivot，将pivot与left的元素交换位置。

另索引 j 初始为left，扫描从left + 1到right的元素，若小于pivot，则将其与 ++j 处的元素交换。

这样当扫描结束，left的元素即主元pivot，从left + 1到 j 的元素都大于pivot，从 j + 1到right的元素都小于等于pivot。

将left位置的元素与 j 位置的互换，则从left到 j-1 的元素都大于pivot，j 位置元素等于pivot，j 右边元素都小于等于pivot。

因此partition完成。返回pivot的位置 j。

2、若pivot的下标 idx 等于 k - 1，则pivot位置的元素即第K大的元素。

 若idx大于 k - 1，另right = idx - 1，返回第一步在左边寻找。

若idx小于 k - 1，另left = idx + 1，返回第一步在右边寻找。

code:

class Solution:

    def findKthLargest(self, nums: List[int], k: int) -> int:
        def partition(nums, left, right):
            pivot_idx = random.randint(left, right)
            if nums[pivot_idx] != nums[left]:
                nums[left], nums[pivot_idx] = nums[pivot_idx], nums[left]
            pivot = nums[left]

            j = left
            for i in range(left + 1, right + 1):
                if nums[i] > pivot:
                    j += 1 
                    nums[j], nums[i] = nums[i], nums[j]
            # nums[left] = pivot,nums[left+1...j] > pivot，交换后nums[left..j-1] > pivot,nums[j] = pivot,nums[j+1...right] <= pivot
            if nums[j] != nums[left]:
                nums[j], nums[left] = nums[left], nums[j]
            return j

        left = 0
        right = len(nums) - 1
        while True:
            idx = partition(nums, left, right)
            if idx == k - 1:
                return nums[idx]
            elif idx > k - 1:
                right = idx - 1
            else:
                left = idx + 1

方法2：

用优先队列实现。

1、可以用小顶堆，维护K个最大的元素。

先将数组前K个元素入堆，遍历数组的元素，当某元素大于堆顶元素，则堆顶出堆，将此元素加入。

最终堆顶元素即第K大的元素。

2、可用大顶堆，维护N - K + 1个最小的元素，这是因为第K大即第N - K + 1 小。

先将数组前N - K + 1个元素入堆，遍历数组的元素，当某元素小于堆顶元素，则堆顶出堆，将此元素加入。

最终堆顶元素即第K大的元素。

3、时间复杂度为O(NlogK)，空间复杂度为O(K)，因此当K < N / 2，用小顶堆，否则大顶堆。

code:

class Solution {
public:
    int findKlarge(vector<int>& nums, int k) {
        priority_queue<int, vector<int>, greater<int>> pq; //小顶堆
        for (int i = 0; i < k; i++) {
            pq.push(nums[i]);
        }
        for (int i = k; i < nums.size(); i++) {
            if (nums[i] > pq.top()) {
                pq.pop();
                pq.push(nums[i]);
            }
        }
        return pq.top();
    }

    int findKsmall(vector<int>& nums, int k) {
        priority_queue<int> pq; //默认大顶堆
        for (int i = 0; i < k; i++) {
            pq.push(nums[i]);
        }
        for (int i = k; i < nums.size(); i++) {
            if (nums[i] < pq.top()) {
                pq.pop();
                pq.push(nums[i]);
            }
        }
        return pq.top();
    }
    int findKthLargest(vector<int>& nums, int k) {
        if (k < nums.size() / 2) {
            return findKlarge(nums, k);
        }
        return findKsmall(nums, nums.size() - k + 1);
    }
};