今日记录
150.逆波兰表达式求值
给你一个字符串数组 tokens ,表示一个根据 逆波兰表示法 表示的算术表达式。
请你计算该表达式。返回一个表示表达式值的整数。
注意:
有效的算符为 ‘+’、‘-’、‘*’ 和 ‘/’ 。
每个操作数(运算对象)都可以是一个整数或者另一个表达式。
两个整数之间的除法总是 向零截断 。
表达式中不含除零运算。
输入是一个根据逆波兰表示法表示的算术表达式。
答案及所有中间计算结果可以用 32 位 整数表示。
逆波兰表达式:是一种后缀表达式(运算符写在后面) 用栈来实现:遇到数字则入栈;遇到运算符则取出栈顶的两个元素进行运算再压入栈中 ;
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<long long> st;
for (int i = 0; i < tokens.size(); i++) {
if (tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" ||
tokens[i] == "/") {
long long num1 = st.top();
st.pop();
long long num2 = st.top();
st.pop();
if (tokens[i] == "+")
st.push(num2 + num1);
if (tokens[i] == "-")
st.push(num2 - num1);
if (tokens[i] == "*")
st.push(num2 * num1);
if (tokens[i] == "/")
st.push(num2 / num1);
} else {
st.push(stoll(tokens[i])); // 将字符串str转成 long long 整数
}
}
int result = st.top();
st.pop();
return result;
}
};
239.滑动窗口最大值
给你一个整数数组 nums,有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回 滑动窗口中的最大值 。
使用队列,将窗口里的元素放入,随着窗口移动,队列加入新元素,前面的元素也出队。
queue que;
窗口移动,先que.pop()移除元素,que.push()加入新元素, que.front()
class Solution {
private:
class Myqueue {
public:
deque<int> que; // 一个双向队列
// pop函数实现:因为比队列出口的元素已经在push函数里被弹出了,所以除非新加入元素等于队列出口元素,否则不用做任何操作
void pop(int value) {
if (!que.empty() && value == que.front()) { // 返回队列头部的元素
que.pop_front(); // 移除队列前端的元素
}
}
// push函数实现:当新加入的元素比队列入口元素大,将入口元素一个一个弹出直到比入口元素小,保证了弹出顺序是从小到大(如果此时新加入的元素比队列出口的元素还大,一直弹出到队列出口的元素也被弹出)
void push(int value) {
while (!que.empty() && value > que.back()) {
que.pop_back();
}
que.push_back(value);
}
int front() { return que.front(); }
};
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
Myqueue que;
vector<int> result;
for (int i = 0; i < k; i++) { // 滑动窗口值为k,先将前k个值放入
que.push(nums[i]);
}
result.push_back(
que.front()); // result将前k个最大值记录:向容器末尾添加值
for (int i = k; i < nums.size(); i++) {
que.pop(nums[i - k]); // 移除前面的值
que.push(nums[i]);
result.push_back(que.front());
}
return result;
}
};
347.前K个高频元素
给你一个整数数组 nums 和一个整数 k ,请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。
思路
这道题目主要涉及到如下三块内容:
1.要统计元素出现频率 —— map可以实现
2.对频率排序 —— 优先级队列 priority_queue
3.找出前K个高频元素
优先级队列 priority_queue
就是一个披着队列外衣的堆,因为优先级队列对外接口只是从队头取元素,从队尾添加元素,再无其他取元素的方式,看起来就是一个队列。
而且优先级队列内部元素是自动依照元素的权值排列。
什么是堆呢?
堆是一棵完全二叉树,树中每个结点的值都不小于(或不大于)其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆,小于等于左右孩子就是小顶堆。
大顶堆(堆头是最大元素),小顶堆(堆头是最小元素),如果懒得自己实现的话,就直接用priority_queue(优先级队列)就可以了,底层实现都是一样的,从小到大排就是小顶堆,从大到小排就是大顶堆。
我们要用小顶堆,因为要统计最大前k个元素,只有小顶堆每次将最小的元素弹出,最后小顶堆里积累的才是前k个最大元素。
定义:
priority_queue< type, container, function>;
这三个参数,后面两个可以省略,第一个不可以。其中:
type:数据类型;
container:实现优先队列的底层容器,必须是可随机访问的容器,例如vector、deque,而不能使用list;
function:元素之间的比较方式;
在STL中,默认情况下(不加后面两个参数)是以vector为容器,以 operator< 为比较方式,所以在只使用第一个参数时,优先队列默认是一个最大堆,每次输出的堆顶元素是此时堆中的最大元素。
class Solution {
public:
// 小顶堆
class mycomparison {
public:
//()符号重载
bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
return lhs.second > rhs.second;
}
};
vector<int> topKFrequent(vector<int>& nums, int k) {
// 要统计元素出现频率
unordered_map<int, int> map; // map<nums[i],对应出现的次数>
for (int i = 0; i < nums.size(); i++) {
map[nums[i]]++;
}
// 对频率排序
// 定义一个小顶堆,大小为k
priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;
// 用固定大小为k的小顶堆,扫面所有频率的数值
for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
pri_que.push(*it);
if (pri_que.size() > k) { // 如果堆的大小大于了K,则队列弹出,保证堆的大小一直为k
pri_que.pop();
}
}
// 找出前K个高频元素,因为小顶堆先弹出的是最小的,所以倒序来输出到数组
vector<int> result(k);
for (int i = k - 1; i >= 0; i--) {
result[i] = pri_que.top().first;
pri_que.pop();
}
return result;
}
};