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

一、力扣20.有效的括号

1.1题目

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串，判断字符串是否有效。
有效字符串需满足：

• 左括号必须用相同类型的右括号闭合。
• 左括号必须以正确的顺序闭合。
• 注意空字符串可被认为是有效字符串。

1.2思路：

括号匹配是使用栈解决的经典问题。

**注意：**有一些技巧，在遍历到左括号的时候，将其所对应的右括号入栈，那么当遍历到右括号的时候就只需要比较当前元素和栈顶相不相等就可以了，比左括号入栈代码实现要简单的多了！

1.3 代码

左括号对应的右括号入栈（推荐）：

class Solution {
    public boolean isValid(String s) {
        //将左括号对应的右括号入栈方法
        Stack<Character> stack = new Stack<>();
        //遍历字符串
        for(int i =0;i<s.length();i++){
             Character ch = s.charAt(i);
            if(ch == '('){
                stack.push(')');
            }else if(ch == '{'){
                stack.push('}');
            }else if(ch == '['){
                stack.push(']');
            }else if(stack.isEmpty()){
                return false;
            }else if(stack.pop() != ch){
                return false;
            }
        }
        return stack.isEmpty();
    }
}

左括号入栈（自己的写法）：

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        //遍历字符串
        for(int i = 0;i<s.length();i++){
             char ch = s.charAt(i);
            if(ch == '(' || ch =='{' || ch=='[' ){
                stack.push(ch);
            }else{
                if(isRightTrue(stack,ch)==false){
                    return false;
                }
            }

        }
        //遍历完成，如果stack还有元素，那么失败，否则成功
        if(stack.size() > 0){
            return false;
        }
        return true;
  }
    public boolean isRightTrue(Stack<Character> stack,char ch){
        if(stack.size()==0){
            return false;
        }
        char left;
        switch(ch){
            case '}':
                left = stack.pop();
                if(left == '{'){
                    return true;
                }
                return false;
            case ']':
                left = stack.pop();
                if(left == '['){
                    return true;
                }
                return false;
            case ')':
                left = stack.pop();
                if(left == '('){
                    return true;
                }
                return false;
        }
        return false;
    }
}

1.4 总结

注意：Stack的泛型中要放包装类，char的包装类是Character;
使用String.charAt(index)方法来读取字符。

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

2.1 题目：

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
在 S 上反复执行重复项删除操作，直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

2.2 思路：

用栈来存放，那么栈的目的，就是存放刚刚遍历过的元素，当遍历当前的这个元素的时候，去栈顶看一下我们是不是遍历过相同数值的相邻元素，再做相应处理。

2.3 代码：

Stack栈

class Solution {
    public String removeDuplicates(String s) {
        //用栈来解决匹配问题，栈顶元素刚好是刚刚遍历过的相邻元素
        Stack<Character> stack = new Stack<>();
        for(int i = 0;i<s.length();i++){
             Character ch = s.charAt(i);
             //如果栈为空，那么直接入栈，继续遍历
            if(stack.isEmpty()){
                stack.push(ch);
            } else if(ch != stack.peek()){//如果和栈顶元素不同,入栈，继续遍历
               stack.push(ch);
            } else if(ch == stack.peek()){//与栈顶元素相同，pop，继续遍历
               stack.pop();
            }
        }
        //遍历结束后，此时的栈转为字符串后即为最后的结果,注意最先pop的字符为res的最后一个字符
        String res = "";
        while(!stack.isEmpty()){
            res = stack.pop() + res;
        }
        return res;
    }
}

用字符串来模拟栈

2.4 总结：

匹配问题都是栈的强项。
当Stack为空时，stack.peek()方法并不返回null，而是直接报错，要注意优先处理为空的特殊情况。

三、力扣150.逆波兰表达式求值

3.1 题目：

根据 逆波兰表示法，求表达式的值。
有效的运算符包括 + , - , * , / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
说明：
整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。
示例 1：

• 输入: [“2”, “1”, “+”, “3”, " * "]
• 输出: 9
• 解释: 该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
  注：什么是逆波兰表达式呢？实际上是一种后缀表达式，即运算符写在后面。
  

3.2 思路：

数字入栈，遇到运算符pop出栈顶的两个元素，计算结果后再push进去，按照此方法一直遍历结束！

3.3 代码：

class Solution {
    public int evalRPN(String[] tokens) {
        //碰到数字则入栈，碰到运算符则pop出栈顶的两个，计算结果后push
        Stack<String> stack  = new Stack<>();
        //遍历字符串数组
        for(int i =0;i<tokens.length;i++){
            if(tokens[i].equals("+") || tokens[i].equals("-")||tokens[i].equals("*")||tokens[i].equals("/")){
                int num1 = Integer.parseInt(stack.pop());
                int num2 = Integer.parseInt(stack.pop());
                int res = 0;
                //要注意 -和/的操作数顺序 num2在前
                if(tokens[i].equals("+")){
                    res = num2 +num1;
                }else if(tokens[i].equals("-")){
                    res = num2 -num1;
                }else if(tokens[i].equals("*")){
                    res = num1 * num2;
                }else if(tokens[i].equals("/")){
                    res = num2 / num1;
                }
                stack.push(Integer.toString(res));
            }else{
                stack.push(tokens[i]);
            }
        }
        //遍历完成，出栈即为结果
         return Integer.parseInt(stack.pop());
    }
}

3.4 总结：

栈这种数据结构就非常适合相邻元素的消除操作！
知道什么是逆波兰表达式，后缀的概念！
String的比较方法equals以及将String转化为整型的方法Integer.parseInt()，将整型转化为String的方法Integer.toString().