Day 11 | 栈和队列 20. 有效的括号 、1047. 删除字符串中的所有相邻重复项 、 150. 逆波兰表达式求值

20. 有效的括号

题目
文章讲解
视频讲解

思路：首先遍历左括号，在栈中存放右括号。

1. 其中，匹配不成功有三种情况：

   • 左括号多：遍历完字符串，发现栈中有剩余，就是有左括号没被匹配
   • 右括号多：遍历字符串中，栈空了
   • 不匹配：遍历过程中，栈中字符不匹配

2. 匹配成功：遍历结束，栈空了

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();// 注意存放的是字符

        int size = s.length();
        if (size % 2 != 0)
            return false;// 剪枝：当字符串中字符个数为奇数，最后一定无法对应匹配
        for (int i = 0; i < size; i++) {
            if (s.charAt(i) == '(') {// 字符串的读取用charAt()
                stack.push(')');
            } else if (s.charAt(i) == '{') {
                stack.push('}');
            } else if (s.charAt(i) == '[') {
                stack.push(']');
            } else if (stack.isEmpty() || stack.peek()!=s.charAt(i)) {
                return false;//判断右括号多了或不匹配
            }else{
                stack.pop();
            }
        }
        return stack.isEmpty();//判断左括号多了
    }
}

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

题目
文章讲解
视频讲解
思路：
遍历字符串，对比栈中元素，若栈为空或者栈中元素与遍历字符不等 ，就将字符放到栈中，剩余元素就是不重复的，但注意是逆序。最后用字符串输出，不用的话应该涉及数据类型转换，是我还不太了解的知识。

class Solution {
    public String removeDuplicates(String s) {
        //设置一个栈去存放遍历字符串的每个字符
        ArrayDeque<Character> deque = new ArrayDeque<>();

        //遍历字符串，对比栈中元素，若栈为空或者栈中元素与遍历字符不等    
        //将字符放到栈中
        for(int i=0;i<s.length();i++){
            char ch=s.charAt(i);
            if(deque.isEmpty()||ch!=deque.peek()){
                deque.push(ch);
            }else{
                deque.pop();
            }
        }
        String str="";
        //剩余的元素就是不重复的
        while(!deque.isEmpty()){
            str = deque.pop()+str;//将双端队列中的元素逆序地拼接到str的前面
        }
        return str;
    }
}

150. 逆波兰表达式求值

题目
文章讲解
视频讲解
思路：逆波兰表达式又叫“后缀表达式”，其实就是二叉树的后序遍历，方便计算机计算；中序遍历方便人去理解，但计算机计算时需要处理括号，不方便。

问题：

• 需要在堆栈或队列中推送整数对象，你可以使用push(Integer.valueOf(s))；如果你只需要原始的int类型，你可以使用push(Integer.parseInt(s))

class Solution {
    public int evalRPN(String[] tokens) {
        ArrayDeque<Integer> deque = new ArrayDeque<>();

        for (int i = 0; i < tokens.length; i++) {
            if (tokens[i].equals("+") || tokens[i].equals("-") || tokens[i].equals("*") ||tokens[i].equals("/") ) {
                int num1 = deque.pop();
                int num2 = deque.pop();

                if (tokens[i].equals("+")) {
                    deque.push(num2 + num1);
                } else if (tokens[i].equals("-")) {
                    deque.push(num2 - num1);
                } else if (tokens[i].equals("*")) {
                    deque.push(num2 * num1);
                } else if (tokens[i].equals("/")) {
                    deque.push(num2 / num1);
                }
            } else {
                deque.push(Integer.parseInt(tokens[i]));
            }
        }
        return deque.pop();
    }
}

注意类型转换需要在循环之外，注意字符串的判断写法，注意数据类型转换！！！需要补！！！

补充

1.Java中的栈Stack、Deque、ArrayDeque、LinkedList
2. 栈比较擅长处理相邻两个元素的操作