leetcode 215. 数组中的第K个最大元素 实现最小堆 随机partition

template<typename Item>
class MinHeap{
private:
    Item * data;
    int count;// 记录堆中元素个数
    int capacity; // 记录堆中最大可容纳的个数
    void shiftUp(int k){
        while(k>1 && data[k/2]>data[k]){
            swap(data[k/2],data[k]);
            k/=2;
        }
    }
    void shiftDown(int k){
       
        while(2*k<=count){
            int j=2*k;
            if(j+1<=count && data[j+1]<data[j]){
                j++;
            }
            if(data[k]<=data[j]) break;
            swap(data[k],data[j]);
            k=j;
   
        }
    }
public :
    MinHeap(int capacity){
        data=new Item[capacity+1];
        count=0;
        this->capacity=capacity;
    }
    ~MinHeap(){
        delete[] data;
    }
    int size(){
        return count;
    }
    bool isEmpty(){
        return count==0;
    }
    void push(Item item){
        assert(count+1<=capacity);
        data[count+1]=item;
        count++;
        shiftUp(count);
    }
    Item pop(){//extractMin
        assert(count>0);
        Item res=data[1];
        swap(data[1], data[count]);
        count --;
        shiftDown(1);
        return res;
    }
    Item top(){
        assert(count>0);
        return data[1];
    }

};
class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        MinHeap<int>minheap = MinHeap<int>(k);
        // priority_queue<int,vector<int>,greater<int>> minheap;
        for(int i=0;i<k;i++){
            minheap.push(nums[i]);
        }
        for(int i=k;i<nums.size();i++){
            if(nums[i]<=minheap.top()) continue;
            minheap.pop();
            minheap.push(nums[i]);
            
        }
        return minheap.top();
    }
};

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        k=nums.size()-k;
        return sorted(nums, k, 0,nums.size()-1);
    }
    int sorted(vector<int>nums,  int k, int left,int right){
        
        int piv=partition(nums,left,right);
        if(piv==k) return nums[piv];
        if(piv<k) return sorted(nums,k, piv+1, right);
        return sorted(nums,k, left, piv-1);
    }
    int partition(vector<int>& nums, int left, int right){
        int pivot=left+rand()%(right-left+1);
        swap(nums[pivot],nums[left]);
        int p=left;
        for(int i=left+1;i<=right;i++){
            if(nums[i]<nums[left]){
                p++;
                swap(nums[i],nums[p]);
              
            }
        }
        swap(nums[left],nums[p]);
        return p;
    }
};