数组中的第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
public int findKthLargest(int[] nums, int k) {
PriorityQueue<Integer> maxQueue = new PriorityQueue<Integer>(k, new Comparator<Integer>() {
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
for (int i : nums) {
maxQueue.add(i);
}
for (int i = 0; i < k; i++) {
maxQueue.poll();
}
return maxQueue.poll();
}
剑指 Offer 41. 数据流中的中位数
- 难度 ****
- 如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
例如，
[2,3,4] 的中位数是 3
[2,3] 的中位数是 (2 + 3) / 2 = 2.5
设计一个支持以下两种操作的数据结构：
void addNum(int num) - 从数据流中添加一个整数到数据结构中。
double findMedian() - 返回目前所有元素的中位数。
示例 1：
输入：
["MedianFinder","addNum","addNum","findMedian","addNum","findMedian"]
[[],[1],[2],[],[3],[]]
输出：[null,null,null,1.50000,null,2.00000]
示例 2：
输入：
["MedianFinder","addNum","findMedian","addNum","findMedian"]
[[],[2],[],[3],[]]
输出：[null,null,2.00000,null,2.50000]
官方简答：
class MedianFinder {
PriorityQueue<Integer> maxheap;
PriorityQueue<Integer> minHead;
public MedianFinder() {
maxheap = new PriorityQueue<Integer>(new Comparator<Integer>(){
public int compare(Integer num1 ,Integer num2){
return num2 - num1;
}
});
minHead = new PriorityQueue<Integer>();
}
/**队列对半开的解法，简单，但是会不断的操作队列出列*/
public void addNum(int num) {
if (minHead.size() != maxheap.size()){
minHead.add(num);
maxheap.add(minHead.poll());
} else {
maxheap.add(num);
minHead.add(maxheap.poll());
}
}
public double findMedian() {
//队列大小不相等，则是基数，取小顶堆，因为第一个元素在小顶堆
// 细节：2.0 ，如果是2，输出的结果会是整数
return minHead.size() != maxheap.size() ? minHead.peek() : (minHead.peek() + maxheap.peek()) /2.0;
}
}
个人简答：
class MedianFinder {
PriorityQueue<Integer> maxheap;
PriorityQueue<Integer> minHead;
/** initialize your data structure here. */
public MedianFinder() {
maxheap = new PriorityQueue<Integer>(new Comparator<Integer>(){
public int compare(Integer num1 ,Integer num2){
return num2 - num1;
}
});
minHead = new PriorityQueue<Integer>();
}
public void addNum(int num) {
if (minHead.isEmpty()){
minHead.add(num);
return;
}
if (minHead.peek() > num){
maxheap.add(num);
} else {
minHead.add(num);
}
balance();
}
public double findMedian() {
// 细节：2.0 ，如果是2，输出的结果会是整数
return minHead.size() != maxheap.size() ? minHead.peek() : (minHead.peek() + maxheap.peek()) /2.0;
}
/**
* 两种情况：
* 1 、两个堆的大小差距为2，则需要将元素多的堆的堆顶移动到元素小的堆
* 2、大顶堆{@link maxheap} 的元素比小顶堆{@link minHead}的多1，
* 因为我们要保证如果是基数，就取小顶堆{@link minHead}元素，
* 所以需要保证小顶堆{@link minHead}元素大于等于大顶堆{@link maxheap}。
*/
private void balance(){
if (Math.abs(maxheap.size() - minHead.size()) > 1){
if (minHead.size() - minHead.size() > 1){
minHead.add(maxheap.poll());
} else {
maxheap.add(minHead.poll());
}
}
if (maxheap.size() - minHead.size() == 1){
minHead.add(maxheap.poll());
}
}
}
480. 滑动窗口中位数
- 难度 *****
中位数是有序序列最中间的那个数。如果序列的长度是偶数，则没有最中间的数；此时中位数是最中间的两个数的平均数。
例如：
[2,3,4]，中位数是 3
[2,3]，中位数是 (2 + 3) / 2 = 2.5
给你一个数组 nums，有一个长度为 k 的窗口从最左端滑动到最右端。窗口中有 k 个数，每次窗口向右移动 1 位。你的任务是找出每次窗口移动后得到的新窗口中元素的中位数，并输出由它们组成的数组。
示例：
给出 nums = [1,3,-1,-3,5,3,6,7]，以及 k = 3。
窗口位置 中位数
[1 3 -1] -3 5 3 6 7 1
1 [3 -1 -3] 5 3 6 7 -1
1 3 [-1 -3 5] 3 6 7 -1
1 3 -1 [-3 5 3] 6 7 3
1 3 -1 -3 [5 3 6] 7 5
1 3 -1 -3 5 [3 6 7] 6
因此，返回该滑动窗口的中位数数组 [1,-1,-1,3,5,6]。
class Solution {
public double[] medianSlidingWindow(int[] nums, int k) {
DualHeap dh = new DualHeap(k);
for (int i = 0; i < k; ++i) {
dh.insert(nums[i]);
}
double[] ans = new double[nums.length - k + 1];
ans[0] = dh.getMedian();
for (int i = k; i < nums.length; ++i) {
dh.insert(nums[i]);
dh.erase(nums[i - k]);
ans[i - k + 1] = dh.getMedian();
}
return ans;
}
}
class DualHeap {
// 大根堆，维护较小的一半元素
private PriorityQueue<Integer> small;
// 小根堆，维护较大的一半元素
private PriorityQueue<Integer> large;
// 哈希表，记录「延迟删除」的元素，key 为元素，value 为需要删除的次数
private Map<Integer, Integer> delayed;
private int k;
// small 和 large 当前包含的元素个数，需要扣除被「延迟删除」的元素
private int smallSize, largeSize;
public DualHeap(int k) {
this.small = new PriorityQueue<Integer>(new Comparator<Integer>() {
public int compare(Integer num1, Integer num2) {
return num2.compareTo(num1);
}
});
this.large = new PriorityQueue<Integer>(new Comparator<Integer>() {
public int compare(Integer num1, Integer num2) {
return num1.compareTo(num2);
}
});
this.delayed = new HashMap<Integer, Integer>();
this.k = k;
this.smallSize = 0;
this.largeSize = 0;
}
public double getMedian() {
return (k & 1) == 1 ? small.peek() : ((double) small.peek() + large.peek()) / 2;
}
public void insert(int num) {
if (small.isEmpty() || num <= small.peek()) {
small.offer(num);
++smallSize;
} else {
large.offer(num);
++largeSize;
}
makeBalance();
}
public void erase(int num) {
delayed.put(num, delayed.getOrDefault(num, 0) + 1);
if (num <= small.peek()) {
--smallSize;
if (num == small.peek()) {
prune(small);
}
} else {
--largeSize;
if (num == large.peek()) {
prune(large);
}
}
makeBalance();
}
// 不断地弹出 heap 的堆顶元素，并且更新哈希表
private void prune(PriorityQueue<Integer> heap) {
while (!heap.isEmpty()) {
int num = heap.peek();
if (delayed.containsKey(num)) {
delayed.put(num, delayed.get(num) - 1);
if (delayed.get(num) == 0) {
delayed.remove(num);
}
heap.poll();
} else {
break;
}
}
}
// 调整 small 和 large 中的元素个数，使得二者的元素个数满足要求
private void makeBalance() {
if (smallSize > largeSize + 1) {
// small 比 large 元素多 2 个
large.offer(small.poll());
--smallSize;
++largeSize;
// small 堆顶元素被移除，需要进行 prune
prune(small);
} else if (smallSize < largeSize) {
// large 比 small 元素多 1 个
small.offer(large.poll());
++smallSize;
--largeSize;
// large 堆顶元素被移除，需要进行 prune
prune(large);
}
}
}
