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

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

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

示例 1:

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

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

 

 

 快速排序的

最差的时间复杂度为O()

 快速排序的解法，一轮for循环会排好一个基数的位置。从小到大。我们只关注第K大的元素所在的区间。往这个区间去做递归。随机选取一个基数，经过运算后，发现当前基数是第几大的数。就将当前区间划分为了两部分。如果当前基数不是第K大的，我们就往第K大所在的区间，做递归。

class Solution {
    Random random = new Random();
    public int findKthLargest(int[] nums, int k) {
        return quickSelect(nums, 0, nums.length - 1, nums.length - k);
    }

    public int quickSelect(int[] a, int l, int r, int index){
        int q = randomPartition(a, l, r);
        if(q == index){
            return a[q];
        }
        else{
            return q < index?quickSelect(a, q+1, r, index) : quickSelect(a, l, q-1, index);
        }
    }

    public int randomPartition(int[] a, int l, int r) {
        int i = random.nextInt(r - l +1) +l;//生成的随机数在区间[l, r]中
    	//将随机选取的索引对应的元素作为基数，将基数移到区间的最右边
        swap(a, i, r);
        //排好基数的位置        
    	return partition(a, l, r);
    }
    
    public int partition(int[] a, int l, int r) {
    	int x = a[r];//保存基数
    	//用来定位基数应该放到哪个位置，表示这个区间从索引j到索引i，都是比基数小的数
    	//到时候，只要把索引r处的基数放到索引i+1处即可
    	int i = l -1;
    	for(int j = l; j < r; ++j) {
    		if(a[j] <= x) {
    			swap(a, ++i, j);
    		}
    	}
    	swap(a, i+1, r);
    	return i +1;
    }
    
    public void swap(int[] a, int i, int j) {
    	int temp = a[i];
    	a[i] = a[j];
    	a[j] = temp;
    }
}

---

快速排序算法模板

常用代码模板1——基础算法 - AcWing代码模板，基础算法https://www.acwing.com/blog/content/277/

class Solution {
    //这个是从小排到大的
    public void quick_sort(int q[], int l, int r)
    {
        if (l >= r) return;
        int i = l - 1, j = r + 1, x = q[l + r >> 1];
        while (i < j)
        {
            do i ++ ; while (q[i] < x);
            do j -- ; while (q[j] > x);
            if (i < j) swap(q, i, j);
        }
        quick_sort(q, l, j);
        //必须是 j+1，不能写 i。因为会有 j等于i 的情况，然后一直不停的递归，最终导致栈溢出
        quick_sort(q, j+1, r);
    }
    private void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
    public static void main(String[] a){
        int[] q = new int[]{2,15,1,6,8,99};
        new Solution().quick_sort(q,0, q.length-1);
        for (int i:q) {
            System.out.print(i+",");
        }
    }
}

解法二：

class Solution {
    public int findKthLargest(int[] nums, int k) {
        //快速选择是基于快速排序来做的
        return quickt_sort(nums, 0, nums.length - 1, k - 1);
    }
    /**
    快速排序一轮，排好一个数的位置
     */
    private int quickt_sort(int[] nums, int l, int r, int k){
        if(l == r) return nums[k];
        //x 是基数
        int x = nums[l], i = l - 1, j = r + 1;
        //通过while，先找出比基数小的、在基数左边的数nums[i]，比基数大的、在基数右边的数nums[j]。两个数相交换。
        //把比基数小的数放到基数的右边，比基数大的数放到基数的左边
        //从大到小排序，第k个数
        while(i < j){
            do i++ ; while (nums[i] > x);
            do j-- ; while (nums[j] < x);
            if (i < j) swap(nums, i, j);
        }
        if (k <= j){
            return quickt_sort(nums, l, j, k);
        }else {
            return quickt_sort(nums, j + 1, r, k);
        }
    }
    private void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

}