LeetCode 215 数组中的第K个最大元素

LeetCode 215 数组中的第K个最大元素

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

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

思路：

• 方式一：快排
  先对原数组采用快排方式排序（由小到大），再返回倒数第K个数，时间复杂度为O(nlogn)
  优化：快排中的partition函数返回值为，在调整数组的元素使得左边的元素都小于它，右边的元素都等于它，中间的元素都等于它后，返回中间那段区间的起始结束下标p[]。通过将k与p[0],p[1]比较，决定对哪段区间进行再排序，另一段直接扔掉。
  具体地，k>p[1],则只排序nums[p[1]+1,r]区间即可；k<p[0]，则只排序nums[l,p[0]-1]即可；k在这个区间直接返回即可
  时间复杂度：O(logn)

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[] nums, int l,int r,int k){
        if(l<=r){//特别注意对l=r的处理，要让这种情况进去
            int index = l+(int)Math.random()*(r-l+1);

            swap(nums,index,r);
            int[] p = partition(nums,l,r);
            if(p[0]>k){
                return quickSort(nums,0,p[0]-1,k);
            }else if(p[1]<k){
                return quickSort(nums,p[1]+1,r,k);
            }else return nums[k];
        }
        return l;
    }
    public int[] partition(int[] nums,int l,int r){
        int less = l-1;
        int more = r;
        while(l<more){
            if(nums[l]>nums[r]){
                swap(nums,l,--more);
            }else if(nums[l]<nums[r]){
                swap(nums,l++,++less);
            }else l++;
        }
        swap(nums,more,r);
        return new int[]{++less,more};
    }
    public void swap(int[] a,int i,int j){
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

• 方式二：小顶堆
  先将前K个数值小堆化，将数组中剩余的元素依次与堆顶比较，若比堆顶大，则将其与堆顶交换，再堆化；若比堆顶小，则跳过；最后返回arr[0]即可
  时间复杂度 O(nlogk),空间复杂度O(1)

class Solution {
    public int findKthLargest(int[] nums, int k) {
        if(nums.length < 2) return nums[0];
        int i,j;
        for(i = k-1;i>=0;i--){//先将前k个数，小堆化
            heapify(nums,i,k);
        }
        
        for(i = k;i<nums.length;i++){
            if(nums[i]<=nums[0]) continue;
            else{
                swap(nums,i,0);
                heapify(nums,0,k);
            }
        }
        return nums[0];
    }
    public void heapify(int[] a ,int index,int heapSize){
        int left = 2*index+1;
        while(left < heapSize){
            int smallest = left+1< heapSize && a[left] >= a[left+1]?left+1:left;//小堆化要特别注意此处！！！
            smallest = a[smallest] < a[index]? smallest:index;
            if(smallest == index){
                break;
            }
            swap(a,index,smallest);
            index = smallest;
            left = 2*index+1;
        }
    }
    public void swap(int[] a, int i,int j){
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

• 方式三
  利用Arrays.sort()直接排，特别地，此处只能升序排列，int不属于引用类型对象，因此不能自定义比较器。
  返回arr[arr.length-k]即可

class Solution {
    public int findKthLargest(int[] nums, int k) {
        Arrays.sort(nums);
        return nums[nums.length-k];
    }
}