代码随想录算法训练营第十一天| 150. 逆波兰表达式求值 239. 滑动窗口最大值 347.前 K 个高频元素
Leetcode 150. 逆波兰表达式求值
题目链接：https://leetcode.cn/problems/evaluate-reverse-polish-notation/description/
题目描述：
-
给你一个字符串数组
tokens，表示一个根据 逆波兰表示法 表示的算术表达式。请你计算该表达式。返回一个表示表达式值的整数。
注意：
- 有效的算符为
'+'、'-'、'*'和'/'。 - 每个操作数（运算对象）都可以是一个整数或者另一个表达式。
- 两个整数之间的除法总是 向零截断 。
- 表达式中不含除零运算。
- 输入是一个根据逆波兰表示法表示的算术表达式。
- 答案及所有中间计算结果可以用 32 位 整数表示。
示例 1：
输入：tokens = ["2","1","+","3","*"] 输出：9 解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9示例 2：
输入：tokens = ["4","13","5","/","+"] 输出：6 解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6示例 3：
输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"] 输出：22 解释：该算式转化为常见的中缀算术表达式为： ((10 * (6 / ((9 + 3) * -11))) + 17) + 5 = ((10 * (6 / (12 * -11))) + 17) + 5 = ((10 * (6 / -132)) + 17) + 5 = ((10 * 0) + 17) + 5 = (0 + 17) + 5 = 17 + 5 = 22提示：
1 <= tokens.length <= 104tokens[i]是一个算符（"+"、"-"、"*"或"/"），或是在范围[-200, 200]内的一个整数
逆波兰表达式：
逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。
- 平常使用的算式则是一种中缀表达式，如
( 1 + 2 ) * ( 3 + 4 )。 - 该算式的逆波兰表达式写法为
( ( 1 2 + ) ( 3 4 + ) * )。
逆波兰表达式主要有以下两个优点：
- 去掉括号后表达式无歧义，上式即便写成
1 2 + 3 4 + *也可以依据次序计算出正确结果。 - 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中
- 有效的算符为
图示：
代码：
class Solution {
public int evalRPN(String[] tokens) {
// 声明一个栈
Deque<Integer> stack = new LinkedList<>();
for(String s : tokens){
// 当遍历的元素是符号时
if("+".equals(s)){
stack.push(stack.pop()+stack.pop());
}
else if("-".equals(s)){
stack.push(-stack.pop()+stack.pop());
}
else if("/".equals(s)){
int temp1 =stack.pop();
int temp2 = stack.pop();
stack.push(temp2 / temp1);
}
else if("*".equals(s)){
stack.push(stack.pop()*stack.pop());
}
else{
// 添加数字时
stack.push(Integer.valueOf(s));
}
}
return stack.pop();
}
}
Leetcode 239. 滑动窗口最大值
题目链接：https://leetcode.cn/problems/sliding-window-maximum/description/
题目描述：
给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回 滑动窗口中的最大值 。
示例 1：
输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
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 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7
示例 2：
输入：nums = [1], k = 1
输出：[1]
提示：
1 <= nums.length <= 105-104 <= nums[i] <= 1041 <= k <= nums.length
思路1：自定义数组
思路2：自定义单调队列
图示：
代码1：
//自定义数组
class MyQueue {
Deque<Integer> deque = new LinkedList<>();
//弹出元素时，比较当前要弹出的数值是否等于队列出口的数值，如果相等则弹出
//同时判断队列当前是否为空
void poll(int val) {
if (!deque.isEmpty() && val == deque.peek()) {
deque.poll();
}
}
//添加元素时，如果要添加的元素大于入口处的元素，就将入口元素弹出
//保证队列元素单调递减
//比如此时队列元素3,1，2将要入队，比1大，所以1弹出，此时队列：3,2
void add(int val) {
while (!deque.isEmpty() && val > deque.getLast()) {
deque.removeLast();
}
deque.add(val);
}
//队列队顶元素始终为最大值
int peek() {
return deque.peek();
}
}
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 myQueue = new MyQueue();
//先将前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;
}
}
代码2：
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;
// 维护队列出口位置，注意：1没必要维护，1会被pop
for(int i = 0 ; i< n ; i++){
// 根据题义，需要在【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 个高频元素
题目链接：https://leetcode.cn/problems/top-k-frequent-elements/description/
给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。
示例 1:
输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:
输入: nums = [1], k = 1
输出: [1]
提示：
1 <= nums.length <= 105k的取值范围是[1, 数组中不相同的元素的个数]- 题目数据保证答案唯一，换句话说，数组中前
k个高频元素的集合是唯一的
**进阶：**你所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。
思路：小顶堆
1、将数组中元素放入map中
2、统计出现次数，然后将其按照出现次数从小到大进行排序，次数最低的在队头(相当于小顶堆的堆顶)
3、依次弹出小顶堆，先弹出的频率小
图示：
代码:
class Solution {
public int[] topKFrequent(int[] nums, int k) {
// 采用小顶堆实现
Map<Integer,Integer> map = new HashMap<>();
// 将数组中元素放入小顶堆中
for(int num : nums){
map.put(num , map.getOrDefault(num , 0) + 1);
}
// map.getOrDefault(Object key, V defaultValue);
// ①map中存在key，value返回key对应的value即可。
// ②map中不存在key，value则返回defaultValue(默认值)。
// map.put(num,map.getOrDefault(num, 0) + 1)
// ①map中含有num的话，就将num对应的value值+1
// ②map中不含有num的话，num对应的value对应的默认值赋值为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;
}
}
总结：
本题思路还是很好捋的，具体代码实现偏难，希望能在二刷中完善
944
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
