【算法第九天7.23】有效的括号，删除字符串中的所有相邻重复项，逆波兰表达式求值

链接：力扣20-有效的括号
思路：
1、长度不为偶数，直接返回false
2、遇到左括号，则入栈相应的右括号
3、遇到右括号，则查看是否匹配（按顺序）
4、如果栈长度此时为 0 ，则说明右括号多于左括号；如果栈顶元素不等于串当前位置元素，则说明不匹配，这两种情况都返回false
4、当栈顶元素等于串当前位置元素（其它情况），则pop出这个元素，继续栈和串的比较

class Solution {
    public boolean isValid(String s) {
        Stack<Character> st = new Stack<>();
        if(s.length() % 2 != 0) return false;
        char[] charArray = s.toCharArray();
        for(int i = 0;i<s.length();i++){
            char temp = charArray[i];
            if(temp == '('){
                 st.push(')');
            }
            else if( temp== '{'){
                st.push('}');
            }
            else if(temp == '['){
                 st.push(']');
            }
            // 栈为空，或者栈顶弹出的元素和后面的元素不匹配
            // peek 和 pop 是有区别的！
            else if(st.size() == 0|| st.peek() != temp){
                return false;
            }else{
                st.pop();
            }
        }
        return st.isEmpty();
    }
}

链接：力扣1047-删除字符串中的所有相邻重复项
思路：
1、创建一个新串来承接结果（java中的字符串不可变）
2、用栈来解决问题，循环到当前元素时，看一下这个元素是否跟栈顶元素相同，不相同（栈为空），则入栈；如果相同，不仅弹出栈顶元素，当前元素也不会入栈（一举两得，全删了）
3、最后再将栈中元素一一弹出，放入新串中

class Solution {
    public String removeDuplicates(String s) {
        String str = new String();
        Stack<Character> stack = new Stack<>();
        for(int i = 0;i<s.length();i++){
            char ch = s.charAt(i);
            // 栈顶元素不匹配或者栈为空，则此元素入栈
            if(stack.isEmpty() || stack.peek() != ch){
                stack.push(ch);
            // 如果栈匹配，则将栈中匹配的元素弹出（此元素也不会入栈）
            // 这一步很巧妙，可以循环删除栈顶与当前一致的元素
            }else{
                stack.pop();
            }
        }
        // java中字符串不可变，需要一个新字符串来承接结果
        while(!stack.isEmpty()){
            str = stack.pop() + str;
        }
        return str;
    }
}

链接：力扣150-逆波兰表达式求值
思路：
1、逆波兰表达式（后序表达式）：遇到操作符，就让栈中出来两个元素进行运算，运算的结果再入栈；遇到数字，就入栈
2、运算要注意 除法 和 减法 操作：分清两个数的前后顺序
3、入栈的元素要从字符转为数字parseInt（）
4、最后返回栈中的最后一个元素（因为操作完的结果会再入栈）

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for(int i = 0;i<tokens.length;i++){
            String temp = tokens[i];
            // 不能在这里先定义出栈元素，有可能现在的栈里还为空
                // int num1 = stack.pop();
                // int num2 = stack.pop();
                if("+".equals(temp)){
                    stack.push(stack.pop() + stack.pop());
                }else if("-".equals(temp)){
                    // 后出栈的 - 前出栈的
                    stack.push( -stack.pop() + stack.pop());
                }else if("*".equals(temp)){
                    stack.push(stack.pop() * stack.pop());
                }else if("/".equals(temp)){
                    // 后出栈的 / 前出栈的
                    int temp1 = stack.pop();
                    int temp2 = stack.pop();
                    stack.push(temp2/temp1);
                }
            // 如果不是符号，则直接写入栈
            else{
                stack.push(Integer.parseInt(temp));
            }
        }
        return stack.pop();
    }
}