目录
- [1. 最小栈](#1. 最小栈)
- [2. 栈的压入弹出序列](#2. 栈的压入弹出序列)
- [3. 逆波兰表达式求值](#3. 逆波兰表达式求值)
1. 最小栈
题目描述：设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。实现 MinStack 类:
MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。
示例 1:
输入：
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]
输出：
[null,null,null,null,-3,null,0,-2]
解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.
提示：
-231 <= val <= 231 - 1
pop、top 和 getMin 操作总是在 非空栈 上调用
push, pop, top, and getMin最多被调用 3 * 104 次
解题思路： 再创建一个栈出来，则有两个栈------栈A和栈B。原数据每次都往栈A中插入，而栈B为空时插入，或者当前插入数据等于或小于栈B栈顶的数据小时才插入。当弹出数据时，栈A每次都弹出栈顶，栈B栈顶的数据与栈A弹出的数据进行比较，若相等则弹出。所以，栈B栈顶的数据就是当前栈A中最小的数据。
代码如下：
cpp
class MinStack {
private:
stack<int> A;
stack<int> B;
public:
MinStack() {
}
void push(int val) {
// 栈A每次都压入数据
A.push(val);
// 当栈B为空时，或者栈A的栈顶数据小于等于栈B栈顶的数据，就往栈B中压入数据
if (B.empty() || B.top() >= A.top())
B.push(val);
}
void pop() {
// 当栈B栈顶的数据等于栈A栈顶的数据时，栈B弹出数据
if (A.top() == B.top())
B.pop();
// 栈A每次都弹出数据
A.pop();
}
int top() {
// 栈A栈顶的数据就是当前栈顶的数据
return A.top();
}
int getMin() {
// 栈B栈顶的数据就是当前栈中最小的数据
return B.top();
}
};2. 栈的压入弹出序列
题目描述：输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。
输入限制：
1. 0<=pushV.length == popV.length <=1000
2. -1000<=pushV[i]<=1000
3. pushV 的所有数字均不相同
示例1
输入：
[1,2,3,4,5],[4,5,3,2,1]
返回值：true
说明：可以通过push(1)=>push(2)=>push(3)=>push(4)=>pop()=>push(5)=>pop()=>pop()=>pop()=>pop()这样的顺序得到[4,5,3,2,1]这个序列，返回true
示例2
输入：[1,2,3,4,5],[4,3,5,1,2]
返回值：false
说明：由于是[1,2,3,4,5]的压入顺序，[4,3,5,1,2]的弹出顺序，要求4，3，5必须在1，2前压入，且1，2不能弹出，但是这样压入的顺序，1又不能在2之前弹出，所以无法形成的，返回false
题目链接： https://www.nowcoder.com/share/jump/8812161311718109046298
**解题思路：**新建一个 tmp 栈通过循环来模拟栈的压入弹出的过程。当tmp栈为空或者tmp栈栈顶的数据不等于弹出数组的数据时，则通过压入数组压入数据。定义两个下标变量，跟踪压入和弹出数组当前元素的位置。当压入数组下标超出之后便结束循环。此时，若tmp数组中没有元素，则证明该弹出序列正确，否则该弹出序列错误。
代码如下：
cpp
class Solution {
public:
bool IsPopOrder(vector<int>& pushV, vector<int>& popV) {
// 存储模拟过程
stack<int> tmp;
// 所需变量
int push_size = 0, pop_size = 0;
// 循环计算
while (push_size < pushV.size())
{
tmp.push(pushV[push_size]);
++push_size;
// 如果tmp栈不为空并且栈顶数据与弹出数组当前元素相同，tmp栈弹出数据
while (!tmp.empty() && tmp.top() == popV[pop_size])
{
tmp.pop();
++pop_size;
}
}
// 结果判断
return tmp.empty();
}
};3. 逆波兰表达式求值
题目描述：给你一个字符串数组 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 <= 104
tokens[i] 是一个算符（"+"、"-"、"*" 或 "/"），或是在范围 [-200, 200] 内的一个整数
逆波兰表达式：
逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。
平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。
逆波兰表达式主要有以下两个优点：
去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中
题目链接： link
**解题思路：**大家日常生活中使用的都是中缀表达式，也就是运算符在中间，操作数在两边。然后运算时根据操作符的优先级和结合顺序进行计算。而后缀表达式，则是已经排序好了，根据顺序计算就行，遇到运算符就把前第一个数当右操作数，前第二个数当作做操作数进行运算。则我们使用一个栈，当遇到操作数时进行压栈操作，当遇到操作符时取出栈顶的前两个数据进行运算，然后把结果压入栈中。如此往复，则最终栈顶的数据就是该表达式的结果。由于传入的数据是以字符串的形式传入的，则需要把字符串转换为整形，可以自己设计函数也可以使用string类库中的函数------void stoi(const string& s)。作者判断当前字符串是否为运算符是根据ASCII码表的值进行比较的。
代码如下：
cpp
class Solution {
public:
int evalRPN(vector<string>& tokens) {
// 使用一个int栈
stack<int> i_stack;
// 使用迭代器遍历数组
for (auto& val : tokens)
{
// 是运算符就运算
if (val[0] < 48 && val[1] < 48)
{
// 向栈中取两个操作数
int n2 = i_stack.top();
i_stack.pop();
int n1 = i_stack.top();
i_stack.pop();
// 根据符号进行运算
switch (val[0])
{
case '+':
i_stack.push(n1 + n2);
break;
case '-':
i_stack.push(n1 - n2);
break;
case '*':
i_stack.push(n1 * n2);
break;
case '/':
i_stack.push(n1 / n2);
break;
}
}
else // 不是运算符就压栈
{
i_stack.push(stoi(val));
}
}
// 完成处理后，栈顶就是运算结果
return i_stack.top();
}
};