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

20. 有效的括号

20. 有效的括号https://leetcode.cn/problems/valid-parentheses/

思路：直接push对应的右括号，是右括号的话直接就pop栈顶括号，否则说明前后括号不匹配，直接false，卡哥的思路很不错

class Solution {
    public boolean isValid(String s) {
        int n=s.length();
        Deque<Character> deque=new LinkedList<Character>();
        for(int i=0;i<n;i++){
            char c=s.charAt(i);
            if(c=='['){
                deque.push(']');
            }else if(c=='{'){
                deque.push('}');
            }else if(c=='('){
                deque.push(')');
            }else if(deque.isEmpty() || c!=deque.peek()){
                return false;
            }else{
                deque.pop();
            }
        }
        return deque.isEmpty();

    }
}

我自己写的比较复杂，还用map存储了对应的映射

class Solution {
    public boolean isValid(String s) {
        int n=s.length();
        //奇数个必定不有效
        if(n%2==1){
            return false;
        }
        //存储配对关系 只有遇到右侧的括号才会pop
        Map<Character,Character> pair=new HashMap<Character,Character>();
        pair.put(')','(');
        pair.put(']','[');
        pair.put('}','{');
        //栈进行比较
        Deque<Character> stack=new LinkedList<>();
        for(int i=0;i<n;i++){
            char c=s.charAt(i);
            //peek满足一对的 才pop
            if(pair.containsKey(c)){
                if(!stack.isEmpty()&& stack.peek()==pair.get(c)){
                    stack.pop();
                }
                else{
                    return false;
                }
            }
            else{
                stack.push(c);
            }
        }
        return stack.isEmpty();

    }
}

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

1047. 删除字符串中的所有相邻重复项https://leetcode.cn/problems/remove-all-adjacent-duplicates-in-string/

思路：直接模拟，就好像是消消乐，栈顶与当前字符直接消除，否则push进去，然后把保留的符号直接倒序出来，返回出去。

class Solution {
    public String removeDuplicates(String s) {
        int n = s.length();
        Deque<Character> deque = new LinkedList<Character>();

        for (int i = 0; i < n; i++) {
            char c = s.charAt(i);
            if (!deque.isEmpty() && deque.peek() == c) {
                deque.pop();
                continue;
            }else{
                deque.push(c);
            }
        }
        char[] res=new char[deque.size()];
        int l=deque.size();
        int i=0;
        while(!deque.isEmpty()){
            res[l-1-i]=deque.pop();
            i++;
        }
        return String.valueOf(res);
    }
}

 150. 逆波兰表达式求值

150. 逆波兰表达式求值https://leetcode.cn/problems/evaluate-reverse-polish-notation/

思路：直接模拟，思路很简单，遇到那4个符号了直接把栈顶的2个元素给计算了，计算完再push进去。

class Solution {
    public int evalRPN(String[] tokens) {
        int n=tokens.length;
        Deque<Integer> deque=new LinkedList<Integer>();
        for(int i=0;i<n;i++){
            String cs=tokens[i];
            if(cs.equals("+")){
                Integer b=Integer.valueOf(deque.pop());
                Integer a=Integer.valueOf(deque.pop());
                Integer c=a+b;
                deque.push(c);
            }else if(cs.equals("-")){
                Integer b=Integer.valueOf(deque.pop());
                Integer a=Integer.valueOf(deque.pop());
                Integer c=a-b;
                deque.push(c);
            }else if(cs.equals("*")){
                Integer b=Integer.valueOf(deque.pop());
                Integer a=Integer.valueOf(deque.pop());
                Integer c=a*b;
                deque.push(c);
            }else if(cs.equals("/")){
                Integer b=Integer.valueOf(deque.pop());
                Integer a=Integer.valueOf(deque.pop());
                Integer c=a/b;
                deque.push(c);
            }else{
                deque.push(Integer.valueOf(cs));
            }
        }

        return deque.pop();
    }
}