力扣_215题_C++【小根堆】+【大根堆】+【快速选择】实现

1.题目描述

　　 

 

2.过程

主要分享小根堆的构建和调整过程，解题逻辑
　　1.在原数组的基础上建立一个大小为k的小根堆；

　　2.顺序遍历数组，遇到大于堆顶的元素，替换堆顶元素并向下调整堆；

　　3.最终返回堆顶元素nums[0], 即为第k大元素。

建堆和调整函数可以复用，可以改为大根堆，删除k-1个元素，堆顶即为题解

3.小顶堆代码

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        buildheap(nums,k);              //小根堆，大小为k，存储最大的k个元素
        for(int i=k;i<nums.size();i++){
            cout<<nums[0]<<endl;
            if(nums[i]>nums[0]){
                swap(nums[0],nums[i]);  //更换堆顶元素
                downadjust(nums,k);     //下降调整堆
            }
        }
        cout<<endl;
        return nums[0];
    }

    void buildheap(vector<int> &nums,int k){        //建小顶堆
        for(int i=1;i<=k;i++){                      //插入k个元素到堆中,第1~K个元素
            int n=i;
            while(n!=1 &&nums[n-1]<nums[n/2-1]){  //第n个元素的下标是i-1（为了整齐，i的左儿子是2i，右儿子是2i+1）
                swap(nums[n-1],nums[n/2-1]);      //根节点如果是0，则要用2i+1和2i+2 代表左右儿子
                n=n/2;
            }
        }
    }
    void downadjust(vector<int>&nums,int k){//删除堆顶元素，插入新的元素，两个步骤合成为一个函数更简单
        int i=1;                        //第一个元素，对应nums[0]
        while(true){                    //删除堆顶和插入部分在主函数，这里直接下降调整堆顶元素
            if(2*i>k){                  //第i个元素的左儿子不存在
                break;
            }else if(2*i==k){           //只有一个左儿子,
                if(nums[i-1]>nums[2*i-1]){
                    swap(nums[i-1],nums[2*i-1]);
                }
                break;
            }else{                      //两个儿子都在
                int f=nums[2*i-1]<nums[2*i] ? 0 : 1;
                if(nums[2*i-1+f]<nums[i-1]){
                    swap(nums[i-1],nums[2*i-1+f]);
                    i=2*i+f;
                }else{
                    break;
                }
            }
        }            
    }  
};

 4.大顶堆实现

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        int n=nums.size();
        buildheap(nums,n);              //大根堆，大小为nums.size()
        for(int i=1;i<k;i++){           //删除k-1个元素
            swap(nums[0],nums[n-i]);  //更换堆顶，堆尾元素，相当于删除堆顶
            downadjust(nums,n-i);     //下降调整堆,size--
        }
        return nums[0];
    }

    void buildheap(vector<int> &nums,int k){        //建大顶堆
        for(int i=1;i<=k;i++){                      //插入k个元素到堆中,第1~K个元素
            int n=i;
            while(n!=1 &&nums[n-1]>nums[n/2-1]){  //第n个元素的下标是i-1（为了整齐，i的左儿子是2i，右儿子是2i+1）
                swap(nums[n-1],nums[n/2-1]);      //根节点如果是0，则要用2i+1和2i+2 代表左右儿子
                n=n/2;
            }
        }
    }
    void downadjust(vector<int>&nums,int k){//删除堆顶:堆顶和堆尾元素交换，直接下降调整堆顶元素
        int i=1;                        //第一个元素，对应nums[0]
        while(true){                    
            if(2*i>k){                  //第i个元素的左儿子不存在，说明到底了
                break;
            }else if(2*i==k){           //只有一个左儿子,
                if(nums[i-1]<nums[2*i-1]){
                    swap(nums[i-1],nums[2*i-1]);
                }
                break;
            }else{                      //两个儿子都在，选一个大的交换
                int f=nums[2*i-1]>nums[2*i] ? 0 : 1;
                if(nums[2*i-1+f]>nums[i-1]){
                    swap(nums[i-1],nums[2*i-1+f]);
                    i=2*i+f;
                }else{
                    break;
                }
            }
        }            
    }  
};
/*
1.删除堆顶 ：堆顶和堆尾元素交换，然后从堆顶 下降调整，堆大小-1；
2.插入元素 ：插入元素放到堆尾，堆大小+1，向上调整堆即可；
*/

作者：xi-jiu
链接：https://leetcode.cn/problems/kth-largest-element-in-an-array/solution/-by-xi-jiu-9dtr/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 5.快速选择

快速选择：每次选择一个关键字（通常范围内第一个），利用快排的思想找到它在有序数组中的位置index，比较和k的大小进一步缩小查找范围，
快排一次后：左侧的数字都比关键字小，右侧都比关键字大；

//快排的思想，降序
class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        int l=0,r=nums.size()-1;
        swap(nums[0],nums[nums.size()/2]);  //防止有序测例，退化为线性
        while(l<r){
            int mid =partition(nums,l,r);
            if(mid==k-1){               //找到第k大的数
                return nums[mid];
            }else if(mid>=k){
                r=mid-1;
            }else{
                l=mid+1;
            }
        }
        return nums[l];
    }
    int partition(vector<int> &nums,int l,int r){    //降序快排
        int pivot=l;
        while(l<r){
            while(l<r && nums[r] < nums[pivot] ) r--;           //右侧的数只能小于 支点
            while(l<r && nums[l] >= nums[pivot] ) l++;          //左侧的数可以大于等于
            swap(nums[l],nums[r]);
        }
        swap(nums[pivot],nums[l]);   
        return l;
    }
};