Leetcode215_数组中的第K个最大元素

1.leetcode原题链接：. - 力扣（LeetCode）

2.题目描述

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

示例 1:

复制代码

输入: [3,2,1,5,6,4], k = 2
输出: 5

示例 2:

复制代码

输入: [3,2,3,1,2,4,5,5,6], k = 4
输出: 4

3.实现方法

方法一：基于快排

在分区的过程当中，我们会对子数组进行划分，如果需要的下标正好就是划分得到的位置（q[0]和q[1]之间），就直接返回；如果 q 比目标下标小，就递归右子区间，否则递归左子区间。这样就可以把原来递归两个区间变成只递归一个区间。

快速排序：排序算法-快速排序-CSDN博客

java 复制代码

class Solution {
    public int findKthLargest(int[] nums, int k) {
        if( nums.length <2){
            return nums[0];
        }
       return quickSort(nums,0,nums.length-1,nums.length-k);
    }

    public int quickSort(int[] arr,int l,int r,int index){
        if(l==r){
            return arr[l];
        }
        swap(arr,l+(int)(Math.random() * (r-l+1)),r);
        int[] p=partition(arr,l,r);

        if(p[0]<=index && index<=p[1]){
            return arr[index];
        }else{
            return p[0]<index ? quickSort(arr,p[1]+1,r,index): quickSort(arr,l,p[0]-1,index);
        }
    
    }

    public int[] partition(int[] arr, int l,int r){
        int small = l-1;
        int big =r;

        while(l<big){
            if(arr[l]<arr[r]){
                swap(arr,++small,l++);
            }else if(arr[l]>arr[r]){
                swap(arr,--big,l);
            }else{
                l++;
            }
        }

        swap(arr,big,r);
        return new int[]{small+1,big};
    }




    public void swap(int[] arr,int a,int b){
        int temp=arr[a];
        arr[a]=arr[b];
        arr[b]=temp;
    }

}

方法二：基于堆排序

构建一个大顶堆，做 k−1 次删除操作后堆顶元素就是要找的答案。

堆排序：排序算法-堆排序-CSDN博客

java 复制代码

class Solution {
    public int findKthLargest(int[] nums, int k) {
        if( nums.length <2){
            return nums[0];
        }

        int heapSize=nums.length;

        for(int i=0;i<heapSize;i++){
            heapInsert(nums,i);
        }

        while(heapSize> nums.length-k+1){
            swap(nums,0,--heapSize);
            heapify(nums,0,heapSize);
        }
        return nums[0];
    }

    public void heapInsert(int[] arr,int i){
        while(arr[i]>arr[(i-1)/2]){
            swap(arr,i,(i-1)/2);
            i=(i-1)/2;
        }
    }

    public void heapify(int[] arr, int index, int heapSize){
        //左孩子
        int left = 2*index+1;
        //当有孩子的情况下(没有左孩子一定就没有右孩子)
        while(left < heapSize){
            //left+1 有右孩子的情况 ，比较左右孩子哪个最大
            int largest = left+1< heapSize && arr[left+1] >arr[left] ? left+1 :left;
            //判断当前节点和子节点的数谁大
            largest = arr[largest] >arr[index] ? largest :index;
            //如果最大数已经是当前数了，结束，否则与子节点交换
            if(largest == index){
                break;
            }
            swap(arr,largest,index);
            index =largest;
            left = 2*index +1;
        }
    }

  




    public void swap(int[] arr,int a,int b){
        int temp=arr[a];
        arr[a]=arr[b];
        arr[b]=temp;
    }

}