数组中第K大元素

最新推荐文章于 2025-06-23 10:28:48 发布

zhaoyunfullmetal

最新推荐文章于 2025-06-23 10:28:48 发布

阅读量3.3k

点赞数

CC 4.0 BY-SA版权

分类专栏：算法文章标签：算法第K大元素算法导论

本文链接：https://blog.youkuaiyun.com/zhaoyunfullmetal/article/details/46663573

算法专栏收录该内容

20 篇文章

订阅专栏

博客探讨了在面试中常见的数组中第K大元素问题，指出全排序不是最优解。文章介绍了两种常见思路：构建最大堆和快速排序。构建最大堆的时间复杂度为O(n+klgn)，而快速排序在平均情况下时间复杂度为O(N)，最坏情况为O(N^2)。此外，提到了《算法导论》中关于优化快速排序算法的方法，选择中位数作为pivot以达到线性时间复杂度。

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

数组中第K大元素

在面试的时候遇到过这个问题，后来在leetcode上也遇到了这个问题，于是记录下来以便以后快速回忆。

题目有多种思路，全排序是比较直观的想法，然而最低的时间复杂度为O(nlgn),并且不符合该题目的初衷。

题目更多想问的是如何在不进行全排序的条件下找到数组中第K大的元素，个人认为比较被面试官中意的解答有两个(理应也有其他的..)，如下：

构建最大堆

简单分析时间复杂度: 构建堆的时间O(n)，k次取最大元素要k(lgn),最终的时间复杂度为O(n+klgn).

显然是比全排序要好一些，但是当时面试的时候我回答这个思路，面试官认为并不是一个好的思路，因为面试官认为构建最大堆更适合题目：求数组中前K大的元素(维护一个大小为K的最大堆).
然而我还是认为这是一个可以的思路…..恩，代码还是贴一下，以后就省事了..

   int heap_size;
   int parent(int idx) {
        return (idx - 1) >> 1; //求父节点
    }
   int left(int idx) {
        return (idx << 1) + 1;//左子树
    }
   int right(int idx) {
        return (idx << 1) + 2;//右子树
    }

   void max_heapify(vector<int>& nums, int idx) {
        int largest = idx;
        int l = left(idx), r = right(idx);
        if (l < heap_size && nums[l] > nums[largest]) largest = l;
        if (r < heap_size && nums[r] > nums[largest]) largest = r;
        if (largest != idx) {
            swap(nums[idx], nums[largest]);
            max_heapify(nums, largest);
        }
     }
    //构建最大堆，从非叶子节点开始操作,可证明时间复杂度是O(n)
    void build_max_heap(vector<int>& nums) {
        heap_size = nums.size();
        for (int i = (heap_size >> 1) - 1; i >= 0; i--)
            max_heapify(nums, i);
    }

    int findKthLargest(vector<int>& nums, int k) {
        build_max_heap(nums);
        for (int i = 0; i < k; i++) {
            swap(nums[0], nums[heap_size - 1]);
            heap_size--;
            max_heapify(nums, 0);
        }//不断交换末尾元素和最大元素，之后重新max_heapify
        return nums[heap_size];
    }

快速排序思路

该思想类似快速排序：

以某一个元素为pivot元素，将元素分为两个集合，一个集合元素比pivot小，另一个比pivot大。
若比pivot大的元素数目正好为k-1，那么pivot就是我们要找到元素；若比pivot大的元素为m(小于k), 那么就在比pivot小的集合里面找第(k-m)大的元素; 若是比pivot大的元素为m(大于k)，那就继续在该集合里面找第k大的元素。
重复上面步骤，直到找到第k大的元素

代码如下：

int partition(vector<int>& nums, int i, int j)
    {//类似快速排序的分组
        if (i == j) return i;

        int pivot = nums[i];
        std::swap(nums[i], nums[j]);

        int i0 = i;
        for(int k = i; k < j; k ++)
        {
            if(nums[k] <= pivot)
            {
                std::swap(nums[k], nums[i0 ++]);
            }
        }
        std::swap(nums[i0], nums[j]);
        return i0;
    }

    int findKthEle(vector<int>& nums, int i, int j,int k)
    {
        int index = partition(nums,i,j);
        int length = j-index+1;
        if(length == k)
            return nums[index];
        else if(length > k)
            return findKthEle(nums,index+1,j,k);
        else if(length <k)
            return findKthEle(nums,i,index-1,k-length);
    }

    int findKthLargest(vector<int>& nums, int k) 
    {
        size_t len = nums.size();

        return findKthEle(nums,0,len-1,k);
    }