leetcode-第k大的数、最小的k个数_第k大的数 leetcode-CSDN博客

本文链接：https://blog.csdn.net/github_39605284/article/details/121955941

这篇博客介绍了两种寻找数组中最小k个数的方法：快速排序的变种和堆排序。通过`partition`函数进行数组划分，并利用递归在不同子数组中寻找目标。对于快速排序，采用中值作为基准并调整数组结构，而堆排序则构建最小堆来找到第k个最大元素。这两种方法都涉及到排序算法的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

剑指 Offer 40. 最小的k个数

class Solution:
    def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
        def partition(arr, l, r):
            #选定中值
            pivotvalue = arr[l]
            lmark = l + 1
            rmark = r
            done = False

            while not done:
                while lmark <= rmark and arr[lmark] <= pivotvalue:
                    lmark += 1
                while rmark >= lmark and arr[rmark] >= pivotvalue:
                    rmark -= 1
                if rmark < lmark:
                    done = True
                else:
                    arr[lmark], arr[rmark] = arr[rmark], arr[lmark]

            arr[l], arr[rmark] = arr[rmark], arr[l]
            return rmark
        
        def quicksort(arr, l, r, k):
            if l > r:
                return 
            pos = partition(arr, l, r)
            num = pos - l + 1
            if k == num:
                return
            if k < num:
                quicksort(arr, l, pos - 1, k)
            else:
                quicksort(arr, pos+1, r, k - num)

        if k == 0:
            return []
        quicksort(arr, 0, len(arr) - 1, k)
        return arr[:k]

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

class Solution(object):
    import heapq
    def findKthLargest(self, nums, k):
        left, right, target = 0, len(nums)-1, k-1

        while True:
            pos = self.partitions(nums, left, right)
            if pos == target:
                return nums[pos]
            elif pos > target:
                right = pos - 1
            else:
                left = pos + 1

    def partitions(self, nums, left, right):
        pivot = nums[left]
        while left<right:
            while left < right and nums[right] <= pivot:
                right -= 1
            nums[left] = nums[right]

            while left < right  and nums[left] >= pivot:
                left += 1
            nums[right] = nums[left]

        nums[left] = pivot

        return left