【栈与队列part02】| 20.有效的括号、1047.删除字符串中所有相邻重复项、150.逆波兰表达式求值

目录

✿LeetCode20. 有效的括号❀

✿LeetCode1047.删除字符串中的所有相邻重复项❀ 

✿LeetCode150. 逆波兰表达式求值❀ 

---

✿LeetCode20. 有效的括号❀

链接：20.有效的括号

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

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
3. 每个右括号都有一个对应的相同类型的左括号。

有效的括号是经典 的用栈来解决的问题，一共有三种情况：

1. （ [ { } ] ）  true
2.  ) ( )[ ]     false
3. [ )    false

只有逐一讨论这几种情况就可，代码如下：

public boolean isValid(String s) {
        // 1 <= s.length <= 104
        // s 仅由括号 '()[]{}' 组成
        Stack<Character> stack=new Stack<>();
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)=='(' || s.charAt(i)=='[' || s.charAt(i)=='{'){
                stack.push(s.charAt(i));
            }
            if(s.charAt(i)==')' || s.charAt(i)==']' || s.charAt(i)=='}'){
                if(stack.isEmpty()){
                    return false;
                }else{
                    if(s.charAt(i)==')'){
                        if(stack.peek()!='('){
                            return false;
                        }else{
                            stack.pop();
                        }
                    }
                    if(s.charAt(i)==']'){
                        if(stack.peek()!='['){
                            return false;
                        }else{
                            stack.pop();
                        }
                    }
                    if(s.charAt(i)=='}'){
                        if(stack.peek()!='{'){
                            return false;
                        }else{
                            stack.pop();
                        }
                    }
                }
                
            }
        }
        return stack.isEmpty();
    }

✿LeetCode1047.删除字符串中的所有相邻重复项❀ 

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

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

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

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

 

此题还是用栈解决，当栈为空时，将字母直接入栈，当栈不为空时，判断字母与栈口元素是否相等，相等出栈，不相等入栈，最后栈里的元素即为答案，代码如下：

注意：因为栈是先进后出的，所以最后还要进行翻转一下 

public static String removeDuplicates(String s) {
        // 1 <= S.length <= 20000
        Stack<Character> st=new Stack<>();
        for(int i=0;i<s.length();i++){
            if(st.isEmpty()){
                st.push(s.charAt(i));
            }else{
                if(s.charAt(i)!=st.peek()){
                    st.push(s.charAt(i));
                }else{
                    while(!st.isEmpty() && s.charAt(i)==st.peek()){
                        st.pop();
                    }
                }

            }
        }
        StringBuilder result=new StringBuilder();
        while(!st.isEmpty()){
            result.append(st.pop());
        }
        result.reverse();
        return result.toString();
    }

✿LeetCode150. 逆波兰表达式求值❀ 

链接：150.逆序波兰求值

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

• 有效的算符为 '+'、'-'、'*' 和 '/' 。
• 每个操作数（运算对象）都可以是一个整数或者另一个表达式。
• 两个整数之间的除法总是 向零截断 。
• 表达式中不含除零运算。
• 输入是一个根据逆波兰表示法表示的算术表达式。
• 答案及所有中间计算结果可以用 32 位 整数表示

 

 可以先在纸上模拟一下逆波兰表达式的求值过程，不难发现此题也是栈的一个经典题目，把数字放入栈中，遇到+、-、*、/ 则拿出来运算，要注意 - 和 / 不满足交换律，需要用到一个临时变量，代码如下：

public int evalRPN(String[] tokens) {
        // 1 <= tokens.length <= 104
        Stack<Integer> st=new Stack<>();
        int result=0;
        for(int i=0;i<tokens.length;i++){
            if(tokens[i].equals("+")){
                result=st.pop()+st.pop();
                st.push(result);
            }else if(tokens[i].equals("-")){
                int temp=st.pop();
                result=st.pop()-temp;
                st.push(result);
            }else if(tokens[i].equals("*")){
                result=st.pop()*st.pop();
                st.push(result);
            }else if(tokens[i].equals("/")){
                int temp=st.pop();
                result=st.pop()/temp;
                st.push(result);
            }else{
                st.push(Integer.valueOf(tokens[i]));
            }
            
        }
        return st.pop();
    }