239. 滑动窗口最大值
思路:
1. 【单调队列】单调递减,使队列出口处永远是最大值:每加入一个元素,移除掉队列中所有比它小的元素。
2. poll(value): 如果窗口移除的元素value等于单调队列的出口元素,那么队列弹出元素。
2. push(value): 如果push的元素value大于入口元素的数值,那么就弹出队列入口的元素,直到push元素的数值小于等于队列入口元素的数值。
3. 每次返回队列头元素到结果数组中。
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
if(nums.length==1){
return nums;
}
int len = nums.length-k+1;
int[] res = new int[len];//存放结果的数组
int num = 0;
MyQueue my = new MyQueue();
for(int i = 0;i<k;i++){//将前k个元素放入单调队列
my.add(nums[i]);
}
res[num++] = my.peek();
for(int i=k;i<nums.length;i++){
my.poll(nums[i-k]);
my.add(nums[i]);
res[num++] = my.peek();
}
return res;
}
class MyQueue{
Deque<Integer> deque = new LinkedList<>();
void poll(int val){
if(!deque.isEmpty() && val==deque.peek()){
deque.poll();
}
}
void add(int val){
while(!deque.isEmpty() && val>deque.getLast()){
deque.removeLast();
}
deque.add(val);
}
int peek(){
return deque.peek();
}
}
}
其他思路:
【利用双端队列手动实现单调队列】:用一个单调队列来存储对应的下标。每当窗口滑动时,取队列头部指针对应的值放入结果集。
offer:在成功执行操作的前提下,可以向队列末端添加一个元素;当操作不成功时(列队已满),返回false。
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
ArrayDeque<Integer> deque = new ArrayDeque<>();
int n = nums.length;
int[] res = new int[n-k+1];
int idx = 0;
for(int i = 0; i < n; i++){
//i为nums下标;要在[i - k + 1, i] 中选到最大值,需要保证两点
//1.队列头结点在[i - k + 1, i]范围内,不符合则要弹出
while(!deque.isEmpty() && deque.peek() < i - k + 1){
deque.poll();
}
//2.【单调队列】保证每次放进去的数字要比末尾元素小,否则弹出队列元素
while(!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
deque.pollLast();
}
deque.offer(i);
//当i增长到符合第一个k范围的时候,每滑动一步,就将队列头节点放入结果
if(i >= k - 1){
res[idx++] = nums[deque.peek()];
}
}
return res;
}
}
347.前 K 个高频元素
思路:
1. 用Map统计元素出现频率
2. 使用【优先级队列】对元素进行排序:用小顶堆,每次将小顶堆最小的元素弹出,最后积累的就是前k个最大元素(即高频元素)。
3. Comparator接口:返回负数,形参中第一个参数排在前面;返回正数,形参中第一个参数排在后面。对于堆(使用PrioritQueue实现):从队头到队尾从小到大排,就是小顶堆;从队头到队尾从大到小排,就是大顶堆。
PriorityQueue详解见:https://blog.csdn.net/hellokitty136/article/details/105831884/
class Solution {
public int[] topKFrequent(int[] nums, int k) {
Map<Integer,Integer> map = new HashMap<>();
for(int n:nums){
map.put(n,map.getOrDefault(n,0)+1);
}
PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(p -> p[1]));
for(Map.Entry<Integer,Integer> en:map.entrySet()){//小顶堆只需要维持k个元素有序
if(pq.size()<k){//小顶堆元素少于k个时直接加
pq.add(new int[]{en.getKey(),en.getValue()});
}else if(en.getValue()>pq.peek()[1]){//当前元素出现次数大于小顶堆根节点
pq.poll();//弹出根节点
pq.add(new int[]{en.getKey(),en.getValue()});
}
}
int[] res = new int[k];
for(int i=k-1;i>=0;i--){
res[i] = pq.poll()[0];
}
return res;
}
}
总结
1. 单调(递减)队列:主要思想是队列没有必要维护窗口里的所有元素,只需要维护有可能成为窗口里最大值的元素就可以了,同时保证队列里的元素数值是由大到小的。
2.优先级队列:内部元素是自动依照元素的权值排列。缺省情况下 PriorityQueue 利用大顶堆完成对元素的排序。堆是一棵完全二叉树,树中每个结点的值都不小于(或不大于)其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆,小于等于左右孩子就是小顶堆。