day11 | 20. 有效的括号 1047. 删除字符串中的所有相邻重复项 150. 逆波兰表达式求值

---

---

20. 有效的括号

1、代码1

class Solution {
    public boolean isValid(String s) {
        char[] ch = s.toCharArray();
        Stack<Character> stack = new Stack<>();
        //1、括号类型不匹配
        //2、左边多括号
        //3、右边多括号
        for(int i=0; i<s.length(); i++){
            if(ch[i] == '('){
                stack.push(')');
            }
            if(ch[i] == '['){
                stack.push(']');
            }
            if(ch[i] == '{'){
                stack.push('}');
            }
            if(ch[i] == ')'){
                if(!stack.isEmpty() && stack.pop() == ')'){
                    continue;
                }else{
                    return false;
                }
            }
            if(ch[i] == ']'){
                if(!stack.isEmpty() && stack.pop() == ']'){
                    continue;
                }else{
                    return false;
                }
            }
            if(ch[i] == '}'){
                if(!stack.isEmpty() && stack.pop() == '}'){
                    continue;
                }else{
                    return false;
                }
            }
        }
        if(!stack.isEmpty()){
            return false;
        }
        return true;
    }
}

2、分析

（1）**栈主要解决的是对称匹配类问题。**匹配指循环遍历的元素在后面遍历的时候需要用到，于是元素出栈完成匹配。主要思路都是遍历入栈，需要的时候拿出来进行计算之后再入栈。
（2）**动手之前需要分析好题目。**看到题没有从更高的角度入手容易顾此失彼。
（3）代码：

!stack.isEmpty() && stack.pop() == '}'

正如链表一样，数据结构在进行操作时要注意该数据结构是否已经为空，否则会发生编译错误。

3、代码2

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();
    }
}

4、分析

（1）Deque可以运用于栈和队列。
（2）代码：

 }else if(deque.isEmpty() || deque.peek()!= ch){

左边表达式解决了左括号多余的情况，右表达式解决了括号类型不匹配的情况，

      return deque.isEmpty();

return语句解决了右括号多余的情况。
（3）代码1中可以发现右括号匹配的时候有大量冗余代码，由于都是判断栈顶元素，所以直接用peek()函数判断与遍历的元素是否相等，简洁了代码。
（4）有时候对于结果的判断也可以直接写到return语句里面，而不用再写一个if判断来决定返回值的值，可以简化代码。

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

1、代码

class Solution {
    public String removeDuplicates(String s) {
        Deque<Character> deque = new LinkedList<>();
        char ch;
        for(int i=0; i<s.length(); i++){
            ch = s.charAt(i);
            if(!deque.isEmpty() && deque.peek() == ch){
                deque.pop();
            }else{
                deque.push(ch);
            }
        }
        String str = "";
        while(!deque.isEmpty()){
            str = deque.pop() + str;//
        }
        return str;
    }
}

2、分析

（1）技巧：当需要返回的字符串都在数据结构（栈）里面的时候，可以建立一个空字符串，通过循环进行字符串值的叠加。

        String str = "";
        while(!deque.isEmpty()){
            str = deque.pop() + str;
        }
        return str;

150. 逆波兰表达式求值

1、代码

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for(int i=0; i<tokens.length; i++){
            if("+".equals(tokens[i])){
                stack.push(stack.pop() + stack.pop());
            }else if("-".equals(tokens[i])){
                stack.push(-stack.pop() + stack.pop());
            }else if("*".equals(tokens[i])){
                stack.push(stack.pop() * stack.pop());
            }else if("/".equals(tokens[i])){
                int temp = stack.pop();
                int temp1 = stack.pop();
                stack.push(temp1 / temp);
            }else{
                // stack.push(tokens[i]);
                //把字符串转化为整数类型
                stack.push(Integer.valueOf(tokens[i]));
            }
        }
        return stack.peek();
    }
}

2、分析

（1）代码：

Integer.valueOf(tokens[i])

技巧：该api将字符串类型转化为整型类型。