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

20. 有效的括号

思路：
1.使用栈完成每组括号的匹配
2.因为本题括号不会交叉，只能()[]{}，降低了难度
3.遍历字符串如果是左括号，放入栈，如果是右括号，使用它的左括号和栈顶元素比较是否相等

class Solution {
    public boolean isValid(String s) {
        Stack<Character> leftStack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '(' || c == '{' || c == '[') {
                leftStack.push(c);
            } else {
                if (!leftStack.empty() && leftOf(c) == leftStack.peek()) {
                    leftStack.pop();
                } else {
                    return false;
                }
            }
        }
        return leftStack.empty();
    }

    public char leftOf(char c) {
        if (c == '}') {
            return '{';
        } else if (c == ')') {
            return '(';
        } else {
            return '[';
        }
    }
}

也可以遍历的时候如果遇到左括号，就把对应的右括号放入栈，然后遇到右括号的时候和栈顶元素比较是否相等

class Solution {
    public boolean isValid(String s) {
        Deque<Character> deque = new LinkedList<>();
        char ch;
        for(int i = 0; i < s.length(); i++){
            ch = s.charAt(i);
            if(ch == '('){
                deque.push(')');
            } else if(ch == '['){
                deque.push(']');
            } else if(ch == '{'){
                deque.push('}');
            } else if(deque.isEmpty() || deque.peek() != ch){
                return false;
            } else {
                deque.pop();
            }
        }
        return deque.isEmpty();
    }
}

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

思路：
1.如果遍历的元素和栈顶元素相等，弹出栈顶元素
2.不相等就push进去
3.因为栈是LIFO，顺序是反的，所以要将结果翻转

class Solution {
    public String removeDuplicates(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            if (!stack.empty() && stack.peek() == s.charAt(i)) {
                stack.pop();
            } else {
                stack.push(s.charAt(i));
            }
        }
        StringBuilder sb = new StringBuilder();
        while (!stack.empty()) {
            sb.append(stack.pop());
        }
        return sb.reverse().toString();
     }
}

150. 逆波兰表达式求值

思路：
1.其实逆波兰表达式相当于是二叉树的后序遍历。 大家可以把运算符作为中间节点，按照后序遍历的规则画出一个二叉树。
2.但我们没有必要从二叉树的角度去解决这个问题，只要知道逆波兰表达式是用后续遍历的方式把二叉树序列化了，就可以了。
3.在进一步看，本题中每一个子表达式要得出一个结果，然后拿这个结果再进行运算，那么这岂不就是一个相邻字符串消除的过程，和1047.删除字符串中的所有相邻重复项中的对对碰游戏是不是就非常像了。

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new LinkedList<>();
        for(int i = 0;i < tokens.length;i++){
            if(tokens[i].equals("+")){
                stack.push(stack.pop() + stack.pop());
            } else if(tokens[i].equals("*")){
                stack.push(stack.pop() * stack.pop());
            } else if(tokens[i].equals("-")){
                stack.push(-stack.pop() + stack.pop());
            } else if(tokens[i].equals("/")){
                int temp1 = stack.pop();
                int temp2 = stack.pop();
                stack.push(temp2 / temp1);
            } else {
                stack.push(Integer.valueOf(tokens[i]));
            }
        }
        return stack.pop();
    }
}