代码随想录算法训练营DAY11|20.有效的括号|1047.删除字符串中所有相邻元素|150.逆波兰表达式

20.有效的括号

思路：经典的括号匹配。

• 遇到左括号，弹入栈
• 遇到右括号，从栈里弹出左括号匹配

写起来还是有两个点要考虑的

• 遇到右括号的时候，弹出左括号之前要对栈判空。'))'这种情况，栈空==没有左括号
• 最后对栈进行判空，栈空表示左括号都弹出去了，不空表示有左括号没匹配完。

class Solution {
        public boolean isValid(String s) {
        Stack<Character> stack=new Stack<>();
        char[] bracket=s.toCharArray();
        if(s.length()<=1){
            return false;
        }
        for(Character c:bracket){
            if('('==c){//遇到左括号入栈
                stack.push(c);
            }else if('['==c){
                stack.push(c);
            }else if('{'==c){
                stack.push(c);
            }else if(')'==c){//遇到右括号
                //对栈判空
                if(stack.isEmpty()){
                    return false;
                }
                if(!(stack.pop() =='(')){
                    return false;
                }
            }else if(']'==c){//遇到右括号
                //对栈判空
                if(stack.isEmpty()){
                    return false;
                }
                if(!(stack.pop() =='[')){
                    return false;
                }
            }else if('}'==c){//遇到右括号
                //对栈判空
                if(stack.isEmpty()){
                    return false;
                }
                if(!(stack.pop() =='{')){
                    return false;
                }
            }
        }
        if(!stack.isEmpty()){
            return false;
        }
        return true;
    }
}

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

***思路：

• 维护一个栈，数组元素入栈规则：当前元素与栈顶元素不一样；栈空。
• 当栈顶元素与当前数组元素一致时，弹出栈顶元素。
  

此时数组元素a与栈顶元素a一致，弹出栈里的a。

最后把栈元素倒出来，反转一下。

class Solution {
     public String removeDuplicates(String s) {
         if("".equals(s)||s==null){
             return "";
         }
        Stack<Character> stack=new Stack<>();
        char[] a=s.toCharArray();
        for(char letter:a){
            //栈不空
            if(!stack.isEmpty()){
                char top=stack.peek();
                //栈顶元素与当前数组元素一致
                if(top==letter){
                    stack.pop();
                }else{
                    stack.push(letter);
                }
            }else{
                stack.push(letter);
            }
        }
       if(stack.isEmpty()){
            return "";
       }
        StringBuilder sb=new StringBuilder();
        while(!stack.isEmpty()){
            sb.append(stack.pop());
        }
        return sb.reverse().toString();
    }
}

150.逆波兰表达式

思路:遇到数字入栈，遇到符号，弹出两个数字，“/”和“-”的时候用第二个数字放前面处理。

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack=new Stack<>();
        for(String token:tokens){
            if("+".equals(token)){
                int number1=stack.pop();
                int number2=stack.pop();
                int temp=number1+number2;
                stack.push(temp);
            }else if("-".equals(token)){
                int number1=stack.pop();
                int number2=stack.pop();
                int temp=number2-number1;
                stack.push(temp);
            }else if("*".equals(token)){
                int number1=stack.pop();
                int number2=stack.pop();
                int temp=number1*number2;
                stack.push(temp);
            }else if("/".equals(token)){
                 int number1=stack.pop();
                int number2=stack.pop();
                int temp=number2/number1;
                stack.push(temp);
            }else{
                stack.push(Integer.parseInt(token));
            }
        }
        return stack.pop();
    }
}