代码随想录算法训练营第11天| LeetCode 20. 有效的括号 1047. 删除字符串中的所有相邻重复项 150. 逆波兰表达式求值

20. 有效的括号

从左到右遍历字符串，当我们遇到一个左括号，我们将其推入堆栈中。当我们遇到一个右括号，我们检查堆栈顶部的元素。如果堆栈顶部的元素是一个匹配的左括号，那么我们将其从堆栈中弹出并继续处理。否则，这意味着字符串是无效的。如果我们处理完字符串后堆栈为空，这意味着所有的括号都被正确地匹配了。

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<Character>();

        for(int i = 0; i < s.length();i++){
            char m = s.charAt(i);

            if(m == '('){
                stack.push(')');
            } else if(m == '['){
                stack.push(']');
            } else if(m == '{'){
                stack.push('}');
            }else{
                if(stack.isEmpty() || stack.pop() != m){
                    return false;
                }
            }

        }
        return stack.isEmpty();
    }
}

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

class Solution {
    public String removeDuplicates(String s) {

        Stack<Character> stack = new Stack<>();

        for(int i = 0; i< s.length();i++){
            char c = s.charAt(i);
            if(!stack.isEmpty() && stack.peek() == c){
                // 如果当前字符和栈顶元素相同 弹出栈顶元素
                stack.pop();
            } else {
                // 如果当前字符和栈顶元素不同 压入堆栈
                stack.push(c);
            }
        }

        String str = "";
        // 剩余的元素为不重复元素
        while(!stack.isEmpty()){
            str = stack.pop() + str;
        }

        return str;
    }
}

150. 逆波兰表达式求值

逆波兰表示法是一种将二元运算符后置的数学表示方法，也叫后缀表达式。解决这类问题的方法通常是使用堆栈，当遇到数字时，压入堆栈；当遇到运算符时，弹出栈顶的两个元素进行运算，并将结果再压入堆栈。当处理完所有的元素后，堆栈顶部的元素就是最后的结果

import java.util.Stack;

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();  // 创建一个堆栈用来存储数字

        for (String token : tokens) {  // 遍历tokens中的每一个元素
            if (token.equals("+")) {  // 如果当前元素是加号
                stack.push(stack.pop() + stack.pop());  // 弹出栈顶的两个元素并进行加法运算，然后把结果压入堆栈
            } else if (token.equals("-")) {  // 如果当前元素是减号
                int b = stack.pop();  // 弹出栈顶元素，用变量b存储
                int a = stack.pop();  // 再弹出栈顶元素，用变量a存储
                stack.push(a - b);  // 计算a - b，然后把结果压入堆栈
            } else if (token.equals("*")) {  // 如果当前元素是乘号
                stack.push(stack.pop() * stack.pop());  // 弹出栈顶的两个元素并进行乘法运算，然后把结果压入堆栈
            } else if (token.equals("/")) {  // 如果当前元素是除号
                int b = stack.pop();  // 弹出栈顶元素，用变量b存储
                int a = stack.pop();  // 再弹出栈顶元素，用变量a存储
                stack.push(a / b);  // 计算a / b，然后把结果压入堆栈
            } else {  // 如果当前元素是数字
                stack.push(Integer.parseInt(token));  // 把当前元素转换为整数，并压入堆栈
            }
        }

        return stack.pop();  // 最后，弹出并返回栈顶元素，这就是最终的结果
    }
}