Day10|栈与队列02

20. 有效的括号

初始思路：

        如果碰到左括号，判断是否下一个为右括号。

        运行可以通过，无法AC，忽略了“{[]}”

题解复盘：

        针对无法通过的情况主要分为三种

        1）左括号多了

        2）左右括号数目相同但不匹配

        3）右括号多了

    

        书写代码时，遇到{（【分别存入}）】，如果此时是}判断栈顶是否为}，如果不是return false，此时对应了左右括号数目相同但不匹配的情况，如果此时是}但是栈为空，对应了右括号多了的情况。

        循环完毕，如果此时栈不为空，则对应了左括号多了的情况。

class Solution {
    public boolean isValid(String s) {
        //定义一个栈
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {

            if(s.charAt(i)=='('){
                stack.push(')');
            }else if(s.charAt(i)=='{'){
                stack.push('}');
            }else if(s.charAt(i)=='['){
                stack.push(']');
            }else if(stack.empty()||stack.pop()!=s.charAt(i)){
                return false;
            }


        }
        if(!stack.empty()){return false;}

        return true;
    }
}

---

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

初始思路：

        有了上一题作为铺垫就很好想了，遍历数组，如果栈空就将元素push进去，栈不空判断是否跟栈顶元素相同，不相同就push，相同就将栈顶pop出来。

然后用一个新数组装栈内元素并反转。

class Solution {
    public String removeDuplicates(String s) {
        Stack<Character> stack = new Stack<>();
        char[] c = s.toCharArray();

        for (int i = 0; i < c.length; i++) {
            if(stack.size()==0){stack.push(c[i]);}
            else if(stack.size()>0&&stack.peek()!=c[i]){stack.push(c[i]);}
            else{stack.pop();}
        }
        char[] result = new char[stack.size()];
        for (int i = 0; i < result.length; i++) {
            result[i] = stack.pop();
        }
        int start = 0;
        int end = result.length-1;
        while(start<end){
            char temp = result[start];
            result[start] = result[end];
            result[end] = temp;
            start++;
            end--;
        }

        return new String(result);

    }
}

 题解复盘：

        本道题题解提供了空间复杂度更低的解决方案。

---

150. 逆波兰表达式求值

初始思路和题解复盘：

1）注意-和/的元素顺序

2）leetcode中无法使用==判断字符串是否相等，需要用equal

• 适合用栈操作运算：遇到数字则入栈；遇到运算符则取出栈顶两个数字进行计算，并将结果压入栈中。（leetcode给的提示直接决定了代码的书写方式）

class Solution {
    public int evalRPN(String[] tokens) {
        //适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < tokens.length; i++) {
            if("+".equals(tokens[i])){
                int a = stack.pop();
                int b = stack.pop();
                stack.push(a+b);
            }else if("-".equals(tokens[i])){
                int a = stack.pop();
                int b = stack.pop();
                stack.push(b-a);
            }else if("*".equals(tokens[i])){
                int a = stack.pop();
                int b = stack.pop();
                stack.push(a*b);
            }else if("/".equals(tokens[i])) {
                int a = stack.pop();
                int b = stack.pop();
                stack.push(b/a);
            }else{
                stack.push(Integer.parseInt(tokens[i]));
            }
        }



    return stack.pop();
    }
}