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

给定整数数组 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
 

提示：

1 <= k <= nums.length <= 105
-104 <= nums[i] <= 104

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/kth-largest-element-in-an-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

感谢 labuladong的详细解法，传送门快速排序的正确理解方及运用

class Solution {
    public int findKthLargest(int[] nums, int k) {
//		return findKthLargestI(nums, k);
//		return findKthLargestII(nums, k);
//		return findKthLargestIII(nums, k);
		return findKthLargestIV(nums, k);
	}

	//方法四：基于方法二改造，便于理解
	private int findKthLargestIV(int[] nums, int k) {
		if (nums == null || nums.length == 0 || k <= 0) {
			throw new IllegalArgumentException("Input param is not illegal.");
		}
		return quickSearchSort(nums, 0, nums.length - 1, nums.length - k);
	}
	private int quickSearchSort(int[] nums, int left, int right, int target) {
		int p = partition(nums, left, right);
		if (p == target) {
			return nums[p];
		}
		return p > target ? quickSearchSort(nums, left, p - 1, target) : quickSearchSort(nums, p + 1, right, target);
	}


	//方法三：使用优先队列
	//默认是小顶堆，较大的元素会沉淀下去，较小的元素会浮上来，当堆大小超过k时就删掉堆顶的元素，因为这些元素比较小
	//当所有的元素都添加大队列中时，此时堆中剩下的就是最大的k个元素，只需要返回堆顶元素即可
	//时间复杂度O(NlogK)，空间复杂度O(K)
	private Integer findKthLargestIII(int[] nums, int k) {
		PriorityQueue<Integer> pq = new PriorityQueue<>();
		for (int num : nums) {
			pq.offer(num);
			if (pq.size() > k) {
				pq.poll();
			}
		}
		return pq.peek();
	}

	//方法二：快速选择算法
	//一句话总结快速排序就是先将一个元素排好序，然后再将剩下的元素排好序。
	//partition函数就是将一个元素排好序，将大于此元素的放在元素的右边，小于此元素的放在元素的左边
	//根据题意，数组中第k大元素，相当于数组升序排序后「排名第 n - k 的元素」，为了方便表述，定义成k' = n - k。
	//所以我们可以比较partition函数返回的索引下标p和k'的大小，如果p < k'，说明nums[k']在p的右边；反之则在p的左边
	//时间复杂度O(N)，空间复杂度O(1)
	private int findKthLargestII(int[] nums, int k) {
		int len = nums.length;
		int target = len - k;
		int left = 0;
		int right = len - 1;
		while (true) {
			int p = partition(nums, left, right);
			if (p < target) {
				left = p + 1;
			} else if (p > target) {
				right = p - 1;
			} else {
				return nums[p];
			}
		}
	}

	private final Random random = new Random();
	private int partition(int[] nums, int left, int right) {
		int randomIndex = left + random.nextInt(right - left + 1);
		swap(nums, left, randomIndex);
		int pivot = nums[left];
		int i = left + 1;
		int j = right;
		while (true) {
			while (i <= right && nums[i] < pivot) {
				i++;
			}
			while (j > left && nums[j] > pivot) {
				j--;
			}
			if (i >= j) {
				break;
			}
			swap(nums, i, j);
			i++;
			j--;
		}
		swap(nums,left, j);
		return j;
	}

	private void swap(int[] nums, int i, int j) {
		int tmp = nums[i];
		nums[i] = nums[j];
		nums[j] = tmp;
	}

	//方法一：暴力解法，时间复杂度O(NlogN)，空间复杂度O(logN)
	private int findKthLargestI(int[] nums, int k) {
		Arrays.sort(nums);
		return nums[nums.length - k];
	}
}