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

栈特别擅长于处理相邻字符某些情况下做一些特殊判断（相邻字符做匹配、做消除等等） 

20. 有效的括号 

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

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

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

有三种不匹配的情况，

1. 第一种情况，字符串里左方向的括号多余了 ，所以不匹配。 

2. 第二种情况，括号没有多余，但是 括号的类型没有匹配上。 

3. 第三种情况，字符串里右方向的括号多余了，所以不匹配。 

第一种情况：已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false

第二种情况：遍历字符串匹配的过程中，发现栈里没有要匹配的字符。所以return false

第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号return false

字符串遍历完之后，栈是空的，就说明左括号和右括号全都匹配了。遍历完，栈不为空，则不匹配

把对应右括号加入栈里，弹出时直接和栈里的元素作比较就行，更简单

class Solution {
    public boolean isValid(String s) {
        Stack<Character> validate = new Stack<>();
        if(s.length() % 2 !=0 ) return false;

        for(int i = 0; i < s.length(); i++){
            char temp = s.charAt(i);

            if(temp == '('){
                validate.push(')');
            }else if(temp == '{'){
                validate.push('}');
            }else if(temp == '['){
                validate.push(']');
            }else if(validate.isEmpty() || validate.peek() != temp){
                return false;
            }else{
                validate.pop();
            }
        }
        return validate.isEmpty();
    }
}

---

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

栈的经典应用。 

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

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

不仅要删除相邻重复项，删完后，如果仍有相邻重复项，还要继续删。

使用栈作为辅助数据结构，帮助记录遍历字符串过程中，1.遍历过哪些元素、2.遍历的前一个元素是什么，同时，也用栈直接做消除操作。

最后从栈中弹出剩余元素，因为从栈里弹出的元素是倒序的，所以再对字符串进行反转一下，就得到了最终的结果。

使用栈：

class Solution {
    public String removeDuplicates(String s) {
        Stack<Character> stack = new Stack<>();
        for(int i = 0; i< s.length(); i++){
            char temp = s.charAt(i);
            if(!stack.isEmpty() && stack.peek() == temp){
                stack.pop();
            }else{
                stack.push(temp);
            }
        }
        StringBuilder sb = new StringBuilder();
        while(!stack.isEmpty()){
            sb.insert(0, stack.pop());
        }
        return sb.toString();
    }
}

 使用双指针：

class Solution {
    public String removeDuplicates(String s) {
        char[] ch = s.toCharArray();
        int fast = 0;
        int slow = 0;
        while(fast < s.length()){
            // 直接用fast指针覆盖slow指针的值
            ch[slow] = ch[fast];
            // 遇到前后相同值的，就跳过，即slow指针后退一步，下次循环就可以直接被覆盖掉了
            if(slow > 0 && ch[slow] == ch[slow - 1]){
                slow--;
            }else{
                slow++;
            }
            fast++;
        }
        return new String(ch,0,slow);
    }
}

在企业项目开发中，尽量不要使用递归！在项目比较大的时候，由于参数多，全局变量等等，使用递归很容易判断不充分return的条件，非常容易无限递归（或者递归层级过深），造成栈溢出错误（这种问题还不好排查！）

---

150. 逆波兰表达式求值 

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

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

逆波兰表达式：是一种后缀表达式，所谓后缀就是指运算符写在后面。(二叉树后序遍历)

逆波兰表达式主要有以下两个优点：

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

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

那么将中缀表达式，转化为后缀表达式之后，计算机可以利用栈来顺序处理，不需要考虑优先级了。也不用回退了， 所以后缀表达式对计算机来说是非常友好的。 

class Solution {
    public int evalRPN(String[] tokens) {
        int temp = 0;
        Deque<String> stack = new LinkedList();
        for(int i = 0; i < tokens.length; i++){
            if(tokens[i].equals("+") || tokens[i].equals("-") || tokens[i].equals("*") || tokens[i].equals("/")){
                int b = Integer.parseInt(stack.pop());
                int a = Integer.parseInt(stack.pop());
                temp = calculate(a, b, tokens[i].charAt(0));
                stack.push(temp+"");
            }else{
                stack.push(tokens[i]);
            }
        }
        return Integer.parseInt(stack.pop());
    }

    public int calculate(int a, int b, char symbol){
        int result = 0;
        switch (symbol){
            case '+':
                result = a + b;
                break;
            case '-':
                result = a - b;
                break;
            case '*':
                result = a * b;
                break;
            case '/':
                result = a / b;
                break;
        }
        return result;
    }
}

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new LinkedList();
        for (String s : tokens) {
            if ("+".equals(s)) {        // leetcode 内置jdk的问题，不能使用==判断字符串是否相等
                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();
    }
}