【刷题day11】栈与队列|20. 有效的括号、1047. 删除字符串中的所有相邻重复项、150. 逆波兰表达式求值-CSDN博客

本文链接：https://blog.csdn.net/weixin_45639929/article/details/129229403

文章提供了几种算法实现，包括检查括号的有效性，删除字符串中的所有相邻重复项以及逆波兰表达式的求值。这些算法使用栈数据结构进行处理，如检查括号匹配时，遇到左括号入栈，遇到右括号则与栈顶的左括号匹配；在处理逆波兰表达式时，遇到数字入栈，遇到运算符则取出栈顶的两个数字进行计算。

摘要由CSDN通过智能技术生成

20. 有效的括号

    bool isValid(string s) {
        stack<char> st;
        for(char &ch:s){
            if(ch == '(' || ch == '{' || ch == '['){
                st.push(ch);
            }
            else{
                if(st.empty())
                    return false;
                char tmp=st.top();
                st.pop();
                if(tmp == '(' && ch != ')'){
                    return false;
                }
                if(tmp == '{' && ch != '}'){
                    return false;
                }
                if(tmp == '[' && ch != ']'){
                    return false;
                }
            }
        }
        return st.empty();
    }

    bool isValid(string s) {
        if (s.size() % 2 != 0) // 如果s的长度为奇数，一定不符合要求
            return false; 
        stack<char> st;
        for (int i = 0; i < s.size(); i++) {
            if (s[i] == '(') 
                st.push(')');
            else if (s[i] == '{') 
                st.push('}');
            else if (s[i] == '[') 
                st.push(']');
            // 发现栈已经为空了，说明右括号没有找到对应的左括号或者发现栈里不是要匹配的字符
            else if (st.empty() || st.top() != s[i]) 
                return false;
            else 
                st.pop(); // st.top() 与 s[i]相等，栈弹出元素
        }
        return st.empty();//已经遍历完了，如果栈不为空，说明左括号没有右括号来匹配，return false，否则return true
    }

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

拿数组当作栈

string removeDuplicates(string s) {
        string st;
        for (char ch : s) {
            if (!st.empty() && st.back() == ch) {
                st.pop_back();
            } else {
                st.push_back(ch);
            }
        }
        return st;
    }

150. 逆波兰表达式求值

后缀表达式

遇见数字就加入到栈里，遇见操作符就从栈里取出元素，做计算，然后再把数字加入到栈里

c_str()：将string转换为字符数组
atoi：把字符串转换为一个整数（类型为 int 型）

int evalRPN(vector<string>& tokens) {
        stack<int> st;
        int n = tokens.size();
        for (int i = 0; i < n; i++) {
            string& token = tokens[i];
            if (isNumber(token)) {
                st.push(atoi(token.c_str()));
            } 
            else {
                int num2 = stk.top();
                st.pop();
                int num1 = stk.top();
                st.pop();
                switch (token[0]) {
                    case '+':
                        st.push(num1 + num2);
                        break;
                    case '-':
                        st.push(num1 - num2);
                        break;
                    case '*':
                        st.push(num1 * num2);
                        break;
                    case '/':
                        st.push(num1 / num2);
                        break;
                }
            }
        }
        return st.top();
    }

    bool isNumber(string& token) {
        return !(token == "+" || token == "-" || token == "*" || token == "/");
    }

int evalRPN(vector<string>& tokens) {
        stack<long long> st;  // 力扣修改了后台测试数据，需要用longlong
        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]));//stoll字符串转换为long long int;stol字符串转换为long int
            }
        }
        int result = st.top();
        st.pop(); // 把栈里最后一个元素弹出（其实不弹出也没事）
        return result;
    }