LeetCode: 数组中的第K个最大元素以及寻找最小/最大的K个数

问题描述

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

解题思路

解决这个问题有多种方法，下面是几种常见的解题策略：

排序后选择: 将数组排序，然后选择第len(array) - k位置上的元素。
优先队列(最小堆): 使用一个大小为k的最小堆，遍历数组维护堆的大小为k，堆顶即为第k个最大元素。
快速选择(QuickSelect): 快速选择算法是快速排序的变体，用于找到未排序数组中第k个最大的元素。

代码示例

排序后选择

class Solution:
    def findKthLargest(self, nums, k):
        nums.sort()
        return nums[-k]

这种方法的时间复杂度为O(NlogN)，空间复杂度为O(1)（如果使用的是原地排序算法）。

优先队列(最小堆)

import heapq

class Solution:
    def findKthLargest(self, nums, k):
        heap = []
        for num in nums:
            heapq.heappush(heap, num)
            if len(heap) > k:
                heapq.heappop(heap)
        return heap[0]

这种方法的时间复杂度为O(NlogK)，空间复杂度为O(K)。

快速选择(QuickSelect)

class Solution:
    def findKthLargest(self, nums, k):
        k = len(nums) - k
        
        def quickselect(l, r):
            pivot, p = nums[r], l
            for i in range(l, r):
                if nums[i] <= pivot:
                    nums[p], nums[i] = nums[i], nums[p]
                    p += 1
            nums[p], nums[r] = nums[r], nums[p]
            if p > k: return quickselect(l, p - 1)
            if p < k: return quickselect(p + 1, r)
            return nums[p]
        
        return quickselect(0, len(nums) - 1)

int partition(vector<int>& nums,int left,int right)
{
    int key = nums[left];
    while(left < right)
    {
        while(left < right and nums[right] >= key )
        {
            right--;
        }
        nums[left] = nums[right]
        while(left < right and nums[left] <= key )
        {
            left++;
        }
        nums[right] = nums[left]
    }
    nums[left] = key; 
    return left;  
    
}

int findk(vector<int>& nums)
{
    random_shuffle(nums.begin(),nums.end());
    int n = nums.size();
    int left = 0,rihgt = n-1;
    while(True)
    {
        int p = partition(nums,left,right);
        if(p == n-k)
        {return nums[p];}
        else if(p > n-k)
        {
            right = p-1;
        }
        else
        {
            left = p +1;
        }
    }
    return -1;
}

快速选择的平均时间复杂度为O(N)，最坏情况下的时间复杂度为O(N^2)，空间复杂度为O(1)。

面试题 17.14. 最小K个数

设计一个算法，找出数组中最小的k个数。以任意顺序返回这k个数均可。

示例：

输入： arr = [1,3,5,7,2,4,6,8], k = 4
输出： [1,2,3,4]

提示：

0 <= len(arr) <= 100000
0 <= k <= min(100000, len(arr))

class Solution {
public:
     int partition(vector<int>& nums, int left, int right)
    {
        int p = nums[left];
        while(left < right)
        {
            while(left < right and nums[right]>=p)
                right--;
            nums[left] = nums[right];
            while(left < right and nums[left] <= p)
                left++;
            nums[right] = nums[left];
        }
        nums[left] = p;
        return left;
    }

    vector<int> smallestK(vector<int>& nums, int k) {
        
        vector<int> res;
        if (k == 0)
            return res;
        int left = 0;
        int right = nums.size()-1;
        while(true)
        {
            int index = partition(nums,left,right);
            if(index == k - 1)
            {
                break;
            }
            else if(index < k-1)
            {
                left=index+1;
            }
            else{
                right = index-1;
            }
        }
        res.assign(nums.begin(),nums.begin()+k);
        return res;

    }
};

最大的k个数的思路

实现找出最大的k个数，可以采用多种方法，包括排序、局部排序、堆排序和快速选择。

1. 排序

将整个数组进行排序，然后取出最大的k个数作为结果。这种方法最简单，但效率不高，特别是当数组非常大时。

2. 局部排序

只对最大的k个数进行排序，可以使用冒泡排序的方法，每次冒泡找出最大值，冒k次泡即可得到TopK。

3. 堆排序

首先使用前k个元素生成一个小顶堆，然后从第k+1个元素开始扫描，与堆顶元素（堆中最小的元素）比较，如果比堆顶元素大，则替换堆顶元素，并调整堆以保持堆内的k个元素总是当前最大的k个元素。最终，堆中的k个元素就是所求的TopK。这种方法适用于大量数据或数据集大小未知的情况。

4. 快速选择

快速选择是一个线性复杂度的方法，通过将数组分为左右两个子数组来实现。其中，快速排序是分治法的一个典型应用，而二分查找是减治法的一个典型应用。通过一次partition操作，可以找到第k大的数，然后根据其位置i进行递归，如果i大于k，则递归左半区，如果i小于k，则递归右半区。

具体实现代码可以参考以下链接：