leetcode 215. 数组中的第K个最大元素(python)

本文介绍了一种使用快速排序分区思想解决寻找未排序数组中第K个最大元素的问题。通过实例展示了如何通过调整数组元素位置来找到目标元素,避免了完全排序的复杂度。
  1. 数组中的第K个最大元素
    在未排序的数组中找到第 k 个最大的元素。请注意,你需要找的是数组排序后的第 k 个最大的元素,而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4
说明:

你可以假设 k 总是有效的,且 1 ≤ k ≤ 数组的长度。

思路:快排 分区的思想 然后再判断

class Solution:
    def findKthLargest(self, nums, k: int) -> int:
        if not nums:
            return None
        low , high = 0 , len(nums)-1
        while True:
            pos = self.partition(nums, low, high)
            if pos == len(nums)-k:
                return nums[pos]
            elif pos > len(nums)-k:
                high = pos -1
            else:
                low = pos +1
    def partition(self,nums, low, high):
        pivot = nums[low]
        while low < high:
            while low < high and pivot <= nums[high]:
                high -= 1
            nums[low] = nums[high]
            while low < high and pivot > nums[low]:
                low += 1
            nums[high] = nums[low]
        nums[low] = pivot
        return low

len(nums) - k :表示第K大的数。
k-1 :表示第K小的数。

进阶题 最小的K个数 / 最大的K个数

### 问题分析 LeetCode 215 题“数组中的第 K 个最大元素”要求在给定数组中找出第 K 大的元素。 ### 解决方案分析 #### 大根堆方法 堆是一种完全二叉树,大根堆的根节点始终大于左右子节点。解题步骤如下: 1. **构造大根堆**:数据以数组形式存储,构造大根堆是将合适元素互换位置的过程。从倒数第二行最后一个元素(即数组长度 `lens` 的 `lens/2` 位置)开始,对于每个节点 `i`,比较其与左右子节点(左子树节点为 `2i + 1`,右子树节点为 `2i + 2`)的大小,若子节点比 `i` 大,则交换位置。交换后,需递归处理交换位置后的节点及其子树,同时用 `heapsize` 防止越界 [^3]。 2. **弹出根节点**:构造好大根堆后,依次弹出大根堆的根节点,弹出 `k - 1` 次后,此时的根节点即为第 `k` 大的值。每次弹出根节点后,将根节点与数组末尾元素交换,更新 `heapsize` 以排除已弹出元素,重新调整堆使其满足大根堆性质 [^3]。 #### 快速选择方法 通过选择一个基准元素 `flag`,将数组分为三部分:大于 `flag` 的元素 `big`、小于 `flag` 的元素 `small` 和等于 `flag` 的元素 `equal`。根据 `k` 与 `big` 和 `small` 数组长度的关系,递归在相应部分继续查找第 `k` 大元素 [^2]。 ### 代码示例 #### 大根堆(C++ 代码) ```cpp #include <iostream> #include <vector> using namespace std; class Solution { public: int findKthLargest(vector<int>& nums, int k) { int n = nums.size(); // 构建大根堆 for (int i = n / 2 - 1; i >= 0; i--) { heapify(nums, n, i); } // 移除前 k - 1 个最大元素 for (int i = n - 1; i >= n - k + 1; i--) { swap(nums[0], nums[i]); heapify(nums, i, 0); } return nums[0]; } void heapify(vector<int>& nums, int n, int i) { int largest = i; int left = 2 * i + 1; int right = 2 * i + 2; if (left < n && nums[left] > nums[largest]) { largest = left; } if (right < n && nums[right] > nums[largest]) { largest = right; } if (largest != i) { swap(nums[i], nums[largest]); heapify(nums, n, largest); } } }; ``` #### 快速选择(Python 代码) ```python class Solution(object): def findKthLargest(self, nums, k): flag = nums[0] big, small, equal = [], [], [] for num in nums: if num > flag: big.append(num) elif num < flag: small.append(num) else: equal.append(num) if k <= len(big): return self.findKthLargest(big, k) if len(nums) - len(small) < k: return self.findKthLargest(small, k - (len(nums) - len(small))) return flag ``` ### 复杂度分析 - **大根堆方法**:时间复杂度为 $O(n + klogn)$,其中构建大根堆的时间复杂度为 $O(n)$,每次调整堆的时间复杂度为 $O(logn)$,共调整 `k - 1` 次。空间复杂度为 $O(1)$,只需要常数级的额外空间 [^3]。 - **快速选择方法**:平均时间复杂度为 $O(n)$,最坏情况下为 $O(n^2)$。空间复杂度为 $O(n)$,主要用于递归调用栈 [^2]。 ### 总结 本题主要考察了堆排序和快速选择算法的应用。大根堆方法通过构建和调整堆结构,逐步找出第 `k` 大元素,稳定性较好,但时间复杂度相对较高。快速选择方法利用分治思想,平均情况下效率较高,但最坏情况性能较差。在实际应用中,可根据具体数据规模和特点选择合适的算法。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值