零基础代码随想录【Day11】|| 20. 有效的括号 ，1047. 删除字符串中的所有相邻重复项 ，150. 逆波兰表达式求值

目录

DAY11

20. 有效的括号 

解题思路&代码

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

解题思路&代码

方法一：使用 Deque 作为堆栈

方法二：拿字符串直接作为栈

150. 逆波兰表达式求值 

解题思路&代码

---

DAY11

20. 有效的括号 

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

有效字符串需满足：

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

讲完了栈实现队列，队列实现栈，接下来就是栈的经典应用了。 

大家先自己思考一下 有哪些不匹配的场景，在看视频 我讲的都有哪些场景，落实到代码其实就容易很多了。

题目链接/文章讲解/视频讲解：代码随想录

解题思路&代码

思路：需要判断的主要是三种情况，左括号多余，左右括号不匹配，右括号多余，每判断一次左括号就往栈中添加一个对应的右括号

其中可以利用不是偶数进行剪枝，因为不是偶数必然不匹配

左括号多余：匹配一次右括号，栈中右括号弹出一次，最后还是会留下右括号

左右括号不匹配：匹配一次右括号，发现与栈中右括号不符合，直接返回false

右括号多余：匹配一次右括号，栈中右括号弹出一次，还没遍历完，栈已经为空了

class Solution {
    public boolean isValid(String s) {
        Deque <Character> deque = new LinkedList<>();
        char ch;
        for (int i = 0; i < s.length(); i++) {
            ch = s.charAt(i);
            //碰到左括号，就把相应的右括号入栈
            if ( ch == '(') {
                deque.push(')');
            } else if (ch == '{') {
                deque.push('}');
            } else if (ch == '[') {
                deque.push(']');
            //如果是右括号判断是否和栈顶元素匹配，这里判断的是左右不匹配和左括号多余的情况
            } else if (deque.isEmpty() || deque.peek() != ch) {
                return false;
            } else {//匹配的右括号从栈中弹出
                deque.pop();
            
            }
        }
        //最后判断栈中元素是否匹配，如果不为空，说明多了右括号
        return deque.isEmpty();
    }
}

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

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

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

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

示例：

• 输入："abbaca"
• 输出："ca"

栈的经典应用。 

要知道栈为什么适合做这种类似于爱消除的操作，因为栈帮助我们记录了遍历数组当前元素时候，前一个元素是什么。

题目链接/文章讲解/视频讲解：代码随想录

解题思路&代码

思路：栈的目的，就是存放遍历过的元素，当遍历当前的这个元素的时候，去栈里看一下我们是不是遍历过相同数值的相邻元素。匹配到了就做消除的操作

本题要删除相邻相同元素，相对于20.有效的括号来说其实也是匹配问题，20.有效的括号是匹配左右括号，本题是匹配相邻元素，最后都是做消除的操作。

方法一：使用 Deque 作为堆栈

class Solution {
    public String removeDuplicates(String S) {
        //ArrayDeque会比LinkedList在除了删除元素这一点外会快一点
        //参考：https://stackoverflow.com/questions/6163166/why-is-arraydeque-better-than-linkedlist
        ArrayDeque<Character> deque = new ArrayDeque<>();
        char ch;
        for (int i = 0; i < S.length(); i++) {
            ch = S.charAt(i);
            /**当栈中顶端元素等于字符时，弹出栈中顶部元素，
            并且进入下一次遍历，最终剩下的元素也都会进入栈中*/
            if (deque.isEmpty() || deque.peek() != ch) {
                deque.push(ch);
            } else {
                deque.pop();
            }
        }
        String str = "";//将栈中元素弹出，并且转化为String
        //剩余的元素即为不重复的元素
        while (!deque.isEmpty()) {
            str = deque.pop() + str;
        }
        return str;
    }
}

方法二：拿字符串直接作为栈

省去了栈还要转为字符串的操作。

class Solution {
    public String removeDuplicates(String s) {
        // 将 res 当做栈
        // 也可以用 StringBuilder 来修改字符串，速度更快
        // StringBuilder res = new StringBuilder();
        StringBuffer res = new StringBuffer();
        // top为 res 的长度
        int top = -1;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            // 当 top > 0,即栈中有字符时，当前字符如果和栈中字符相等，弹出栈顶字符，同时 top--
            if (top >= 0 && res.charAt(top) == c) {
                res.deleteCharAt(top);
                top--;
            // 否则，将该字符 入栈，同时top++
            } else {
                res.append(c);
                top++;
            }
        }
        return res.toString();
    }
}

150. 逆波兰表达式求值 

根据 逆波兰表示法，求表达式的值。

有效的运算符包括 + ,  - ,  * ,  / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

• 输入: ["2", "1", "+", "3", " * "]
• 输出: 9
• 解释: 该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

本题不难，但第一次做的话，会很难想到，所以先看视频，了解思路再去做题 

题目链接/文章讲解/视频讲解：代码随想录

解题思路&代码

思路：其实逆波兰表达式相当于是二叉树中的后序遍历。 大家可以把运算符作为中间节点，按照后序遍历的规则画出一个二叉树。

本题中每一个子表达式要得出一个结果，然后拿这个结果再进行运算，那么不就是一个相邻字符串消除的过程,所以采用栈进行计算

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new LinkedList();
        for (String s : tokens) {
            // leetcode 内置jdk的问题，不能使用==判断字符串是否相等，所以采用equals
            if ("+".equals(s)) {        
                stack.push(stack.pop() + stack.pop());  
             // 注意 - 和/ 需要特殊处理    
            } else if ("-".equals(s)) {
                stack.push(-stack.pop() + stack.pop());
            } else if ("*".equals(s)) {
                stack.push(stack.pop() * stack.pop());
            } else if ("/".equals(s)) {
                int temp1 = stack.pop();
                int temp2 = stack.pop();
                stack.push(temp2 / temp1);
            } else {
                stack.push(Integer.valueOf(s));
            }
        }
        return stack.pop();
    }
}