Kth Largest Element in an Array（快速排序和堆排序方法解决）

最新推荐文章于 2020-11-26 20:47:06 发布

无名_1989

最新推荐文章于 2020-11-26 20:47:06 发布

阅读量362

点赞数

本文介绍了一种在未排序数组中查找第K大元素的方法。提供了两种实现方式：一种是通过快速排序的思想进行分区，另一种是利用堆排序来优化查找过程。这两种方法都能有效地找到指定位置的元素。

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

Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.

Example 1:

Input: [3,2,1,5,6,4] and k = 2
Output: 5

Example 2:

Input: [3,2,3,1,2,4,5,5,6] and k = 4
Output: 4

Note:
You may assume k is always valid, 1 ≤ k ≤ array's length.

class Solution {
public:
   
    //快速排序
    int partition(vector<int>& nums, int start, int end)
    {
        if(nums.size()==0 || start>end )
                return -1;
        int tmp = nums[start];
        while(start<end)
        {
            while(start<end&&nums[end]<=tmp)
                end--;
            nums[start] = nums[end];
            while(start<end&&nums[start]>=tmp)
                start++;
            nums[end] = nums[start];
        }
        nums[start] = tmp;
        return start;
    }
    
    int findKthLargest(vector<int>& nums, int k) {
        if(nums.size()==0 || k == 0 || k > nums.size() )
            return -1;
        int start = 0;
        int end = nums.size()-1;
        int index = partition(nums, start, end);
        while(index!=k-1)
        {
            if(index>k-1)
            {
                end = index-1;
                index = partition(nums, start, end);
            }else if(index<k-1)
            {
                start = index+1;
                index = partition(nums, start, end);
            }
        }
        return nums[index];
    }
    
    //堆排序
    void makeheap(int *heap, int heap_length, int idx)
    {
        int tmp = heap[idx];
        int child = 2*idx+1;
        while(child<heap_length)
        {
            if(child+1<heap_length&&heap[child]>heap[child+1])
                child++;
            if(tmp<=heap[child])
                break;
            heap[idx] = heap[child];
            idx = child;
            child = 2*idx + 1;
        }
        heap[idx] = tmp;
    }
    
    void adjustheap(vector<int>&nums, int *heap, int heap_length, int idx)
    {
        if(nums[idx]>heap[0])
        {
            heap[0] = nums[idx];
            makeheap(heap, heap_length, 0);
        }
    }
    
    int findKthLargest(vector<int>& nums, int k) {
        
        if(nums.size()==0 || k == 0 || k > nums.size() )
                return -1;
        
        int * heap = new int[k];
        for(int i=0; i<k; i++)
        {
            heap[i] = nums[i];
        }
        
        for(int i=k/2-1; i>=0; i--)
        {
            makeheap(heap, k, i);
        }
        
        int size = nums.size();
        for(int i=k; i<size; i++)
        {
            adjustheap(nums, heap, k, i);
        }
        
        return heap[0];
    }
    
};