代码随想录第11天|栈与队列part02|● 20. 有效的括号● 1047. 删除字符串中的所有相邻重复项 ● 150. 逆波兰表达式求值

20.有效的括号

题目链接：20. 有效的括号 - 力扣（LeetCode）

题目：给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。

2. 左括号必须以正确的顺序闭合。

3. 每个右括号都有一个对应的相同类型的左括号。

   思路：左括号就入栈，如果是右括号，就跟栈顶对比

   //有效的括号
   class Solution {
   public:
       bool isValid(string s) {
           int n=s.size();
           stack<char>st;
           st.push(s[0]);
           bool ans=true;
           for(int i=1;i<n;i++){
               if(s[i]=='['||s[i]=='{'||s[i]=='('){
                   //左括号
                   st.push(s[i]);
               }else{
                   //右括号与栈顶对比
                   if(st.empty())  return false;//碰到右括号，且栈为空，直接返回false
                   if((st.top()=='['&&s[i]==']')||(st.top()=='{'&&s[i]=='}')||(st.top()=='('&&s[i]==')')){
                       st.pop();//匹配到，则弹出栈顶元素
                   }else{//不匹配就入栈，直接break
                       st.push(s[i]);
                       break;                    
                   }
               }            
           }
           if(!st.empty())  ans=false;
           return ans;
       }
   };
   

1047.删除字符串中的所有相邻重复项

题目链接：1047. 删除字符串中的所有相邻重复项 - 力扣（LeetCode）

题目：给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

思路：删除相邻重复元素？循环？要多少层才能走完——不可行；数据结构——栈

class Solution {
public:
    string removeDuplicates(string s) {
        stack<char>st;
        for(auto c:s){//遍历字符串，与栈顶判断
            if(!st.empty()&&c==st.top()){//当前字符跟栈顶相同，则弹出栈顶
                st.pop();
            }else{
                st.push(c);
            }
        }
        string ans;
        while(!st.empty()){//弹出栈中剩余元素，记录到ans
            ans.push_back(st.top());
            st.pop();
        }
        //翻转
        reverse(ans.begin(), ans.end());
        return ans;
    }
};

150.逆波兰表达式求值

题目链接：150. 逆波兰表达式求值 - 力扣（LeetCode）

题目：给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

• 有效的算符为 '+'、'-'、'*' 和 '/' 。
• 每个操作数（运算对象）都可以是一个整数或者另一个表达式。
• 两个整数之间的除法总是 向零截断 。
• 表达式中不含除零运算。
• 输入是一个根据逆波兰表示法表示的算术表达式。
• 答案及所有中间计算结果可以用 32 位 整数表示

分析：逆波兰表达式，也称后缀表达式，典型的栈问题。

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        //通过栈，逻辑上后缀转中缀，并计算
        int ans;
        stack<string>st;
        for(auto token:tokens){
            if(token=="+"||token=="-"||token=="*"||token=="/"){//如果是符号，则计算前两位数字，并取出，将结果压入栈中
                string s1=st.top();
                st.pop();
                string s2=st.top();
                st.pop();

                //计算结果
                int num1,num2,tmp;
                num1=stoi(s1);//字符串转整数
                num2=stoi(s2);
                if(token=="+"){
                    tmp=num2+num1;
                }
                if(token=="-"){
                    tmp=num2-num1;
                }
                if(token=="*"){
                    tmp=num2*num1;
                }
                if(token=="/"){
                    tmp=num2/num1;
                }

                //结果压回栈中
                st.push(to_string(tmp));//整数转字符串

            }else{//如果是数字，直接入栈
                st.push(token);
            }
        }
        ans=stoi(st.top());
        return ans;
    }
};