双队列实现栈&&最小栈&&逆波兰式（力扣C++）

题目

用双队列实现栈的操作~

class MyStack {
public:
    queue<int >s1;
    queue<int >s2;
    MyStack() {

    }
    
    void push(int x) {
        s1.push(x);
    }
    
    int pop() {
        int n=0;
       while(!s1.empty()){
           n++;
           s2.push(s1.front());
           s1.pop();
       }
       for(int i=0;i<n-1;i++){
           s1.push(s2.front());
           s2.pop();
       }
       int num=s2.front();
       s2.pop();
       return num;
    }
    
    int top() {
        int n=0;
       while(!s1.empty()){
           n++;
           s2.push(s1.front());
           s1.pop();
       }
       for(int i=0;i<n-1;i++){
           s1.push(s2.front());
           s2.pop();
       }
       int num=s2.front();
       s1.push(s2.front());
           s2.pop();
       return num;
    }
    
    bool empty() {
      if(s1.empty())
      return true;
      else{
          return false;
      }
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

简化版，单队列实现

class MyStack {
public:
    queue<int >s2;
    MyStack() {

    }
    
    void push(int x) {
        int n=s2.size();
        s2.push(x);
        while(n--){
            int temp=s2.front();
            s2.pop();
            s2.push(temp);
        }
    }
    
    int pop() {
       int num=s2.front();
       s2.pop();
       return num;
    }
    
    int top() {
       return s2.front();
    }
    
    bool empty() {
      return s2.empty();
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

题目（最小栈）

解法一：采用两个栈实现，一个数据栈一个最小栈！

class MinStack {
public:
    stack<int >data;
    stack<int >minSt;
    MinStack() {

    }
    
    void push(int val) {
        //学到了，这个=必不可少！！，如果没有这个=的话后期出栈的时候遇到相
        //同的就会把最小栈出去了，以至于本来栈内的最小值还是那个相同的元素
        //但是由于出去了之后就没有了，会出现错误！
        if(minSt.empty()||val<=minSt.top()){
            minSt.push(val);
        }
        data.push(val);
    }
    
    void pop() {
        if(minSt.top()==data.top())
        minSt.pop();
        data.pop();
    }
    
    int top() {
        return data.top();
    }
    
    int getMin() {
        return minSt.top();
    }
};


/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

解法二：class MinStack { /* * 思路：每次入栈 2 个元素，一个是入栈的元素本身，一个是当前栈元素的最小值 * 如：入栈序列为 2-3-1，则入栈后栈中元素序列为：2-2-3-2-1-1 * 用空间代价来换取时间代价 */ private Stack stack;

class MinStack {
public:
    stack<int >stack;
    MinStack() {

    }
    
    void push(int val) {
        if(stack.empty()){
            stack.push(val);
            stack.push(val);
        }else{
            int tmp=stack.top();
            stack.push(val);
            if(val<tmp)
            stack.push(val);
            else
            stack.push(tmp);
        }
    }
    
    void pop() {
        stack.pop();
        stack.pop();
    }
    
    int top() {
        int tmp=stack.top();
        stack.pop();
        int num=stack.top();
        stack.push(tmp);
        return num;
    }
    
    int getMin() {
        return stack.top();
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

题目（逆波兰式）

根据 逆波兰表示法，求表达式的值。

有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

注意 两个整数之间的除法只保留整数部分。

可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 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

提示：

1 <= tokens.length <= 104
tokens[i] 是一个算符（“+”、“-”、“*” 或 “/”），或是在范围 [-200, 200] 内的一个整数

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。
逆波兰表达式主要有以下两个优点：

去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/evaluate-reverse-polish-notation
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
stoi(tokens[i])这个函数是将string类型转换为int类型的数字，划分比较简单可以学习~

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
       int n=tokens.size();
       stack<int >st;
       for(int i=0;i<n;i++){
              if(tokens[i]=="+"||tokens[i]=="-"||tokens[i]=="*"||tokens[i]=="/"){
                  int s1=st.top();
                  st.pop();
                  int s2=st.top();
                  st.pop();
                  int res;
                  if(tokens[i]=="+")
                  res=s2+s1;
                  else if(tokens[i]=="-")
                  res=s2-s1;
                  else if(tokens[i]=="/")
                  res=s2/s1;
                  else
                  res=s1*s2;
                  st.push(res);
              }else{
               st.push(stoi(tokens[i]));  
               /*
               //本来这部分想要手动这么转换的，但是！！！！
               //["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
               //运行输出  23   预期结果   22，一直不知道错了哪里！！！
               //真的无奈！
               int number=0;
               if(tokens[i][0]=='-'){
                   for(int j=1;j 
       }
    }
    return st.top();
    }
};