前topK的快速排序做法

最小k个数，不讲究顺序

class Solution {
    /*
    快速排序，不用堆。https://blog.csdn.net/weixin_43887189/article/details/90518211
    */
public:
    vector<int> smallestK(vector<int>& arr, int k) {
        findTopK(arr,0,arr.size()-1,k);
        vector<int>res;
        for(int i=0;i<k;i++){
            res.push_back(arr[i]);
        }
        return res;
    }
private:
    // 快拍思想找TOPK
    int Partition(vector<int>&arr, int left, int right) {
        int start=left;
        int key=arr[start];
        while(left<right){
            while(left<right&&arr[right]>=key){
                right--;
            }
            while(left<right&&arr[left]<=key){
                left++;
            }  
            // arr[left]>key, arr[right] <key 
            swap(arr[left], arr[right]);             
        }
        // 将pivot与left最后到达的位置进行交换，这个位置也就是pivot最终排序的位置
        swap(arr[left], arr[start]);
        return left;
    }
    int findTopK(vector<int>&arr, int left, int right, int k) {
        /*
        在数组中随便找一个元素key，把数组分为arr_a, arr_b两部分，其中a组中的元素大于等于key，b组的元素小于k。那么：
        1 如果a组中的元素个数大于等于k，那么我们只需要对a组进行排序并且查找最大的k个数；
        2 如果a组中的元素个数小于k，而且长度为length，那么我们只需要在b组中查找接下来的k-length个数字
        */
        int idx=-1;
        if(left<right){
            int pos=Partition(arr, left, right);
            int length=pos-left+1;
            if(length==k){
                idx=pos;
            }else if(length<k){
                // a中元素个数小于K，到b中再去查找剩下的k-len个数字
                idx=findTopK(arr,pos+1,right,k-length);
            }else{
                // a组中的元素个数大于等于k
                idx=findTopK(arr,left,pos-1,k);
            }
        }
        return idx;
    }
};

第k个最大数

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        return findKthLargestByQuickSort(nums,k);
    }
private:
    int findKthLargestByMinHeap(vector<int>&nums,int k){
        priority_queue<int,vector<int>,greater<int>>minHeap;// base vector deque 
        for(int i=0;i<nums.size();i++){
            minHeap.push(nums[i]);
            if(minHeap.size()>k){
                minHeap.pop();//pop 出k个里面最小的一个
            }
        }
        // min heap 保留了最大K个，其中堆顶就是第k个
        return minHeap.top();

    }
    int findKthLargestByHeapSort(vector<int>&nums,int k){
        // 构造大堆
        buildHeap(nums);
        // 交换堆顶和末位元素k-1次后，堆顶元素就是第k大
        for(int i=0;i<k-1;i++){
            swap(nums[0],nums[nums.size()-1-i]);
            sift(nums,0,nums.size()-1-i);
        }
        return nums[0];
    }
    void buildHeap(vector<int>&nums){
        // 从第一个非叶子结点开始
        for(int i=nums.size()/2-1;i>=0;i--){
            sift(nums,i,nums.size());
        }
    }
    // sift from [start,end)
    void sift(vector<int>&nums,int start,int end){
        int i=start;
        int child;
        while(1){
            child=2*i+1;
            if(child>=end){
                break;
            }
            if(child+1<end&&nums[child+1]>nums[child]){
                child++;
            }
            if(nums[i]<nums[child]){
                swap(nums[i],nums[child]);
                i=child;
            }else{
                break;
            }
        }
    }
    // 快排思想，如果锚点前面正好有k-1，则该点就是第k大元素
    // https://leetcode.cn/problems/smallest-k-lcci/description/
    int findKthLargestByQuickSort(vector<int>&nums,int k){
        findTopByQuickSortCore(nums,0,nums.size()-1,k);
        // for(int i=0;i<k;i++){
        //     cout<<(nums[nums.size()-1-i]);
        // }
        return nums[nums.size()-k];
    }
    int findTopByQuickSortCore(vector<int>&nums,int left, int right, int k) {
        /*
        在数组中随便找一个元素key，把数组分为arr_a, arr_b两部分，其中a组中的元素大于等于key，b组的元素小于k。那么：
        1 如果a组中的元素个数大于等于k，那么我们只需要对a组进行排序并且查找最大的k个数；
        2 如果a组中的元素个数小于k，而且长度为length，那么我们只需要在b组中查找接下来的k-length个数字
        */
        int idx=-1;
        if(left<right){
            int pos=partition(nums,left,right);
            int length=right-pos+1;
            if(length==k){
                idx=pos;
            }else if(length<k){
                // arr_b中元素个数小于K，到arr_a中再去查找剩下的k-len个数字
                idx=findTopByQuickSortCore(nums,left,pos-1,k-length);
            }else{
                // arr_b组中的元素个数大于等于k
                idx=findTopByQuickSortCore(nums,pos+1,right,k);
            }
        }
        return idx;
    }
    int partition(vector<int>&arr,int left, int right){
        int start=left;
        int key=arr[start];
        while(left<right){
            while(left<right&&arr[right]>=key){
                right--;
            }
            while(left<right&&arr[left]<=key){
                left++;
            }  
            // arr[left]>key, arr[right] <key 
            swap(arr[left], arr[right]);             
        }
        // 将pivot与left最后到达的位置进行交换，这个位置也就是pivot最终排序的位置
        swap(arr[left], arr[start]);
        return left;
    }
};