【LeetCode】Day4-数组中的第K个最大元素

最新推荐文章于 2024-03-22 23:32:53 发布

倒过来是圈圈

最新推荐文章于 2024-03-22 23:32:53 发布

阅读量104

点赞数

分类专栏： Leetcode进阶之路文章标签：排序算法 leetcode

本文链接：https://blog.csdn.net/qq_43417265/article/details/123323862

版权

Leetcode进阶之路专栏收录该内容

232 篇文章 1 订阅

订阅专栏

题目

数组中的第K个最大元素【中等】

题解

这道题耗了好几天了，终于下定决心把它搞出来

两种解法，都是经典排序问题的衍生，要记住

快排

快速选择算法：快排中的轴值计算（小于轴值 | 轴值 | 大于轴值）
三个函数：交换(swap)、找轴值(partition)、选轴比k递归得结果(quickSelect)

class Solution {
    public void swap(int nums[],int a,int b){
        int tmp=nums[a];
        nums[a]=nums[b];
        nums[b]=tmp;
    }
    //partition:找轴值位置
    //思路是轴值放最右，遍历数组比轴值小就交换
    public int partition(int nums[],int left,int right,int index){
        //暂存轴值
        int pivot=nums[index];
        //方便轴值和所有元素比较，将其放到最右边
        swap(nums,index,right);
        //初始化第一个比轴值小的位置
        int stored_index=left;
        //遍历数组调整轴值位置
        for(int i=left;i<=right;i++){
            //找到比轴值小的就交换
            if(nums[i]<pivot){
                swap(nums,i,stored_index);
                stored_index++;
            }
        }
        //遍历后，stored_index是轴值应该在的地方
        //right目前存储轴值本身
        swap(nums,stored_index,right);
        return stored_index;
    }
    public int quickSelect(int nums[],int left,int right,int k){
        if(left==right)
            return nums[left];
        
        Random random=new Random();
        int pivot_index=left+random.nextInt(right-left);
        pivot_index=partition(nums,left,right,pivot_index);
        if(pivot_index==k)
            return nums[pivot_index];
        else if(pivot_index>k)
            return quickSelect(nums,left,pivot_index-1,k);
        else 
            return quickSelect(nums,pivot_index+1,right,k);
    }
    public int findKthLargest(int[] nums, int k) {
        int n=nums.length;
        return quickSelect(nums,0,n-1,n-k);
    }
}

堆排

建立一个大根堆，做 k - 1次删除操作后堆顶元素就是我们要找的答案

class Solution {
    public void swap(int nums[],int a,int b){
        int tmp=nums[a];
        nums[a]=nums[b];
        nums[b]=tmp;
    }
    //建大根堆
    public void buildMaxHeap(int nums[]){
        for(int i=nums.length/2;i>=0;i--){
            HeapAdjust(nums,i,nums.length);
        }
    }
    //堆调整
    public void HeapAdjust(int nums[],int i,int heapSize){
        int max=i;//根
        int left=i*2+1;//左子
        int right=i*2+2;//右子
        if(left<heapSize && nums[left]>nums[max])
            max=left;
        if(right<heapSize && nums[right]>nums[max])
            max=right;
        //父子交换
        if(max!=i){
            swap(nums,i,max);
            HeapAdjust(nums,max,heapSize);//子节点调整
        }
    }
    public int findKthLargest(int[] nums, int k) {
        int heapSize=nums.length;
        buildMaxHeap(nums);
        for(int i=nums.length-1;i>=nums.length-k+1;i--){
            swap(nums,i,0);
            heapSize--;
            HeapAdjust(nums,0,heapSize);
        }
        return nums[0];
    }
}