代码随想录算法训练营第十一天|LeetCode20,1047,150

代码随想录算法训练营第十一天|LeetCode20,1047,150

20. 有效的括号

主要考虑不匹配的三种情况：
第一种情况，字符串里左方向的括号多余了，所以不匹配。第二种情况，括号没有多余，但是 括号的类型没有匹配上。第三种情况，字符串里右方向的括号多余了，所以不匹配
第一种情况：已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false
第二种情况：遍历字符串匹配的过程中，发现栈里没有要匹配的字符。所以return false
第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号return false
那么什么时候说明左括号和右括号全都匹配了呢，就是字符串遍历完之后，栈是空的，就说明全都匹配了。

public static boolean isValid(String s) {
        if (s.isEmpty()){
            return true;
        }
        if (s.charAt(0)==')'||s.charAt(0) == '}'||s.charAt(0)==']'){
            return false;
        }

        Deque<Character> charStack = new ArrayDeque<>();
        for (char c :s.toCharArray()){
            if (c=='['||c == '{'||c=='('){
                charStack.push(c);
            }else if (c == ']'){
                if (charStack.isEmpty()){
                    return false;
                }
                char tmp = charStack.pop();
                if (tmp != '['){
                   return false;
                }
            }else if (c == '}'){
                if (charStack.isEmpty()){
                    return false;
                }
                char tmp = charStack.pop();
                if (tmp != '{'){
                    return false;
                }
            } else if (c == ')'){
                if (charStack.isEmpty()){
                    return false;
                }
                char tmp = charStack.pop();
                if (tmp != '('){
                    return false;
                }
            }
        }
        if (charStack.isEmpty()){
            return true;
        }
        return false;

    }

参考题解发现，在匹配左括号的时候，右括号先入栈，就只需要比较当前元素和栈顶相不相等就可以了，比左括号先入栈代码实现要简单。

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

用栈存放遍历过的字符，遍历当前的这个元素的时候，看一下栈顶是不是遍历过相同数值的相邻元素。如果是则弹出。最后从栈中弹出剩余元素得到了最终的结果。

public String removeDuplicates(String s) {
        Deque<Character> tmpStack = new ArrayDeque<>();

        for (int i = s.length() -1;i >= 0;i--){
            char c = s.charAt(i);
            if (tmpStack.isEmpty()){
                tmpStack.push(c);
                continue;
            }
            if (c == tmpStack.peek()){
                tmpStack.pop();
            }else {
                tmpStack.push(c);
            }
        }
        StringBuilder sb = new StringBuilder();
        while (!tmpStack.isEmpty()){
            sb.append(tmpStack.pop());
        }
        return sb.toString();

    }

150. 逆波兰表达式求值

逆波兰表达式是一种后缀表达式，所谓后缀就是指运算符写在后面。
逆波兰表达式主要有以下两个优点：

• 去掉括号后表达式无歧义，( 1 + 2 ) * ( 3 + 4 ) 即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。

• 适合用栈操作运算：遇到数字则入栈；遇到运算符则取出栈顶两个数字进行计算，并将结果压入栈中。

public int evalRPN(String[] tokens) {
        ArrayDeque<Integer> tmpStack = new ArrayDeque<>();
        for (int i = 0; i < tokens.length;i++ ){
            if (!tokens[i].equals("+")&&!tokens[i].equals("-")&&!tokens[i].equals("*")&&!tokens[i].equals("/")){
                tmpStack.push(Integer.valueOf(tokens[i]));
            }else if (tokens[i].equals("+")){
                Integer tmp1 = tmpStack.pop();
                Integer tmp2  = tmpStack.pop();
                Integer mid_result = tmp2 + tmp1;
                tmpStack.push(mid_result);

            }else if (tokens[i].equals("-")){
                Integer tmp1 = tmpStack.pop();
                Integer tmp2  = tmpStack.pop();
                Integer mid_result = tmp2 - tmp1;
                tmpStack.push(mid_result);
            }else if (tokens[i].equals("*")){
                Integer tmp1 = tmpStack.pop();
                Integer tmp2  = tmpStack.pop();
                Integer mid_result = tmp2 * tmp1;
                tmpStack.push(mid_result);
            }else if (tokens[i].equals("/")){
                Integer tmp1 = tmpStack.pop();
                Integer tmp2  = tmpStack.pop();
                Integer mid_result = tmp2 / tmp1;
                tmpStack.push(mid_result);
            }
        }
        return tmpStack.pop();
    }