代码随想录算法训练营十期day11｜20. 有效的括号、1047. 删除字符串中的所有相邻重复项、150. 逆波兰表达式求值

day11｜20. 有效的括号、1047. 删除字符串中的所有相邻重复项、150. 逆波兰表达式求值

20. 有效的括号

讲完了栈实现队列，队列实现栈，接下来就是栈的经典应用了。
大家先自己思考一下 有哪些不匹配的场景，在看视频 我讲的都有哪些场景，落实到代码其实就容易很多了。
题目链接：https://leetcode.cn/problems/valid-parentheses/

class Solution {
    public boolean isValid(String s) {
        if(s.length()%2!=0)
            return false;
        Stack<Character> chars = new Stack<>();
        char[] chars1 = s.toCharArray();
        for (char c:chars1) {
            if(c=='('){
                chars.push(')');
            }else if(c=='{'){
                chars.push('}');
            }else if(c=='['){
                chars.push(']');
            }else if(chars.size()==0||chars.peek()!=c){
                return false;
            }else {
                chars.pop();
            }

        }
        return chars.size()==0;

    }
}

• 注意条件 最好用equal
• chars.peek 之后再pop

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

栈的经典应用。
要知道栈为什么适合做这种类似于爱消除的操作，因为栈帮助我们记录了 遍历数组当前元素时候，前一个元素是什么。
题目链接：https://leetcode.cn/problems/remove-all-adjacent-duplicates-in-string/

class Solution {
    public String removeDuplicates(String s) {
        Stack<Character> chs = new Stack<>();
        char[] chars = s.toCharArray();
        chs.push(chars[0]);
        for (int i = 1; i <chars.length ; i++) {
            if(chs.size()==0||chs.peek()!=chars[i]){
                chs.push(chars[i]);
            }else {
                chs.pop();
            }
        }
        StringBuilder stringBuilder = new StringBuilder();
        chs.stream().forEach(stringBuilder::append);
        return stringBuilder.toString();
    }
}

chs.stream().forEach(stringBuilder::append);!!!记得复习stream流

150逆波兰表达式求值

题目链接：https://leetcode.cn/problems/evaluate-reverse-polish-notation/

逆波兰表达式：

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

• 平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
• 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

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

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < tokens.length; i++) {
            if("+".equals(tokens[i])||"*".equals(tokens[i])||"/".equals(tokens[i])||"-".equals(tokens[i])){
                int pop1= stack.pop();
                int pop2 = stack.pop();
                Integer res=1;
                if ("/".equals(tokens[i])) {
                    res = pop2 / pop1;
                } else if ("+".equals(tokens[i])) {
                    res = (int) pop2 + (int) pop1;
                } else if ("-".equals(tokens[i])) {
                    res = (int) pop2 - (int) pop1;
                } else if ("*".equals(tokens[i])) {
                    res = (int) pop2 * (int) pop1;
                }
                System.out.println(tokens[i]);
                stack.push(res);
            } else {
                stack.push(Integer.valueOf(tokens[i]));
            }

        }
        return stack.pop();
    }

}

• equals
• Integer.valueOf