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

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

20. 有效的括号

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

有效字符串需满足：

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

个人思路

• 将左括号存入栈中，遇到有括号就取出来做判断即可
• 奇数个字符可以直接返回false
• 判断过程中栈为null，直接返回false
• 最后返回栈是否为null

class Solution {
    public boolean isValid(String s) {
        if (s.length() % 2 == 1)
            return false;
        Stack<Character> stack = new Stack<>();
        char[] str = s.toCharArray();
        for (int i = 0; i < str.length; i++) {
            if (str[i] == '(' || str[i] == '{' || str[i] == '[')
                stack.push(str[i]);
            else {
                switch (str[i]) {
                    case ')':
                        if (stack.empty() || stack.pop() != '(')
                            return false;
                        break;
                    case ']':
                        if (stack.empty() || stack.pop() != '[')
                            return false;
                        break;
                    case '}':
                        if (stack.empty() || stack.pop() != '{')
                            return false;
                        break;
                }
            }
        }
        return stack.empty();
    }
}

题解解析：

• 基本上也是基于几种特殊情况去排除
• 入栈的时候，可以入其对应的有括号，到出栈的时候就可以直接判断是否相等了

class Solution {
    public boolean isValid(String s) {
        if (s.length() % 2 == 1)
            return false;
        Stack<Character> stack = new Stack<>();
        char[] str = s.toCharArray();
        for (int i = 0; i < str.length; i++) {
            switch (str[i]) {
                case '(':
                    stack.push(')');
                    break;
                case '{':
                    stack.push('}');
                    break;
                case '[':
                    stack.push(']');
                    break;
                default:
                    if (stack.empty() || stack.pop() != str[i])
                        return false;
            }
        }
        return stack.empty();
    }
}

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

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

个人思路：

• 循环遍历，判断此时的元素与栈顶元素是否相等，如果相等则弹出栈顶元素，不相等则入栈
• 之后再将栈中元素弹出，存储到一个字符数组返回即可

class Solution {
    public String removeDuplicates(String s) {
        Stack<Character> stack = new Stack<>();
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if (!stack.empty() && chars[i] == stack.peek())
                stack.pop();
            else stack.push(chars[i]);
        }
        char[] str = new char[stack.size()];
        for (int i = str.length - 1; i >= 0; i--) {
            str[i] = stack.pop();
        }
        return new String(str);
    }
}

150. 逆波兰表达式求值

根据后缀表达式，求出算式结果

个人思路：

• 遇到数字入栈，遇到符号两个数字出栈计算，结果再入栈
• 最后栈中剩下的数字就是结果

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < tokens.length; i++) {
            if (tokens[i].equals("+") || tokens[i].equals("-") || tokens[i].equals("*") || tokens[i].equals("/")) {
                Integer num2 = stack.pop();
                Integer num1 = stack.pop();
                switch (tokens[i]) {
                    case "+":
                        stack.push(num1 + num2);
                        break;
                    case "-":
                        stack.push(num1 - num2);
                        break;
                    case "*":
                        stack.push(num1 * num2);
                        break;
                    case "/":
                        stack.push(num1 / num2);
                        break;
                }
            } else stack.push(Integer.parseInt(tokens[i]));
        }
        return stack.pop();
    }