剑指offer 40.最小的k个数

最新推荐文章于 2024-01-19 11:41:56 发布

hhmy77

最新推荐文章于 2024-01-19 11:41:56 发布

阅读量189

点赞数

分类专栏： leetcode 剑指offer

本文链接：https://blog.csdn.net/hhmy77/article/details/104991951

版权

leetcode 同时被 2 个专栏收录

110 篇文章 0 订阅

订阅专栏

剑指offer

1 篇文章 0 订阅

订阅专栏

文章目录

https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof/
经典的top k问题
在这里插入图片描述

暴力sort

sort返回

class Solution:
    def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
        return sorted(arr)[:k]

在这里插入图片描述

不断寻找最大值替换

维护一个队列ans，存放最终的答案，每当遇到一个新的数就尝试加入，如果新的数小于旧的最大数，那么就替换，如果大于，那么就什么也不做
尝试一下这个写法：

class Solution:
    def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
        if k==0:
            return []
        ans=[]
        for num in arr:
            if len(ans)<k:
                ans.append(num) #没满直接加
            else:
                ind=ans.index(max(ans))
                if ans[ind]<=num:
                    continue
                else:
                    ans[ind]=num
        return ans

比排序慢了很多 😂，这也能AC😂😂
很粗糙的写法
在这里插入图片描述

hash

用hash就快了不少，缺点就是用了很大的额外空间

class Solution:
    def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
        if k==0:
            return []
        maxnum=max(arr)
        lst=[0]*(maxnum+1)
        for num in arr:
            lst[num]+=1
        ans=[]
        for i in range(len(lst)):
            if len(ans)==k:
                break
            if lst[i]:
                for j in range(lst[i]):
                    ans.append(i)
                    if len(ans)==k:
                        break
        return ans

在这里插入图片描述

快排

看了一眼评论区，看到快排，我就想了一下。。
快排的一个重要性质就是，每次都会把一个元素确定到最终位置ind上，并且ind左边的元素都比当前值小，ind右边的元素都比当前值大，那么我们很自然的想到，对于最终位置ind，一共有三种情况

ind=k ，直接返回前k个元素即可
ind>k，这种情况我们要继续对[L,ind)的范围进行快排，因为虽然ind左边的元素都小于当前值，但是它们的大小顺序却是不确定的，例如10 2 3 4 k=2，一遍快排后4 2 3 10这个时候只能对[0,2]范围继续快排得到3 2 4 10，此时ind=k+1
ind<k，这种情况我们要对[ind+1,R]的范围进行快排

class Solution:
    def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
        if k==0:
            return []
        ind=0
        L,R=0,len(arr)-1
        while L<R:		#L>=R的时候就结束了
            ind=self.div(arr,L,R)
            if ind==k:
                break
            elif ind<k:
                L=ind+1
            else:
                R=ind-1
        return arr[:k]
    def div(self,arr,L,R):
        i,j=L,R
        t=arr[L]	#要优化的话这里可以改成随机取一个数交换到起点，避免快排退化
        while i<j:
            while i<j and arr[j]>=t:
                j-=1
            arr[i]=arr[j]
            while i<j and arr[i]<t:
                i+=1
            arr[j]=arr[i]
        arr[i]=t
        return i

效率没有hash高，但是空间开销小
在这里插入图片描述

大根堆

其实这属于top-k问题，我们维护一个长度为k的大根堆就行了
注意是维护大根堆，每次我们弹出来一个最大数，那么当堆的元素中只有k个时候就可以返回了
而且用python的话就不用自己写小根堆了，有一个内置库heapq很方便
在这里插入图片描述
于是我们就可以这样写：…

class Solution:
    def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
        if k==0:
            return []
        return heapq.nsmallest(k, arr)

python就是那么🐂🍺
在这里插入图片描述
但是面试的时候一般都不能这么写吧，用优先队列实现一下比较靠谱，贴一下官方的题解

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        vector<int>vec(k, 0);
        if (k == 0) return vec; // 排除 0 的情况
        priority_queue<int>Q;
        for (int i = 0; i < k; ++i) Q.push(arr[i]);
        for (int i = k; i < (int)arr.size(); ++i) {
            if (Q.top() > arr[i]) {	//如果堆顶大于当前数，则弹出堆顶
                Q.pop();
                Q.push(arr[i]);
            }
        }
        for (int i = 0; i < k; ++i) {
            vec[i] = Q.top();	//获得数
            Q.pop();
        }
        return vec;
    }
};

class Solution:
    def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
        if k == 0:
            return list()

        hp = [-x for x in arr[:k]]
        heapq.heapify(hp)
        for i in range(k, len(arr)):
            if -hp[0] > arr[i]:		#如果堆顶元素大于当前的元素，插入
                heapq.heappop(hp)
                heapq.heappush(hp, -arr[i])
        ans = [-x for x in hp]
        return ans