代码随想录|Day 11|2023.8.5|栈与队列part02

今日内容：20. 有效的括号，1047. 删除字符串中的所有相邻重复项，150. 逆波兰表达式求值

文章链接： 代码随想录

​题目链接：20. 有效的括号 ，1047. 删除字符串中的所有相邻重复项 ，150. 逆波兰表达式求值

1.20. 有效的括号

这道题一开始是想用数字代替字符去检索，但是忽略了括号要按照顺序闭合，例如s = "[{]}"这种就不符合题意。所以还是用字符本身去入栈和出栈，如果最后栈为空，则说明匹配成功。

class Solution {
public:
    bool isValid(string s) {
        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();
        }
        return st.empty();
    }
};

python版：

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        
        for item in s:
            if item == '(':
                stack.append(')')
            elif item == '[':
                stack.append(']')
            elif item == '{':
                stack.append('}')
            elif not stack or stack[-1] != item:
                return False
            else:
                stack.pop()
        
        return not stack

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

这道题有了上一道题的练习，思路是比较容易想到的。因为有栈顶这个属性，所以对于连续相邻的元素查重就比较方便。通过建立一个栈来存储和删除检索的元素就可以达成题意。

class Solution {
public:
    string removeDuplicates(string s) {
        string st = "";
        for(char x:s){
            if(!st.empty() && st.back() == x)
                st.pop_back();
            else
                st.push_back(x);
        }
        return st;
    }
};

python版：

class Solution:
    def removeDuplicates(self, s: str) -> str:
        st = []
        for x in s:
            if st and x == st[-1]:
                st.pop()
            else:
                st.append(x)
        return "".join(st)       

3. 150. 逆波兰表达式求值

这道题的思路感觉比较复杂，是看了讲解去理解的。遇到运算符就对栈中的两个数进行运算并重新入栈，遇到数字就压入栈中，且转化为长整型，最后栈顶就是运算结果。

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]));
            }
        }

        int result = st.top();
        return result;
    }
};

python版：

from operator import add, sub, mul
class Solution:
    op_map = {'+': add, '-': sub, '*': mul, '/': lambda x, y: int(x / y)}
    
    def evalRPN(self, tokens: List[str]) -> int:
        stack = []
        for token in tokens:
            if token not in {'+', '-', '*', '/'}:
                stack.append(int(token))
            else:
                op2 = stack.pop()
                op1 = stack.pop()
                stack.append(self.op_map[token](op1, op2)) 
        return stack[-1]