代码随想录-算法训练营day13【栈与队列03：滑动窗口最大值、前K个高频元素、简化路径、总结】

代码随想录-035期-算法训练营【博客笔记汇总表】-CSDN博客

第五章 栈与队列part03今日内容： ● 239. 滑动窗口最大值
● 347.前 K 个高频元素
● 总结详细布置 239. 滑动窗口最大值 （一刷至少需要理解思路）之前讲的都是栈的应用，这次该是队列的应用了。本题算比较有难度的，需要自己去构造单调队列，建议先看视频来理解。 题目链接/文章讲解/视频讲解：https://programmercarl.com/0239.%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E6%9C%80%E5%A4%A7%E5%80%BC.html 347.前 K 个高频元素  （一刷至少需要理解思路）大/小顶堆的应用， 在C++中就是优先级队列 本题是 大数据中取前k值 的经典思路，了解想法之后，不算难。题目链接/文章讲解/视频讲解：https://programmercarl.com/0347.%E5%89%8DK%E4%B8%AA%E9%AB%98%E9%A2%91%E5%85%83%E7%B4%A0.html  总结 栈与队列做一个总结吧，加油https://programmercarl.com/%E6%A0%88%E4%B8%8E%E9%98%9F%E5%88%97%E6%80%BB%E7%BB%93.html  往日任务
● day 1 任务以及具体安排：https://docs.qq.com/doc/DUG9UR2ZUc3BjRUdY  
● day 2 任务以及具体安排：https://docs.qq.com/doc/DUGRwWXNOVEpyaVpG  
● day 3 任务以及具体安排：https://docs.qq.com/doc/DUGdqYWNYeGhlaVR6 
● day 4 任务以及具体安排：https://docs.qq.com/doc/DUFNjYUxYRHRVWklp 
● day 5 周日休息
● day 6 任务以及具体安排：https://docs.qq.com/doc/DUEtFSGdreWRuR2p4 
● day 7 任务以及具体安排：https://docs.qq.com/doc/DUElCb1NyTVpXa0Jj 
● day 8 任务以及具体安排：https://docs.qq.com/doc/DUGdsY2JFaFhDRVZH 
● day 9 任务以及具体安排：https://docs.qq.com/doc/DUHVXSnZNaXpVUHN4 
● day 10 任务以及具体安排：https://docs.qq.com/doc/DUElqeHh3cndDbW1Q 
●day 11 任务以及具体安排：https://docs.qq.com/doc/DUHh6UE5hUUZOZUd0 
●day 12 周日休息

0239_滑动窗口最大值

单调队列

解法一

解法二

单调栈

0347_前K个高频元素

0071_简化路径

总结

0239_滑动窗口最大值

单调队列

解法一

import java.util.*;class Solution0239 {public int[] maxSlidingWindow(int[] nums, int k) {//时间复杂度：O(n * k)，超时！int res[] = new int[nums.length - k + 1], index = 0;for (int i = 0; i < nums.length - k + 1; i++) {int max = Integer.MIN_VALUE;//sum = 0for (int j = 0; j < k; j++) {//遍历滑动窗口//sum += nums[i + j];if (nums[i + j] > max) {max = nums[i + j];}}res[index++] = max;}return res;}public int[] maxSlidingWindow2(int[] nums, int k) {if (nums.length == 1) {return nums;}int len = nums.length - k + 1;//存放结果元素的数组int[] res = new int[len];int num = 0;//自定义队列MyQueue0239 myQueue = new MyQueue0239();//先将前k的元素放入队列for (int i = 0; i < k; i++) {myQueue.add(nums[i]);}res[num++] = myQueue.peek();for (int i = k; i < nums.length; i++) {//滑动窗口移除最前面的元素，移除是判断该元素是否放入队列myQueue.poll(nums[i - k]);//滑动窗口加入最后面的元素myQueue.add(nums[i]);//记录对应的最大值res[num++] = myQueue.peek();}return res;}
}//解法一
//自定义数组
class MyQueue0239 {Deque<Integer> deque = new LinkedList<>();//弹出元素时，比较当前要弹出的数值是否等于队列出口的数值，如果相等则弹出//同时判断队列当前是否为空void poll(int val) {if (!deque.isEmpty() && val == deque.peek()) {deque.poll();}}//添加元素时，如果要添加的元素大于入口处的元素，就将入口元素弹出//保证队列元素单调递减//比如此时队列元素3,1，2将要入队，比1大，所以1弹出，此时队列：3,2void add(int val) {while (!deque.isEmpty() && val > deque.getLast()) {deque.removeLast();}deque.add(val);}//队列队顶元素始终为最大值int peek() {return deque.peek();}
}

解法二

//解法二
//利用双端队列手动实现单调队列
/*** 用一个单调队列来存储对应的下标，每当窗口滑动的时候，直接取队列的头部指针对应的值放入结果集即可* 单调队列类似 （tail -->） 3 --> 2 --> 1 --> 0 (--> head) (右边为头结点，元素存的是下标)*/
class Solution0239_2 {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;}
}

单调栈

ArrayDeque<Integer> deque = new ArrayDeque<>();

在 Java 中，Deque 接口提供了几种方法来操作双端队列（或称为栈）：

peekFirst(): 返回双端队列的第一个元素（栈顶元素）的值，但不移除它。
peekLast(): 返回双端队列的最后一个元素（栈底元素）的值，但不移除它。
pollFirst(): 移除并返回双端队列的第一个元素（栈顶元素）的值。
pollLast(): 移除并返回双端队列的最后一个元素（栈底元素）的值。
offerFirst(i) : 用于将元素 i 添加到双端队列的开头（队列头部）。
offerLast(i): 将元素 i 添加到双端队列的末尾（栈顶）。

这些方法允许你以栈的方式操作双端队列。

class Solution0239_3 {public int[] maxSlidingWindow(int[] nums, int k) {if (nums == null || nums.length == 0) return new int[0];int n = nums.length;int[] result = new int[n - k + 1];Deque<Integer> stack = new LinkedList<>();for (int i = 0; i < n; i++) {//如果当前窗口的最左侧元素已经不在窗口内，则移除if (!stack.isEmpty() && stack.peekFirst() < i - k + 1) {stack.pollFirst();}//保持单调递减栈while (!stack.isEmpty() && nums[i] >= nums[stack.peekLast()]) {stack.pollLast();}//将当前元素的索引加入栈中stack.offerLast(i);//当窗口大小达到 k 时，将窗口最大值添加到结果数组中if (i >= k - 1) {result[i - k + 1] = nums[stack.peekFirst()];}}return result;}
}

0347_前K个高频元素

import java.util.*;class Solution0347 {public int[] topKFrequent(int[] nums, int k) {Map<Integer, Integer> map = new HashMap<>();//key：数字，value：出现到频次for (int x : nums) {map.put(x, map.getOrDefault(x, 0) + 1);}ArrayList<Map.Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet());Collections.sort(list, (a, b) -> {//根据value进行排序return a.getValue() - b.getValue();});int[] ints = new int[k];for (int i = 0; i < k; i++) {ints[i] = list.get(i).getKey();}return ints;}
}/*Comparator接口说明:* 返回负数，形参中第一个参数排在前面；* 返回正数，形参中第二个参数排在前面** 对于队列：排在前面意味着往队头靠* 对于堆（使用PriorityQueue实现）：从队头到队尾按从小到大排就是最小堆（小顶堆），*                               从队头到队尾按从大到小排就是最大堆（大顶堆）---> 队头元素相当于堆的根节点* */
class Solution0347_2 {//解法1：基于大顶堆实现public int[] topKFrequent1(int[] nums, int k) {Map<Integer, Integer> map = new HashMap<>();//key为数组元素值，val为对应出现次数for (int num : nums) {map.put(num, map.getOrDefault(num, 0) + 1);}//在优先队列中存储二元组(num, cnt),cnt表示元素值num在数组中的出现次数//出现次数按从队头到队尾的顺序是从大到小排,出现次数最多的在队头(相当于大顶堆)PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair2[1] - pair1[1]);for (Map.Entry<Integer, Integer> entry : map.entrySet()) {//大顶堆需要对所有元素进行排序pq.add(new int[]{entry.getKey(), entry.getValue()});}int[] ans = new int[k];for (int i = 0; i < k; i++) { //依次从队头弹出k个,就是出现频率前k高的元素ans[i] = pq.poll()[0];}return ans;}//解法2：基于小顶堆实现public int[] topKFrequent2(int[] nums, int k) {Map<Integer, Integer> map = new HashMap<>(); //key为数组元素值,val为对应出现次数for (int num : nums) {map.put(num, map.getOrDefault(num, 0) + 1);}//在优先队列中存储二元组(num, cnt)，cnt表示元素值num在数组中的出现次数//出现次数按从队头到队尾的顺序是从小到大排，出现次数最低的在队头(相当于小顶堆)PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair1[1] - pair2[1]);for (Map.Entry<Integer, Integer> entry : map.entrySet()) { //小顶堆只需要维持k个元素有序if (pq.size() < k) { //小顶堆元素个数小于k个时直接加pq.add(new int[]{entry.getKey(), entry.getValue()});} else {if (entry.getValue() > pq.peek()[1]) { //当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)pq.poll(); //弹出队头(小顶堆的根结点)，即把堆里出现次数最少的那个删除，留下的就是出现次数多的了pq.add(new int[]{entry.getKey(), entry.getValue()});}}}int[] ans = new int[k];for (int i = k - 1; i >= 0; i--) { //依次弹出小顶堆，先弹出的是堆的根，出现次数少，后面弹出的出现次数多ans[i] = pq.poll()[0];}return ans;}
}class Solution0347_3 {public int[] topKFrequent(int[] nums, int k) {// 优先级队列，为了避免复杂 api 操作，pq 存储数组// lambda 表达式设置优先级队列从大到小存储 o1 - o2 为从小到大，o2 - o1 反之PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> o1[1] - o2[1]);int[] res = new int[k]; // 答案数组为 k 个元素Map<Integer, Integer> map = new HashMap<>(); // 记录元素出现次数for (int num : nums) map.put(num, map.getOrDefault(num, 0) + 1);for (Map.Entry<Integer, Integer> x : map.entrySet()) { // entrySet 获取 k-v Set 集合// 将 kv 转化成数组int[] tmp = new int[2];tmp[0] = x.getKey();tmp[1] = x.getValue();pq.offer(tmp);// 下面的代码是根据小根堆实现的，我只保留优先队列的最后的k个，只要超出了k我就将最小的弹出，剩余的k个就是答案if (pq.size() > k) {pq.poll();}}for (int i = 0; i < k; i++) {res[i] = pq.poll()[0]; // 获取优先队列里的元素}return res;}
}

0071_简化路径

import java.util.ArrayDeque;
import java.util.Deque;class Solution0071 {public String simplifyPath(String path) {String[] names = path.split("/");Deque<String> stack = new ArrayDeque<String>();for (String name : names) {if ("..".equals(name)) {if (!stack.isEmpty()) {stack.pollLast();}} else if (name.length() > 0 && !".".equals(name)) {stack.offerLast(name);}}StringBuffer ans = new StringBuffer();if (stack.isEmpty()) {ans.append('/');} else {while (!stack.isEmpty()) {ans.append('/');ans.append(stack.pollFirst());}}return ans.toString();}
}

总结

ヾ(◍°∇°◍)ﾉﾞ

可以出一道面试题：栈里面的元素在内存中是连续分布的么？

这个问题有两个陷阱：

陷阱1：栈是容器适配器，底层容器使用不同的容器，导致栈内数据在内存中不一定是连续分布的。
陷阱2：缺省情况下，默认底层容器是deque，那么deque在内存中的数据分布是什么样的呢？答案是：不连续的，下文也会提到deque。