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

小顶堆：

	public int findKthLargest(int[] nums, int k) {MinHeap heap = new MinHeap(k);for (int i = 0; i < k; i++) {heap.offer(nums[i]);}for (int i = k; i < nums.length; i++) {if (nums[i] > heap.peek()) {heap.replace(nums[i]);}}return heap.peek();}

这段 Java 代码定义了一个名为 findKthLargest 的方法，该方法接受一个整数数组 nums 和一个整数 k 作为输入，并返回数组中第 k 大的整数。该方法使用一个小顶堆数据结构来高效地找到数组中的第 k 大元素。

1. 初始化一个具有 k 容量的小顶堆。这个最小顶堆存储输入数组中的前 k 个最大元素。
2. 遍历输入数组的前 k 个元素，并将它们添加到最小堆中。
3. 然后遍历输入数组中剩余的元素。如果一个元素大于最小堆中的最小元素，则用该元素替换最小堆中的最小元素。
4. 遍历完所有输入数组元素后，方法返回小顶堆中的最小元素，即数组中的第 k 大元素。

小顶堆数据结构是一个二叉堆数据结构，其中每个元素的子元素存储在一个较低级别的数组中。在最小堆中，父元素总是小于其子元素。findKthLargest 方法充分使用了小顶堆的这种性质，可以在 O(n log k) 的时间复杂度内找到输入数组中的第 k 大元素，其中 n 是输入数组的长度。

设计一个找到数据流中第 k 大元素的类（class）。注意是排序后的第 k 大元素，不是第 k 个不同的元素。

请实现 KthLargest 类：

• KthLargest(int k, int[] nums) 使用整数 k 和整数流 nums 初始化对象。
• int add(int val) 将 val 插入数据流 nums 后，返回当前数据流中第 k 大的元素。

示例：

输入：
["KthLargest", "add", "add", "add", "add", "add"]
[[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]]
输出：
[null, 4, 5, 5, 8, 8]解释：
KthLargest kthLargest = new KthLargest(3, [4, 5, 8, 2]);
kthLargest.add(3);   // return 4
kthLargest.add(5);   // return 5
kthLargest.add(10);  // return 5
kthLargest.add(9);   // return 8
kthLargest.add(4);   // return 8

提示：

• 1 <= k <= 104

• 0 <= nums.length <= 104

• -104 <= nums[i] <= 104

• -104 <= val <= 104

• 最多调用 add 方法 104 次

题目数据保证，在查找第 k 大元素时，数组中至少有 k 个元素

方法一：小顶堆

public class KthLargest {private MinHeap heap;public KthLargest(int k, int[] nums) {heap = new MinHeap(k);for (int num : nums) {add(num);}}public int add(int val) {if (!heap.isFull()) {heap.offer(val);} else if (val > heap.peek()) {heap.replace(val);}return heap.peek();}
}/*** 小顶堆*/
public class MinHeap {private final int[] array;private int size;public MinHeap(int capacity) {array = new int[capacity];}/*** 如果传入一个普通数组，要执行建堆操作，将当前数组转换为堆数组*/public MinHeap(int[] array) {this.array = array;this.size = array.length;heapify();}/*** 返回堆顶元素*/public Integer peek() {if(isEmpty()){return null;}return array[0];}/*** 删除堆顶元素*/public Integer poll() {if(isEmpty()){return null;}/*1.先记录当前堆顶元素，方便返回结果值2.将堆顶元素与堆中最后一个元素交换3.删除最后一个元素4.将推顶元素进行下潜down操作*/int top = array[0];swap(0, size - 1);size--;down(0);return top;}/*** 删除指定索引位置的元素*/public Integer poll(int index) {if(isEmpty()){return null;}int deleted = array[index];swap(index, size - 1);size--;down(index);return deleted;}/*** 替换堆顶元素*/public boolean replace(int replaced) {if(isEmpty()){return false;}array[0] = replaced;down(0);return true;}/*** 向推中添加元素*/public boolean offer(int offered) {if(isFull()){return false;}/*1.判断推是否已满2.调用上浮up方法，将待添加元素加入到堆中合适位置3.堆元素个数size ＋ 1*/up(offered, size);size++;return true;}/*** 上浮* @param offered 待添加元素值* @param index 向哪个索引位置添加*/private void up(int offered, int index) {/*1.记录孩子的索引位置2.通过孩子的索引找到父亲的索引位置     公式： parent = (child - 1) / 2;3.比较添加元素与其父亲节点元素的值4.如果添加元素小于父亲节点元素的值，将父亲节点元素的值下移，如果大于，则直接在孩子索引位置插入元素5.将孩子索引指向其父亲索引6.循环操作 2,3,4,5 直到孩子索引为推顶索引0，或者添加元素大于父亲节点元素的值*/int child = index;while (child > 0) {int parent = (child - 1) >> 1;if (offered < array[parent]) {array[child] = array[parent];} else {break;}child = parent;}array[child] = offered;}/*** 建推*/public void heapify() {/*1.找到完全二叉树的最后一个非叶子节点     公式： size / 2 - 12.从后向前，依次对每个飞非叶子节点调用下潜down方法*/for (int i = (size >> 1) - 1; i >= 0; i--) {down(i);}}/*** 下潜*/private void down(int parent) {/*1.找到当前节点的左孩子节点和右孩子节点2.将当前节点的值和左孩子，右孩子的值进行比较3.定义一个变量min，用于存放当前节点与其左右孩子中最小的值的下标4.默认最小值先为当前节点，如果左孩子的值小于当前节点，更新min指针为左孩子下标，右孩子类似5.如果min指针不等于当前节点的下标（左右孩子中有小于当前节点的值），交换当前节点与min下标对应				  节点的值，递归调用下潜down方法，将原节点继续下潜*/int left = parent * 2 + 1;int right = left + 1;int min = parent;if (left < size && array[left] < array[min]) {min = left;}if (right < size && array[right] < array[min]) {min = right;}if (min != parent) {swap(min, parent);down(min);}}/*** 交换*/private void swap(int i, int j) {int t = array[i];array[i] = array[j];array[j] = t;}/*** 判空*/public boolean isEmpty() {return size == 0;}/*** 判满*/public boolean isFull() {return size == array.length;}
}

这段 Java 代码定义了一个名为 KthLargest 的类，该类包含一个构造函数和一个名为 add 的方法。该类使用了一个名为 heap 的最小堆对象来存储输入数组中的前 k 个最大元素。

1. 构造函数接受两个参数：整数 k 和整数数组 nums。它初始化一个具有 k 容量的小顶堆对象 heap，并将输入数组中的所有元素添加到最小堆中。
2. add 方法接受一个整数 val 作为输入。该方法首先检查最小堆是否已满。如果小顶堆未满，则将 val 添加到最小堆中。如果最小堆已满且 val 大于最小堆中的最小元素，则用 val 替换最小堆中的最小元素。
3. 最后，add 方法返回最小堆中的最小元素，即数组中的第 k 大元素。

小顶堆数据结构是一个二叉堆数据结构，其中每个元素的子元素存储在一个较低级别的数组中。在最小堆中，父元素总是小于其子元素。KthLargest 类充分使用了最小堆的这种性质，可以在 O(n log k) 的时间复杂度内找到输入数组中的第 k 大元素，其中 n 是输入数组的长度。

方法二：优先级队列

class KthLargest {PriorityQueue<Integer> pq;int k;public KthLargest(int k, int[] nums) {this.k = k;pq = new PriorityQueue<Integer>();for (int x : nums) {add(x);}}public int add(int val) {pq.offer(val);if (pq.size() > k) {pq.poll();}return pq.peek();}
}

方法二：优先队列
我们可以使用一个大小为 k 的优先队列来存储前 k 大的元素，其中优先队列的队头为队列中最小的元素，也就是第 k 大的元素。

在单次插入的操作中，我们首先将元素 val 加入到优先队列中。如果此时优先队列的大小大于 k，我们需要将优先队列的队头元素弹出，以保证优先队列的大小为 k。

中位数是有序整数列表中的中间值。如果列表的大小是偶数，则没有中间值，中位数是两个中间值的平均值。

• 例如 arr = [2,3,4] 的中位数是 3 。
• 例如 arr = [2,3] 的中位数是 (2 + 3) / 2 = 2.5 。

实现 MedianFinder 类:

• MedianFinder() 初始化 MedianFinder 对象。
• void addNum(int num) 将数据流中的整数 num 添加到数据结构中。
• double findMedian() 返回到目前为止所有元素的中位数。与实际答案相差 10-5 以内的答案将被接受。

示例 1：

输入
["MedianFinder", "addNum", "addNum", "findMedian", "addNum", "findMedian"]
[[], [1], [2], [], [3], []]
输出
[null, null, null, 1.5, null, 2.0]解释
MedianFinder medianFinder = new MedianFinder();
medianFinder.addNum(1);    // arr = [1]
medianFinder.addNum(2);    // arr = [1, 2]
medianFinder.findMedian(); // 返回 1.5 ((1 + 2) / 2)
medianFinder.addNum(3);    // arr[1, 2, 3]
medianFinder.findMedian(); // return 2.0

提示:

• -105 <= num <= 105
• 在调用 findMedian 之前，数据结构中至少有一个元素
• 最多 5 * 104 次调用 addNum 和 findMedian

1. 使用自定义的堆数据结构实现

class MedianFinder {private final Heap left;private final Heap right;public MedianFinder() {left = new Heap(10,true);right = new Heap(10,false);}/*1.   1   3   5   <->    7    9   10先将数据流分为上述两部分，其中左边是一个大顶堆，右边是一个小顶堆两部分在保持个数之差不大于1的情况下，数据流中的中位数就是如果两部分元素个数相等 = (大顶堆中的堆顶元素+小顶堆中的堆顶元素)/2如果两部分元素个数不等 = 大顶堆中的堆顶元素（后面讲原因）问：如何保证两部分元素个数之差不大于1呢？
我们规定,当添加元素时,如果两部分元素个数相等，则将左部分（大顶堆）中个数加一如果两部分元素个数不相等，则将右部分（小顶堆）中个数加一问：如何将新元素正确加入到两个堆中呢？
我们规定，如果如果两部分元素个数相等，先将元素加入到右部分，再从右部分中拿出最小的元素加入到左部分如果两部分元素个数不相等，先将元素加入到左部分，再从左部分中拿出最大的元素加入到右部分*///添加元素public void addNum(int num) {if (left.getSize() == right.getSize()) {right.offer(num);left.offer(right.poll());} else {left.offer(num);right.offer(left.poll());}}//返回中位数public double findMedian() {if (left.getSize() == right.getSize()) {return (left.peek() + right.peek()) / 2.0;} else {return left.peek();}}/*** 自动扩容 大小堆*/static class Heap {private int[] array;private int size;private final Boolean max;public int getSize() {return size;}public Heap(int capacity, Boolean max) {array = new int[capacity];this.max = max;}/*** 如果传入一个普通数组，要执行建堆操作，将当前数组转换为堆数组*/public Heap(int[] array, Boolean max) {this.array = array;this.size = array.length;this.max = max;heapify();}/*** 返回堆顶元素*/public Integer peek() {if (isEmpty()) {return null;}return array[0];}/*** 删除堆顶元素*/public Integer poll() {if (isEmpty()) {return null;}/*1.先记录当前堆顶元素，方便返回结果值2.将堆顶元素与堆中最后一个元素交换3.删除最后一个元素4.将推顶元素进行下潜down操作*/int top = array[0];swap(0, size - 1);size--;down(0);return top;}/*** 删除指定索引位置的元素*/public Integer poll(int index) {if (isEmpty()) {return null;}int deleted = array[index];swap(index, size - 1);size--;down(index);return deleted;}/*** 替换堆顶元素*/public boolean replace(int replaced) {if (isEmpty()) {return false;}array[0] = replaced;down(0);return true;}/*** 向推中添加元素*/public boolean offer(int offered) {if (isFull()) {//扩容grow();}/*1.判断推是否已满2.调用上浮up方法，将待添加元素加入到堆中合适位置3.堆元素个数size ＋ 1*/up(offered, size);size++;return true;}/*** 扩容*/private void grow() {//新建堆容量         原来的1.5倍int newCapacity = size + (size >> 1);int[] newArray = new int[newCapacity];//将旧堆中的数据移入新堆中System.arraycopy(array,0,newArray,0,size);//更新旧的堆array = newArray;}/*** 上浮** @param offered 待添加元素值* @param index   向哪个索引位置添加*/private void up(int offered, int index) {int child = index;while (child > 0) {int parent = (child - 1) / 2;boolean temp = max ? offered > array[parent] : offered < array[parent];if (temp) {array[child] = array[parent];} else {break;}child = parent;}array[child] = offered;}/*** 建推*/public void heapify() {/*1.找到完全二叉树的最后一个非叶子节点     公式： size / 2 - 12.从后向前，依次对每个飞非叶子节点调用下潜down方法*/for (int i = (size >> 1) - 1; i >= 0; i--) {down(i);}}/*** 下潜*/private void down(int parent) {int left = parent * 2 + 1;int right = left + 1;int maxOrMin = parent;if (left < size && (max ? array[left] > array[maxOrMin] : array[left] < array[maxOrMin])){maxOrMin = left;}if (right < size && (max ? array[right] > array[maxOrMin] : array[right] < array[maxOrMin])){maxOrMin = right;}if (maxOrMin != parent) {swap(maxOrMin, parent);down(maxOrMin);}}/*** 交换*/private void swap(int i, int j) {int t = array[i];array[i] = array[j];array[j] = t;}/*** 判空*/public boolean isEmpty() {return size == 0;}/*** 判满*/public boolean isFull() {return size == array.length;}}
}

2 . 使用jdk自带的数据结构PriorityQueue实现

使用JDK自带的PriorityQueue实现大顶堆与小顶堆：

​ 大顶堆：

PriorityQueue<Integer> maxQue = new PriorityQueue<>((a, b) -> Integer.compare(b, a));
PriorityQueue<Integer> maxQue = new PriorityQueue<>((a, b) -> (a - b));//大顶堆推荐使用

​ 小顶堆（默认）：

PriorityQueue<Integer> minQue = new PriorityQueue<>((a, b) -> Integer.compare(a, b));
PriorityQueue<Integer> minQue = new PriorityQueue<>((a, b) -> (b - a));
PriorityQueue<Integer> minQue = new PriorityQueue<>();		//小顶堆默认

/*** 数据流中的中位数* 使用jdk自带的 PriorityQueue对象实现 大小顶堆*/
@SuppressWarnings("all")
public class E03Leetcode295_jdk {private PriorityQueue<Integer> maxQue;private PriorityQueue<Integer> minQue;public E03Leetcode295_jdk() {// 大顶堆maxQue = new PriorityQueue<>((a, b) -> Integer.compare(b, a));
//      maxQue = new PriorityQueue<>((a, b) -> (a - b));// 小顶堆（默认）minQue = new PriorityQueue<>((a, b) -> Integer.compare(a, b));
//      minQue = new PriorityQueue<>((a, b) -> (b - a));}//添加元素public void addNum(int num) {if (maxQue.size() == minQue.size()) {minQue.offer(num);maxQue.offer(minQue.poll());} else {maxQue.offer(num);minQue.offer(maxQue.poll());}}//返回中位数public double findMedian() {if (maxQue.size() == minQue.size()) {return (maxQue.peek() + minQue.peek()) / 2.0;} else {return maxQue.peek();}}
}