文章目录
150. 逆波兰表达式求值
根据逆波兰表示法，求表达式的值。
有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
注意 两个整数之间的除法只保留整数部分。
可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。
示例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
思路
逆波兰表达式相当于是二叉树中的后序遍历，逆波兰表达式是用后续遍历的方式把二叉树序列化了。
在进一步看，本题中每一个子表达式要得出一个结果，然后拿这个结果再进行运算，那么就是一个相邻字符串消除的过程
难点
看到数就压入栈，看到运算符就从栈中先后取出两个数num1、num2，然后将计算结果放入栈中
- 当运算符为"-"时
num2 - num1
- 当运算符为"/"时
num2 / num1
public int evalRPN(String[] tokens) {
Deque<Integer> st = new ArrayDeque<>();
for (String s : tokens) {
if (s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/")) { // 如果为运算符
int num1 = st.pop();
int num2 = st.pop();
if (s.equals("+")) {
st.push(num1 + num2);
} else if (s.equals("-")) {
st.push(num2 - num1);
} else if (s.equals("*")) {
st.push(num2 * num1);
} else if (s.equals("/")) {
st.push(num2 / num1);
}
} else { // 如果为数字
st.push(Integer.valueOf(s));
}
}
return st.pop();
}
239. 滑动窗口最大值
给你一个整数数组 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]
思路
-
暴力解：遍历窗口，在每个窗口中找到最大的值，这样是O(n × k)的算法。
-
自定义单调队列完成三个操作：
class MyQueue {
void pop(int value) {
}
void push(int value) {
}
int front() {
return que.front();
}
};
-
pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
-
push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止
-
保持如上规则，每次窗口移动的时候，只要问que.front()就可以返回当前窗口的最大值。
难点1：单调队列
其实队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队里里的元素数值是由大到小的。
那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。
实现的单调队列不是对窗口里面的数进行排序，如果排序的话，那么和优先级队列没有什么区别了
为什么只要维护最大值呢，因为滑动窗口要求的就是窗口内的最大值，所以直接当我们push元素的时候，直接把前面小的元素pop掉，不用考虑了，只用考虑现在的大的数就行。最后直到当前的最大数也要被滑动窗口略过，就要pop掉当前的大数。
难点2：push操作
在定义push操作时，为了保证单调递减，进入队列的元素应该比前面的元素小，如果卡面对元素大，要pop出去。
要先判断此时要push的元素是否比队尾大，如果比队尾大，就要弹出队尾，然后继续比较是否与弹出后的队尾大，所以应该用while (!que.isEmpty() && val > que.getLast())
完整代码：
public class MaxSlidingWindow {
public int[] maxSlidingWindow(int[] nums, int k) {
// 自定义单调队列
MyQueue myQueue = new MyQueue();
// 存放滑动窗口最大值的数组长度
int len = nums.length - k + 1;
// 返回数组
int[] res = new int[len];
int count = 0;
// 先将第一个窗口的元素push入队列
for (int i = 0; i < k; i++) {
myQueue.push(nums[i]);
}
res[count++] = myQueue.peek();
// 开始滑动窗口
for (int i = k; i < nums.length; i++) {
// 当前要弹出元素的下标是滑动窗口的第一个元素
myQueue.pop(nums[i - k]);
// 加入滑动窗口末尾的元素
myQueue.push(nums[i]);
// 记录当前滑动窗口最大值
res[count++] = myQueue.peek();
}
return res;
}
// 自定义单调队列
class MyQueue {
Deque<Integer> que = new ArrayDeque<>();
// pop 操作时判断此时，比较当前要弹出的数值是否等于队列出口的数值，如果相等则弹出
// 同时判断队列当前是否为空
void pop(int val) {
// 如果当前弹出元素等于队列头可以弹，不然不用弹，因为当初就没push进来
if (!que.isEmpty() && val == que.getFirst()) {
que.pollFirst();
}
}
// 添加元素时，如果要添加的元素大于入口处的元素，就将入口元素弹出
// 保证队列元素单调递减
void push(int val) {
while (!que.isEmpty() && val > que.getLast()) {
que.pollLast();
}
que.addLast(val);
}
// 队列队顶元素始终为最大值
int peek(){
return que.getFirst();
}
}
}
- 时间复杂度是 O(n)
在队列中 push元素的过程中，还有pop操作呢，感觉不是纯粹的O(n)。
其实，大家可以自己观察一下单调队列的实现，nums 中的每个元素最多也就被 push_back 和 pop_back 各一次，没有任何多余操作，所以整体的复杂度还是 O(n)。
空间复杂度因为我们定义一个辅助队列，所以是O(k)。
347. 前 K 个高频元素
给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。
示例1：
输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例2：
输入: nums = [1], k = 1
输出: [1]
思路
求该题分为三个内容：
- 要统计元素出现频率
将元素存为key，频率统计为value，放入hashmap
- 对频率排序
利用PriorityQueue，小根堆进行排序
- 找出前K个高频元素
限制priorityQueue.size()=k
难点1：小根堆
- 为什么不用大根堆用小根堆，因为小根堆每次弹出的是堆顶（出现频率小的），我们最后要留下k个频率最高的
- 在往map里存值的时候，用
get()时可能map里没有相应的key值，因此要用getOrDefault()方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值。
难点2：Comparator
比如要实现Arrays.sort的自定义，对一个二维数组array进行排序，按其中每个一维数组的第一个数字升序排序
o1 - o2 是升序排序，o2 - o1 是降序排序。
- 可通过定义
class MyComparator implements Comparator<int[]>{
public int compare(int[] o1, int[] o2) {
return o1[0] - o2[0];
}
}
Arrays.sort(array, new MyComparator<int[]>());
- 如果不想单独去定义一个MyComparator类，可通过匿名类
Arrays.sort(array, new Comparator<int[]>{
public int compare(int[] o1, int[] o2) {
return o1[0] - o2[0];
}
});
- 匿名类也不想写了，就用Lambda表达式
Arrays.sort(array, (int[] o1, int[] o2)->o1[0] - o2[0]);
- lambda表达式中类型也省掉
Arrays.sort(array, (o1, o2)->o1[0] - o2[0]);
o1[0]表示第0个元素，o1[1]表示第1个元素
难点3：Map.Entry
Map是java中的接口，Map.Entry是Map的一个内部接口。
Map提供了一些常用方法，如keySet()、entrySet()等方法，keySet()方法返回值是Map中key值的集合；entrySet()的返回值也是返回一个Set集合，此集合的类型为Map.Entry。
完整代码
public int[] topKFrequent(int[] nums, int k) {
// key为数组元素值,val为对应出现次数
HashMap<Integer, Integer> map = new HashMap<>();
// 统计频率
for (int i : nums) {
map.put(i, map.getOrDefault(i,0) + 1);
}
// 将map里的<key,val>存入优先队列
PriorityQueue<int[]> pq = new PriorityQueue<>((pair1,pair2)->pair1[1]-pair2[1]);
for (Map.Entry<Integer, Integer> entry : map.entrySet()) { // 小顶堆只需要维持k个元素有序
// 小顶堆元素个数小于k个时直接入队
if (pq.size() < k) {
pq.add(new int[]{entry.getKey(), entry.getValue()});
}else {
// 当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)
if (entry.getValue() > pq.peek()[1]) {
// 弹出队头(小顶堆的根结点),即把堆里出现次数最少的那个删除,留下的就是出现次数多的了
pq.poll();
pq.add(new int[]{entry.getKey(), entry.getValue()});
}
}
}
int[] res = new int[k];
// 依次弹出小顶堆,先弹出的是堆的根,出现次数少,后面弹出的出现次数多
for (int i = k - 1; i >= 0; i--) {
res[i] = pq.poll()[0];
}
return res;
}
429
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
