LeetCode hot 100—数组中的第K个最大元素

最新推荐文章于 2025-07-20 12:45:35 发布

rigidwill666

最新推荐文章于 2025-07-20 12:45:35 发布

阅读量610

点赞数 13

CC 4.0 BY-SA版权

分类专栏： leetcode 文章标签：算法数据结构 leetcode c++ 排序算法

本文链接：https://blog.youkuaiyun.com/rigidwill/article/details/146392081

leetcode 专栏收录该内容

87 篇文章

订阅专栏

题目

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

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

你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

示例

示例 1:

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

示例 2:

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

分析

快速选择法

快速选择算法是基于快速排序算法的一种变体，它通过部分排序数组来找到目标元素，避免了对整个数组进行排序。

整体思路

通过类似快速排序的分治策略，我们每次将数组分成两部分：一部分比基准元素小，另一部分比基准元素大。然后根据 k 的位置决定继续在左半部分还是右半部分继续递归。要找出数组中第 k 个最大的元素，实际上就是找出升序排序后数组中索引为 n - k 的元素（n 是数组的长度）。

时间复杂度：平均情况下为 O( $n$ )，最坏情况下为 O( $n^{2}$ )，通过随机选择基准元素可以将最坏情况的概率降到很低， $n$ 是数组的长度

空间复杂度：O( $\log n$ )

class Solution {
public:
    int quickselect(std::vector<int>& nums, int l, int r, int k) {
        if (l == r) {
            return nums[l];
        }
        // 随机选择基准元素
        srand(time(0));
        int randomIndex = l + rand() % (r - l + 1);
        std::swap(nums[l], nums[randomIndex]);
        int partition = nums[l], i = l - 1, j = r + 1;
        while (i < j) {
            do i++; while (nums[i] < partition);
            do j--; while (nums[j] > partition);
            if (i < j)
                std::swap(nums[i], nums[j]);
        }
        if (k <= j) return quickselect(nums, l, j, k);
        else return quickselect(nums, j + 1, r, k);
    }
    int findKthLargest(std::vector<int>& nums, int k) {
        int n = nums.size();
        return quickselect(nums, 0, n - 1, n - k);
    }
};

知识充电

快排

快速排序（Quick Sort）是一种高效的排序算法，它采用分治法（Divide and Conquer）的策略来对一个数组进行排序。

基本思想

快速排序的核心思想是通过选择一个基准元素（pivot），将数组分为两部分，使得左边部分的所有元素都小于等于基准元素，右边部分的所有元素都大于等于基准元素，然后分别对左右两部分递归地进行排序。

实现步骤

选择基准元素：从数组中选择一个元素作为基准元素。通常可以选择数组的第一个元素、最后一个元素或者随机选择一个元素。
分区操作：将数组中小于等于基准元素的元素放到基准元素的左边，大于等于基准元素的元素放到基准元素的右边。这个过程称为分区（partition）。
递归排序：对左右两部分分别递归地应用快速排序算法，直到子数组的长度为 1 或 0，此时子数组已经有序。

复杂度分析

时间复杂度：平均情况下为 O( $n\log n$ )，最坏情况下为 O( $n^{2}$ )。最坏情况发生在数组已经有序或者接近有序的情况下。
空间复杂度：平均情况下为 O( $\log n$ )，主要是递归调用栈的空间开销。最坏情况下为 O( $n$ )。

代码示例

#include <iostream>
#include <vector>

// 分区函数
int partition(std::vector<int>& arr, int low, int high) {
    // 选择最后一个元素作为基准元素
    int pivot = arr[high];
    int i = low - 1;

    for (int j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;
            std::swap(arr[i], arr[j]);
        }
    }
    std::swap(arr[i + 1], arr[high]);
    return i + 1;
}

// 快速排序函数
void quickSort(std::vector<int>& arr, int low, int high) {
    if (low < high) {
        // 分区操作，获取基准元素的最终位置
        int pi = partition(arr, low, high);

        // 递归排序左半部分
        quickSort(arr, low, pi - 1);
        // 递归排序右半部分
        quickSort(arr, pi + 1, high);
    }
}

// 测试代码
int main() {
    std::vector<int> arr = {10, 7, 8, 9, 1, 5};
    int n = arr.size();
    quickSort(arr, 0, n - 1);
    std::cout << "排序后的数组: ";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}